command.cpp

Go to the documentation of this file.

/*
 * command.cpp
 *
 *  Created on: Jan 9, 2012
 *      Author: sushil
 */

#include <const.h>
#include <ent.h>
#include <group.h>
#include <target.h>
#include <engine.h>
#include <OgreVector3.h>
#include "DEBUG.h"
#include "buildings.h"
#include "command.h"

//#include <command.h>
inline bool FastEcslent::Move::done() {
        return (entity->pos.squaredDistance((target->location)) <= entity->turningRadius);
}

void FastEcslent::Move::init(){
        Ogre::Vector3 diff = target->location - entity->pos;
        entity->desiredHeading = -atan2(diff.z, diff.x);
        entity->desiredSpeed = entity->maxSpeed;
        return;
}

inline void FastEcslent::Move::tick(double dt) {
        if(!done()) {
                relativePos = target->location - entity->pos;
                entity->desiredHeading = -atan2(relativePos.z, relativePos.x);
                entity->desiredSpeed = entity->maxSpeed;
        } else {
                entity->desiredSpeed = 0.0f;
        }
        return;
}

//Build for SCV building structures
//----------------------------------------------------------------------------
//inline bool FastEcslent::BuildStructure::done() {
//      return (entity->pos.squaredDistance((target->location)) <= entity->turningRadius);
//}
//
//void FastEcslent::BuildStructure::init(){
//      Ogre::Vector3 diff = target->location - entity->pos;
//      entity->desiredHeading = -atan2(diff.z, diff.x);
//      entity->desiredSpeed = entity->maxSpeed;
//      return;
//}
//
//inline void FastEcslent::BuildStructure::tick(double dt) {
//      if(!done()) {
//              relativePos = target->location - entity->pos;
//              entity->desiredHeading = -atan2(relativePos.z, relativePos.x);
//              entity->desiredSpeed = entity->maxSpeed;
//      } else {
//              entity->desiredSpeed = 0.0f;
//      }
//      return;
//}
//Build for structures
//------------------------------------------------------------------------------------------
inline void FastEcslent::BuildCommand::init()
{
    if(entity != NULL && entity->getAspect(BUILDER) != NULL)
    {
        //Building* structure = dynamic_cast<Building*>(entity);
        //structure->enqueue(type);
        //entity->getAspect(BUILDER);
        Builder* builder = dynamic_cast<Builder *> (entity->getAspect(BUILDER));
        //if(builder != NULL)
        //{
        builder->enqueue(entType);
        //}
    }
    isDone = true;
        

}
inline bool FastEcslent::BuildCommand::done(){
        return isDone;
}

inline void FastEcslent::BuildCommand::tick(double dt){
//    if(!isDone)
//        this->init();
}
//Gather for SCV
//------------------------------------------------------------------------------------------
inline void FastEcslent::Wait::init(){
        timeLeftToWait = target->waitTime;

}
inline bool FastEcslent::Wait::done(){
        return timeLeftToWait < 0.0;
}

inline void FastEcslent::Wait::tick(double dt){
        if(timeLeftToWait > 0) {
                timeLeftToWait -= dt;
        } else {
                DEBUG(std::cout << entity->uiname  << ": Done waiting" << std::endl;)
        }
}
//------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------
inline void FastEcslent::GasFieldCommand::init(){

}
inline bool FastEcslent::GasFieldCommand::done(){
    return false;
}

inline void FastEcslent::GasFieldCommand::tick(double dt){
    if(((FastEcslent::Gas*)this->entity)->refinary != NULL && ((FastEcslent::Gas*)this->entity)->refinary->entityState != FastEcslent::DEAD)
    {
        this->entity->selectable = false;
        this->entity->isSelected = false;
        ((FastEcslent::Gas*)this->entity)->refinary= NULL;
    }
    else
    {
        this->entity->selectable = true;
    }
}
//------------------------------------------------------------------------------------------


// Potential fields move for groups

inline bool FastEcslent::PotentialMove::done(){
        //preturn false;
        return (entity->pos.squaredDistance(target->location) <= (entity->turningRadius * entity->turningRadius)*10.0);// && (int) ((entity->attractivePotential)) > -15);
}

void FastEcslent::PotentialMove::init(){
        Ogre::Vector3 diff = target->location - entity->pos;
        entity->desiredSpeed = entity->maxSpeed;

}

inline void FastEcslent::PotentialMove::tick(double dt){
        int nEnts = entity->engine->entityMgr->nEnts;

        if (!done()){
                // compute force
                        double repulsivePotential = 0.0f;
                        entity->potentialVec = Ogre::Vector3::ZERO;
                        Ogre::Vector3 tmp;
                        int nInRange = 1; // at least one so that you don't multiply by 0 later
                        for (int i = 0; i < nEnts; i++){
                                if(i != entity->entityId.id){// repulsed by all other entities
                                        if (entity->engine->distanceMgr->distance[entity->entityId.id][i] < RepulsionThresholdDistance) { // Don't care about entities too far away
                                                nInRange += 1;
                                                tmp = (entity->engine->distanceMgr->normalizedDistanceVec[i][entity->entityId.id]);
                                                repulsivePotential =  (B * entity->engine->entityMgr->ents[i]->mass) / pow(entity->engine->distanceMgr->distance[entity->entityId.id][i], m);
                                                if(repulsivePotential  > INT_MAX){   //repulsive potential could be infinite
                                                        repulsivePotential = INT_MAX;
                                                }
                                                entity->potentialVec += (tmp * repulsivePotential);
                                        }
                                }
                        }
                        //attracted by target
                        tmp = (entity->pos - target->location);
                        //tmp = target->location - entity->pos;
                        double targetDistance = tmp.length();
                        entity->attractivePotential =  -(A ) / pow(targetDistance, n);// + (B) /pow (targetDistance, m);
                        entity->potentialVec += (tmp.normalisedCopy() * entity->attractivePotential * nInRange); // nInRange needs to be at least 1
                        //applyPotential(entity, potentialVec);

                        entity->desiredHeading = atan2(-entity->potentialVec.z, entity->potentialVec.x);

                        double cosDiffFrac = (1.0 - cos(entity->vel.angleBetween(entity->potentialVec).valueRadians()))/2.0;// between 0 and 2 divided by 2.0 gives something between 0 and 1
                        entity->desiredSpeed   = (entity->maxSpeed - entity->minSpeed) * (1.0 - cosDiffFrac);



                // apply force
        } else {
                DEBUG(std::cout << "Attractive Potential: " << entity->attractivePotential << std::endl;)
                entity->desiredSpeed = 0.0f;
                entity->desiredHeading = entity->heading;
        }
}




