From d7fa7ea64f6bb0bc0b097e4bf1ceb4bd9620d0da Mon Sep 17 00:00:00 2001 From: Erik Schilling Date: Wed, 10 Apr 2013 23:04:42 +0200 Subject: Converted Being into a Component I did not really care too much about staying consistent with the use of static_casts to Actors since they are only temporary anyway until Actor is a component too. --- src/game-server/combatcomponent.cpp | 67 +++++++++++++++++++++---------------- 1 file changed, 38 insertions(+), 29 deletions(-) (limited to 'src/game-server/combatcomponent.cpp') diff --git a/src/game-server/combatcomponent.cpp b/src/game-server/combatcomponent.cpp index d71f86a3..df2d034d 100644 --- a/src/game-server/combatcomponent.cpp +++ b/src/game-server/combatcomponent.cpp @@ -25,12 +25,12 @@ #include "utils/logger.h" -CombatComponent::CombatComponent(Being &being): - mTarget(0), - mCurrentAttack(0) +CombatComponent::CombatComponent(Entity &being): + mTarget(nullptr), + mCurrentAttack(nullptr) { - being.signal_died.connect(sigc::mem_fun(this, - &CombatComponent::diedOrRemoved)); + being.getComponent()->signal_died.connect(sigc::mem_fun( + this, &CombatComponent::diedOrRemoved)); being.signal_removed.connect(sigc::mem_fun(this, &CombatComponent::diedOrRemoved)); } @@ -44,10 +44,11 @@ void CombatComponent::update(Entity &entity) // Temporary for as long as Being is not split into Components // Prevents to implement all at once // TODO: remove this as soon as possible - Being &being = static_cast(entity); + Actor &actor = static_cast(entity); + auto *beingComponent = entity.getComponent(); - if (being.getAction() != ATTACK || !mTarget) + if (beingComponent->getAction() != ATTACK || !mTarget) return; std::vector attacksReady; @@ -55,7 +56,7 @@ void CombatComponent::update(Entity &entity) if (Attack *triggerableAttack = mAttacks.getTriggerableAttack()) { - processAttack(being, *triggerableAttack); + processAttack(entity, *triggerableAttack); mAttacks.markAttackAsTriggered(); } @@ -69,11 +70,11 @@ void CombatComponent::update(Entity &entity) it_end = attacksReady.end(); it != it_end; ++it) { // check if target is in range using the pythagorean theorem - int distx = being.getPosition().x - mTarget->getPosition().x; - int disty = being.getPosition().y - mTarget->getPosition().y; + int distx = actor.getPosition().x - mTarget->getPosition().x; + int disty = actor.getPosition().y - mTarget->getPosition().y; int distSquare = (distx * distx + disty * disty); AttackInfo *info = (*it)->getAttackInfo(); - int maxDist = info->getDamage().range + being.getSize(); + int maxDist = info->getDamage().range + actor.getSize(); if (distSquare <= maxDist * maxDist && (!highestPriorityAttack || @@ -87,9 +88,9 @@ void CombatComponent::update(Entity &entity) { mAttacks.startAttack(highestPriorityAttack); mCurrentAttack = highestPriorityAttack; - being.setDestination(being.getPosition()); + beingComponent->setDestination(entity, actor.getPosition()); // TODO: Turn into direction of enemy - being.raiseUpdateFlags(UPDATEFLAG_ATTACK); + actor.raiseUpdateFlags(UPDATEFLAG_ATTACK); } } @@ -98,8 +99,12 @@ void CombatComponent::update(Entity &entity) * stats, deducts the result from the hitpoints and adds the result to * the HitsTaken list. */ -int CombatComponent::damage(Being &target, Being *source, const Damage &damage) +int CombatComponent::damage(Entity &target, + Entity *source, + const Damage &damage) { + auto *beingComponent = target.getComponent(); + int HPloss = damage.base; if (damage.delta) HPloss += rand() * (damage.delta + 1) / RAND_MAX; @@ -108,8 +113,10 @@ int CombatComponent::damage(Being &target, Being *source, const Damage &damage) switch (damage.type) { case DAMAGE_PHYSICAL: - if (!damage.trueStrike && - rand()%((int) target.getModifiedAttribute(ATTR_DODGE) + 1) > + { + const double dodge = + beingComponent->getModifiedAttribute(ATTR_DODGE); + if (!damage.trueStrike && rand()%((int)dodge + 1) > rand()%(damage.cth + 1)) { HPloss = 0; @@ -118,18 +125,19 @@ int CombatComponent::damage(Being &target, Being *source, const Damage &damage) } else { - HPloss = HPloss * (1.0 - (0.0159375f * - target.getModifiedAttribute(ATTR_DEFENSE)) / - (1.0 + 0.017 * - target.getModifiedAttribute(ATTR_DEFENSE))) + - (rand()%((HPloss >> 4) + 1)); + const double defense = + beingComponent->getModifiedAttribute(ATTR_DEFENSE); + HPloss = HPloss * (1.0 - (0.0159375f * defense) / + (1.0 + 0.017 * defense)) + + (rand()%((HPloss / 16) + 1)); // TODO Process triggers for receiving damage here. // If there is an attacker included, also process triggers for the attacker (successful physical strike) } break; + } case DAMAGE_MAGICAL: #if 0 - target.getModifiedAttribute(BASE_ELEM_BEGIN + damage.element); + beingComponent.getModifiedAttribute(BASE_ELEM_BEGIN + damage.element); #else LOG_WARN("Attempt to use magical type damage! This has not been" "implemented yet and should not be used!"); @@ -146,12 +154,13 @@ int CombatComponent::damage(Being &target, Being *source, const Damage &damage) if (HPloss > 0) { mHitsTaken.push_back(HPloss); - const Attribute *HP = target.getAttribute(ATTR_HP); - LOG_DEBUG("Being " << target.getPublicID() << " suffered " << HPloss + const Attribute *HP = beingComponent->getAttribute(ATTR_HP); + LOG_DEBUG("Being " << static_cast(target).getPublicID() + << " suffered " << HPloss << " damage. HP: " << HP->getModifiedAttribute() << "/" - << target.getModifiedAttribute(ATTR_MAX_HP)); - target.setAttribute(ATTR_HP, HP->getBase() - HPloss); + << beingComponent->getModifiedAttribute(ATTR_MAX_HP)); + beingComponent->setAttribute(target, ATTR_HP, HP->getBase() - HPloss); // No HP regen after being hit if this is set. // TODO: Reenable this once the attributes are available as a component // A bit too fuzzy to implement at the moment @@ -170,7 +179,7 @@ int CombatComponent::damage(Being &target, Being *source, const Damage &damage) /** * Performs an attack */ -void CombatComponent::processAttack(Being &source, Attack &attack) +void CombatComponent::processAttack(Entity &source, Attack &attack) { performAttack(source, attack.getAttackInfo()->getDamage()); } @@ -194,12 +203,12 @@ void CombatComponent::removeAttack(AttackInfo *attackInfo) /** * Performs an attack. */ -int CombatComponent::performAttack(Being &source, const Damage &dmg) +int CombatComponent::performAttack(Entity &source, const Damage &dmg) { // check target legality if (!mTarget || mTarget == &source - || mTarget->getAction() == DEAD + || mTarget->getComponent()->getAction() == DEAD || !mTarget->canFight()) return -1; -- cgit v1.2.3-60-g2f50