#include <ResourceManager.h>

Collaboration diagram for ResourceManagerClass:

Public Member Functions
	ResourceManagerClass ()
void	update ()
void	onDestroy (Unit unit)
bool	isSaturated ()
bool	requiresRefineries ()
int	getGasLevel ()
Private Attributes
std::map< Unit, Base >	mResourceToBase
std::map< Base, std::map< Unit, GatherTaskPointer > >	mResourceTasks
std::set< Base >	mMyActiveBases
TaskPump	mTaskPump
bool	mSaturated
int	mGasLevel
int	mTimeAllowGasChange

Detailed Description

Definition at line 10 of file ResourceManager.h.

Constructor & Destructor Documentation

ResourceManagerClass::ResourceManagerClass ( )

Definition at line 9 of file ResourceManager.cpp.

        : mTaskPump(BWAPI::Broodwar->self()->getRace().getWorker(), TaskType::Worker)
        , mSaturated(false)
        , mGasLevel(0)
        , mTimeAllowGasChange(0)
{
}

Member Function Documentation

int ResourceManagerClass::getGasLevel ( ) [inline]

Definition at line 21 of file ResourceManager.h.

References mGasLevel.

{ return mGasLevel; }

bool ResourceManagerClass::isSaturated ( ) [inline]

Definition at line 19 of file ResourceManager.h.

References mSaturated.

{ return mSaturated; }

void ResourceManagerClass::onDestroy ( Unit unit )

Definition at line 157 of file ResourceManager.cpp.

References mResourceTasks, and mResourceToBase.

{
        std::map<Unit, Base>::iterator baseIT = mResourceToBase.find(unit);
        if(baseIT != mResourceToBase.end())
        {
                std::map<Unit, GatherTaskPointer>::iterator resourceIT = mResourceTasks[baseIT->second].find(unit);
                if(resourceIT != mResourceTasks[baseIT->second].end())
                {
                        resourceIT->second->cancel();
                        mResourceTasks[baseIT->second].erase(unit);
                        mResourceToBase.erase(baseIT);
                }
        }
}

bool ResourceManagerClass::requiresRefineries ( ) [inline]

Definition at line 20 of file ResourceManager.h.

References mGasLevel.

{ return mGasLevel == 8; }

void ResourceManagerClass::update ( )

Definition at line 17 of file ResourceManager.cpp.

References BWAPI::Broodwar, TaskPump::changeTargetQuantity(), UnitGroup::count(), BWAPI::Game::getFrameCount(), BWAPI::Orders::getOrder(), BWAPI::Races::getRace(), Singleton< T >::Instance(), mGasLevel, mMyActiveBases, mResourceTasks, mResourceToBase, mSaturated, mTaskPump, mTimeAllowGasChange, BWAPI::Game::self(), OrderDef::TrainWorkers, and TaskPump::update().

