sf_onhit_hook.c

Go to the documentation of this file.

#include "sf_onhit_hook.h"
 
 
// getFigureJobData_ptr getFigureJobData;
// FUN_006f8c06_ptr FUN_006f8c06;
// FUN_006fa3ce_ptr FUN_006fa3ce;
// setFigureAction_ptr setFigureAction;
 
// uint32_t __thiscall onSpellCastHook(SF_CGdFigureToolbox *_this, uint16_t figure_id, uint16_t spell_id,
//                                     uint16_t target_id, uint8_t target_type, SF_Coord position, uint32_t param6,
//                                     uint32_t param7)
// {
//     FigureJobData *ac24 = getFigureJobData(_this->CGdFigure, figure_id);
//     if (!FUN_006f8c06(_this, figure_id, spell_id, target_id, target_type, position, param6, param7, 0))
//     {
//         return 0;
//     }
//     else
//     {
//         FUN_006fa3ce(_this, figure_id, 0);
//         ac24->flags |= MANUAL_JOB_CHANGE;
//         ac24->GdJobId = kGdJobManualWalkToTarget;
//         ac24->target.entity_index = target_id;
//         ac24->target.entity_type = target_type;
//         ac24->target.position.X = position.X;
//         ac24->target.position.Y = position.Y;
//         SF_CGdResourceSpell spell_data;
//         spellAPI->getResourceSpellData(_this->CGdResource, &spell_data, spell_id);
 
//         SF_SGtFigureAction action;
//         action.type = spell_data.spell_line_id;
//         action.subtype = spell_id;
//         action.unkn2 = 0;
//         action.unkn3 = 0;
//         action.unkn4 = 0;
//         action.unkn5 = 0;
 
//         setFigureAction(ac24, &action);
//         return 1;
//     }
//     return 0;
// }
 
typedef uint16_t (__thiscall *get_reduced_damage_ptr)(void *AutoClass34,
                                                      uint16_t source_index,
                                                      uint16_t target_index,
                                                      uint16_t unkn);
typedef uint16_t (__thiscall *get_reduced_building_damage_ptr)(
    void *AutoClass32, uint16_t source_index, uint16_t target_index,
    uint16_t damage);
typedef uint16_t (__thiscall *get_hit_chance_ptr)(void *AutoClass34,
                                                  uint16_t source_index,
                                                  uint16_t target_index);
typedef void (__thiscall *FUN_006c3a60_ptr)(void *AutoClass30,
                                            uint16_t source_index,
                                            uint16_t target_index, uint8_t unkn,
                                            uint32_t unkn2);
typedef uint32_t (__thiscall *FUN_0071d7b0_ptr)(void *CGdObject,
                                                uint16_t object_index);
typedef uint32_t (__thiscall *FUN_00755180_ptr)(uint32_t param1);
typedef uint32_t (__thiscall *objectDealDamage_ptr)(void *CGdObjectToolBox,
                                                    uint16_t source_index,
                                                    uint16_t target_index,
                                                    uint16_t damage,
                                                    uint32_t unknown);
typedef uint32_t (__thiscall *getWeaponEffects_ptr)(void *CGdResource,
                                                    uint32_t *param1,
                                                    uint16_t weapon_id);
 
get_reduced_damage_ptr g_get_reduced_damage;
get_hit_chance_ptr g_get_hit_chance;
FUN_006c3a60_ptr g_FUN_006c3a60;
get_reduced_building_damage_ptr g_get_reduced_building_damage;
FUN_0071d7b0_ptr g_FUN_0071d7b0;
FUN_00755180_ptr g_FUN_00755180;
objectDealDamage_ptr g_objectDealDamage;
getWeaponEffects_ptr g_getWeaponEffects;
 
// TODO PassThrough GET CURRENT STAT
 
uint16_t __thiscall getCurrentDex(SF_CGdFigure *_this, uint16_t figure_index)
{
    uint16_t base_val = _this->figures[figure_index].dexterity.base_val;
    uint16_t bonus_val = _this->figures[figure_index].dexterity.bonus_val;
    uint16_t multiplier =
        _this->figures[figure_index].dexterity.bonus_multiplier + 100;
    if (base_val + bonus_val > 0)
    {
        return ((base_val + bonus_val) * multiplier) / 100;
    }
    return 0;
}
 
