void CKAIK::UnitIdle(int unitID) {
if (ai->Initialized()) {
if (ai->GetUnit(unitID)->isDead) {
return;
}
if (ai->uh->lastCapturedUnitFrame == ai->cb->GetCurrentFrame()) {
if (unitID == ai->uh->lastCapturedUnitID) {
// KLOOTNOTE: for some reason this also gets called when one
// of our units is captured (in the same frame as, but after
// HandleEvent(AI_EVENT_UNITCAPTURED)), *before* the unit has
// actually changed teams (ie. for any unit that is no longer
// on our team but still registers as such)
ai->uh->lastCapturedUnitFrame = -1;
ai->uh->lastCapturedUnitID = -1;
return;
}
}
// AttackHandler handles cat_g_attack units
if (GCAT(unitID) == CAT_G_ATTACK && ai->GetUnit(unitID)->groupID != -1) {
// attackHandler->UnitIdle(unit);
} else {
ai->uh->IdleUnitAdd(unitID, ai->cb->GetCurrentFrame());
}
}
}
void CEconomyTracker::UnitFinished(int unit) {
if (trackerOff)
return;
const int frame = ai->cb->GetCurrentFrame();
const UnitDef* unitDef = ai->cb->GetUnitDef(unit);
if (unitDef == NULL || CUNIT::IsCommander(unitDef) || unitDef->canDGun) {
// add the commander to an EconomyUnitTracker
EconomyUnitTracker * economyUnitTracker = new EconomyUnitTracker;
economyUnitTracker->clear();
economyUnitTracker->economyUnitId = unit;
economyUnitTracker->createFrame = frame;
economyUnitTracker->alive = true;
economyUnitTracker->category = GCAT(unit);
economyUnitTracker->unitDef = unitDef;
SetUnitDefDataInTracker(economyUnitTracker);
newEconomyUnitTrackers.push_back(economyUnitTracker);
return;
}
// move the new EconomyUnitTrackers
bool found = false;
std::list<EconomyUnitTracker*> removeList;
for (std::list<EconomyUnitTracker*>::iterator i = underConstructionEconomyUnitTrackers.begin(); i != underConstructionEconomyUnitTrackers.end(); i++) {
EconomyUnitTracker *bt = *i;
if (bt->economyUnitId == unit) {
bt->createFrame = frame;
assert(bt->alive);
newEconomyUnitTrackers.push_back(bt);
removeList.push_back(bt);
found = true;
break;
}
}
assert(found);
// remove them from underConstructionEconomyUnitTrackers
for (std::list<EconomyUnitTracker*>::iterator i = removeList.begin(); i != removeList.end(); i++) {
underConstructionEconomyUnitTrackers.remove(*i);
}
UnitCategory category = ai->ut->GetCategory(unit);
found = false;
if (category != CAT_LAST) {
for (std::list<BuildingTracker>::iterator i = allTheBuildingTrackers[category].begin(); i != allTheBuildingTrackers[category].end(); i++) {
BuildingTracker* bt = &*i;
if (bt->unitUnderConstruction == unit) {
updateUnitUnderConstruction(bt);
found = true;
allTheBuildingTrackers[category].erase(i);
break;
}
}
if (!found) {
// unit not in a BuildingTracker?
}
}
}
void CGlobalAI::UnitFinished(int unit) {
ai->econTracker->UnitFinished(unit);
int frame = ai->cb->GetCurrentFrame();
const UnitDef* udef = ai->cb->GetUnitDef(unit);
if (udef) {
// let attackhandler handle cat_g_attack units
if (GCAT(unit) == CAT_G_ATTACK) {
ai->ah->AddUnit(unit);
} else {
ai->uh->IdleUnitAdd(unit, frame);
}
ai->uh->BuildTaskRemove(unit);
}
}
void CKAIK::UnitFinished(int unitID) {
if (ai->Initialized()) {
ai->econTracker->UnitFinished(unitID);
if (ai->cb->GetUnitDef(unitID) != NULL) {
// let attackhandler handle cat_g_attack units
if (GCAT(unitID) == CAT_G_ATTACK) {
ai->ah->AddUnit(unitID);
} else {
ai->uh->IdleUnitAdd(unitID, ai->cb->GetCurrentFrame());
}
ai->uh->BuildTaskRemove(unitID);
}
}
}
void CGlobalAI::UnitIdle(int unit) {
ai -> math -> StartTimer(totalSumTime);
ai -> math -> StartTimer(globalAILogTime);
L("Idle: " << unit);
ai -> math -> StopTimer(globalAILogTime);
ai -> math -> StartTimer(unitIdleTime);
ai -> econTracker -> frameUpdate();
// attackhandler handles cat_g_attack units atm
if (GCAT(unit) == CAT_G_ATTACK && ai -> MyUnits.at(unit) -> groupID != -1) {
// attackHandler -> UnitIdle(unit);
}
else {
ai -> uh -> IdleUnitAdd(unit);
}
ai -> math -> StopTimer(unitIdleTime);
ai -> math -> StopTimer(totalSumTime);
}
int CUNIT::category()
{
return GCAT(myid);
}
float CDamageControl::GetCurrentDamageScore(const UnitDef* unit)
{
//L("Getting CombatScore for : " << unit->humanName << " number of units: " << NumOfUnitTypes);
float score = 0;
int category = GCAT(unit);
bool foundaunit = false;
if(category == CAT_ATTACK || category == CAT_ARTILLERY || category == CAT_ASSAULT){
for(int i = 1; i <= NumOfUnitTypes; i++){
if(TheirUnitsAll[i].Cost > 0 && ai->ut->unittypearray[unit->id].DPSvsUnit[i] > 0 && ai->ut->unittypearray[i].AverageDPS > 0){
//L("unit->id: " << unit->id << " I: " << i);
//L("DPSvsUnit[i] " << ai->ut->unittypearray[unit->id].DPSvsUnit[i] << " TheirUnitsAll[i].Cost " << TheirUnitsAll[i].Cost);
score+= ai->ut->unittypearray[unit->id].DPSvsUnit[i] * TheirUnitsAll[i].Cost / TheirUnitsAll[i].Hitpoints / (MyArmy[i].Damage + 1); // kill the stuff with the best value
//L("Score:" << score);
//score+= 0; // This was for making a debug brakepoint
foundaunit = true;
}
}
if(!foundaunit){ // if nothing found try to kill his movable units (comm and builders)
for(int i = 1; i <= NumOfUnitTypes; i++){
if(TheirUnitsAll[i].Cost > 0 && ai->ut->unittypearray[unit->id].DPSvsUnit[i] > 0 && ai->ut->unittypearray[i].def->speed > 0){
score+= ai->ut->unittypearray[unit->id].DPSvsUnit[i] * TheirUnitsAll[i].Cost / TheirUnitsAll[i].Hitpoints / (MyArmy[i].Damage + 1); // kill the stuff with the best value
foundaunit = true;
}
}
}
if(!foundaunit){ // if all fails just get whatever hes got and try to hit it
for(int i = 1; i <= NumOfUnitTypes; i++){
if(TheirUnitsAll[i].Cost > 0 && ai->ut->unittypearray[unit->id].DPSvsUnit[i] > 0){
score+= ai->ut->unittypearray[unit->id].DPSvsUnit[i] * TheirUnitsAll[i].Cost / TheirUnitsAll[i].Hitpoints / (MyArmy[i].Damage + 1); // kill the stuff with the best value
}
}
}
}
else if(category == CAT_DEFENCE){
for(int i = 1; i <= NumOfUnitTypes; i++){
if(TheirArmy[i].Cost > 0 && ai->ut->unittypearray[unit->id].DPSvsUnit[i] > 0 && (ai->ut->unittypearray[i].category == CAT_ATTACK || ai->ut->unittypearray[i].category == CAT_ARTILLERY || ai->ut->unittypearray[i].category == CAT_ASSAULT)){
//L("unit->id: " << unit->id << " I: " << i);
//L("DPSvsUnit[i] " << ai->ut->unittypearray[unit->id].DPSvsUnit[i] << " TheirUnitsAll[i].Cost " << TheirUnitsAll[i].Cost);
score+= ai->ut->unittypearray[unit->id].DPSvsUnit[i] * TheirArmy[i].Cost / TheirArmy[i].Hitpoints / (MyDefences[i].Damage + 1); // kill the stuff with the best value
//L("Score:" << score);
//score+= 0; // This was for making a debug brakepoint
foundaunit = true;
}
}
if(!foundaunit){ // if nothing found try to kill his movable units (comm and builders)
for(int i = 1; i <= NumOfUnitTypes; i++){
if(TheirUnitsAll[i].Cost > 0 && ai->ut->unittypearray[unit->id].DPSvsUnit[i] > 0 && ai->ut->unittypearray[i].def->speed > 0){
score+= ai->ut->unittypearray[unit->id].DPSvsUnit[i] * TheirUnitsAll[i].Cost / TheirUnitsAll[i].Hitpoints / (MyArmy[i].Damage + 1); // kill the stuff with the best value
foundaunit = true;
}
}
}
if(!foundaunit){ // if all fails just get whatever hes got and try to hit it
for(int i = 1; i <= NumOfUnitTypes; i++){
if(TheirUnitsAll[i].Cost > 0 && ai->ut->unittypearray[unit->id].DPSvsUnit[i] > 0){
score+= ai->ut->unittypearray[unit->id].DPSvsUnit[i] * TheirUnitsAll[i].Cost / TheirUnitsAll[i].Hitpoints / (MyArmy[i].Damage + 1); // kill the stuff with the best value
}
}
}
}
//L(" score " << score << " TheirTotalCost " << TheirTotalCost);
if (TheirTotalArmyCost <= 0)
return 1;
if (category == CAT_ATTACK || category == CAT_ARTILLERY || category == CAT_ASSAULT) {
return score / TheirTotalArmyCost / (TheirUnitsAll[unit->id].Damage + 1);
}
else if (category == CAT_DEFENCE) {
return score / TheirTotalArmyCost / (TheirArmy[unit->id].Damage + 1);
}
L("***** Getdamagescore Error! *****");
return 1;
}
void CEconomyTracker::UnitCreated(int unitID) {
if (trackerOff) {
return;
}
const int frame = ai->cb->GetCurrentFrame();
const UnitDef* unitDef = ai->cb->GetUnitDef(unitID);
const bool iscommander = CUNIT::IsCommander(unitDef);
if (unitDef == NULL || iscommander || unitDef->canDGun) {
// ignore the commander
return;
}
EconomyUnitTracker* economyUnitTracker = new EconomyUnitTracker;
economyUnitTracker->clear();
economyUnitTracker->economyUnitId = unitID;
economyUnitTracker->createFrame = -frame;
economyUnitTracker->alive = true;
economyUnitTracker->category = GCAT(unitID);
economyUnitTracker->unitDef = unitDef;
SetUnitDefDataInTracker(economyUnitTracker);
underConstructionEconomyUnitTrackers.push_back(economyUnitTracker);
// find it (slow++)
int catIdx = int(CAT_COMM);
bool found = false;
for (; catIdx < int(CAT_LAST); catIdx++ ) {
std::list<BuildTask>::iterator i;
for (i = ai->uh->BuildTasks[catIdx].begin(); i != ai->uh->BuildTasks[catIdx].end(); i++) {
BuildTask bt = *i;
if (bt.id == unitID) {
// add this new unit to the list
BuildingTracker tracker;
tracker.clear();
tracker.economyUnitTracker = economyUnitTracker;
tracker.buildTask = true;
tracker.category = UnitCategory(catIdx);
tracker.unitUnderConstruction = unitID;
allTheBuildingTrackers[catIdx].push_front(tracker);
found = true;
break;
}
}
}
if (!found) {
// it is made by a factory
float3 unitPos = ai->cb->GetUnitPos(unitID);
UnitCategory category = GCAT(unitID);
for (std::list<Factory>::iterator i = ai->uh->Factories.begin(); i != ai->uh->Factories.end(); i++) {
Factory factory = *i;
int factoryId = factory.id;
// bad, no easy way to get the factory of the unit
float3 factoryPos = ai->cb->GetUnitPos(factoryId);
float distance = factoryPos.distance2D(unitPos);
if (distance < 100.0f) {
BuildingTracker tracker;
tracker.clear();
tracker.economyUnitTracker = economyUnitTracker;
tracker.category = category;
tracker.unitUnderConstruction = unitID;
tracker.factory = factoryId;
allTheBuildingTrackers[category].push_front(tracker);
found = true;
break;
}
}
}
// unit constructor not found?!
// assert(found);
}
void CEconomyTracker::UnitFinished(int unit)
{
if(trackerOff)
return;
int frame=ai->cb->GetCurrentFrame();
if(frame == 0)
{
// Add the commander to a EconomyUnitTracker
EconomyUnitTracker * economyUnitTracker = new EconomyUnitTracker;
economyUnitTracker->clear();
economyUnitTracker->economyUnitId = unit;
economyUnitTracker->createFrame = frame;
economyUnitTracker->alive = true;
economyUnitTracker->category = GCAT(unit);
economyUnitTracker->unitDef = ai->cb->GetUnitDef(unit);
SetUnitDefDataInTracker(economyUnitTracker);
newEconomyUnitTrackers.push_back(economyUnitTracker);
return;
}
// Move the new EconomyUnitTrackers
bool found = false;
list<EconomyUnitTracker*> removeList;
for(list<EconomyUnitTracker*>::iterator i = underConstructionEconomyUnitTrackers.begin(); i != underConstructionEconomyUnitTrackers.end(); i++) {
EconomyUnitTracker *bt = *i; // This is bad, but needed
if(bt->economyUnitId == unit)
{
bt->createFrame = frame;
// Move it to the new list
assert(bt->alive);
newEconomyUnitTrackers.push_back(bt);
removeList.push_back(bt);
//L("Moved " << bt->unitDef->humanName << " to newEconomyUnitTrackers");
found = true;
break;
}
}
assert(found);
// Remove them from underConstructionEconomyUnitTrackers:
for(list<EconomyUnitTracker*>::iterator i = removeList.begin(); i != removeList.end(); i++) {
underConstructionEconomyUnitTrackers.remove(*i);
}
//L("Finished a " << ai->cb->GetUnitDef(unit)->humanName);
int category = ai->ut->GetCategory(unit);
found = false;
if(category != -1)
for(list<BuildingTracker>::iterator i = allTheBuildingTrackers[category]->begin(); i != allTheBuildingTrackers[category]->end(); i++) {
BuildingTracker *bt = &*i;
if(bt->unitUnderConstruction == unit)
{
updateUnitUnderConstruction(bt);
found = true;
allTheBuildingTrackers[category]->erase(i);
break;
}
}
if(!found) {
//L("This unit was not in a BuildingTracker!!!!!!!!!");
}
}
void CEconomyTracker::UnitCreated(int unit)
{
if(trackerOff)
return;
int frame=ai->cb->GetCurrentFrame();
if(frame == 0)
{
// Ignore the commander
return;
}
EconomyUnitTracker * economyUnitTracker = new EconomyUnitTracker;
economyUnitTracker->clear();
economyUnitTracker->economyUnitId = unit;
economyUnitTracker->createFrame = -frame;
economyUnitTracker->alive = true;
economyUnitTracker->category = GCAT(unit);
economyUnitTracker->unitDef = ai->cb->GetUnitDef(unit);
SetUnitDefDataInTracker(economyUnitTracker);
underConstructionEconomyUnitTrackers.push_back(economyUnitTracker);
//L("Started to make an " << ai->cb->GetUnitDef(unit)->humanName);
// Find it (slow++)
bool found = false;
for(int category = 0; category < LASTCATEGORY; category++ )
{
for(list<BuildTask>::iterator i = ai->uh->BuildTasks[category]->begin(); i != ai->uh->BuildTasks[category]->end(); i++) {
BuildTask bt = *i;
if(bt.id == unit)
{
// Add this new unit to the list
BuildingTracker tracker;
tracker.clear();
tracker.economyUnitTracker = economyUnitTracker;
tracker.buildTask = true;
tracker.category = category;
tracker.unitUnderConstruction = unit;
allTheBuildingTrackers[category]->push_front(tracker);
found = true;
break;
}
}
}
if(!found)
{
// It is made by a factory
float3 unitPos = ai->cb->GetUnitPos(unit);
int category = GCAT(unit);
for(list<Factory>::iterator i = ai->uh->Factories.begin(); i != ai->uh->Factories.end(); i++) {
Factory factory = *i;
int factoryId = factory.id;
// This is bad, no easy way to get the factory of the unit...
float3 factoryPos = ai->cb->GetUnitPos(factoryId);
float distance = factoryPos.distance2D(unitPos);
//L("factory distance: " << distance);
if(distance < 100)
{
BuildingTracker tracker;
tracker.clear();
tracker.economyUnitTracker = economyUnitTracker;
tracker.category = category;
tracker.unitUnderConstruction = unit;
tracker.factory = factoryId;
allTheBuildingTrackers[category]->push_front(tracker);
found = true;
break;
}
}
}
if(!found) {
//L("Unit constructor not found !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
}
/*
float EProductionNeed = unit->energyCost - ai->cb->GetEnergy();//ai->cb->GetEnergy() - unit->energyCost;
float EProduction = ai->cb->GetEnergyIncome() - ai->cb->GetEnergyUsage();
if(EProduction < 1)
EProduction = 1;
////L("EProductionNeed: " << EProductionNeed);
////L("EProduction: " << EProduction);
float MProductionNeed = unit->metalCost - ai->cb->GetMetal();//ai->cb->GetMetal() - unit->metalCost;
float MProduction = ai->cb->GetMetalIncome() - ai->cb->GetMetalUsage();
if(MProduction < 1)
MProduction = 1;
////L("MProductionNeed: " << MProductionNeed);
////L("MProduction: " << MProduction);
float timeToBuild = max (EProductionNeed / EProduction, MProductionNeed / MProduction);
if(timeToBuild < 1)
timeToBuild = 1; // It can be built right now... Make something more costly instead?
////L("timeToBuild: " << timeToBuild);
//float METAL2ENERGY_current = ai->cb->GetEnergy() (ai->cb->GetEnergyIncome()*0.9 - ai->cb->GetEnergyUsage())
//float buildtime = //unit->buildTime / builder->buildSpeed;
// Take the buildtime, and use it smart.
// Make a ratio of unit->buildTime / timeToBuild ???:
// This realy needs to know its creators build speed.
float buildTimeRatio = unit->buildTime / timeToBuild;
////L("buildTimeRatio: " << buildTimeRatio);
float buildTimeFix = unit->buildTime / 100;
*/
}