{
        std::set<Base> bases = BaseTracker::Instance().getActiveBases(true);
        if(mMyActiveBases != bases)
        {
                for each(Base base in mMyActiveBases)
                {
                        std::set<Base>::iterator it = bases.find(base);
                        if(it == bases.end())
                        {
                                for(std::map<Unit, GatherTaskPointer>::iterator resourceIT = mResourceTasks[base].begin(); resourceIT != mResourceTasks[base].end(); ++resourceIT)
                                        resourceIT->second->cancel();

                                mResourceTasks.erase(base);
                        }
                }

                mMyActiveBases = bases;
        }

        unsigned int neededWorkers = 0;
        for each(Base base in mMyActiveBases)
        {
                if(!base->getResourceDepot() || !base->getResourceDepot()->exists())
                        continue;

                const UnitGroup &minerals = base->getMinerals();
                const UnitGroup &refineries = base->getRefineries();

                for(std::map<Unit, GatherTaskPointer>::iterator resourceIT = mResourceTasks[base].begin(); resourceIT != mResourceTasks[base].end();)
                {
                        if(minerals.count(resourceIT->first) == 0 && refineries.count(resourceIT->first) == 0)
                        {
                                resourceIT->second->cancel();
                                mResourceToBase.erase(resourceIT->first);
                                mResourceTasks[base].erase(resourceIT++);
                        }
                        else
                                ++resourceIT;
                }

                for each(Unit mineral in minerals)
                {
                        neededWorkers += 2;
                        if(mResourceTasks[base].count(mineral) == 0)
                        {
                                GatherTaskPointer gatherTask(new GatherTask(mineral, base));
                                TaskManager::Instance().addTask(gatherTask);
                                mResourceTasks[base][mineral] = gatherTask;
                                mResourceToBase[mineral] = base;
                        }
                }

                for each(Unit refinery in refineries)
                {
                        if(refinery->getPlayer() == BWAPI::Broodwar->self())
                        {
                                neededWorkers += 3;
                                if(mResourceTasks[base].count(refinery) == 0 && refinery->exists())
                                {
                                        GatherTaskPointer gatherTask(new GatherTask(refinery, base));
                                        TaskManager::Instance().addTask(gatherTask);
                                        mResourceTasks[base][refinery] = gatherTask;
                                        mResourceToBase[refinery] = base;
                                }
                        }
                }
        }

        if(!BuildOrderManager::Instance().getOrder(Order::TrainWorkers))
                neededWorkers = 0;

        unsigned int numWorkers = UnitTracker::Instance().selectAllUnits(BWAPI::Broodwar->self()->getRace().getWorker()).size();

        mSaturated = numWorkers >= neededWorkers;

        neededWorkers = std::min(neededWorkers, 50u);
        neededWorkers -= std::min(numWorkers, neededWorkers);
        neededWorkers = std::min(neededWorkers, UnitTracker::Instance().selectAllUnits(BWAPI::Broodwar->self()->getRace().getWorker().whatBuilds().first).size() + 1);

        mTaskPump.changeTargetQuantity(neededWorkers);
        mTaskPump.update();

        double mineralRate = 0;
        double gasRate = 0;
        for(std::map<Base, std::map<Unit, GatherTaskPointer>>::iterator it = mResourceTasks.begin(); it != mResourceTasks.end(); ++it)
        {
                for(std::map<Unit, GatherTaskPointer>::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2)
                {
                        mineralRate += it2->second->getMineralRate();
                        gasRate += it2->second->getGasRate();
                }
        }

        ResourceTracker::Instance().setMineralRate(mineralRate);
        ResourceTracker::Instance().setGasRate(gasRate);

        int futureMinerals = ResourceTracker::Instance().availableMineralAtTime(BWAPI::Broodwar->getFrameCount() + 450);
        int futureGas = ResourceTracker::Instance().availableGasAtTime(BWAPI::Broodwar->getFrameCount() + 450);

        if(mTimeAllowGasChange < BWAPI::Broodwar->getFrameCount())
        {
                int newLevel = 0;
                if(UnitTracker::Instance().selectAllUnits(BWAPI::Broodwar->self()->getRace().getRefinery()).size() == 0)
                        newLevel = 8;
                else if(futureMinerals != 0)
                {
                        float ratio = float(futureGas) / float(futureMinerals);

                        if(ratio > 2.5f)
                                newLevel = 0;
                        else if(ratio > 1.9f)
                                newLevel = 1;
                        else if(ratio > 1.3f)
                                newLevel = 2;
                        else if(ratio > 1.0f)
                                newLevel = 3;
                        else if(ratio > 0.95f)
                                newLevel = 4;
                        else if(ratio > 0.9f)
                                newLevel = 5;
                        else if(ratio > 0.85f)
                                newLevel = 6;
                        else if(ratio > 0.4f)
                                newLevel = 7;
                        else
                                newLevel = 8;
                }

                if(mGasLevel != newLevel)
                {
                        mTimeAllowGasChange = BWAPI::Broodwar->getFrameCount() + 24;
                        if(mGasLevel > newLevel)
                                --mGasLevel;
                        else if(newLevel > mGasLevel)
                                ++mGasLevel;
                }
        }
}