aaiexecute.cpp

这是整套横扫千军3D版游戏的源码

	water_plant = bt->GetPowerPlant(ai->side, eff, urgency, max_power, energy, true, false, false);
	// currently aai cannot build this building
	if(water_plant && bt->units_dynamic[water_plant].buildersAvailable <= 0)
	{
		if( bt->units_dynamic[water_plant].buildersRequested <= 0)
			bt->AddBuilder(water_plant);

		water_plant = bt->GetPowerPlant(ai->side, eff, urgency, max_power, energy, true, false, true);
	}

	for(list<AAISector*>::iterator sector = brain->sectors[0].begin(); sector != brain->sectors[0].end(); ++sector)
	{
		if((*sector)->water_ratio < 0.15)
		{
			checkWater = false;
			checkGround = true;	
		}
		else if((*sector)->water_ratio < 0.85)
		{
			checkWater = true;
			checkGround = true;
		}
		else
		{
			checkWater = true;
			checkGround = false;
		}

		if(checkWater == true)
		{
			fprintf(ai->file, "Water ratio in sector %i, %i: %f\n", (*sector)->x, (*sector)->y, (*sector)->water_ratio);
		}

		if(checkGround && ground_plant)
		{
			if(ut->constructors.size() > 1 || ai->activeUnits[POWER_PLANT] >= 2)
				pos = (*sector)->GetBuildsite(ground_plant, false);
			else 
			{
				builder = ut->FindBuilder(ground_plant, true, 10);

				if(builder)
				{
					pos = map->GetClosestBuildsite(bt->unitList[ground_plant-1], cb->GetUnitPos(builder->unit_id), 40, false);

					if(pos.x <= 0)
						pos = (*sector)->GetBuildsite(ground_plant, false);
				}
				else
					pos = (*sector)->GetBuildsite(ground_plant, false);
			}

			if(pos.x > 0)
			{
				builder = ut->FindClosestBuilder(ground_plant, pos, true, 10);

				if(builder)
				{
					futureAvailableEnergy += bt->units_static[ground_plant].efficiency[0];
					builder->GiveConstructionOrder(ground_plant, pos, false);
					return true;
				}
				else
				{
					bt->AddBuilder(ground_plant);
					return false;
				}
			}
			else
			{
				brain->ExpandBase(LAND_SECTOR);
				fprintf(ai->file, "Base expanded by BuildPowerPlant()\n");
			}
		}

		if(checkWater && water_plant)
		{
			if(ut->constructors.size() > 1 || ai->activeUnits[POWER_PLANT] >= 2)
				pos = (*sector)->GetBuildsite(water_plant, true);
			else 
			{
				builder = ut->FindBuilder(water_plant, true, 10);
				
				if(builder)
				{
					pos = map->GetClosestBuildsite(bt->unitList[water_plant-1], cb->GetUnitPos(builder->unit_id), 40, true);

					if(pos.x <= 0)
						pos = (*sector)->GetBuildsite(water_plant, true);
				}
				else
					pos = (*sector)->GetBuildsite(water_plant, true);
			}

			if(pos.x > 0)
			{
				builder = ut->FindClosestBuilder(water_plant, pos, true, 10);

				if(builder)
				{
					futureAvailableEnergy += bt->units_static[water_plant].efficiency[0];
					builder->GiveConstructionOrder(water_plant, pos, true);
					return true;
				}
				else
				{
					bt->AddBuilder(water_plant);
					return false;
				}
			}
			else
			{
				brain->ExpandBase(WATER_SECTOR);
				fprintf(ai->file, "Base expanded by BuildPowerPlant() (water sector)\n");
			}
		}
	}

	return true;
}

