Horizon::Zone::Combat Class Reference

#include <Combat.hpp>

Public Member Functions
	Combat (std::shared_ptr< Unit > unit, std::shared_ptr< Unit > target)
	~Combat ()
std::shared_ptr< Unit >	unit () const
std::shared_ptr< Unit >	target () const
combat_retaliate_type	weapon_attack ()
int64_t	calculate_weapon_defense (int64_t damage)
int64_t	calculate_magic_defense (int64_t damage)
combat_damage	calculate_weapon_attack ()
combat_damage	calculate_magic_attack ()
combat_damage	calculate_misc_attack ()
int64_t	deduce_weapon_element_attack (int64_t damage, element_type def_ele, item_equip_location_index loc)
int64_t	deduce_damage_size_modifier (int64_t damage, item_equip_location_index loc)

Private Attributes
time_t	_start_time {0}
std::weak_ptr< Unit >	_unit
std::weak_ptr< Unit >	_target

Constructor & Destructor Documentation

Combat()

Combat::Combat ( std::shared_ptr< Unit >  unit, std::shared_ptr< Unit >  target  )

explicit

: _unit(unit), _target(target), _start_time(std::time(nullptr))
{
}

~Combat()

Combat::~Combat

(

)

{
}

Member Function Documentation

calculate_magic_attack()

combat_damage Combat::calculate_magic_attack

(

)

{
    combat_damage dmg;
    if (unit()->type() == UNIT_PLAYER) {
        EquipmentListType const& equipments = unit()->downcast<Horizon::Zone::Units::Player>()->inventory()->equipments();
        std::shared_ptr<const item_entry_data> weapon_right = nullptr;
    }
 
    int magic_atk = unit()->status()->equip_matk()->get_min() + std::rand() % (unit()->status()->equip_matk()->get_max() - unit()->status()->equip_matk()->get_min());
 
    dmg.right_damage = magic_atk;
 
    dmg.right_damage -= calculate_magic_defense(dmg.right_damage);
    
    return dmg;
}

References calculate_magic_defense(), combat_damage::right_damage, unit(), and UNIT_PLAYER.

Here is the call graph for this function:

calculate_magic_defense()

int64_t Combat::calculate_magic_defense

(

int64_t

damage

)

{
    return (int)((100.0f - target()->status()->hard_mdef()->total() / (target()->status()->hard_mdef()->total() + 100.0f) * 90.0f) / 100.0f * damage - target()->status()->soft_mdef()->total()); 
}

References target().

Referenced by calculate_magic_attack().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_misc_attack()

combat_damage Combat::calculate_misc_attack

(

)

{
    combat_damage dmg;
    return dmg;
}

calculate_weapon_attack()

combat_damage Combat::calculate_weapon_attack

(

)

