unitWeapons.cpp

Go to the documentation of this file.

/*
 * weapon.cpp
 *
 *  Created on: Feb 28, 2012
 *      Author: sushil
 */
#include <ent.h>
#include <engine.h>
#include <distanceMgr.h>
#include "unitWeapons.h"
#include "DEBUG.h"

using namespace Ogre;

FastEcslent::Weapon::Weapon(Entity* ent, UnitAspectType ast,const WeaponType *wtype): UnitAspect(ent, ast) {
        weaponType = wtype;
        init();
}

FastEcslent::Weapon::Weapon(Entity* ent, UnitAspectType ast): UnitAspect(ent, ast) {
        init();
}

void FastEcslent::Weapon::init(){
        distanceMgr = this->entity->engine->distanceMgr;
        weaponMgr   = this->entity->engine->weaponMgr;
        weaponType = weaponMgr->weaponType[this->entity->entityType];

        this->entity->hitpoints = weaponMgr->maxHitpoints[this->entity->entityType];
        armor     = weaponMgr->initArmor[this->entity->entityType];
        damageMultiplier =  weaponMgr->initDamageMultiplier[this->entity->entityType];

        m_cooldown = 0;
        STANDSTILL = 10;
        m_onfire = 0;
        BEINGATTACKED = 100;
        m_beingAttacked = 0;
}


void FastEcslent::Weapon::tick(double dt) {
        if(m_beingAttacked > 0){
                m_beingAttacked -=dt;
        }

        //onfile stand still
        if(m_onfire > 0){
                m_onfire -= dt;
                this->entity->speed = 0;
                return;
        }

        if(m_cooldown <= 0 && distanceMgr->closestEnemyDistance[this->entity->entityId.id] < this->weaponType->maxRange()){//weaponMgr->range[weaponType]){
                target.entity = this->entity->engine->entityMgr->ents[distanceMgr->closestEnemy[this->entity->entityId.id]];
                if (target.entity->entityState == FastEcslent::ALIVE){
                        if(this->weaponType->explosionType() == FastEcslent::ExplosionTypes::Enemy_Splash){
                                dealEnemySplashDamageToTarget(target,dt,this->weaponType->outerSplashRadius());  //radius splash damage
                        }else if(this->weaponType->explosionType() == FastEcslent::ExplosionTypes::Enemy_Line_Splash){
                                dealLineSplashDamageToTarget(target, dt, this->weaponType->outerSplashRadius(), this->weaponType->innerSplashRadius());                //line splash damage
                        }else {
                                dealDamageToTarget(target, dt);
                        }
                }
//              DEBUG(std::cout << "Entity: " << entity->entityId.id << ", Side: " << entity->entityId.side << " dealing : " << dealDamageToTarget(target, dt)
//                              << " to TargetEntity:  " << target.entity->entityId.id << ", target's Side: " << target.entity->entityId.side << std::endl;)
        }else if(m_cooldown > 0){
                m_cooldown -= dt;
        }
}

void FastEcslent::Weapon::dealDamageToTarget(Target tgt, double dt){
        //double damage = weaponMgr->damageMap[entity->entityType][tgt.entity->entityType] * damageMultiplier;
        double damage = this->weaponType->damageAmount();//weaponMgr->damageMap[tgt.entity->entityType][weaponType] * damageMultiplier*WeaponMgr::DAMAGESCALER;
        tgt.entity->weapon->takeDamage(damage);
        m_cooldown = this->weaponType->damageCooldown();//weaponMgr->cooldown[this->entity->entityType] * WeaponMgr::COOLDOWNSCALER;
        this->m_onfire = STANDSTILL;
}

void FastEcslent::Weapon::dealEnemySplashDamageToTarget(Target tgt, double dt, double radius){
        //double damage = weaponMgr->damageMap[entity->entityType][tgt.entity->entityType] * damageMultiplier;
        double damage = this->weaponType->damageAmount();//weaponMgr->damageMap[tgt.entity->entityType][weaponType] * damageMultiplier*WeaponMgr::DAMAGESCALER;
        std::vector<FastEcslent::Entity*> ents = this->getUnitsInRadius(tgt.entity, radius, true);

        for(unsigned int i=0;i<ents.size();i++){
                ents[i]->weapon->takeDamage(damage);
        }

        DEBUG(std::cout<<"Deal enemy radius splash damage: hits: "<<ents.size()<< " units."<<std::endl;)

        m_cooldown = this->weaponType->damageCooldown();
        this->m_onfire = STANDSTILL;
}