bool AAIExecute::BuildMetalMaker()
{
	if(ai->activeFactories < 1 && ai->activeUnits[EXTRACTOR] >= 2)
		return true;

	if(ai->futureUnits[METAL_MAKER] > 0 || disabledMMakers >= 1)
		return true;

	bool checkWater, checkGround;
	int maker;
	AAIConstructor *builder;
	float3 pos;
	// urgency < 4
	
	float urgency = GetMetalUrgency() / 2.0f;
	
	float cost = 0.25f + brain->Affordable() / 2.0f;

	float efficiency = 0.25f + ai->activeUnits[METAL_MAKER] / 4.0f ;
	float metal = efficiency;


	// sort sectors according to threat level
	learned = 70000.0 / (cb->GetCurrentFrame() + 35000) + 1;
	current = 2.5 - learned;

	brain->sectors[0].sort(least_dangerous);
	
	for(list<AAISector*>::iterator sector = brain->sectors[0].begin(); sector != brain->sectors[0].end(); sector++)
	{
		if((*sector)->water_ratio < 0.15)
		{
			checkWater = false;
			checkGround = true;	
		}
		else if((*sector)->water_ratio < 0.85)
		{
			checkWater = true;
			checkGround = true;
		}
		else
		{
			checkWater = true;
			checkGround = false;
		}

		if(checkGround)
		{
			maker = bt->GetMetalMaker(ai->side, cost,  efficiency, metal, urgency, false, false); 
	
			// currently aai cannot build this building
			if(maker && bt->units_dynamic[maker].buildersAvailable <= 0)
			{
				if(bt->units_dynamic[maker].buildersRequested <= 0)
					bt->BuildBuilderFor(maker);
				
				maker = bt->GetMetalMaker(ai->side, cost, efficiency, metal, urgency, false, true);
			}

			if(maker)
			{
				pos = (*sector)->GetBuildsite(maker, false);

				if(pos.x > 0)
				{
					builder = ut->FindClosestBuilder(maker, pos, true, 10);

					if(builder)
					{
						futureRequestedEnergy += bt->unitList[maker-1]->energyUpkeep;
						builder->GiveConstructionOrder(maker, pos, false);
						return true;
					}
					else
					{
						bt->AddBuilder(maker);
						return false;
					}
				}
				else
				{
					brain->ExpandBase(LAND_SECTOR);	
					fprintf(ai->file, "Base expanded by BuildMetalMaker()\n");
				}
			}
		}

		if(checkWater)
		{
			maker = bt->GetMetalMaker(ai->side, brain->Affordable(),  8.0/(urgency+2.0), 64.0/(16*urgency+2.0), urgency, true, false); 
	
			// currently aai cannot build this building
			if(maker && bt->units_dynamic[maker].buildersAvailable <= 0)
			{
				if(bt->units_dynamic[maker].buildersRequested <= 0)
					bt->BuildBuilderFor(maker);
				
				maker = bt->GetMetalMaker(ai->side, brain->Affordable(),  8.0/(urgency+2.0), 64.0/(16*urgency+2.0), urgency, true, true);
			}

			if(maker)
			{
				pos = (*sector)->GetBuildsite(maker, true);
	
				if(pos.x > 0)
				{
					builder = ut->FindClosestBuilder(maker, pos, true, 10);

					if(builder)
					{
						futureRequestedEnergy += bt->unitList[maker-1]->energyUpkeep;
						builder->GiveConstructionOrder(maker, pos, true);
						return true;
					}
					else
					{
						bt->AddBuilder(maker);
						return false;
					}
				}
				else
				{
					brain->ExpandBase(WATER_SECTOR);
					fprintf(ai->file, "Base expanded by BuildMetalMaker() (water sector)\n");
				}
			}
		}
	}
		
	return true;
}

bool AAIExecute::BuildStorage()
{
	if(ai->futureUnits[STORAGE] > 0 || ai->activeUnits[STORAGE] >= cfg->MAX_STORAGE)
		return true;

	if(ai->activeFactories < 2)
		return true;

	int storage = 0;
	bool checkWater, checkGround;
	AAIConstructor *builder;
	float3 pos;

	float metal = 4 / (cb->GetMetalStorage() + futureStoredMetal - cb->GetMetal() + 1);
	float energy = 2 / (cb->GetEnergyStorage() + futureStoredMetal - cb->GetEnergy() + 1);

	// urgency < 4
	float urgency = 16.0 / (ai->activeUnits[METAL_MAKER]+ai->futureUnits[METAL_MAKER]+4);

	for(list<AAISector*>::iterator sector = brain->sectors[0].begin(); sector != brain->sectors[0].end(); sector++)
	{
		if((*sector)->water_ratio < 0.15)
		{
			checkWater = false;
			checkGround = true;	
		}
		else if((*sector)->water_ratio < 0.85)
		{
			checkWater = true;
			checkGround = true;
		}
		else
		{
			checkWater = true;
			checkGround = false;
		}

		if(checkGround)
		{		
			storage = bt->GetStorage(ai->side, brain->Affordable(),  metal, energy, 1, false, false); 
	
			if(storage && bt->units_dynamic[storage].buildersAvailable <= 0 && bt->units_dynamic[storage].buildersRequested <= 0)
			{
				bt->BuildBuilderFor(storage);
				storage = bt->GetStorage(ai->side, brain->Affordable(),  metal, energy, 1, false, true); 
			}

			if(storage)
			{
				pos = (*sector)->GetBuildsite(storage, false);

				if(pos.x > 0)
				{
					builder = ut->FindClosestBuilder(storage, pos, true, 10);
	
					if(builder)
					{
						builder->GiveConstructionOrder(storage, pos, false);
						return true;
					}
					else
					{
						bt->AddBuilder(storage);
						return false;
					}
				}
				else
				{
					brain->ExpandBase(LAND_SECTOR);
					fprintf(ai->file, "Base expanded by BuildStorage()\n");
				}
			}
		}

		if(checkWater)
		{
			storage = bt->GetStorage(ai->side, brain->Affordable(),  metal, energy, 1, true, false); 
	
			if(storage && bt->units_dynamic[storage].buildersAvailable <= 0 && bt->units_dynamic[storage].buildersRequested <= 0)
			{
				bt->BuildBuilderFor(storage);
				storage = bt->GetStorage(ai->side, brain->Affordable(),  metal, energy, 1, true, true); 
			}

			if(storage)
			{
				pos = (*sector)->GetBuildsite(storage, true);

				if(pos.x > 0)
				{
					builder = ut->FindClosestBuilder(storage, pos, true, 10);

					if(builder)
					{
						builder->GiveConstructionOrder(storage, pos, true);
						return true;
					}
					else
					{
						bt->AddBuilder(storage);
						return false;
					}
				}
				else
				{
					brain->ExpandBase(WATER_SECTOR);
					fprintf(ai->file, "Base expanded by BuildStorage()\n");
				}
			}
		}
	}
		
	return true;
}

