int TransportAgent::getCurrentLoad()
{
Squad* sq = Commander::getInstance()->getSquad(squadID);
if (sq != NULL)
{
int load = 0;
vector<BaseAgent*> agents = sq->getMembers();
for (int i = 0; i < (int)agents.size(); i++)
{
BaseAgent* a = agents.at(i);
if (a->isAlive())
{
if (a->getUnit()->isLoaded())
{
if (a->getUnit()->getTransport()->getID() == unit->getID())
{
load += a->getUnitType().spaceRequired();
}
}
}
}
currentLoad = load;
}
return currentLoad;
}
void CombatCommander::updateDefenseSquadUnits(Squad & defenseSquad, const size_t & flyingDefendersNeeded, const size_t & groundDefendersNeeded)
{
auto & squadUnits = defenseSquad.getUnits();
// TODO: right now this will assign arbitrary defenders, change this so that we make sure they can attack air/ground
// if there's nothing left to defend, clear the squad
if (flyingDefendersNeeded == 0 && groundDefendersNeeded == 0)
{
defenseSquad.clear();
return;
}
size_t defendersNeeded = flyingDefendersNeeded + groundDefendersNeeded;
size_t defendersAdded = 0;
while (defendersNeeded > defendersAdded)
{
UnitTag defenderToAdd = findClosestDefender(defenseSquad, defenseSquad.getSquadOrder().getPosition());
if (defenderToAdd)
{
m_squadData.assignUnitToSquad(defenderToAdd, defenseSquad);
defendersAdded++;
}
else
{
break;
}
}
}
BaseAgent* TransportAgent::findUnitToLoad(int spaceLimit)
{
BaseAgent* agent = NULL;
double bestDist = 100000;
Squad* sq = Commander::getInstance()->getSquad(squadID);
if (sq != NULL)
{
vector<BaseAgent*> agents = sq->getMembers();
for (int i = 0; i < (int)agents.size(); i++)
{
BaseAgent* a = agents.at(i);
if (isValidLoadUnit(a))
{
double cDist = unit->getPosition().getDistance(a->getUnit()->getPosition());
if (cDist < bestDist)
{
bestDist = cDist;
agent = a;
}
}
}
}
return agent;
}
int Commander::addBunkerSquad()
{
Squad* bSquad = new Squad(100 + AgentManager::getInstance()->countNoUnits(UnitTypes::Terran_Bunker), Squad::BUNKER, "BunkerSquad", 5);
bSquad->addSetup(UnitTypes::Terran_Marine, 4);
squads.push_back(bSquad);
//Try to fill from other squads.
int added = 0;
for (Squad* s : squads)
{
if (s->isOffensive() || s->isDefensive())
{
for (int i = 0; i < 4 - added; i++)
{
if (s->hasUnits(UnitTypes::Terran_Marine, 1))
{
if (added < 4)
{
BaseAgent* ma = s->removeMember(UnitTypes::Terran_Marine);
if (ma != NULL)
{
added++;
bSquad->addMember(ma);
ma->clearGoal();
}
}
}
}
}
}
return bSquad->getID();
}
bool MarineAgent::isNeededInBunker()
{
if (!unit->isLoaded())
{
Squad* sq = Commander::getInstance()->getSquad(squadID);
if (sq != NULL)
{
if (sq->isBunkerDefend())
{
vector<BaseAgent*> agents = AgentManager::getInstance()->getAgents();
for (int i = 0; i < (int)agents.size(); i++)
{
if (agents.at(i)->isAlive() && agents.at(i)->isOfType(UnitTypes::Terran_Bunker))
{
if (agents.at(i)->getUnit()->getLoadedUnits().size() < 4)
{
unit->rightClick(agents.at(i)->getUnit());
return true;
}
}
}
}
}
}
return false;
}
BaseAgent* TransportAgent::findUnitToLoad(int spaceLimit)
{
BaseAgent* agent = NULL;
double bestDist = 100000;
Squad* sq = Commander::getInstance()->getSquad(squadID);
if (sq != NULL)
{
Agentset agents = sq->getMembers();
for (auto &a : agents)
{
if (isValidLoadUnit(a))
{
double cDist = unit->getPosition().getDistance(a->getUnit()->getPosition());
if (cDist < bestDist)
{
bestDist = cDist;
agent = a;
}
}
}
}
return agent;
}
void NodeCombat::incoming(Squad s)
{
const Gamer &g = s.getOwner();
int ressource = s.getNbRessources();
if(&g == owner)
{
//Entrée d'allier
setRessources(nbRessources+ressource);
}
else
{
//Entrée d'ennemis
if(invicible) ressource = 0;
ressource = dealDamageOnArmor(ressource);
if (nbRessources < ressource)
{
//Changement de propriétaire
ressource -= nbRessources;
setRessources(ressource);
setOwner(&g);
}
else
{
setRessources(nbRessources-ressource);
}
}
}
int TransportAgent::getCurrentLoad()
{
Squad* sq = Commander::getInstance()->getSquad(squadID);
if (sq != NULL)
{
int load = 0;
Agentset agents = sq->getMembers();
for (auto &a : agents)
{
if (a->isAlive())
{
if (a->getUnit()->isLoaded())
{
if (a->getUnit()->getTransport()->getID() == unit->getID())
{
load += a->getUnitType().spaceRequired();
}
}
}
}
currentLoad = load;
}
return currentLoad;
}
void CombatCommander::updateDefenseSquadUnits(Squad & defenseSquad, const size_t & flyingDefendersNeeded, const size_t & groundDefendersNeeded)
{
int zerglingsInOurBase = numZerglingsInOurBase();
bool zerglingRush = zerglingsInOurBase > 0 && BWAPI::Broodwar->getFrameCount() < 5000;
const BWAPI::Unitset & squadUnits = defenseSquad.getUnits();
size_t flyingDefendersInSquad = std::count_if(squadUnits.begin(), squadUnits.end(), UnitUtil::CanAttackAir);
size_t groundDefendersInSquad = std::count_if(squadUnits.begin(), squadUnits.end(), UnitUtil::CanAttackGround);
// if there's nothing left to defend, clear the squad
if (flyingDefendersNeeded == 0 && groundDefendersNeeded == 0)
{
defenseSquad.clear();
return;
}
// add flying defenders if we still need them
size_t flyingDefendersAdded = 0;
while (flyingDefendersNeeded > flyingDefendersInSquad + flyingDefendersAdded)
{
BWAPI::Unit defenderToAdd = findClosestDefender(defenseSquad, defenseSquad.getSquadOrder().getPosition(), true);
// if we find a valid flying defender, add it to the squad
if (defenderToAdd)
{
_squadData.assignUnitToSquad(defenderToAdd, defenseSquad);
++flyingDefendersAdded;
}
// otherwise we'll never find another one so break out of this loop
else
{
break;
}
}
// add ground defenders if we still need them
size_t groundDefendersAdded = 0;
while (groundDefendersNeeded > groundDefendersInSquad + groundDefendersAdded)
{
BWAPI::Unit defenderToAdd = findClosestDefender(defenseSquad, defenseSquad.getSquadOrder().getPosition(), false);
// if we find a valid ground defender add it
if (defenderToAdd)
{
_squadData.assignUnitToSquad(defenderToAdd, defenseSquad);
++groundDefendersAdded;
}
// otherwise we'll never find another one so break out of this loop
else
{
break;
}
}
}
int SquadBindings::apiJoinSquad(apikey squadKey, apikey shipKey) {
Squad* squad = m_scriptEngine.get<Squad>(squadKey);
if (!squad) { return -1; }
Ship* ship = m_scriptEngine.get<Ship>(shipKey);
if (!ship) { return -1; }
ship->squadLogic()->joinSquadOf(squad->leader());
return 0;
}
void Squad::_copyUnits(const Squad& src)
{
int i = 0;
int n = src.getCount();
while (i < n) {
push(src.getUnit(i));
++i;
}
}
void Commander::assistBuilding(BaseAgent* building) {
for (int i = 0; i < (int)squads.size(); i++) {
Squad* sq = squads.at(i);
if (sq->isDefensive()) {
sq->setGoal(building->getUnit()->getTilePosition());
}
if (sq->isOffensive() && currentState == DEFEND) {
sq->setGoal(building->getUnit()->getTilePosition());
}
}
}
void Commander::unitDestroyed(BaseAgent* agent)
{
int squadID = agent->getSquadID();
if (squadID != -1)
{
Squad* squad = getSquad(squadID);
if (squad != NULL)
{
squad->removeMember(agent);
}
}
}
int SquadBindings::apiCreatePatrolWaypointsTask(apikey squadKey) {
Squad* squad = m_scriptEngine.get<Squad>(squadKey);
if (!squad) { return -1; }
auto task = std::make_shared<PatrolWaypointsTask>(*squad);
m_scriptEngine.registerScriptable(task.get());
squad->setTask(task);
return task->scriptKey();
}
int SquadBindings::apiCreateDefendAreaTask(apikey squadKey, const glm::vec3& point, float range) {
Squad* squad = m_scriptEngine.get<Squad>(squadKey);
if (!squad) { return -1; }
auto task = std::shared_ptr<DefendAreaTask>(new DefendAreaTask(*squad, { point }, range));
m_scriptEngine.registerScriptable(task.get());
squad->setTask(task);
return task->scriptKey();
}
void SquadData::assignUnitToSquad(BWAPI::Unit unit, Squad & squad)
{
UAB_ASSERT_WARNING(canAssignUnitToSquad(unit, squad), "We shouldn't be re-assigning this unit!");
Squad * previousSquad = getUnitSquad(unit);
if (previousSquad)
{
previousSquad->removeUnit(unit);
}
squad.addUnit(unit);
}
void Commander::removeSquad(int id)
{
for (int i = 0; i < (int)squads.size(); i++)
{
Squad* sq = squads.at(i);
if (sq->getID() == id)
{
sq->disband();
squads.erase(squads.begin() + i);
return;
}
}
}
void NodeCombat::sendSquad(int ressource, int nodeId)
{
if(nodeId != getId() && mapConnexion.contains(nodeId))
{
int nbToSend = ressource > nbRessources ? nbRessources : ressource;
if(nbToSend > 0)
{
nbRessources -= nbToSend;
Squad s = Squad(*owner);
s.setNbRessources(nbToSend);
mapConnexion.value(nodeId)->sendSquad(s, getId());
}
}
}
void Commander::unitDestroyed(BaseAgent* agent) {
int squadID = agent->getSquadID();
if (squadID != -1) {
Squad* squad = getSquad(squadID);
if (squad != NULL) {
squad->removeMember(agent);
}
// remove empty squad
//for ( // I AM HERE
if (squad->getMembers().size() == 0)
squad->disband(squad->getCenter());
// squads.erase(squads.begin());
}
}
// ----------------------------------------------------------------------
void Squad::combineWith(Squad & squad)
{
LOGC(ConfigServerGame::isSpaceAiLoggingEnabled(), "space_debug_ai", ("Squad::combineWith() className(%s) squadId(%d) combineWithSquadId(%d)", getClassName(), m_id, squad.getId()));
LOGC((ConfigServerGame::isSpaceAiLoggingEnabled() && squad.isEmpty()), "space_debug_ai", ("Squad::combineWith() className(%s) squadId(%d) combineWithSquadId(%d) Why are we combining with an empty squad?", getClassName(), m_id, squad.getId()));
//-- Add all the units to this squad
UnitMap::const_iterator iterUnitMap = squad.getUnitMap().begin();
for (; iterUnitMap != squad.getUnitMap().end(); ++iterUnitMap)
{
NetworkId const & unit = iterUnitMap->first;
addUnit(unit);
}
}
void Commander::assignUnit(BaseAgent* agent)
{
//Broodwar->printf("%s (%s) is not assigned to a squad", agent->getUnitType().getName().c_str(), agent->getTypeName().c_str());
for (int i = 0; i < (int)squads.size(); i++)
{
Squad* sq = squads.at(i);
if (sq->needUnit(agent->getUnitType()))
{
sq->addMember(agent);
//Broodwar->printf("%s is assigned to SQ %d", agent->getUnitType().getName().c_str(), sq->getID());
return;
}
}
}
void Commander::assistWorker(BaseAgent* worker)
{
if (worker->getSquadID() != -1) return;
if (!worker->getUnit()->isGatheringMinerals())
{
if (!worker->getUnit()->isGatheringGas())
{
return;
}
}
//Find out who targets the worker
TilePosition defPos = worker->getUnit()->getTilePosition();
Unit* target = NULL;
int bestScore = -1;
for(set<Unit*>::const_iterator i=Broodwar->enemy()->getUnits().begin();i!=Broodwar->enemy()->getUnits().end();i++)
{
if ((*i)->exists())
{
double dist = (*i)->getDistance(Position(defPos));
if (dist <= 13 * 32)
{
//Found a target
if ((*i)->getType().destroyScore() > bestScore)
{
target = (*i);
bestScore = (*i)->getType().destroyScore();
}
}
}
}
if (target != NULL)
{
//Broodwar->printf("Assisting building: Targeting enemy %s", target->getType().getName().c_str());
defPos = target->getTilePosition();
}
for (int i = 0; i < (int)squads.size(); i++)
{
Squad* sq = squads.at(i);
if (!sq->isExplorer())
{
sq->assist(defPos);
}
}
}
bool SquadData::canAssignUnitToSquad(BWAPI::Unit unit, const Squad & squad) const
{
const Squad * unitSquad = getUnitSquad(unit);
// make sure strictly less than so we don't reassign to the same squad etc
return !unitSquad || (unitSquad->getPriority() < squad.getPriority());
}
bool MarineAgent::useAbilities()
{
//Load into a Bunker
if (!unit->isLoaded())
{
Squad* sq = Commander::getInstance()->getSquad(squadID);
if (sq != NULL)
{
if (sq->isBunkerDefend())
{
Agentset agents = AgentManager::getInstance()->getAgents();
for (auto &a : agents)
{
if (a->isAlive() && a->isOfType(UnitTypes::Terran_Bunker) && a->getUnit()->exists())
{
if (a->getUnit()->getLoadedUnits().size() < 4)
{
unit->rightClick(a->getUnit());
sq->setBunkerID(a->getUnitID());
return true;
}
}
}
}
}
}
//Use Stim Packs
if (Broodwar->self()->hasResearched(TechTypes::Stim_Packs) && !unit->isStimmed() && unit->getHitPoints() >= 20 && !unit->isLoaded())
{
//Check if enemy units are visible
for (auto &u : Broodwar->enemy()->getUnits())
{
if (u->exists())
{
if (unit->getDistance(u) <= unit->getType().sightRange())
{
unit->useTech(TechTypes::Stim_Packs);
return true;
}
}
}
}
return false;
}
void FirebatAgent::computeActions()
{
if (!unit->isLoaded())
{
Squad* sq = Commander::getInstance()->getSquad(squadID);
if (sq != NULL)
{
if (sq->isBunkerDefend())
{
vector<BaseAgent*> agents = AgentManager::getInstance()->getAgents();
for (int i = 0; i < (int)agents.size(); i++)
{
if (agents.at(i)->isAlive() && agents.at(i)->isOfType(UnitTypes::Terran_Bunker))
{
if (agents.at(i)->getUnit()->getLoadedUnits().size() < 4)
{
unit->rightClick(agents.at(i)->getUnit());
return;
}
}
}
}
}
}
if (Broodwar->self()->hasResearched(TechTypes::Stim_Packs))
{
if (!unit->isStimmed() && unit->getHitPoints() >= 20)
{
if (unit->isAttacking())
{
unit->useTech(TechTypes::Stim_Packs);
//Broodwar->printf("[%d] Using stim packs", unitID);
return;
}
}
}
defensive = false;
if (unit->getAirWeaponCooldown() > 2 || unit->getGroundWeaponCooldown() > 2) defensive = true;
NavigationAgent::getInstance()->computeMove(this, goal, defensive);
if (!defensive) TargetingAgent::checkTarget(this);
}
void AIPlayer::CheckBeingAttacked()
{
for (int i = 0; i < m_SimMailbox.size(); ++i)
{
const Message* message = m_SimMailbox[i];
switch (message->Type)
{
case MessageTypes::AI_MSG:
{
const AIMessage* openMsg = static_cast<const AIMessage*>(message);
if (openMsg->TeamID == m_Team)
{
if (static_cast<AIStateMessages>(openMsg->AIMsg) == AIStateMessages::UNDER_ATTACK)
{
if (openMsg->SquadID >= m_Squads.size())
continue;
Squad* squadUnderAttack = m_Squads[openMsg->SquadID];
Agent* agentUnderAttack = GetAgentPointer(openMsg->EntityID);
if (squadUnderAttack->GetSize() == 0)
continue;
m_Brain.SquadIDUnderAttack = openMsg->SquadID;
if (agentUnderAttack != nullptr)
{
m_Perceptions[PERCEPTION_UNDER_ATTACK] = 1;
m_Brain.TimeSinceAttacked = 0;
m_Brain.AgentUnderAttack = agentUnderAttack->GetEntityID();
}
}
}
}
break;
default:
Logger::Log("Received unrecognized message", "SSAI", LogSeverity::WARNING_MSG);
break;
}
}
}
void SiegeTankAgent::computeActions()
{
if (Broodwar->self()->hasResearched(TechTypes::Tank_Siege_Mode))
{
bool goSiege = false;
//If we have enemy targets nearby, go into siege mode
int eCnt = enemyGroundUnitsWithinRange(getGroundRange(UnitTypes::Terran_Siege_Tank_Siege_Mode));
if (eCnt > 0)
{
goSiege = true;
}
if (eCnt == 0)
{
goSiege = false;
}
//If we are defending and are at the defense position, go
//in siege mode
Squad* sq = Commander::getInstance()->getSquad(squadID);
if (sq != NULL)
{
if (!sq->isActive())
{
int range = UnitTypes::Terran_Siege_Tank_Siege_Mode.groundWeapon().maxRange() * 0.5;
double d = unit->getDistance(Position(goal));
if (d <= range) goSiege = true;
}
}
if (goSiege && !unit->isSieged()) unit->siege();
if (!goSiege && unit->isSieged()) unit->unsiege();
}
defensive = false;
TargetingAgent::checkTarget(this);
//The tank cant move if sieged
if (!unit->isSieged())
{
NavigationAgent::getInstance()->computeMove(this, goal, defensive);
}
}
// give back workers who were in squads
BOOST_FOREACH (Squad & squad, squads)
{
const UnitVector & units = squad.getUnits();
for (size_t u(0); u<units.size(); ++u)
{
if (units[u]->getType().isWorker())
{
WorkerManager::Instance().finishedWithWorker(units[u]);
}
}
}
//----------------------------------------------------------------------------------------------------------------------
void GameWorld::draw(ngl::Camera* _cam, ngl::Mat4 _mouseGlobalTX)
{
ngl::Material a(ngl::Colour(0.2f,0.2f,0.2f, 1.0), ngl::Colour(0.32f,0.31f,0.3f, 1.), ngl::Colour(0.77391f,0.77391f,0.77391f, 1.0));
a.setSpecularExponent(20.f);
a.loadToShader("material");
loadMatricesToShader(_cam, _mouseGlobalTX);
m_streetMesh->draw();
ngl::Material b(ngl::Colour(0.2f,0.2f,0.2f, 1.0), ngl::Colour(0.45f,0.45f,0.45f, 1.), ngl::Colour(0.77391f,0.77391f,0.77391f, 1.0));
b.setSpecularExponent(20.f);
b.loadToShader("material");
loadMatricesToShader(_cam, _mouseGlobalTX);
m_buildingMesh->draw();
for(unsigned int a=0; a<m_numberOfObstacles; ++a)
{
StaticEntity* currentObstacle = m_obstacles[a];
currentObstacle->draw(_cam, _mouseGlobalTX);
}
for(unsigned int a=0; a<m_numberOfRioters; ++a)
{
Rioter* currentRioter = m_rioters[a];
currentRioter->draw(_cam, _mouseGlobalTX);
}
m_numberOfSquads = m_squads.size();
for(unsigned int a=0; a<m_numberOfSquads; ++a)
{
Squad* currentSquad = m_squads[a];
currentSquad->draw(_cam, _mouseGlobalTX);
if(currentSquad->getSquadState() == squadMove)
{
currentSquad->drawTarget(_cam, _mouseGlobalTX);
}
}
}
void PFManager::computeAttackingUnitActions(BaseAgent* agent, TilePosition goal, bool defensive, bool forceMove)
{
Unit* unit = agent->getUnit();
if (!defensive || !forceMove)
{
//if (agent->getUnit()->isStartingAttack()) return;
if (agent->getUnit()->isAttacking()) return;
if (agent->getUnit()->isSieged()) return;
}
if (agent->getUnit()->isLoaded()) return;
//PF
int unitX = unit->getPosition().x();
int unitY = unit->getPosition().y();
float bestP = getAttackingUnitP(agent, unitX, unitY, defensive);
float cP = 0;
float startP = bestP;
int bestX = -1;
int bestY = -1;
for (int cX = unitX - checkRange; cX <= unitX + checkRange; cX += stepSize)
{
for (int cY = unitY - checkRange; cY <= unitY + checkRange; cY += stepSize)
{
if (cX >= 0 && cY >= 0 && cX <= mapW && cY <= mapH)
{
cP = getAttackingUnitP(agent, cX, cY, defensive);
//Broodwar->printf("p(%d,%d)=%d",cX,cY,cP);
if (cP != bestP)
{
bestP = cP;
bestX = cX;
bestY = cY;
}
}
}
}
if (bestX >= 0 && bestY >= 0)
{
Position toMove(bestX, bestY);
if (!defensive)
{
unit->attack(toMove);
}
else
{
unit->rightClick(toMove);
}
return;
}
//EndPF
TilePosition checkpoint = goal;
if (agent->getSquadID() >= 0)
{
Squad* sq = Commander::getInstance()->getSquad(agent->getSquadID());
if (sq != NULL)
{
checkpoint = sq->nextMovePosition();
}
}
if (goal.x() != -1)
{
moveToGoal(agent, checkpoint, goal);
}
}
