ent.cpp

Go to the documentation of this file.

/*
 * ent.cpp
 *
 *  Created on: Dec 18, 2011
 *      Author: sushil
 */

#include <iostream>
#include <assert.h>
#include <ent.h>
#include <engine.h>
#include <aspect.h>
#include <command.h>
#include "DEBUG.h"

int FastEcslent::Entity::count = 0;

void FastEcslent::Entity::print(){
        DEBUG(std::cout << "Id: " << entityId.id << ", instanceId: " << engine->instanceId << std::endl;)
        DEBUG(std::cout << "UIName " << uiname << ", meshName: " << meshName << std::endl;)
        DEBUG(std::cout << "Position: " << pos.x << ", " << pos.y << ", " << pos.z << std::endl;)
        DEBUG(std::cout << "Velocity: " << vel.x << ", " << vel.y << ", " << vel.z << std::endl;)
        DEBUG(std::cout << "Accelert: " << acc.x << ", " << acc.y << ", " << acc.z << std::endl;)
        DEBUG(std::cout << "Speed:    " << speed << std::endl;)
        DEBUG(std::cout << "Heading:  " << heading << std::endl;)
        DEBUG(std::cout << "dsrdSpd:  " << desiredSpeed << std::endl;)
        DEBUG(std::cout << "dsrdHdg:  " << desiredHeading << std::endl;)
        DEBUG(std::cout << "yaw:      " << yaw << std::endl;)
        DEBUG(std::cout << "selected: " << isSelected << std::endl;)
        DEBUG(std::cout << "-------------------------------------------------------------------" << std::endl;)
}


void FastEcslent::Entity::reset(){
        //FastEcslent::Entity::tick = &FastEcslent::Entity::gestatingTick;
        //this->tick = &FastEcslent::Entity::gestatingTick;
        //tic = &FastEcslent::Entity::gestatingTick;
        pos = Ogre::Vector3(0.0f, 0.0f, 0.0f);
        vel = Ogre::Vector3(0.0f, 0.0f, 0.0f);
        acc = Ogre::Vector3(0.0f, 0.0f, 0.0f);
        maxSpeed = 40.0f;
        minSpeed = -10.0f;
        speedRange = maxSpeed - minSpeed;
        rot = Ogre::Quaternion(Ogre::Radian(0.0f), Ogre::Vector3::UNIT_Y);
        maxAcceleration = 1.0f;

        yaw = 0.0f;
        maxRotationalSpeed = 0.1;
        desiredSpeed = 0.0f;
        desiredHeading = 0.0f;
        speed = 0.0f;
        heading = 0.0f;
        //entityType = CIGARETTE;
        //alive = true;
        selectable = false;

        turningRadius = 10000;

        //selection
        isSelected = false;

        entityId.side = BATTLEMASTER;
        entityId.player = ONE;
        entityClass   = SURFACE;
        entityState   = ALIVE;
        gestationPeriod = 10.0;
        timeLeftToBirth = 10.0;
        timeLeftToDie   = 10.0;

        /*
        preReqs.neededResources.gas = 0;
        preReqs.neededResources.minerals = 50;
        preReqs.neededResources.supply = 1;

        preReqs.neededTypes[0] = BARRACKS;
        preReqs.nNeededTypes = 1;
*/

        aspects.clear();

}

FastEcslent::Entity::Entity(Engine *eng, EntityType entType) {

        engine = eng;
        //entityId.id = id;
        entityType = entType;
        meshName = "cigarette.mesh";
        uiname = "Cigarette";
        //uiname.append(boost::lexical_cast<std::string>(count++));
        reset();
}






// There should only be one aspect of each type