{
    combat_damage dmg;
    
    if (unit()->type() == UNIT_PLAYER) {
        EquipmentListType const& equipments = unit()->downcast<Horizon::Zone::Units::Player>()->inventory()->equipments();
 
        // Calculate element damage ratio and damage.
        int64_t batk = unit()->status()->base_attack()->total();
 
        if (unit()->type() == UNIT_PLAYER) {
            std::shared_ptr<const item_entry_data> weapon_right = nullptr, weapon_left = nullptr;
 
            std::function<bool(item_weapon_type)> is_ranged_weapon = [](item_weapon_type weapon_type) -> bool {
                switch (weapon_type) {
                    case IT_WT_BOW:
                    case IT_WT_MUSICAL:
                    case IT_WT_WHIP:
                    case IT_WT_REVOLVER:
                    case IT_WT_RIFLE:
                    case IT_WT_GATLING:
                    case IT_WT_SHOTGUN:
                    case IT_WT_GRENADE:
                        return true;
                    default:
                        break;
                }
 
                return false;
            };
 
            if (equipments[IT_EQPI_HAND_R].second.expired() == false) {
                int64_t status_atk_min = 0, status_atk_max = 0;
                float bonus = 0.00f, variance = 0.00f;
                batk = deduce_weapon_element_attack(batk, ELE_NEUTRAL, IT_EQPI_HAND_R);
                batk = deduce_damage_size_modifier(batk, IT_EQPI_HAND_R);
                dmg.right_damage = (batk << 1);
                weapon_right = equipments[IT_EQPI_HAND_R].second.lock();
                if (is_ranged_weapon(weapon_right->config->sub_type.weapon_t)) {
                    bonus = unit()->status()->weapon_attack_right()->total() * unit()->status()->dexterity()->total() / 100.00f;
                } else {
                    bonus = unit()->status()->weapon_attack_right()->total() * unit()->status()->strength()->total() / 100.00f;
                }
                variance = 5.0f * unit()->status()->weapon_attack_right()->total() * weapon_right->config->level.weapon / 100.00f;
                status_atk_min = unit()->status()->weapon_attack_right()->total() - variance + bonus;
                status_atk_max = unit()->status()->weapon_attack_right()->total() + variance + bonus;
                dmg.right_damage += (status_atk_max > status_atk_min) ? status_atk_min + std::rand() % (status_atk_max - status_atk_min + 1) : status_atk_min;
            }
 
            if (equipments[IT_EQPI_HAND_L].second.expired() == false) {
                int64_t status_atk_min = 0, status_atk_max = 0;
                float bonus = 0.00f, variance = 0.00f;
                batk = deduce_weapon_element_attack(batk, ELE_NEUTRAL, IT_EQPI_HAND_L);
                batk = deduce_damage_size_modifier(batk, IT_EQPI_HAND_L);
                dmg.left_damage = batk;
                weapon_left = equipments[IT_EQPI_HAND_L].second.lock();
                if (is_ranged_weapon(weapon_left->config->sub_type.weapon_t)) {
                    bonus = unit()->status()->weapon_attack_left()->total() * unit()->status()->dexterity()->total() / 100.00f;
                } else {
                    bonus = unit()->status()->weapon_attack_left()->total() * unit()->status()->strength()->total() / 100.00f;
                }
                variance = 5.0f * unit()->status()->weapon_attack_left()->total() * weapon_left->config->level.weapon / 100.00f;
                status_atk_min = unit()->status()->weapon_attack_left()->total() - variance + bonus;
                status_atk_max = unit()->status()->weapon_attack_left()->total() + variance + bonus;
                dmg.left_damage += (status_atk_max > status_atk_min) ? status_atk_min + std::rand() % (status_atk_max - status_atk_min + 1) : status_atk_min;
            }
        }
    } else {
        dmg.right_damage = (std::rand() % unit()->status()->creature_attack_damage()->get_min()) + (unit()->status()->creature_attack_damage()->get_max() - unit()->status()->creature_attack_damage()->get_min());
        int64_t status_atk_min = 0, status_atk_max = 0;
        status_atk_min = dmg.right_damage * 80 / 100;
        status_atk_max = dmg.right_damage * 120 / 100;
        dmg.right_damage += (status_atk_max > status_atk_min) ? status_atk_min + std::rand() % (status_atk_max - status_atk_min + 1) : status_atk_min;
    }
 
    int target_flee = target()->status()->flee()->total();
    bool hit = (std::rand() % 100) < (unit()->status()->hit()->total() - target_flee);
 
    if (dmg.left_damage)
        dmg.left_damage = calculate_weapon_defense(dmg.left_damage);
    
    dmg.right_damage = calculate_weapon_defense(dmg.right_damage);
 
    int damage_total = dmg.left_damage + dmg.right_damage;
 
    if (dmg.left_damage < 0)
        dmg.left_damage = 0;
    if (dmg.right_damage < 0)
        dmg.right_damage = 0;
        
    if (damage_total < 0) {
        damage_total = 0;
    }
 
    int cri = unit()->status()->crit()->total();
 
    cri -= target()->status()->base_level()->total() / 15 + 2 * target()->status()->luck()->total();
 
    dmg.is_critical = (std::rand() % 1000 < cri) ? true : false;
    
    if (dmg.is_critical) {
        hit = true;
        dmg.left_damage += dmg.left_damage * 40 / 100;
        dmg.right_damage += dmg.right_damage * 40 / 100;
    }
 
    if (hit) {
        dmg.result = combat_retaliate_type::CBT_RET_DEF;
    } else {
        dmg.result = combat_retaliate_type::CBT_RET_FLEE;
        dmg.left_damage = 0;
        dmg.right_damage = 0;
        damage_total = 0;
    }
 
    if (!hit) {
        dmg.number_of_hits *= -1;
    } else {
        if (dmg.left_damage > 0)
            dmg.number_of_hits = 2;
        else
            dmg.number_of_hits = 1;
    }
 
    return dmg;
}