void FastEcslent::Weapon::dealLineSplashDamageToTarget(Target tgt, double dt, double length, double width){
        double damage = this->weaponType->damageAmount();//weaponMgr->damageMap[tgt.entity->entityType][weaponType] * damageMultiplier*WeaponMgr::DAMAGESCALER;

        std::vector<FastEcslent::Entity*> ents = this->getUnitsInRectangle(this->entity, tgt.entity, length, width, true);
        for(unsigned int i=0;i<ents.size();i++){
                ents[i]->weapon->takeDamage(damage);
        }

        DEBUG(std::cout<<"Deal enemy line splash damage: hits: "<<ents.size()<< " units."<<std::endl;)

        m_cooldown = this->weaponType->damageCooldown();
        this->m_onfire = STANDSTILL;
}

void FastEcslent::Weapon::takeDamage(double amt) {
        if (this->entity->entityState == FastEcslent::ALIVE) {
                m_beingAttacked = BEINGATTACKED;
                this->entity->hitpoints -= amt * armor;
                if (this->entity->hitpoints <= 0){
                        this->entity->switchState(DYING);
                        this->entity->hitpoints = 0;
                }
        }
}
void FastEcslent::Weapon::takeDamage(double amt, double dt) {
        if (this->entity->entityState == FastEcslent::ALIVE) {
                this->entity->hitpoints -= amt * (armor) * dt;
                if (this->entity->hitpoints <= 0){
                        this->entity->switchState(DYING);
                        this->entity->hitpoints = 0;
                }
        }
}

std::vector<FastEcslent::Entity*> FastEcslent::Weapon::getUnitsInRadius(Entity* ent, double radius, bool enemyOnly){
        std::vector<FastEcslent::Entity*> ents;
        for (int i = 0; i < this->entity->engine->entityMgr->nEnts; i++){
                //ignore dead units
                if(this->entity->engine->entityMgr->ents[i]->entityState != ALIVE){
                        continue;
                }
                //ignore own units if we only do damage to enemy units
                if(enemyOnly && this->entity->engine->entityMgr->ents[i]->entityId.side == this->entity->entityId.side){
                        continue;
                }
                double distance = (ent->pos - this->entity->engine->entityMgr->ents[i]->pos).length();
                if(distance <= radius){
                        ents.push_back(this->entity->engine->entityMgr->ents[i]);
                }
        }
        return ents;
}

std::vector<FastEcslent::Entity*> FastEcslent::Weapon::getUnitsInRectangle(Entity* src, Entity* tgt, double length, double width, bool enemyOnly){
        Vector3 vec = tgt->pos - src->pos;
        Vector3 v1,v2,v3,v4;

        double xdelta = width/2 * sin(atan2(vec.z, vec.x));
        double zdelta = width/2 * cos(atan2(vec.z, vec.x));
        v1.x = src->pos.x - xdelta;
        v2.x = src->pos.x + xdelta;

        v1.z = src->pos.z + zdelta;
        v2.z = src->pos.z - zdelta;

        v3.x = v2.x + length* cos(atan2(vec.z, vec.x));
        v3.z = v2.z + length* sin(atan2(vec.z, vec.x));

        v4.x = v1.x + length* cos(atan2(vec.z, vec.x));
        v4.z = v1.z + length* sin(atan2(vec.z, vec.x));

        std::vector<FastEcslent::Entity*> ents;
        for (int i = 0; i < this->entity->engine->entityMgr->nEnts; i++){
                if(this->entity->engine->entityMgr->ents[i]->entityState != ALIVE){
                        continue;
                }
                //ignore own units if we only do damage to enemy units
                if(enemyOnly && this->entity->engine->entityMgr->ents[i]->entityId.side == this->entity->entityId.side){
                        continue;
                }

                if(this->isPointInRectangle(v1,v2,v3,v4, this->entity->engine->entityMgr->ents[i]->pos)){
                        ents.push_back(this->entity->engine->entityMgr->ents[i]);
                }
        }
        return ents;
}

bool FastEcslent::Weapon::isPointInRectangle(Ogre::Vector3 sp1, Ogre::Vector3 sp2, Ogre::Vector3 sp3, Ogre::Vector3 sp4, Ogre::Vector3 point){
        double areaRectangle = (sp1-sp2).length() * (sp2-sp3).length();
        double area1 = this->getAreaTriangle(sp1,sp2,point);
        double area2 = this->getAreaTriangle(sp2,sp3,point);
        double area3 = this->getAreaTriangle(sp3,sp4,point);
        double area4 = this->getAreaTriangle(sp4,sp1,point);
        double sum = area1+area2+area3+area4;
        if(sum - areaRectangle < 50){   // 5 is the deviation
                return true;
        }else {
                return false;
        }
}

double FastEcslent::Weapon::getAreaTriangle(Ogre::Vector3 tp1, Ogre::Vector3 tp2, Ogre::Vector3 tp3){
        double a = (tp1-tp2).length();
        double b = (tp2-tp3).length();
        double c = (tp3-tp1).length();
        double p = (a + b + c)/2;
        return sqrt(p*(p-a)*(p-b)*(p-c));
}

---