C++ Firm::cast_to_FirmCamp方法代码示例

//----- Begin of function Town::update_camp_link -----//
//
// Update the status of links from this town to camps.
//
void Town::update_camp_link()
{
	//--- enable the link of the town's side to all linked camps ---//

	Firm* firmPtr;

	int i;
	for( i=0 ; i<linked_firm_count ; i++ )
	{
		 firmPtr = firm_array[linked_firm_array[i]];

		 if( !firmPtr->cast_to_FirmCamp() )	 
			 continue;

		 //--- don't set it if the town and camp both belong to a human player, the player will set it himself ---//

		 if( firmPtr->nation_recno == nation_recno &&
			  nation_recno && !nation_array[nation_recno]->is_ai() )
		 {
			 continue;
		 }

		 //--------------------------------------------//

		 toggle_firm_link( i+1, 1, COMMAND_AUTO );
	}

	//------- update camp link status -------//

	has_linked_own_camp = 0;
	has_linked_enemy_camp = 0;

	for( i=0 ; i<linked_firm_count ; i++ )
	{
		if( linked_firm_enable_array[i] != LINK_EE )
			continue;

		firmPtr = firm_array[linked_firm_array[i]];

		if( !firmPtr->cast_to_FirmCamp() || 
			firmPtr->cast_to_FirmCamp()->overseer_recno == 0 )
		{
			continue;
		}

		if( firmPtr->nation_recno == nation_recno )
			has_linked_own_camp = 1;
		else
			has_linked_enemy_camp = 1;
	}
}

//--------- Begin of function SpyArray::update_firm_spy_count ---------//
//
// Update the player_spy_count of this firm. This function is called
// when the firm change its nation.
//
// <int> firmRecno - recno of the firm to be updated.
//
void SpyArray::update_firm_spy_count(int firmRecno)
{
	//---- recalculate Firm::player_spy_count -----//

	Spy*  spyPtr;
	Firm* firmPtr = firm_array[firmRecno];

	if( firmPtr->cast_to_FirmCamp() )
	{
		FirmCamp *firmCamp = firmPtr->cast_to_FirmCamp();
		firmCamp->player_spy_count = 0;
		for( int i=spy_array.size() ; i>0 ; i-- )
		{
			if( spy_array.is_deleted(i) )
				continue;

			spyPtr = spy_array[i];

			if( spyPtr->spy_place == SPY_FIRM &&
				 spyPtr->spy_place_para == firmRecno &&
				 spyPtr->true_nation_recno == nation_array.player_recno )
			{
				firmCamp->player_spy_count++;
			}
		}
	}
	else if( firmPtr->cast_to_FirmTrain() )
	{
		FirmTrain *firmTrain = firmPtr->cast_to_FirmTrain();
		firmTrain->player_spy_count = 0;
		for( int i=spy_array.size() ; i>0 ; i-- )
		{
			if( spy_array.is_deleted(i) )
				continue;

			spyPtr = spy_array[i];

			if( spyPtr->spy_place == SPY_FIRM &&
				 spyPtr->spy_place_para == firmRecno &&
				 spyPtr->true_nation_recno == nation_array.player_recno )
			{
				firmTrain->player_spy_count++;
			}
		}
	}

	return;
}

//----------- Begin of function Unit::return_camp -----------//
//
// Order this unit to return to the camp. For ordering many
// units to return to a camp, UnitArray::return_camp() should
// be called instead.
//
int Unit::return_camp()
{
	if( !home_camp_firm_recno )
		return 0;

	err_when( firm_array.is_deleted(home_camp_firm_recno) );

	Firm* firmPtr = firm_array[home_camp_firm_recno];

	if( firmPtr->region_id != region_id() )
		return 0;

	err_when( !firmPtr->cast_to_FirmCamp() && !firmPtr->cast_to_FirmMonsterFortress() );
	err_when( firmPtr->nation_recno != nation_recno );

	//--------- assign now ---------//

	// ##### begin Gilbert 2/6 #########//
	assign(firmPtr->loc_x1, firmPtr->loc_y1, -1, true);

//	force_move_flag = 1;
	// ##### end Gilbert 2/6 #########//

	return cur_action != SPRITE_IDLE;
}

