gameMgr.cpp

Go to the documentation of this file.

/*
 * gameMgr.cpp
 *
 *  Created on: Jan 9, 2012
 *      Author: sushil
 */
#include <assert.h>

#include <const.h>
#include <utils.h>
#include <engine.h>
#include <ent.h>
#include <aspect.h>
#include <ai/gather.h>
#include <commandHelp.h>
#include <unitAI.h>

#include <groupAI.h>
#include <flock.h>

#include <gameMgr.h>

#include <OgreVector3.h>
#include <cfloat>
#include "DEBUG.h"

//FastEcslent::GameMgr::GameMgr() {
//      gameNumber = 0;
        //reset();
//}

FastEcslent::GameMgr::GameMgr(Engine* engine, Options opts): Mgr(engine) {
        //reset();
        options = opts;

}

void FastEcslent::GameMgr::init() {
}

void FastEcslent::GameMgr::loadLevel(){
        switch (engine->options.gameNumber) {
        case 0:
                game0();
                break;
        case 1:
                WaterCraft();
                break;
        case 2:
                tester();
                break;
        default:
                tester();
        }
}

bool FastEcslent::GameMgr::notExceedPopCap(Identity entId) {
        Entity *ent = this->engine->entityMgr->ents[entId.id];
        return (this->pop[ent->entityId.player] + this->entTypeData[ent->entityType].supply <= this->currentPopCap[ent->entityId.player]);
        //return true;
}

bool FastEcslent::GameMgr::preReqExists(EntityType entType) {
        return true;
}

void FastEcslent::GameMgr::setupEntityBuildTimes(){
        this->entTypeData[SCV].buildTime = 17;
        this->entTypeData[MARINE].buildTime = 25;
        this->entTypeData[REAPER].buildTime = 45;
        this->entTypeData[TANK].buildTime = 45;
        this->entTypeData[THOR].buildTime = 60;
        this->entTypeData[MARAUDER].buildTime = 30;
        this->entTypeData[HELLION].buildTime = 30;

        this->entTypeData[COMMANDCENTER].buildTime = 100;
        this->entTypeData[BARRACKS].buildTime = 65;
        this->entTypeData[FACTORY].buildTime = 60;
        this->entTypeData[ARMORY].buildTime = 65;
        this->entTypeData[ENGINEERINGBAY].buildTime = 35;

        this->entTypeData[REFINERY].buildTime = 30;
        this->entTypeData[SUPPLYDEPOT].buildTime = 30;

        this->entTypeData[MINERALS].buildTime = 0;
        this->entTypeData[GAS].buildTime      = 0;
}

void FastEcslent::GameMgr::setupEntitySupply(){
        for (int i = 0; i < NENTITYTYPES; i++){
                this->entTypeData[i].supply = 0;
        }
        this->entTypeData[SCV].supply      = 1;
        this->entTypeData[MARINE].supply   = 1;
        this->entTypeData[REAPER].supply   = 1;
        this->entTypeData[TANK].supply     = 3;
        this->entTypeData[THOR].supply     = 5;
        this->entTypeData[MARAUDER].supply = 2;
        this->entTypeData[HELLION].supply  = 2;
}

void FastEcslent::GameMgr::game0(){
        for(int i = 0; i < NPLAYERS; i++){
                this->popCap[i] = 200;
                this->currentPopCap[i] = 10;
                this->pop[i] = 0;
        }
        setupEntityBuildTimes();

        tester();
}

void FastEcslent::GameMgr::WaterCraft(){
        if(engine->options.isServer){
                for(int i = 0; i < NPLAYERS; i++){
                        this->popCap[i] = 200;
                        this->pop[i]    = 0;
                        this->currentPopCap[i] = 10;
                        this->resources[i].gas      = 0;
                        this->resources[i].minerals = 50;
                        this->playerNEnts[i] = 0;
                }
                setupEntityBuildTimes();
                setupEntitySupply();
                float offset = 3500.0f;
                makeBaseForSidePlayer(RED, ONE, Ogre::Vector3(-offset, 0, -offset), 550.0f, 0.06f);
                makeBaseForSidePlayer(BLUE, THREE, Ogre::Vector3(offset, 0, offset), 550.0f, 0.06f);
                //makeBaseForSidePlayer(YELLOW, THREE, Ogre::Vector3(-offset, 0, offset), 550.0f, 0.06f);
                //makeBaseForSidePlayer(GREEN, FOUR, Ogre::Vector3(offset, 0, -offset), 550.0f, 0.06f);
                startMining(RED, ONE);
                startMining(BLUE, THREE);
        }else{
                clearClient();
        }
}