uint16_t __thiscall getCurrentInt(SF_CGdFigure *_this, uint16_t figure_index)
{
    uint16_t base_val = _this->figures[figure_index].intelligence.base_val;
    uint16_t bonus_val = _this->figures[figure_index].intelligence.bonus_val;
    uint16_t multiplier =
        _this->figures[figure_index].intelligence.bonus_multiplier + 100;
    if (base_val + bonus_val > 0)
    {
        return ((base_val + bonus_val) * multiplier) / 100;
    }
    return 0;
}
// End TODO
 
uint16_t get_effect_chance(uint16_t dex_val, uint16_t int_val,
                           uint16_t spell_line)
{
    if (spell_line != kGdSpellLinePoison)
    {
        return (dex_val + int_val + 100) * 5;
    }
    return dex_val * 8 + int_val * 5 + 0x578;
}
 
void initialize_onhit_data_hooks()
{
    g_get_reduced_damage = (get_reduced_damage_ptr)(ASI::AddrOf(0x3177d0));
    g_get_hit_chance = (get_hit_chance_ptr)(ASI::AddrOf(0x317860));
    g_FUN_006c3a60 = (FUN_006c3a60_ptr)(ASI::AddrOf(0x2c3a60));
    g_get_reduced_building_damage =
        (get_reduced_building_damage_ptr)(ASI::AddrOf(0x317740));
    g_FUN_0071d7b0 = (FUN_0071d7b0_ptr)(ASI::AddrOf(0x31d7b0));
    g_FUN_00755180 = (FUN_00755180_ptr)(ASI::AddrOf(0x355180));
    g_objectDealDamage = (objectDealDamage_ptr)(ASI::AddrOf(0x2b7d70));
    g_getWeaponEffects = (getWeaponEffects_ptr)(ASI::AddrOf(0x2693b0));
}
 
void __thiscall getTargetData(FigureJobData *_this, SF_CGdTargetData *target)
{
    target->entity_type = _this->target.entity_type;
    target->entity_index = _this->target.entity_index;
    target->position = _this->target.position;
}
 
bool isJobDoNothing(uint16_t job_id)
{
    if ((job_id == kGdJobGroupNothing) || (job_id == kGdJobWarriorNothing) ||
        (job_id == kGdJobCheckBattleSleep) || (job_id == kGdJobPetIdle))
    {
        return 1;
    }
    return 0;
}
 
bool __thiscall isFigureJobSpell(SF_CGdFigureJobs *_this, uint16_t figure_id)
{
    uint16_t job_id = figureAPI.getJob(_this->CGdFigure, figure_id);
    if ((job_id == kGdJobCast) || (job_id == kGdJobPreCast) ||
        (job_id == kGdJobCastResolve) || (job_id == kGdJobCastPreResolve))
    {
        return 1;
    }
    if (job_id == kGdJobWalkToTarget)
    {
        SF_SGtFigureAction action;
        aiAPI.getTargetAction(_this->CGdFigure, &action, figure_id);
        if ((action.type != 0) && (action.type < 10000))
        {
            return 1;
        }
    }
    return 0;
}
 
bool __thiscall canJobBeInterrupted(FigureJobs job_id)
{
    if ((((job_id != kGdJobCastPreResolve) && (job_id != kGdJobCastResolve)) &&
         (job_id != kGdJobHitTargetRange2)) &&
        (((job_id != kGdJobEnterBuilding && (job_id != kGdJobExitBuilding)) &&
          ((job_id != kGdJobMeleeAbility &&
            (job_id != kGdJobStartWorkAtBuilding))))))
    {
        return 1;
    }
    return 0;
}
 
uint16_t __thiscall getAttackInterruptionChance(SF_CGdFigure *_this,
                                                uint16_t source_index,
                                                uint16_t target_index)
{
    uint8_t source_level = _this->figures[source_index].level;
    uint8_t target_level = _this->figures[target_index].level;
    if (target_level < source_level)
    {
        uint16_t precalc_chance = (source_level - target_level) * 5 + 15;
        if (precalc_chance > 100)
        {
            return 100;
        }
        return precalc_chance;
    }
    if (target_level == source_level)
    {
        return 15;
    }
    if ( 15 < ((target_level - source_level) * 2))
    {
        return 0;
    }
    return 15 - (target_level - source_level) * 2;
}
 