FastEcslent::Maintain::Maintain (Entity *ent, Target *tgt): UnitCommand(ent, MaintainCommand, tgt){
        if(valid(tgt->entity)) {
                DEBUG(std::cout << "Maintaining with respect to: " << tgt->entity->uiname << std::endl;)
                tgt->location = tgt->entity->pos + tgt->offset;
        }
}
bool FastEcslent::Maintain::valid(Entity *entity) {
        return true;
}

inline bool FastEcslent::Maintain::done() {
        return false;
}

void FastEcslent::Maintain::init(){

        if (kInvalidFloat == target->offsetDistance) { // offset must contain absolute position right now. Convert to offsetRot and offsetDistance
                Ogre::Quaternion q = Ogre::Vector3(cos(-target->entity->heading) * 100.0f, 0.0f, sin(-target->entity->heading) * 100.0f).getRotationTo(target->offset);
                target->offsetYaw = q.getYaw().valueRadians();
                target->offsetDistance = (target->entity->pos - target->offset).length();
                DEBUG(std::cout << "OffsetYaw: " << target->offsetYaw << " offsetDistance: " << target->offsetDistance << std::endl;)
        }
        return;
}

inline void FastEcslent::Maintain::tick(double dt) { //offsetRotation and offsetDistance set by init()
        target->offset = (target->entity->rot * Ogre::Quaternion(Ogre::Radian(target->offsetYaw), Ogre::Vector3::UNIT_Y)) * (Ogre::Vector3::UNIT_X * target->offsetDistance);
        target->location = target->entity->pos + target->offset;

        relativePos = target->location - entity->pos;
        relativeVel = target->entity->vel - entity->vel;
        relativeSpeed = relativeVel.length();
        predictedTimeToClose = relativePos.length()/relativeSpeed;
        predictedPos =  target->location + (target->entity->vel * predictedTimeToClose);
        interceptPos = predictedPos - entity->pos;

        entity->desiredHeading = -atan2(interceptPos.z, interceptPos.x);
        if ((relativeSpeed * predictedTimeToClose) > 30)
                entity->desiredSpeed = entity->maxSpeed;
        else
                entity->desiredSpeed = target->entity->speed;

        return;
}


void FastEcslent::Tactic::changeLeadership(LeadershipType selector){

        Ogre::Vector3 tpos;
        if(this->target->target.location == InvalidLocation){
                tpos = this->target->target.entity->pos;
        } else {
                tpos = this->target->target.location;
        }
        this->group->leaderIndex = 0;
        if (this->group->nEntitiesInGroup > 0) {
                switch(selector){
                case 0:
                        this->group->leaderIndex = closestToTarget(true, tpos);
                        break;
                case 2:
                        this->group->leaderIndex = closestToTarget(false, tpos); //furthest from target
                        break;
                case 3:
                        this->group->leaderIndex = mostMassive(true);
                        break;
                case 4:
                        this->group->leaderIndex = mostMassive(true);//smallest mass
                        break;
                case 5:
                        this->group->leaderIndex = randInt(0, this->group->nEntitiesInGroup);
                        break;
                default:
                        this->group->leaderIndex = 0;
                        break;
                }
        }

}


int FastEcslent::Tactic::mostMassive(bool massest){
        float minMass = 0;
        int minIndex = INT_MAX;
        float maxMass = 0;
        int maxIndex = 0;
        float mass;
        for (int i = 0; i < this->group->nEntitiesInGroup; i++){
                mass = this->group->members[i]->mass;
                if(mass < minMass){
                        minMass = mass;
                        minIndex = i;
                }
                if (mass > maxMass){
                        maxMass = mass;
                        maxIndex = i;
                }
        }
        if(!massest) {
                return minIndex;
        } else {
                return maxIndex;
        }

}


int FastEcslent::Tactic::closestToTarget(bool closest, Ogre::Vector3 tpos){
        //Entity** members = this->group->members;
                //int dist = members[leaderIndex]->pos.distance(this->target->target.location);

        float minDist = 0;
        int minIndex = INT_MAX;
        float maxDist = 0;
        int maxIndex = 0;
        float dist;
        for (int i = 0; i < this->group->nEntitiesInGroup; i++){
                dist = this->group->members[i]->pos.distance(tpos);
                if(dist < minDist) {
                        minDist = dist;
                        minIndex = i;
                }
                if (dist > maxDist){
                        maxDist = dist;
                        maxIndex = i;
                }
        }
        if(closest) {
                return minIndex;
        } else {
                return maxIndex;
        }
}

---