//----- Begin of function Town::has_linked_camp -----//
//
// Return whether there is a camp of the specific nation
// linked to this town.
//
// <int> nationRecno  - recno of the nation.
// <int> needOverseer - whether only count camps with overseers or not.
//
int Town::has_linked_camp(int nationRecno, int needOverseer)
{
	Firm* firmPtr;

	for( int i=0 ; i<linked_firm_count ; i++ )
	{
		firmPtr = firm_array[ linked_firm_array[i] ];
	
		if( firmPtr->cast_to_FirmCamp() &&
			 firmPtr->nation_recno == nationRecno )
		{
			if( !needOverseer || firmPtr->cast_to_FirmCamp()->overseer_recno )
				return 1;
		}
	}

	return 0;
}

//--------- Begin of function Unit::commander_power ---------//
//
// A commander's power is determined:
//
// -Population of the towns he controls
// -The employment rate of the towns he controls, the higher the
//  employment rate, the higher his power is
// -If there are any other commanders controls the towns at the same time.
// -the no. of soldiers led by the commander and their combat levels.
//
int Unit::commander_power()
{
	//---- if the commander is in a military camp -----//

	int commanderPower=0;

	if( unit_mode == UNIT_MODE_OVERSEE )
	{
		Firm* firmPtr = firm_array[unit_mode_para];

		if( firmPtr->cast_to_FirmCamp() )
		{
			Town* townPtr;

			for( int i=firmPtr->linked_town_count-1 ; i>=0 ; i-- )
			{
				if( firmPtr->linked_town_enable_array[i] == LINK_EE )
				{
					townPtr = town_array[firmPtr->linked_town_array[i]];

					int linkedCampCount = townPtr->linked_camp_count(true);

					if( linkedCampCount > 0 )
						commanderPower += townPtr->population / linkedCampCount;
				}
			}

			commanderPower += firmPtr->cast_to_FirmCamp()->soldier_count*3;		// 0 to 24
		}
		else if( firmPtr->firm_id == FIRM_BASE )
		{
			commanderPower = 60;
		}
	}
	else
	{
		commanderPower = team_info->member_count*3;		// 0 to 24
	}

	return commanderPower;
}

//-------- Begin of function Town::linked_camp_count ------//
//
// Return the number of linked military camp to this town.
//
// <bool> hasOverseer - only count the camps with an overseer.
//
int Town::linked_camp_count(bool hasOverseer)
{
	int 	i, linkedCount=0;
	Firm* firmPtr;

	for( i=0 ; i<linked_firm_count ; i++ )
	{
		if( linked_firm_enable_array[i] == LINK_EE )
		{
			firmPtr = firm_array[linked_firm_array[i]];

			if( firmPtr->cast_to_FirmCamp() )
			{
				if( !hasOverseer || firmPtr->cast_to_FirmCamp()->overseer_recno )
				{
					linkedCount++;
				}
			}
		}
	}

	return linkedCount;
}

// ---------- Begin of function FirmWar::can_set_rally_point ------//
//
// whether the firm can set rally point
//
// [int] destBaseObjRecno		- destination base obj recno, 0 for setting position
//
int FirmWar::can_set_rally_point(int destBaseObjRecno)
{
    if( destBaseObjRecno == 0 )
    {
        return 1;
    }
    else
    {
        if( base_obj_array.is_deleted(destBaseObjRecno) )
            return 0;

        Firm *firmPtr = base_obj_array[destBaseObjRecno]->cast_to_Firm();
        if( firmPtr )
        {
            if( firmPtr->cast_to_FirmCamp() )
            {
                return 1;
            }
        }
    }

    return 0;
}

