C++ CSystem::GetWorker方法代码示例

	//removes workers from factories until they are the minimum number to finish the current project
	//in still the same number of turns (as at the start of the function)
	int DecrementDueToWastedIndustry(bool max_industry)
	{
		m_pSystem->CalculateVariables();
		const CAssemblyList& assembly_list = *m_pSystem->GetAssemblyList();
		int unset = 0;
		if(assembly_list.IsEmpty() || assembly_list.GetWasBuildingBought())
			return unset;
		const int min_rounds = m_pSystem->NeededRoundsToBuild(0, true);
		AssertBotE(min_rounds >= 1);
		if(max_industry && min_rounds > 1 || m_pSystem->GetWorker(WORKER::INDUSTRY_WORKER) == 0)
			return unset;
		while(true)
		{
			SetWorker(WORKER::INDUSTRY_WORKER, CSystem::SET_WORKER_MODE_DECREMENT);
			++unset;
			m_pSystem->CalculateVariables();
			const int current_rounds = m_pSystem->NeededRoundsToBuild(0, true, false);
			if(m_pSystem->GetWorker(WORKER::INDUSTRY_WORKER) == 0)
			{
				if(min_rounds < current_rounds)
					OnBestIndustryWorkerCountFound(unset);
				return unset;
			}
			if(min_rounds < current_rounds)
			{
				OnBestIndustryWorkerCountFound(unset);
				return unset;
			}
		}
	}

	//puts an additional worker into industry, to prevent not finishing the project because
	//industry prod decreased due to loss of moral
	void SafeMoral()
	{
		const CAssemblyList& assembly_list = *m_pSystem->GetAssemblyList();
		AssertBotE(m_WorkersLeftToSet >= 0);
		if(assembly_list.IsEmpty() || m_WorkersLeftToSet == 0)
			return;
		const int max_buildings = m_pSystem->GetNumberOfWorkbuildings(WORKER::INDUSTRY_WORKER, 0);
		if(m_pSystem->GetWorker(WORKER::INDUSTRY_WORKER) < max_buildings)
			SetWorker(WORKER::INDUSTRY_WORKER, CSystem::SET_WORKER_MODE_INCREMENT);
	}

	//fills all remaining empty buildings of the given cathegory, only considering available workers and buildings
	bool FillRemainingSlots(WORKER::Typ type)
	{
		AssertBotE(m_WorkersLeftToSet >= 0);
		if(m_WorkersLeftToSet == 0)
			return false;
		m_WorkersLeftToSet += m_pSystem->GetWorker(type);
		m_pSystem->SetWorker(type, CSystem::SET_WORKER_MODE_SET, 0);
		const int buildings = m_pSystem->GetNumberOfWorkbuildings(type, 0);
		const int to_set = min(buildings, m_WorkersLeftToSet);
		SetWorker(type, CSystem::SET_WORKER_MODE_SET,to_set);
		return true;
	}

	//removes workers from a cathegory which has a store until production + store <= store,
	//so that nothing will be wasted on next turn change
	int DecrementDueToFullStore(WORKER::Typ type)
	{
		int unset = 0;
		if(!m_pSystem->HasStore(type))
			return unset;
		const int store = m_pSystem->GetResourceStore(type);
		while(true)
		{
			const int workers = m_pSystem->GetWorker(type);
			if(workers == 0)
				break;
			m_pSystem->CalculateVariables();
			const int prod = m_pSystem->GetProduction()->GetXProd(type);
			if(store + prod <= m_pSystem->GetXStoreMax(type))
				break;
			SetWorker(type, CSystem::SET_WORKER_MODE_DECREMENT);
			++unset;
		}
		return unset;
	}

	//Indreases workers in cathegories energy and food until we produce enough to suffice for the consumption we have
	bool IncreaseWorkersUntilSufficient(WORKER::Typ type, bool allow_insufficient)
	{
		AssertBotE(type == WORKER::ENERGY_WORKER || type == WORKER::FOOD_WORKER);
		if(m_pSystem->GetDisabledProductions()[type])
			return true;
		while(true)
		{
			const int value = (type == WORKER::ENERGY_WORKER) ? m_pProd->GetEnergyProd() : m_pProd->GetFoodProd();
			if(value >= 0)
				return true;
			if(m_WorkersLeftToSet <= 0)
				return allow_insufficient;
			const int number_of_buildings = m_pSystem->GetNumberOfWorkbuildings(type, 0);
			const int workers_set = m_pSystem->GetWorker(type);
			AssertBotE(workers_set <= number_of_buildings);
			if(workers_set == number_of_buildings)
				return allow_insufficient;
			SetWorker(type, CSystem::SET_WORKER_MODE_INCREMENT);
			m_pSystem->CalculateVariables();
		}
	}

	CWorkersDistributionCalculator(CSystem& system) :
		m_pSystem(&system),
		m_pProd(system.GetProduction()),
		m_WorkersLeftToSet(system.GetWorker(WORKER::ALL_WORKER))
	{
	}