bool AAIExecute::BuildAirBase()
{
	if(ai->futureUnits[AIR_BASE] > 0 || ai->activeUnits[AIR_BASE] >= cfg->MAX_AIR_BASE)
		return true;

	int airbase = 0;
	bool checkWater, checkGround;
	AAIConstructor *builder;
	float3 pos;

	for(list<AAISector*>::iterator sector = brain->sectors[0].begin(); sector != brain->sectors[0].end(); sector++)
	{
		if((*sector)->water_ratio < 0.15)
		{
			checkWater = false;
			checkGround = true;	
		}
		else if((*sector)->water_ratio < 0.85)
		{
			checkWater = true;
			checkGround = true;
		}
		else
		{
			checkWater = true;
			checkGround = false;
		}

		if(checkGround)
		{		

			airbase = bt->GetAirBase(ai->side, brain->Affordable(), false, false); 
	
			if(airbase && bt->units_dynamic[airbase].buildersAvailable <= 0)
			{
				if(bt->units_dynamic[airbase].buildersRequested <= 0)
					bt->BuildBuilderFor(airbase);

				airbase = bt->GetAirBase(ai->side, brain->Affordable(), false, true);
			}

			if(airbase)
			{
				pos = (*sector)->GetBuildsite(airbase, false);

				if(pos.x > 0)
				{
					builder = ut->FindClosestBuilder(airbase, pos, true, 10);
	
					if(builder)
					{
						builder->GiveConstructionOrder(airbase, pos, false);
						return true;
					}
					else
					{
						bt->AddBuilder(airbase);
						return false;
					}
				}
				else
				{
					brain->ExpandBase(LAND_SECTOR);
					fprintf(ai->file, "Base expanded by BuildAirBase()\n");
				}
			}
		}

		if(checkWater)
		{
			airbase = bt->GetAirBase(ai->side, brain->Affordable(), true, false); 
	
			if(airbase && bt->units_dynamic[airbase].buildersAvailable <= 0 )
			{
				if(bt->units_dynamic[airbase].buildersRequested <= 0)
					bt->BuildBuilderFor(airbase);

				airbase = bt->GetAirBase(ai->side, brain->Affordable(), true, true);  
			}

			if(airbase)
			{
				pos = (*sector)->GetBuildsite(airbase, true);

				if(pos.x > 0)
				{
					builder = ut->FindClosestBuilder(airbase, pos, true, 10);

					if(builder)
					{
						builder->GiveConstructionOrder(airbase, pos, true);
						return true;
					}
					else
					{
						bt->AddBuilder(airbase);
						return false;
					}
				}
				else
				{
					brain->ExpandBase(WATER_SECTOR);
					fprintf(ai->file, "Base expanded by BuildAirBase() (water sector)\n");
				}
			}
		}
	}
		
	return true;
}

bool AAIExecute::BuildDefences()
{
	if(ai->futureUnits[STATIONARY_DEF] > 2 || next_defence <= 0)
		return true;

	BuildOrderStatus status = BuildStationaryDefenceVS(def_category, next_defence);

	if(status == BUILDORDER_NOBUILDER)
		return false;
	else if(status == BUILDORDER_NOBUILDPOS)
		++next_defence->failed_defences;
		
	 
	next_defence = 0;
	
	return true;
}

BuildOrderStatus AAIExecute::BuildStationaryDefenceVS(UnitCategory category, AAISector *dest)
{
	// dont build in sectors already occupied by allies
	if(dest->allied_structures > 50)
		return BUILDORDER_SUCCESFUL;

	// dont start construction of further defences if expensive defences are already under construction in this sector
	for(list<AAIBuildTask*>::iterator task = ai->build_tasks.begin(); task != ai->build_tasks.end(); ++task)
	{
		if(bt->units_static[(*task)->def_id].category == STATIONARY_DEF)
		{
			if(dest->PosInSector(&(*task)->build_pos))