//------- Begin of function Town::setup_link ---------//
//
void Town::setup_link()
{
	//-----------------------------------------------------------------------------//
	// check the connected firms location and structure if ai_link_checked is true
	//-----------------------------------------------------------------------------//

	if(ai_town)
		ai_link_checked = 0;

	//----- build town-to-firm link relationship -------//

	int   firmRecno;
	Firm* firmPtr;
	FirmInfo* firmInfo;

	linked_firm_count = 0;

	for( firmRecno=firm_array.size() ; firmRecno>0 ; firmRecno-- )
	{
		if( firm_array.is_deleted(firmRecno) )
			continue;

		firmPtr  = firm_array[firmRecno];
		firmInfo = firm_res[firmPtr->firm_id];

		if( !firmInfo->is_linkable_to_town )
			continue;

		//----- only linkable if the firm and the town belong to the same nation or the firm can influence a foreign town, i.e. Camp, Fort and Fryhtan Lair,

		if( nation_recno==0 )
		{
			//--- independent towns can linked to work firms and markets ---//

			if( !firmPtr->cast_to_FirmWork() && !firmPtr->cast_to_FirmMarket()
				 && !firmPtr->cast_to_FirmCamp() )
			{
				continue;
			}
		}
		else
		{
			//--- nation towns can only linked to own firms or camps -------//

			if( firmPtr->nation_recno != nation_recno && !firmPtr->cast_to_FirmCamp() )
				continue;
		}

		//---------- check if the firm is close enough to this firm -------//

		if( m.points_distance( firmPtr->center_x, firmPtr->center_y, center_x, center_y )
			 > world.effective_distance(firmPtr->firm_id, 0) )
		{
			continue;
		}

		//------ check if both are on the same terrain type ------//

		if( (world.get_loc(firmPtr->loc_x1, firmPtr->loc_y1)->is_plateau()==1)
			 != (world.get_loc(loc_x1, loc_y1)->is_plateau()==1) )
		{
			continue;
		}

		//----- if the firm requires same race -------//

		if( !firm_res.is_linkable_to_town(firmPtr->firm_id, firmPtr->race_id, race_id) )
			continue;

		//------- determine default link flag -------//

		int defaultLinkStatus = LINK_EE;

		if( nation_recno==0 )		// if this is an independent town
		{
			if( firmPtr->nation_recno==0 || resistance(firmPtr->nation_recno) > INDEPENDENT_LINK_RESISTANCE )
				defaultLinkStatus = LINK_DD;
		}

		//-------- add the link now -------//

		if( linked_firm_count < MAX_LINKED_FIRM_TOWN )
		{
			err_when( linked_firm_count>0 && linked_firm_array[linked_firm_count-1] == firmRecno );		// BUGHERE - check double linking error

			linked_firm_array[linked_firm_count] = firmRecno;
			linked_firm_enable_array[linked_firm_count] = defaultLinkStatus;

			linked_firm_count++;
		}
		else
		{
			err_here();
		}

		if( firmPtr->linked_town_count < MAX_LINKED_TOWN_TOWN )
		{
			firmPtr->linked_town_array[firmPtr->linked_town_count] = town_recno;
//.........这里部分代码省略.........

//------- Begin of function NationArray::update_total_human_count ------//
//
// Update total human count as there are some bugs in calculation of
// total human count. This function is used for on-fly correcting
// the problem.
//
void NationArray::update_total_human_count()
{
	int totalHumanCountArray[MAX_NATION];

	memset( totalHumanCountArray, 0, sizeof(totalHumanCountArray) );

	//------ calculate firm statistic -------//

	Firm* firmPtr;

	int i;
	for( i=firm_array.size() ; i>0 ; i-- )
	{
		if( firm_array.is_deleted(i) )
			continue;

		firmPtr = firm_array[i];

		if( firmPtr->nation_recno == 0 || !firmPtr->is_human() )
			continue;

		if( firmPtr->cast_to_FirmCamp() )
		{
			FirmCamp *firmCamp = firmPtr->cast_to_FirmCamp();

			for( int j=firmCamp->soldier_count-1 ; j>=0 ; j-- )
			{
				if( firmCamp->soldier_array[j].is_human() )
					totalHumanCountArray[firmCamp->nation_recno-1]++;
			}
		}

		if( firmPtr->cast_to_FirmTrain() )
		{
			FirmTrain *firmTrain = firmPtr->cast_to_FirmTrain();

			totalHumanCountArray[firmTrain->nation_recno-1] += firmTrain->trainee_count;
		}
	}

	//------ calculate unit statistic -------//

	Unit* unitPtr;

	for( i=unit_array.size() ; i>0 ; i-- )
	{
		if( unit_array.is_truly_deleted(i) )
			continue;

		unitPtr = unit_array[i];

		if( unitPtr->nation_recno && unitPtr->is_human() &&
			 unitPtr->rank_id != RANK_KING )		// does not count kings
		{
			if( unitPtr->unit_id == UNIT_WAGON )
				totalHumanCountArray[unitPtr->nation_recno-1] += unitPtr->cast_to_UnitWagon()->population;
			else
				totalHumanCountArray[unitPtr->nation_recno-1]++;
		}
	}

	//------ update nation statistic ------//

	for( i=size() ; i>0 ; i-- )
	{
		if( nation_array.is_deleted(i) )
			continue;

		nation_array[i]->total_human_count = totalHumanCountArray[i-1];
	}
}

//------- Begin of function NationArray::update_military_rating ------//
//
void NationArray::update_military_rating()
{
	int nationCombatLevelArray[MAX_NATION];

	memset( nationCombatLevelArray, 0, sizeof(nationCombatLevelArray) );

	//------ calculate firm statistic -------//

	Firm* firmPtr;

	int i;
	for( i=firm_array.size() ; i>0 ; i-- )
	{
		if( firm_array.is_deleted(i) )
			continue;

		firmPtr = firm_array[i];

		if( firmPtr->nation_recno == 0 )
			continue;

		if( firmPtr->cast_to_FirmCamp() )
		{
			FirmCamp *firmCamp = firmPtr->cast_to_FirmCamp();

			nationCombatLevelArray[firmPtr->nation_recno-1] +=
				firmCamp->total_combat_level() +
				(firmCamp->overseer_recno>0 + firmCamp->soldier_count) * 20;
				// 20 is the base military points for a unit, so the nation that has many more units can be reflected in the military rating
		}
		// ###### patch begin 9/11 ########//
		else if( firmPtr->cast_to_FirmTrain() )
		{
			FirmTrain *firmTrain = firmPtr->cast_to_FirmTrain();

			nationCombatLevelArray[firmPtr->nation_recno-1] +=
				firmTrain->total_military_combat_level() +
				firmTrain->total_military_count() * 20;
				// 20 is the base military points for a unit, so the nation that has many more units can be reflected in the military rating
		}
		// ###### patch end 9/11 ########//
	}

	//------ calculate unit statistic -------//

	Unit* unitPtr;

	for( i=unit_array.size() ; i>0 ; i-- )
	{
		if( unit_array.is_deleted(i) )
			continue;

		unitPtr = unit_array[i];

		if( unitPtr->nation_recno == 0 )
			continue;

		//---- if this unit is a ship, increase total_ship_combat_level ----//

		if( unit_res[unitPtr->unit_id]->unit_class == UNIT_CLASS_SHIP )
		{
			nation_array[unitPtr->nation_recno]->total_ship_combat_level += (int) unitPtr->hit_points;
		}

		//----------------------------------//

		if( unitPtr->unit_mode == UNIT_MODE_OVERSEE )		// firm commanders are counted above with firm_array
			continue;

		int addPoints = (int) unitPtr->hit_points;

		UnitInfo* unitInfo = unit_res[unitPtr->unit_id];

		// ##### begin Gilbert 24/3 ########//
//		if( unitInfo->unit_class == UNIT_CLASS_WEAPON )
//			addPoints += (unitInfo->weapon_power + unitPtr->get_weapon_version() - 1) * 30;
		if( !unitInfo->class_info.has_combat_level )
		{
			addPoints += unitInfo->weapon_power * 30;
			if( unitInfo->class_info.has_weapon_version )
				addPoints += (unitPtr->get_weapon_version() - 1) * 30;
		}
		// ##### end Gilbert 24/3 ########//

		if( unitPtr->leader_unit_recno && !unit_array.is_deleted(unitPtr->leader_unit_recno) )
			addPoints += addPoints * unit_array[unitPtr->leader_unit_recno]->skill_level() / 100;

		nationCombatLevelArray[unitPtr->nation_recno-1] += addPoints + 20;		// 20 is the base military points for a unit, so the nation that has many more units can be reflected in the military rating
	}

	//------ update nation statistic ------//

	for( i=size() ; i>0 ; i-- )
	{
		if( nation_array.is_deleted(i) )
			continue;

		nation_array[i]->military_rating = nationCombatLevelArray[i-1]/50;
//.........这里部分代码省略.........

//-------- Begin of function SpyArray::catch_spy ------//
//
// <int> spyPlace - either SPY_TOWN or SPY_FIRM
// <int> spyPlacePara - town_recno or firm_recno
//
int SpyArray::catch_spy(int spyPlace, int spyPlacePara)
{
	int nationRecno, totalPop;

	if( spyPlace == SPY_TOWN )
	{
		Town* townPtr = town_array[spyPlacePara];

		nationRecno = townPtr->nation_recno;
		totalPop    = townPtr->population;
	}
	else if( spyPlace == SPY_FIRM )
	{
		Firm* firmPtr = firm_array[spyPlacePara];

		nationRecno = firmPtr->nation_recno;
		if( firmPtr->cast_to_FirmCamp() )
		{
			FirmCamp *firmCamp = firmPtr->cast_to_FirmCamp();
			totalPop    = firmCamp->soldier_count + (firmCamp->overseer_recno>0);
		}
		else if( firmPtr->cast_to_FirmWork() )
		{
			FirmWork *firmWork = firmPtr->cast_to_FirmWork();
			totalPop    = firmWork->worker_count;
		}
		else if( firmPtr->cast_to_FirmTrain() )
		{
			totalPop = firmPtr->cast_to_FirmTrain()->trainee_count;
			return 0;		// don't catch spy
		}
		else if( firmPtr->cast_to_FirmInn() )
		{
			totalPop = firmPtr->cast_to_FirmInn()->inn_unit_count;
			return 0;		// don't catch spy
		}
		else if( firmPtr->cast_to_FirmMarket() )
		{
			totalPop = 0;
			return 0;
		}
		else if( firmPtr->cast_to_FirmMonsterTrain() )
		{
			totalPop = firmPtr->cast_to_FirmMonsterTrain()->trainee_count;
			return 0;		// don't catch spy
		}
		else if( firmPtr->cast_to_FirmMonsterAlchemy() )
		{
			totalPop = 0;
			return 0;
		}
		else if( firmPtr->cast_to_FirmLishorr() )
		{
			totalPop = 0;
			return 0;
		}
		else if( firmPtr->cast_to_FirmMonsterFortress() )
		{
			FirmMonsterFortress *firmMonsterFortress = firmPtr->cast_to_FirmMonsterFortress();
			totalPop = firmMonsterFortress->archer_count + firmMonsterFortress->extra_builder_count;
		}
		else if( firmPtr->cast_to_FirmAnimal() )
		{
			totalPop = 0;
			return 0;
		}
		else if( firmPtr->cast_to_FirmIncubator() )
		{
			totalPop = 0;
			return 0;
		}
		else if( firmPtr->cast_to_FirmMagic() )
		{
			totalPop = 0;
			return 0;
		}
		else if( firmPtr->cast_to_FirmOffensive() )
		{
			totalPop = 0;
			return 0;
		}
		else if( firmPtr->cast_to_FirmOffensive2() )
		{
			totalPop = 0;
			return 0;
		}
		else
		{
			err_here();
			totalPop = 0;
		}
	}
	else
		err_here();

//.........这里部分代码省略.........

//-------- Begin of function Place::invoke_camp_defense ---------//
//
// Call out defenders from neighboring camps to help.
//
void Place::invoke_camp_defense(BaseObj* attackerObj)
{
	if( !attackerObj )
		return;

	//----- if this is an independent town -----//

	if( !nation_recno )
	{
		//---- if this is a slave town ----//

		if( cast_to_Town() && cast_to_Town()->is_pay_tribute_to_monster() )
		{
			//---- reckon the net attacking power in the battling area ----//

			int hasWar;			// ref var for returning the result

			int netAttackerPower = world.net_attacker_power_in_area(center_x, center_y,
									  attackerObj->nation_recno, nation_recno, 0, hasWar, EFFECTIVE_DEFEND_DISTANCE);

			//-- no need to call for reinforcement if the defense force is more powerful than the attacking force --//

			if( netAttackerPower <= 0 )
				return;

			//------ call enslaving lair's AI to protect it ------//

			Town* thisTown = cast_to_Town();

			for( int i=0 ; i<thisTown->linked_firm_count ; i++ )
			{
				//--- if this linked firm is a lair enslaving the town ---//

				if( thisTown->tribute_to_lair( thisTown->linked_firm_array[i], 1 ) )
				{
					FirmLair* firmLair = firm_array[ thisTown->linked_firm_array[i] ]->cast_to_FirmLair();

					if( firmLair && firmLair->is_ai )
						firmLair->invoke_defense(attackerObj, netAttackerPower);
				}
			}
		}

		return;
	}

	//---- reckon the net attacking power in the battling area ----//

	int hasWar;			// ref var for returning the result

	int netAttackerPower = world.net_attacker_power_in_area(center_x, center_y,
							  attackerObj->nation_recno, nation_recno, 0, hasWar, EFFECTIVE_DEFEND_DISTANCE);

	//-- no need to call for reinforcement if the defense force is more powerful than the attacking force --//

	if( netAttackerPower <= 0 )
		return;

	//--------- call for reinforcement now -------//

	for( int i=firm_array.size() ; i>0 ; i-- )
	{
		if( firm_array.is_deleted(i) )
			continue;

		Firm* firmPtr = firm_array[i];

		//--- look for our camp ----//

		// ###### begin Gilbert 15/4 #########//
		// if( !firmPtr->cast_to_FirmCamp() || firmPtr->nation_recno!=nation_recno )
		if( !firmPtr->cast_to_FirmCamp() || firmPtr->nation_recno!=nation_recno || nation_recno == 0 )
		// ###### end Gilbert 15/4 #########//
			continue;

		//--- only if the camp's within the effective defense distance ---//

		if( misc.points_distance(firmPtr->center_x, firmPtr->center_y, center_x, center_y )
			 > EFFECTIVE_DEFEND_DISTANCE )
		{
			continue;
		}

		//----- ask the camp to send out defenders now ------//

		int defensePower = firmPtr->cast_to_FirmCamp()->invoke_defense(attackerObj, netAttackerPower);

		netAttackerPower -= defensePower;

		if( netAttackerPower <= 0 )
			break;
	}
}

//--------- Begin of function Nation::ai_find_unit --------//
//
// <int>	isCivilian		-	whether the unit is a civilian unit
// <int>		raceId			-	the race the selected unit should have
//										(0 for any races)
// <short>	destX, destY	-	location the unit move to
// <char&>	resultFlag		-	describle how to find the skilled unit
//										0 - for unable to train unit,
//										1 - for existing skilled unit
//										2 - for unit hired from inn
//										3 - for training unit in town (training is required)
//
// [int]	   actionId - the action id. of the action which
//							  the unit should do after it has finished training.
//
// return the unit pointer pointed to the skilled unit
//
Unit* Nation::ai_find_unit(int isCivilian, int raceId, short destX, short destY, char& resultFlag, int actionId)
{
	//----- try to find an existing unit with the required skill -----//

	Unit	*wantedUnit = NULL;
	Unit	*unitPtr;
	Firm	*firmPtr;
	short	curDist, minDist=0x1000;
	int   destRegionId = world.get_region_id(destX, destY);

	for(int i=unit_array.size(); i>0; i--)
	{
		if(unit_array.is_deleted(i))
			continue;

		unitPtr = unit_array[i];

		if( unitPtr->nation_recno!=nation_recno || !unitPtr->race_id )
			continue;

		if( raceId )
		{
			if( unitPtr->race_id != raceId )
				continue;
		}
		else
		{
			if( !unitPtr->is_human() )
				continue;
		}

		//---- if this unit is on a mission ----//

		if( unitPtr->home_camp_firm_recno )
			continue;

		if( unitPtr->region_id() != destRegionId )
			continue;

		if( unitPtr->is_civilian() != isCivilian )
			continue;

		if( unitPtr->unit_mode )		// it can be a camp defender.
			continue;

		//----- if this is a mobile unit ------//

		if( unitPtr->is_visible() )
		{
			if( !unitPtr->is_all_stop() )
				continue;

			if( unitPtr->cur_action!=SPRITE_ATTACK && !unitPtr->cur_order.ai_action_id )
			{
				curDist = m.points_distance(unitPtr->next_x_loc(), unitPtr->next_y_loc(), destX, destY);

				if(curDist < minDist)
				{
					wantedUnit = unitPtr;
					minDist = curDist;
				}
			}
		}

		//------- if this is an overseer ------//

		else if( unitPtr->unit_mode==UNIT_MODE_OVERSEE )
		{
			firmPtr = firm_array[unitPtr->unit_mode_para];

			if( firmPtr->region_id != destRegionId )
				continue;

			if( firmPtr->cast_to_FirmCamp() )
			{
				//--- if this military camp is going to be closed, use this overseer ---//

				if( firmPtr->should_close_flag )
				{
					firmPtr->cast_to_FirmCamp()->mobilize_overseer();
					wantedUnit = unitPtr;       	// pick this overseer
					break;
				}
//.........这里部分代码省略.........