References calculate_weapon_defense(), CBT_RET_DEF, CBT_RET_FLEE, deduce_damage_size_modifier(), deduce_weapon_element_attack(), ELE_NEUTRAL, combat_damage::is_critical, IT_EQPI_HAND_L, IT_EQPI_HAND_R, IT_WT_BOW, IT_WT_GATLING, IT_WT_GRENADE, IT_WT_MUSICAL, IT_WT_REVOLVER, IT_WT_RIFLE, IT_WT_SHOTGUN, IT_WT_WHIP, combat_damage::left_damage, combat_damage::number_of_hits, combat_damage::result, combat_damage::right_damage, target(), unit(), and UNIT_PLAYER.

Referenced by weapon_attack().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_weapon_defense()

int64_t Combat::calculate_weapon_defense

(

int64_t

damage

)

{
    return (int)((100.0f - target()->status()->soft_def()->total() / (target()->status()->soft_def()->total() + 400.0f) * 90.0f) / 100.0f * damage - target()->status()->hard_def()->total());
}

References target().

Referenced by calculate_weapon_attack().

Here is the call graph for this function:

Here is the caller graph for this function:

deduce_damage_size_modifier()

int64_t Combat::deduce_damage_size_modifier	(	int64_t	damage,
		item_equip_location_index	loc
	)

{
    if (unit()->type() == UNIT_PLAYER) {
        EquipmentListType const &equipments = unit()->downcast<Horizon::Zone::Units::Player>()->inventory()->equipments();
        std::shared_ptr<const item_entry_data> weapon = nullptr;
 
        if (equipments[loc].second.expired())
            return damage;
 
        weapon = equipments[loc].second.lock();
 
        if (loc == IT_EQPI_HAND_R || loc == IT_EQPI_HAND_L) 
            return damage; // not a weapon.
 
        std::shared_ptr<const item_config_data> weapond = ItemDB->get_item_by_id(weapon->item_id);
 
        if (weapond == nullptr) {
            HLog(warning) << "Combat::deduce_weapon_element_attack: could not find item config of right hand weapon ID: " << weapon->item_id << ". ignoring..." ;
            return damage;
        }
 
        int32_t size_damage_ratio = ItemDB->get_weapon_target_size_modifier(weapond->sub_type.weapon_t, (unit_size_type) unit()->status()->size()->get_base());
 
        damage += (size_damage_ratio < 100 ? -(damage * (size_damage_ratio - 100) / 100) : (damage * (size_damage_ratio - 100) / 100));
    }
 
    return damage;
}

References HLog, IT_EQPI_HAND_L, IT_EQPI_HAND_R, ItemDB, unit(), and UNIT_PLAYER.

Referenced by calculate_weapon_attack().

Here is the call graph for this function:

Here is the caller graph for this function:

deduce_weapon_element_attack()

int64_t Combat::deduce_weapon_element_attack	(	int64_t	damage,
		element_type	def_ele,
		item_equip_location_index	loc
	)