/*int FastEcslent::Entity::addAspect(Aspect *asp) {
        aspects[nAspects++] = asp;
        return nAspects - 1;
}*/
void FastEcslent::Entity::init(){

        for (int aType = 0; aType < NASPECTTYPES; aType++){ // the problem with enums in C++n
                switch (aType){
                case (PHYSICS):
                        physics = new Physics2D2(this, PHYSICS);
                        physics->init();
                        this->addAspect(physics);
                        break;
                case (UNITAI):
                        ai = new UnitAI(this, UNITAI);
                        ai->init();
                    this->addAspect(ai);
                        break;
                case (WEAPON):
                        weapon = new Weapon(this, WEAPON, RIFLE);
                        weapon->init();
                        this->addAspect(weapon);
                        break;
                case (NET):
                        if(this->engine->options.enableNetworking && this->entityClass == SURFACE){
                                netAspect = new NetAspect(this, NET);
                                netAspect->init();
                                this->addAspect(netAspect);
                        }
                        break;
                }
                //this->addAspect(asp);
        }


        this->gestationPeriod = this->engine->gameMgr->entTypeData[this->entityType].buildTime;

}

bool FastEcslent::Entity::sinking(double dt){
        this->timeLeftToDie -= dt;
        this->pos.y = -(-this->height  + (this->height * (this->gestationPeriod - this->timeLeftToDie)/this->gestationPeriod));
        if (this->timeLeftToDie <= 0.0) {
                //this->entityState = FastEcslent::DEAD;
                this->switchState(DEAD);
                //this->pos.y = -2 * this->height;
                this->pos.y = -100000.0;
                return false;
        }

        return true;
}

bool FastEcslent::Entity::raising(double dt){
        this->timeLeftToBirth -= dt;
        this->pos.y = -this->height  + (this->height * (this->gestationPeriod - this->timeLeftToBirth)/this->gestationPeriod);
        if (this->timeLeftToBirth <= 0.0) {
                this->switchState(ALIVE);
                //this->entityState = FastEcslent::ALIVE;
                //this->engine->entityMgr->addEntity(this);
                this->pos.y = 0.0f;
                return false;
        }
        return true;
}

void FastEcslent::Entity::addAspect(UnitAspect *asp) {
        aspects.push_back(asp);
}

FastEcslent::UnitAspect* FastEcslent::Entity::getAspect(UnitAspectType at) {
        for (std::deque<UnitAspect*>::iterator it = aspects.begin(); it != aspects.end(); it++){
                if ((*it)->aspectType == at)
                        return (*it);
        }
        return 0;
}

void FastEcslent::Entity::removeAspect(UnitAspectType at) {
        int index = -1;
        for (std::deque<UnitAspect*>::iterator it = aspects.begin(); it != aspects.end(); it++){
                index++;
                if ((*it)->aspectType == at) {
                        break;
                }
        }
        if(index >= 0 && index < (int) aspects.size()){
                aspects.erase(aspects.begin()+index);
        }
}

void FastEcslent::Entity::tick(double dt){
        switch(this->entityState) {
        case GESTATING:
                this->gestatingTick(dt);
                break;

        case ALIVE:
                this->aliveTick(dt);
                break;

        case DYING:
                //this->dyingTick(dt);
                break;

        case DEAD:
                //this->deadTick();
                break;

        default:

                break;
        }
}

void FastEcslent::Entity::switchState(EntityState newState){
        this->entityState = newState;
        if(newState == GESTATING) {
                this->timeLeftToBirth = this->engine->gameMgr->entTypeData[this->entityType].buildTime;//this->gestationPeriod;
        } else if (newState == DYING) {
                this->timeLeftToDie = this->engine->gameMgr->entTypeData[this->entityType].buildTime;//this->gestationPeriod;
        }
}

void FastEcslent::Entity::gestatingTick(double dt){
        boost::mutex::scoped_lock scoped_lock(entLock);
        if (!raising(dt)){ // entity rises up through the surface. Return true when done
                this->switchState(ALIVE);
        }
}

void FastEcslent::Entity::aliveTick(double dt){
        DEBUG(std::cout << "Ent: " << this->uiname << " EntityState: " << this->entityState << std::endl;)
        boost::mutex::scoped_lock scoped_lock(entLock);
        for (std::deque<UnitAspect*>::iterator it = aspects.begin(); it != aspects.end(); it++){
                (*it)->tick(dt);
        }
}

void FastEcslent::Entity::dyingTick(double dt){
        boost::mutex::scoped_lock scoped_lock(entLock);
        if (!sinking(dt)) { //entity sinks. Returns true when sunk below surface of water
                this->switchState(DEAD);
        }
}

void FastEcslent::Entity::deadTick(double dt){
        return;
}

---