void FastEcslent::GameMgr::clearClient(){

}

void FastEcslent::GameMgr::makeBaseForSidePlayer(Side side, Player player, Ogre::Vector3 location, float offset, float yawOffset){
        //create command center
        Entity *ent;
        ent = engine->entityMgr->createEntityForPlayerAndSide(COMMANDCENTER, location, 0.0f, side, player);
        ent->pos = location;
        DEBUG(std::cout << "Game Manager: " << ent->uiname << std::endl;)
        ent->init();
        this->currentEntityCounts[player][ent->entityType]++;
        this->playerEnts[player][this->playerNEnts[player]++] = ent;
        ent->entityState = ALIVE;

        //create Minerals
        createMineralPatch(8, side, player, location, offset, yawOffset);
//      createNEntitiesRadial(MINERALS, 8, side, player, location, offset, yawOffset);
        // create Gas
        createNEntitiesRadial(GAS, 2, side, player, location, offset, yawOffset * 5, 2.0f);
        //create SCVS
        createNEntitiesRadial(SCV, 5, side, player, location, offset/3.0f, yawOffset/2.0f);

}

std::vector<FastEcslent::Entity*> FastEcslent::GameMgr::createNEntitiesRadial(EntityType entType, int nEntities, Side side, Player player, Ogre::Vector3 location, float offset, float yawOffset, int yawOffsetMultiplier){
        std::vector<Entity*> ents;
        Entity *ent;
        Ogre::Vector3 entityLocation(location.x, 0, location.z);
        float radius = entityLocation.length();
        radius = radius + fabs(offset);
        float yaw  = atan2(location.z, location.x);
        yaw = yaw - yawOffset*nEntities/2.0f;

        entityLocation.x = cos(yaw) * radius;
        entityLocation.z = sin(yaw) * radius;
        for (int i = 0; i < nEntities; i++) {
                ent = engine->entityMgr->createEntityForPlayerAndSide(entType, entityLocation, yaw, side, player );
                ent->init();

                this->pop[player] += this->entTypeData[ent->entityType].supply;
                this->currentEntityCounts[player][ent->entityType]++;
                this->playerEnts[player][this->playerNEnts[player]++] = ent;
                ent->entityState = ALIVE;

                ents.push_back(ent);

                yaw += yawOffset * yawOffsetMultiplier;
                entityLocation.x = cos(yaw) * radius;
                entityLocation.z = sin(yaw) * radius;
        }

        return ents;
}

void FastEcslent::GameMgr::createMineralPatch(int nEntities, Side side, Player player, Ogre::Vector3 location, float offset, float yawOffset, int yawOffsetMultiplier){
        MineralPatch *mp = new MineralPatch();
        mineralPatches.push_back(mp);
        std::vector<Entity*> ents = createNEntitiesRadial(MINERALS, nEntities, side, player, location, offset, yawOffset);
        for(std::vector<Entity*>::iterator i= ents.begin(); i!= ents.end();i++){
                Minerals *m = dynamic_cast<Minerals*>(*i);
                mp->addMineral(m);
                m->patch = mp;
        }
}

FastEcslent::Entity *FastEcslent::GameMgr::findClosestEntityOfTypeWithinDistance(EntityType entityType, Ogre::Vector3 pos, float maxDistance, Side side, Player player){
        float minDistance = FLT_MAX;
        float distance;
        Entity *minEnt = 0;
        Entity *ent = 0;
        for (int i = 0; i < this->playerNEnts[player]; i++){
                ent = this->playerEnts[player][i];
                //if (ent->entityType == MINERALS && ent->entityId.side == side && ent->entityId.player == player){
                if (ent->entityType == entityType && ent->entityState == ALIVE){
                        DEBUG(std::cout << "Found: " << ent->uiname << ": " << ent->entityState << std::endl;)
                        distance = pos.distance(ent->pos);
                        if (distance < maxDistance) {
                                DEBUG(std::cout << ent->uiname << ", distance: " << distance << std::endl;)
                                if (distance < minDistance) {
                                        minDistance = distance;
                                        minEnt      = ent;
                                }
                        }
                }
        }
        return minEnt;
}