{
    if (unit()->type() == UNIT_PLAYER) {
        EquipmentListType const &equipments = unit()->downcast<Horizon::Zone::Units::Player>()->inventory()->equipments();
        std::shared_ptr<const item_entry_data> weapon = nullptr;
 
        if (equipments[loc].second.expired())
            return damage;
 
        weapon = equipments[loc].second.lock();
 
        if (loc != IT_EQPI_HAND_R || loc != IT_EQPI_HAND_L)
            return damage; // not a weapon.
 
        std::shared_ptr<const item_config_data> weapond = ItemDB->get_item_by_id(weapon->item_id);
 
        if (weapond == nullptr) {
            HLog(warning) << "Combat::deduce_weapon_element_attack: could not find item config of right hand weapon ID: " << weapon->item_id << ". ignoring..." ;
            return damage;
        }
 
        int32_t attribute_damage_ratio = ItemDB->get_weapon_attribute_modifier(weapond->level.weapon, ELE_NEUTRAL, def_ele);
 
        damage += (attribute_damage_ratio < 100 ? -(damage * (attribute_damage_ratio - 100) / 100) : (damage * (attribute_damage_ratio - 100) / 100));
    }
 
    return damage;
}

References ELE_NEUTRAL, HLog, IT_EQPI_HAND_L, IT_EQPI_HAND_R, ItemDB, unit(), and UNIT_PLAYER.

Referenced by calculate_weapon_attack().

Here is the call graph for this function:

Here is the caller graph for this function:

target()

std::shared_ptr< Unit > Horizon::Zone::Combat::target ( ) const

inline

{ return _target.lock(); }

References _target.

Referenced by calculate_magic_defense(), calculate_weapon_attack(), calculate_weapon_defense(), Horizon::Zone::UnitComponent::sync_data_types(), and weapon_attack().

Here is the caller graph for this function:

unit()

std::shared_ptr< Unit > Horizon::Zone::Combat::unit ( ) const

inline

{ return _unit.lock(); }

References _unit.

Referenced by calculate_magic_attack(), calculate_weapon_attack(), deduce_damage_size_modifier(), deduce_weapon_element_attack(), Horizon::Zone::UnitComponent::sync_data_types(), and weapon_attack().

Here is the caller graph for this function:

weapon_attack()

combat_retaliate_type Combat::weapon_attack

(

)

{
    combat_damage dmg = calculate_weapon_attack();
    
    int64_t damage_total = dmg.left_damage + dmg.right_damage;
    
    CombatRegistry::MeleeResultOperation::MeleeResultOperand *melee_operand = new CombatRegistry::MeleeResultOperation::MeleeResultOperand(unit(), target());
    CombatRegistry::CombatValueDamage *melee_value = new CombatRegistry::CombatValueDamage(dmg);
    CombatRegistry::MeleeResultOperation *melee_operation = new CombatRegistry::MeleeResultOperation(melee_operand, CombatRegistry::MeleeResultOperation::melee_result_operation_type::MELEE_RESULT_OPERATION_DAMAGE, melee_value);
 
    CombatRegistry::AttributeOperation::AttributeOperand *attr_operand = new CombatRegistry::AttributeOperation::AttributeOperand(unit(), target(), target()->status()->current_hp());
    CombatRegistry::CombatValueInteger *attr_value = new CombatRegistry::CombatValueInteger(damage_total);
    CombatRegistry::AttributeOperation *attr_operation = new CombatRegistry::AttributeOperation(attr_operand, CombatRegistry::AttributeOperation::attribute_operation_type::ATTRIBUTE_OPERATION_SUBTRACT_FROM_BASE, attr_value);
    
    int time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
    CombatRegistry::CombatStage *stage = new CombatRegistry::CombatStage(time);
    stage->add_operation(melee_operation);
    stage->add_operation(attr_operation);
    unit()->combat_registry()->queue_combat_stage(stage);
 
    return dmg.result;
}

References Horizon::Zone::CombatRegistry::CombatStage::add_operation(), calculate_weapon_attack(), combat_damage::left_damage, combat_damage::result, combat_damage::right_damage, target(), and unit().

Here is the call graph for this function:

Member Data Documentation

_start_time

time_t Horizon::Zone::Combat::_start_time {0}

private

_target

std::weak_ptr<Unit> Horizon::Zone::Combat::_target

private

Referenced by target().

_unit

std::weak_ptr<Unit> Horizon::Zone::Combat::_unit

private

Referenced by unit().

---

The documentation for this class was generated from the following files:

• src/Server/Zone/Game/Units/Battle/Combat.hpp
• src/Server/Zone/Game/Units/Battle/Combat.cpp