gather.cpp

Go to the documentation of this file.

/*
 * gather.cpp
 *
 *  Created on: Mar 20, 2013
 *      Author: sushil
 */

#include <ai/gather.h>
#include "DEBUG.h"

namespace FastEcslent {

        FastEcslent::Gather::Gather(Entity* ent, Target *target): UnitCommand(ent, GatherCommand, target) {
                this->scv = dynamic_cast<SCVehicle *> (ent);
                if (target->entity){
                        this->mineralEntity = dynamic_cast<Minerals *> (target->entity);
                } else {
                        this->mineralEntity = 0;
                }
                this->commandCenter = findNearestCommandCenter();
                this->finished = false;
                this->state    = MOVETOMINERALS;
        }

        inline bool Gather::done(){
                return finished;
        }

        inline void Gather::init(){
                this->commandCenter = findNearestCommandCenter();
                this->state = MOVETOMINERALS;
                this->finished = false;
                this->mineralEntity->miners++;
        }

        inline void Gather::postProcess(){
                this->mineralEntity->miners--;
                if(this->mineralEntity->miner == this->entity)
                        this->mineralEntity->miner = 0;
        }

        inline void Gather::switchState(GatherState newState){
                this->state = newState;
                switch(newState){
                case RETURNTOCC:
                        this->commandCenter = findNearestCommandCenter();
                        break;
                case GATHERINGMINERALS:
                        this->scv->mineralCount = 0; //what happens if you run out of minerals while gathering?
                        //if time to find a less utilized mineral ent, find and set your mineralEntity
                        break;
                case MOVETOMINERALS:
                        this->entity->engine->gameMgr->resources[this->scv->entityId.player].minerals += this->scv->mineralCount; // should be 0 or maxMineralCount
                        break;
                default:
                        break;
                }
        }

        inline void Gather::tick(double dt){
                switch(this->state){
                case RETURNTOCC:
                        //this->commandCenter = findNearestCommandCenter();
                        moveToEntityTick(this->commandCenter, dt);

                        break;

                case GATHERINGMINERALS:
                        gatherTick(dt);
                        //checks for switching in gatherTick
                        break;

                case MOVETOMINERALS:
                        moveToEntityTick(this->mineralEntity, dt);

                        break;
                default:
                        break;
                }
        }

        void Gather::switchMoveToState(){
                if (this->state == MOVETOMINERALS) {
                        switchState(GATHERINGMINERALS);
                } else if (this->state == RETURNTOCC){
                        //increment player minerals by 5 == mineralCount == maxMineralCount here
                        switchState(MOVETOMINERALS);
                }
        }

        inline void Gather::moveToEntityTick(Entity *targetEnt, double dt){
                if(!targetEnt){
                        DEBUG(std::cout << "No target ent: state: " << this->state << std::endl;)
                        return;
                }
                relativePos = targetEnt->pos - this->entity->pos;
                if (relativePos.length() < this->scv->length * 2) {  //in front of mineral
                        if(this->mineralEntity->miner){   //check if it is mining by another SCV
                                Minerals* mineral = this->mineralEntity->patch->getNextMineral(this->mineralEntity); //check if there is optimal one
                                if(mineral){ //if there is optimal, give up the original mineral and switch to the new mineral.
                                        this->mineralEntity->miners--;
                                        this->mineralEntity = mineral;
                                        this->mineralEntity->miners++;
                                        return;
                                }
                        }
                        this->entity->desiredHeading = this->entity->heading;
                        this->entity->desiredSpeed = 0;
                        this->entity->speed = 0;
                        switchMoveToState();//and count additional resources if scv was at CC

                } else {
                        this->entity->desiredHeading = -atan2(relativePos.z, relativePos.x);
                        this->entity->desiredSpeed = this->entity->maxSpeed;
                }
        }


        inline void Gather::gatherTick(double dt){
                if(!this->mineralEntity->miner || this->mineralEntity->miner == this->entity ){ //nobody mining, start to mine
                        float mineralsGathered = this->scv->mineralGatherRate * dt; // how does this change with number of scvs?
                        float fractionOverMaxMineralsPerTrip = 0.0f;
                        this->scv->mineralCount += mineralsGathered;
                        this->mineralEntity->mineralAmount -= mineralsGathered;
                        this->mineralEntity->miner = this->entity;
                        if(this->scv->mineralCount >= this->scv->maxMineralCount){
                                fractionOverMaxMineralsPerTrip = this->scv->maxMineralCount - this->scv->mineralCount;
                                this->mineralEntity->mineralAmount += fractionOverMaxMineralsPerTrip; // give back the fraction
                                this->scv->mineralCount = this->scv->maxMineralCount;
                                this->mineralEntity->miner = 0;
                                switchState(RETURNTOCC);
                        }
                        // If you run out of minerals
                        if(this->mineralEntity->mineralAmount <= 0.0f){
                                Entity *ent = this->entity->engine->gameMgr->findClosestEntityOfTypeWithinDistance(MINERALS, this->entity->pos, MaxMineralFindingDistance, this->entity->entityId.side, this->entity->entityId.player);
                                if(ent){
                                        this->mineralEntity = dynamic_cast<Minerals *> (ent);
                                } else {
                                        switchState(STOPPED);
                                }
                        }
                }
        }


        FastEcslent::CommandCenter * FastEcslent::Gather::findNearestCommandCenter(){
                DEBUG(std::cout << "***************************Finding closest Command Center: " << std::endl;)
                Entity *ent = this->entity->engine->gameMgr->findClosestEntityOfTypeWithinDistance(COMMANDCENTER, this->entity->pos, FLT_MAX, this->entity->entityId.side, this->entity->entityId.player);
                if (ent){
                        DEBUG(std::cout << "-----------------Found command center: -------------" << ent->uiname  << std::endl;)
                        return dynamic_cast<CommandCenter*>(ent);
                } else {
                        DEBUG(std::cout << "********************************************No command center found" << std::endl;)
                        return 0;
                }
        }

}

---