void FastEcslent::GameMgr::startMining(Side side, Player player){
        Entity *ent;
        for (int i = 0; i < this->playerNEnts[player]; i++){
                ent = this->playerEnts[player][i];
                if (ent->entityType == SCV ){
                        SCVehicle *scv = dynamic_cast<SCVehicle *>(ent);
                        Entity *mineral = findClosestEntityOfTypeWithinDistance(MINERALS, scv->pos, FLT_MAX, side, player);
                        assert(mineral != 0);
                        Gather *g = createGatherForEntAndMineral(scv, dynamic_cast<Minerals *>(mineral));
                        UnitAI *ai = dynamic_cast<UnitAI *> (scv->getAspect(UNITAI));
                        ai->setCommand(g);
                }
        }
}


void FastEcslent::GameMgr::tester(){
        int x = 0;
        int z = 0;

        int rangex = 2000;
        int rangez = rangex;
        int nEnts  = 50;
        DEBUG(std::cout << "Game2...nEnts: " << nEnts << std::endl;)
        engine->selectionMgr->resetAll();
        //Group *group = engine->groupMgr->createGroup();

        Entity *ent;
        ent = engine->entityMgr->createEntityAfterTime(BARRACKS, Ogre::Vector3(0, 0, 0), 0.0f);
        ent->pos = Ogre::Vector3(x, 0.0f, z);
        x += 500;
        DEBUG(std::cout << "Game Manager: " << ent->uiname << std::endl;)
        ent->init();

        ent = engine->entityMgr->createEntityAfterTime(COMMANDCENTER, Ogre::Vector3(0, 0, 0), 0.0f);
        ent->pos = Ogre::Vector3(x, 0.0f, z);
        x += 500;
        DEBUG(std::cout << "Game Manager: " << ent->uiname << std::endl;)
        ent->init();

        ent = engine->entityMgr->createEntityAfterTime(FACTORY, Ogre::Vector3(0, 0, 0), 0.0f);
        ent->pos = Ogre::Vector3(x, 0.0f, z);
        x += 500;
        DEBUG(std::cout << "Game Manager: " << ent->uiname << std::endl;)
        ent->init();

        ent = engine->entityMgr->createEntityAfterTime(REFINERY, Ogre::Vector3(0, 0, 0), 0.0f);
        ent->pos = Ogre::Vector3(x, 0.0f, z);
        x += 500;
        DEBUG(std::cout << "Game Manager: " << ent->uiname << std::endl;)
        ent->init();

        ent = engine->entityMgr->createEntityAfterTime(SUPPLYDEPOT, Ogre::Vector3(0, 0, 0), 0.0f);
        ent->pos = Ogre::Vector3(x, 0.0f, z);
        x += 500;
        DEBUG(std::cout << "Game Manager: " << ent->uiname << std::endl;)
        ent->init();

        ent = engine->entityMgr->createEntityAfterTime(ENGINEERINGBAY, Ogre::Vector3(0, 0, 0), 0.0f);
        ent->pos = Ogre::Vector3(x, 0.0f, z);
        x += 500;
        DEBUG(std::cout << "Game Manager: " << ent->uiname << std::endl;)
        ent->init();

        ent = engine->entityMgr->createEntityAfterTime(ARMORY, Ogre::Vector3(0, 0, 0), 0.0f);
        ent->pos = Ogre::Vector3(x, 0.0f, z);
        x += 500;
        DEBUG(std::cout << "Game Manager: " << ent->uiname << std::endl;)
        ent->init();

        x = 0;
        z = 0;
        for(int i = 0; i < nEnts; i++){
                ent = engine->entityMgr->createEntityAfterTime(static_cast<EntityType>(i%7), Ogre::Vector3(0, 0, 0), 0.0f);
                DEBUG(std::cout << "Game Manager: " << ent->uiname << std::endl;)
                ent->init();
                ent->pos = Ogre::Vector3(x, 0.0f, z);
                z = rangez - random() % (2 * rangez);
                x = rangex - random() % (2 * rangex);
                ent->heading = (random()%180) * 0.0174532925;
                ent->yaw = ent->heading;
                ent->desiredHeading = ent->heading;
                ent->desiredSpeed = 0.0f;
        }

}



void FastEcslent::GameMgr::tick(double dtime){
        return;
}

---