uint16_t __thiscall handle_riposte_set(SF_CGdFigureJobs *_this,
                                       uint16_t source_index,
                                       uint16_t target_index,
                                       uint16_t weapon_damage)
{
    bool apply_set = false;
    if (_this->CGdFigure->figures[target_index].set_type == 0x03)
    {
        uint16_t counter = spellAPI.getRandom(_this->OpaqueClass, 100);
        apply_set = (counter < 0x0b);
    }
    if (apply_set)
    {
        uint16_t damage = g_get_reduced_damage(_this->AutoClass34, source_index, source_index, weapon_damage);
        toolboxAPI.dealDamage(_this->CGdFigureToolBox, source_index, source_index, damage, 0, 0, 0);
        return 0;
    }
    // TODO: fix enchatments on weapon applying with reflected hit
    return weapon_damage;
}
 
uint16_t __thiscall handle_berserk_set(SF_CGdFigureJobs *_this,
                                       uint16_t source_index,
                                       uint16_t target_index,
                                       uint16_t weapon_damage)
{
    bool apply_set = false;
    if (_this->CGdFigure->figures[source_index].set_type == 0x04)
    {
        uint16_t counter = spellAPI.getRandom(_this->OpaqueClass, 100);
        apply_set = (counter < 0x0b);
    }
    // 7FFF is one-shot magic number
    if ((apply_set) && (weapon_damage != 0x7FFF))
    {
        uint16_t damage = weapon_damage * 3;
        return damage;
    }
    return weapon_damage;
}
 
uint16_t __thiscall handle_trueshot_set(SF_CGdFigureJobs *_this,
                                        uint16_t source_index,
                                        uint16_t target_index,
                                        uint16_t weapon_damage)
{
    bool apply_set = false;
    if (_this->CGdFigure->figures[source_index].set_type == 0x05)
    {
        uint16_t counter = spellAPI.getRandom(_this->OpaqueClass, 100);
        apply_set = (counter < 0x0b);
    }
    // 7FFF is one-shot magic number
    if ((apply_set) && (weapon_damage != 0x7FFF))
    {
        uint16_t damage = weapon_damage * 4;
        return damage;
    }
    return weapon_damage;
}
 
void __thiscall sf_onhit_hook(SF_CGdFigureJobs *_this, uint16_t source_index,
                              uint32_t param_2, uint8_t param_3)
{
    if ((_this->CGdFigure->figures[source_index].owner == -1) || (_this->CGdFigure->figures[source_index].flags & 10))
    {
        return;
    }
 
    SF_CGdFigureWeaponStats weapon_stats;
    SF_CGdTargetData target;
    SF_SGtFigureAction action;
    figureAPI.getWeaponStats(_this->CGdFigure, &weapon_stats, source_index);
    uint16_t weapon_damage_rng = spellAPI.getRandom(_this->OpaqueClass, weapon_stats.max_dmg - weapon_stats.min_dmg);
    uint16_t weapon_damage = weapon_damage_rng + weapon_stats.min_dmg;
    getTargetData(&_this->CGdFigure->figures[source_index].current_job, &target);
    aiAPI.getTargetAction(_this->CGdFigure, &action, source_index);
 
    if (target.entity_type == 1)
    {
        // NB Parenthis matters in flags check. I mean it
        if ((_this->CGdFigure->figures[target.entity_index].owner == -1) ||
            ((_this->CGdFigure->figures[target.entity_index].flags & (RESESRVED_ONLY | IS_DEAD)) != 0) ||
            (!toolboxAPI.isTargetable(_this->CGdFigureToolBox, target.entity_index)))
        {
            return;
        }
 
        uint16_t hit_chance = g_get_hit_chance(_this->AutoClass34, source_index, target.entity_index);
 
        // miss handling
        if ((hit_chance < spellAPI.getRandom(_this->OpaqueClass, 100)) && (param_2 == 0))
        {
            g_FUN_006c3a60(_this->AutoClass30, source_index, target.entity_index, 1, 0);
            uint16_t aggro = figureAPI.getAggroValue(_this->CGdFigure, target.entity_index, source_index);
            if (aggro < 10000)
            {
                figureAPI.setAggroValue(_this->CGdFigure, target.entity_index, source_index, 12000, 0);
            }
            uint16_t job_id = figureAPI.getJob(_this->CGdFigure, target.entity_index);
 
            if (isJobDoNothing(job_id))
            {
                _this->CGdFigure->figures[target.entity_index].to_do_count = 1;
                return;
            }
        }
        /*
           target_index = get_reduced_hit_damage
                        (this->field11_0x2c,uVar3,(ushort)local_12c._1_4_,(ushort)local_160);
           target_index = ((target_index & 0xffff) * (uint)param_3 + 0x32) / 100;
           damage = target_index & 0xffff;
         */
 
 
        uint16_t damage = g_get_reduced_damage(_this->AutoClass34, source_index, target.entity_index, weapon_damage);
        damage = ((damage & 0xffff) * ((uint8_t) param_3) + 0x32) / 100;
        damage = damage & 0xffff;
        // glanced hit
        if (damage == 0)
        {
#if _DEBUG_
            log_info("Damage IS 0");
#endif
            uint16_t aggro = figureAPI.getAggroValue(_this->CGdFigure, target.entity_index, source_index);
            if (aggro < 10000)
            {
                figureAPI.setAggroValue(_this->CGdFigure, target.entity_index, source_index, 12000, 0);
            }
        }
        else
        {
            if (isFigureJobSpell(_this, target.entity_index))
            {
                uint16_t job_id = figureAPI.getJob(_this->CGdFigure, target.entity_index);
                if (canJobBeInterrupted((FigureJobs) job_id))
                {
                    uint16_t chance = getAttackInterruptionChance(_this->CGdFigure, source_index, target.entity_index);
                    if (spellAPI.getRandom(_this->OpaqueClass, 100) <= chance)
                    {
                        toolboxAPI.figureSetNewJob(_this, target.entity_index, kGdJobOfferMe, 0, 0, 0);
                    }
                }
            }
            for (int i = PHASE_0; i < OnHitEnd; ++i)
            {
                if (i == PHASE_0)
                {
                    if (isActionMelee(&action))
                    {
                        damage = handle_berserk_set(_this, source_index, target.entity_index, damage);
                        damage = handle_riposte_set(_this, source_index, target.entity_index, damage);
                    }
                    else
                    {
                        damage = handle_trueshot_set(_this, source_index, target.entity_index, damage);
                    }
                }
                std::list<std::pair<uint16_t, onhit_handler_ptr>> onhit_list =
                    get_onhit_phase(static_cast<OnHitPhase>(i));
                for (auto it = onhit_list.crbegin(); it != onhit_list.crend(); ++it)
                {
                    std::pair<uint16_t, onhit_handler_ptr> entry = *it;
 
                    uint16_t spell_line_id = entry.first;
 
                    if (hasSpellTag(spell_line_id, TARGET_ONHIT_SPELL))
                    {
                        //Target on-hits for ranged spells should be handled in phys effect hook, not here
                        if (isActionMelee(&action))
                        {
                            if ((_this->CGdFigure->figures[target.entity_index].flags & F_CHECK_SPELLS_BEFORE_JOB) != 0)
                            {
                                if (toolboxAPI.hasSpellOnIt(_this->CGdFigureToolBox, target.entity_index,
                                                            spell_line_id))
                                {
                                    onhit_handler_ptr onhit_func = entry.second;
                                    damage = onhit_func(_this, source_index, target.entity_index, damage);
                                }
                            }
                        }
                    }
                    else
                    {
                        if ((_this->CGdFigure->figures[source_index].flags & F_CHECK_SPELLS_BEFORE_JOB) != 0)
                        {
                            if (toolboxAPI.hasSpellOnIt(_this->CGdFigureToolBox, source_index, spell_line_id))
                            {
                                onhit_handler_ptr onhit_func = entry.second;
                                damage = onhit_func(_this, source_index, target.entity_index, damage);
                            }
                        }
                    }
                }
            }
            // donnoe wtf is it, looks like shooting?
            if (action.type == 0x2712)
            {
                uint16_t maxY = (_this->CGdFigure->figures[source_index].position.Y <=
                                 _this->CGdFigure->figures[target.entity_index].position.Y)
                                    ? (_this->CGdFigure->figures[target.entity_index].position.Y)
                                    : (_this->CGdFigure->figures[source_index].position.Y);
 
                uint16_t maxX = (_this->CGdFigure->figures[source_index].position.X <=
                                 _this->CGdFigure->figures[target.entity_index].position.X)
                                    ? (_this->CGdFigure->figures[target.entity_index].position.X)
                                    : (_this->CGdFigure->figures[source_index].position.X);
 
                uint16_t minY = (_this->CGdFigure->figures[source_index].position.Y >
                                 _this->CGdFigure->figures[target.entity_index].position.Y)
                                    ? (_this->CGdFigure->figures[target.entity_index].position.Y)
                                    : (_this->CGdFigure->figures[source_index].position.Y);
 
                uint16_t minX = (_this->CGdFigure->figures[source_index].position.X >
                                 _this->CGdFigure->figures[target.entity_index].position.X)
                                    ? (_this->CGdFigure->figures[target.entity_index].position.X)
                                    : (_this->CGdFigure->figures[source_index].position.X);
                SF_Coord p1;
                SF_Coord p2;
                SF_Rectangle vector;
                p1.X = maxX;
                if (minX < maxX)
                {
                    p1.X = minX;
                }
                p1.Y = maxY;
                if (minY < maxY)
                {
                    p1.Y = minY;
                }
 
                p2.X = maxX;
                if (maxX <= minX)
                {
                    p2.X = minX;
                }
                p2.Y = maxY;
                if (maxY <= minY)
                {
                    p2.Y = minY;
                }
                vector.partA = p1.Y << 0x10 | p1.X;
                vector.partB = p2.Y << 0x10 | p2.X;
 
                uint32_t distance = getDistance(&_this->CGdFigure->figures[source_index].position,
                                                &_this->CGdFigure->figures[target.entity_index].position);
                distance = ((distance & 0xffff) * 1400) / 3000;
                SF_CGdTargetData source = {1, source_index, {0, 0}};
                uint16_t effect_id = effectAPI.addEffect(_this->CGdEffect, kGdEffectProjectile, &source, &target,
                                                         _this->OpaqueClass->current_step,
                                                         ((distance != 0) ? distance : 1), &vector);
                log_debug(DEBUG_LOW, "Effect %d Distance %d", effect_id, distance);
 
                effectAPI.setEffectXData(_this->CGdEffect, effect_id, EFFECT_ENTITY_TYPE, 1);
                effectAPI.setEffectXData(_this->CGdEffect, effect_id, EFFECT_ENTITY_TYPE2, 1);
                effectAPI.setEffectXData(_this->CGdEffect, effect_id, EFFECT_ENTITY_INDEX, source_index);
                effectAPI.setEffectXData(_this->CGdEffect, effect_id, EFFECT_ENTITY_INDEX2, target.entity_index);
                effectAPI.setEffectXData(_this->CGdEffect, effect_id, EFFECT_ADD_SUBSPELL, 1);
                effectAPI.setEffectXData(_this->CGdEffect, effect_id, EFFECT_PHYSICAL_DAMAGE, damage);
 
                uint16_t subspell_id = 0;
                // troll fire thrower
                if (_this->CGdFigure->figures[source_index].unit_data_id == 0x508)
                {
                    subspell_id = 0x6de;
                }
                // troll ice thrower
                if (_this->CGdFigure->figures[source_index].unit_data_id == 0x505)
                {
                    subspell_id = 0x6ea;
                }
                // windarcher
                if (_this->CGdFigure->figures[source_index].unit_data_id == 0x4cd)
                {
                    subspell_id = 0x6d2;
                }
                if (subspell_id != 0)
                {
                    uint16_t spell_lvl = _this->CGdFigure->figures[source_index].level;
                    uint16_t spell_id =spellAPI.getLeveledSpellID(_this->CGdResource, subspell_id, spell_lvl);
                    if (spell_id != 0)
                    {
                        effectAPI.setEffectXData(_this->CGdEffect, effect_id, EFFECT_SUBSPELL_ID, spell_id);
                    }
                }
            }
            else
            {
                // Havoc & DeathKnight upgrade
                if ((_this->CGdFigure->figures[target.entity_index].unit_data_id == 0x510) ||
                    (_this->CGdFigure->figures[target.entity_index].unit_data_id == 0x513))
                {
                    // NOT a bug, but feature. The higher the level of enemy, the stronger curse gets.
                    uint16_t spell_id = spellAPI.getLeveledSpellID(_this->CGdResource, 0x167,
                                                                   _this->CGdFigure->figures[source_index].level);
                    if (spell_id != 0)
                    {
                        SF_CGdTargetData t_data;
                        t_data.entity_index = source_index;
                        t_data.entity_type = 1;
                        t_data.position = {0, 0};
                        spellAPI.addSpell(_this->CGdSpell, spell_id, _this->OpaqueClass->current_step, &target, &t_data,
                                          0);
                    }
                }
                if(damage != 0)
                {
                    toolboxAPI.dealDamage(_this->CGdFigureToolBox, source_index, target.entity_index, damage, 0, 0, 0);
                }
            }
 
            if (figureAPI.isAlive(_this->CGdFigure, target.entity_index))
            {
                uint16_t weapon_id = _this->CGdFigure->figures[source_index].equipment[(action.type != 10000) * 2 + 1];
                // can't make heads or tails here
                uint32_t puVar15[2];
                g_getWeaponEffects(_this->CGdResource, puVar15, weapon_id);
                if (puVar15[0] != 0)
                {
                    for (int i = 0; i < 3; i++)
                    {
                        uint16_t enchant_id = *(uint16_t *)((uint32_t)(&puVar15[0]) + i * 2 + 2);
 
                        if (enchant_id == 0)
                            break;
                        SF_CGdResourceSpell spell_data;
                        spellAPI.getResourceSpellData(_this->CGdResource, &spell_data, enchant_id);
 
/*
                        uint16_t curr_dex = getCurrentDex(_this->CGdFigure, source_index);
                        uint16_t curr_int = getCurrentInt(_this->CGdFigure, source_index);
                        uint16_t chance = get_effect_chance(curr_dex, curr_int, spell_data.spell_line_id);
 */
 
                        enchant_handler_ptr chance_handler =  get_enchant_handler(spell_data.spell_line_id);
                        uint32_t chance = chance_handler(_this->CGdFigure, source_index);
                        if (spellAPI.getRandom(_this->OpaqueClass, 10000) < chance)
                        {
                            if ((_this->CGdFigure->figures[source_index].race != 0) &&
                                (_this->CGdFigure->figures[source_index].race < 7))
                            {
                                if (_this->CGdFigure->figures[source_index].owner != 0)
                                {
                                    enchant_id = spellAPI.getLeveledSpellID(_this->CGdResource, enchant_id,
                                                                            _this->CGdFigure->figures[source_index].
                                                                            level);
                                }
                            }
                            if (enchant_id != 0)
                            {
                                // FIXME reflect enchants as well in riposte set handler;
                                SF_CGdTargetData source;
                                source.entity_type = 1;
                                source.entity_index = source_index;
                                source.position = {0, 0};
                                spellAPI.addSpell(_this->CGdSpell, enchant_id, _this->OpaqueClass->current_step,
                                                  &source, &target, 0);
                            }
                        }
                    }
                }
            }
        }
    }
    if (target.entity_type == 2)
    {
        uint16_t damage = g_get_reduced_building_damage(_this->AutoClass34, source_index, target.entity_index,
                                                        weapon_damage);
        if ((target.entity_index != 0) && (_this->CGdBuilding->buildings[target.entity_index].health_current != 0))
        {
            buildingAPI.buildingDealDamage(_this->CGdBuildingToolBox, source_index, target.entity_index, damage, 0);
        }
    }
    if (target.entity_type == 3)
    {
        if (target.entity_index != 0)
        {
            uint32_t value_1 = g_FUN_0071d7b0(_this->CGdObject, target.entity_index);
            if ((value_1 != 0) && (g_FUN_00755180(value_1) != 0))
            {
                g_objectDealDamage(_this->CGdObjectToolBox, source_index, target.entity_index, weapon_damage, 0);
            }
        }
    }
}