khanat-opennel-code/code/ryzom/server/src/entities_game_service/harvest_source.cpp

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.



#include "stdpch.h"
#include "harvest_source.h"
#include "deposit.h"
#include "egs_globals.h"
#include "phrase_manager/phrase_utilities_functions.h"
#include "entity_manager/entity_base.h"
#include "player_manager/player_manager.h"
#include "player_manager/player.h"
#include "player_manager/character.h"
#include "forage_progress.h"
#include "range_selector.h"
#include "egs_sheets/egs_sheets.h"
#include "nel/misc/variable.h"
#include "phrase_manager/s_effect.h"
#include "server_share/r2_vision.h"


using namespace NLMISC;
using namespace NLNET;
using namespace std;

NL_INSTANCE_COUNTER_IMPL(CHarvestSource);
NL_INSTANCE_COUNTER_IMPL(CHarvestSourceManager);

NL_ISO_TEMPLATE_SPEC CSimpleEntityManager<CHarvestSource>	*CSimpleEntityManager<CHarvestSource>::_Instance = NULL;

uint NbAutoSpawnedForageSources = 0;


const NLMISC::TGameCycle MaxT = 1200; // 2 min for prospected sources (TODO: external data)
const float CommonRiskThreshold = 127.0f;
const float ThresholdD1 = CommonRiskThreshold;
const float ThresholdD2 = CommonRiskThreshold * 1.20f;
const float ThresholdE = CommonRiskThreshold;
const float ThresholdC = CommonRiskThreshold;

const float DeltaMoveBarPerTick = (DeltaMoveBarPerSec / 10.0f);
const float DeltaResetBarPerTick = (DeltaResetBarPerSec / 10.0f);

sint32 ForageSourceDisplay = -1;

static const NLMISC::TGameCycle Locked = ~0;
static const NLMISC::TGameCycle IniTime = (~0)-1; // highest positive integer (suitable for unsigned)


// Minimum extraction session:
// 6 extractions = 24 seconds with 4 seconds per extraction
// Maximum extraction session:
// 80 extractions = 120 seconds with 1.5 second per extraction



// MaxA: 3.5
// MaxS: 1/15
// nlctassert(MaxAS>0);
const float MaxAS = (3.5f / 15.0f);

// MaxRequiredQ: 250; InitResultQ: 1 => MaxDeltaQ: 26
// nlctassert(MaxDeltaQ>0);
const float MaxQ = 250.0f;
const float MaxDeltaQ = 26.0f;

// { D, E, C } impacted by (0=Qtty, 1=Qlty, 2=Both)
uint ImpactSchemes [6][3] = { { 0, 1, 2 }, { 0, 2, 1 }, { 1, 0, 2 }, { 1, 2, 0 }, { 2, 0, 1 }, { 2, 1, 0 } };
// Observed impact on D (/10):     1            3            6           10            3            1
// Observed impact on E (/10):     6            3            1            1            3           10
// Note: if modifying this schemes, please change FORAGE_SOURCE_IMPACT_MODE in phrase_en.txt.
uint SpecialNewbieImpactSchemeD = 10;
uint16 LowDangerMappings [2] = { SpecialNewbieImpactSchemeD+1, SpecialNewbieImpactSchemeD+4 };

sint8 ExplosionResetPeriod = 50; // 5 s

CHarvestSource AutoSpawnSourceIniProperties;

/*
 * Initialization of source manager
 */
void CHarvestSourceManager::init( TDataSetIndex baseRowIndex, TDataSetIndex size )
{
	CSimpleEntityManager<CHarvestSource>::init( baseRowIndex, size );

	// Note: Now, most of these values are overridden by deposit settings (see CFgProspectionPhrase::autoSpawnSource())
	AutoSpawnSourceIniProperties.setLifetime( 6000 ); // 10 min
	AutoSpawnSourceIniProperties.setProspectionExtraExtractionTime( 0 ); // no extra time
	//AutoSpawnSourceIniProperties.setDistVis( 100 );
}



/*
 * HarvestSource constructor
 */
CHarvestSource::CHarvestSource()
{
	_NbExtractions = 0;
	_ForageSite = NULL;
	_DepositForK = NULL;

	// Set default values (TODO: external data)
	_LifeTime = 200; // 20 s
	_ExtractionTime = 250; // 25 s for initial extraction time (now, recalculated using quality of material)
	_ExtraExtractionTime = 25; // 2.5 s
	_IncludedBonusExtractionTime = 0;
	_T = Locked; // until spawn is completed
	_S = 0.025f; // 4 s per delivery (initial value may be not used by the extraction action)
	_A = 0.1f;
	_Q = 1.0f;
	_D = 0;
	_E = 0;
	_TargetRTProps[TargetD] = 0;
	_TargetRTProps[TargetE] = 0;
	//_C = 0;
	_MaxQuality = ~0;
	_IImpactMappingScheme = 0;
	_N = 0;	
	_IsInNewbieMode = false;
	_BonusForAPct = 0;
	//_DistanceVisibility = 80;
	//_StealthVisibility = VISIBILITY_RIGHTS::All;
	_IsExtractionInProgress = false;
	_ExplosionResetCounter = -1;
	_IsAutoSpawned = false;
	_SafeSource = false;
	_NbEventTriggered = 0;
}


/*
 * HarvestSource destructor
 */
CHarvestSource::~CHarvestSource()
{
	// unregister the deposit auto spawn if any
	setDepositAutoSpawn(NULL);
}


/*
 * setDepositAutoSpawn
 */
void	CHarvestSource::setDepositAutoSpawn(CDeposit *deposit)
{
	// unregister the current deposit, if any
	if(_DepositAutoSpawn)
	{
		_DepositAutoSpawn->decreaseAutoSpawnedSources();
		_DepositAutoSpawn= NULL;
	}

	// register the new one if any
	if(deposit)
	{
		_DepositAutoSpawn= deposit;
		_DepositAutoSpawn->increaseAutoSpawnedSources();
	}
}


/*
 * Init the source. All pointers must be valid (but forageSite may be NULL).
 * Return false if the current quantity in the deposit is 0.
 */
bool CHarvestSource::init( const CHarvestSource& ini, const NLMISC::CVector2f& pos,
	CRecentForageSite *forageSite,
	CDeposit *depositForK,
	const CStaticDepositRawMaterial *rmInfo, float quantityRatio )
{
	initFrom( ini );
	setPos( pos );
	setForageSite( forageSite );
	bool isNonEmpty = setRawMaterial( rmInfo, quantityRatio );

	// Set link to deposit for kami anger level
	_DepositForK = depositForK;

	return isNonEmpty;
}


/*
 * Set the raw material, the initial amount and the max quality, or return false if the current quantity in the deposit is 0.
 */
bool CHarvestSource::setRawMaterial( const CStaticDepositRawMaterial *rmInfo, float quantityRatio )
{
	H_AUTO(CHarvestSource_setRawMaterial);
	
	_MaterialSheet = rmInfo->MaterialSheet;

	// Get corresponding initial quantity & max quality
	const CStaticItem *staticItem = CSheets::getForm( _MaterialSheet );
	if ( staticItem && staticItem->Mp )
	{
		/// The quantity is a fraction of the 'Stackable' property (but it is limited by the constraints of the deposit)
		_N = min( max( (((float)staticItem->Stackable) * quantityRatio), 1.0f ), _ForageSite->getQuantityInDeposit() );

		// Select either the MaxQuality in the deposit primitive or in the RM sheet (if -1 in the deposit, or no deposit)
		sint16 depositMaxQuality = _ForageSite ? _ForageSite->deposit()->maxQuality() : -1;
		if ( depositMaxQuality != -1 )
			_MaxQuality = (uint16)depositMaxQuality;
		else
			_MaxQuality = staticItem->Mp->MaxQuality;
		//nldebug( "Quality limited by source to %hu", _MaxQuality );

		if ( _N == 0 )
			return false;
	}
	else
	{
		nlwarning( "%s is not a valid raw material sheet", _MaterialSheet.toString().c_str() );
		return false;
	}
	return true;
}


/*
 * Recalculate the remaining extraction time depending on the requested quality.
 * Does nothing if the source is in "extra extraction time".
 * _ExtraExtractionTime is included in _ExtraExtractionTime.
 *
 * Precondition: _ExtractionTime != 0
 */
void CHarvestSource::recalcExtractionTime( float requestedQuality )
{
	if ( _T > _ExtraExtractionTime )
	{
		nlassert( _ExtractionTime > _ExtraExtractionTime );
		float timeRatio = ((float)_T) / ((float)_ExtractionTime);
		//float fExtractionTime = requestedQuality*(0.3092f*10.0f) + (22.0f*10.0f); // Q10 -> 25 s; Q250 -> 1'40 s
		float fExtractionTime = requestedQuality*ForageExtractionTimeSlopeGC.get() + ForageExtractionTimeMinGC.get() + (float)_ExtraExtractionTime;
		_ExtractionTime = (NLMISC::TGameCycle)fExtractionTime;
		_T = (NLMISC::TGameCycle)(fExtractionTime * timeRatio);
	}
}


/*
 * Prepare the source as an unpublished entity in mirror. Return false in case of failure. 
 * Must be called *after* init().
 * prospectorDataSetRow must be either null (isNull()) or an accessible row (isAccessible()).
 */
bool CHarvestSource::spawnBegin( uint8 knowledgePrecision, const TDataSetRow& prospectorDataSetRow, bool isAutoSpawned )
{
	H_AUTO(CHarvestSource_spawn);
	
	// Add into mirror (but unpublished)
	CEntityId entityId = CEntityId::getNewEntityId( RYZOMID::forageSource );
	if ( ! Mirror.createEntity( entityId ) )
		return false;
	_DataSetRow = TheDataset.getDataSetRow( entityId );
	_IsAutoSpawned = isAutoSpawned;

	// Set the sheet id (including knowledge information)
	uint sourceFXIndex = _ForageSite ? (uint)_ForageSite->deposit()->sourceFXIndex() : 0;
	CMirrorPropValue<TYPE_SHEET> sheet( TheDataset, _DataSetRow, DSPropertySHEET );
	sheet = CSheetId( toString( "%u_%u.forage_source", sourceFXIndex, knowledgePrecision ) ).asInt();

	// For knowledge 3, fit the sheet id of the RM sitem into NAME_STRING_ID (instead of a string id) !
	CMirrorPropValue<TYPE_NAME_STRING_ID> nameId( TheDataset, _DataSetRow, DSPropertyNAME_STRING_ID );
	nameId = (knowledgePrecision == 3) ? _MaterialSheet.asInt() : 0;
	if ( knowledgePrecision != 0 )
	{
		const CStaticItem *staticItem = CSheets::getForm( materialSheet() );
		if ( staticItem && staticItem->Mp )
		{
			// Set additional knowledge info into VISUAL_FX
			CMirrorPropValue<TYPE_VISUAL_FX> visualFx( TheDataset, _DataSetRow, DSPropertyVISUAL_FX );
			switch ( knowledgePrecision )
			{
			case 1: visualFx = (TYPE_VISUAL_FX)staticItem->Mp->getGroup(); break; // initializes the prop, but only 10 bits allowed
			case 2: // family sent for 2 & 3 (for knowledge 3, used only as icon index)
			case 3: visualFx = (TYPE_VISUAL_FX)staticItem->Mp->Family; break; // initializes the prop, but only 10 bits allowed
			default:; // default value is 0
			}
			if ( (visualFx() & 0x400) != 0 )
			{
				nlwarning( "FG: Family or group index exceeding max!" ); // bit 10 is reserved for explosion FX
				visualFx = 0;
			}
		}
	}

	// Set the target (the prospector, or a nul datasetrow if auto-spawned)
	CMirrorPropValue<TYPE_TARGET_ID> targetRow( TheDataset, _DataSetRow, DSPropertyTARGET_ID );
	targetRow = prospectorDataSetRow;

	// Add to manager so that update() will be called at each game cycle
	CHarvestSourceManager::getInstance()->addEntity( this ); // we don't do it in spawnEnd(), because the source would remain unpublished forever if the AIS quit before replying to the transport class message

	return true;
}


/*
 * Complete the source spawn: publish the entity in mirror or delete it.
 * Caution: if authorized, the source object is deleted!
 */
void CHarvestSource::spawnEnd( bool authorized )
{
	if ( ! authorized )
	{
		despawn();
		CHarvestSourceManager::getInstance()->destroyEntity( _DataSetRow );
		return;
	}

	// Unlock update
	_ExtractionTime = IniTime; // will trigger calculation in recalcExtractionTime() because _T > _ExtraExtractionTime
	_T = _ExtractionTime;      // ratio 1.0 => beginning of extraction time

	if ( _IsAutoSpawned )
		++NbAutoSpawnedForageSources;

	// Set the initial position
	CMirrorPropValue<TYPE_POSX> posX( TheDataset, _DataSetRow, DSPropertyPOSX );
	CMirrorPropValue<TYPE_POSY> posY( TheDataset, _DataSetRow, DSPropertyPOSY );
	posX = (TYPE_POSX)(_Pos.x * 1000.0f);
	posY = (TYPE_POSY)(_Pos.y * 1000.0f);

	// Set the WhoSeesMe bitfield (distance of visibility by players (0-31) and creatures (32-63)) (now constant)
	uint32 nbBitsOn = /*_DistanceVisibility*/80 * 32 / 250; // (250 m is the max, corresponding to 32 bits on
	const uint64 distanceBitfield = IsRingShard? R2_VISION::buildWhoSeesMe(R2_VISION::WHOSEESME_VISIBLE_MOB,false): ((uint64)1 << (uint64)nbBitsOn) - 1; // (hide to creatures)
	CMirrorPropValue<TYPE_WHO_SEES_ME> whoSeesMe(TheDataset, _DataSetRow, DSPropertyWHO_SEES_ME );
	whoSeesMe = distanceBitfield;

	// Set selectable property to true
	CMirrorPropValue<TYPE_CONTEXTUAL> contextualProperties(TheDataset, _DataSetRow, DSPropertyCONTEXTUAL );
	CProperties prop(0);
	prop.selectable(true);
	contextualProperties = prop;

	// Update bars and other variable properties
	updateVisuals();

	// Publish in mirror
	TheDataset.declareEntity( _DataSetRow );
}


/*
 * Return the prospector or a null datasetrow if there was no prospection (auto-spawn)
 * The accessibility of this datasetrow must be checked before use.
 */
const TDataSetRow& CHarvestSource::getProspectorDataSetRow() const
{
	CMirrorPropValueRO<TYPE_TARGET_ID> targetRow( TheDataset, _DataSetRow, DSPropertyTARGET_ID );
	return targetRow();
}


/*
 * Despawn the source in mirror, and exit from forage site
 */
void CHarvestSource::despawn()
{
	H_AUTO(CHarvestSource_despawn);
	
	// Remove from mirror
	CEntityId entityId = TheDataset.getEntityId( _DataSetRow );
	Mirror.removeEntity( entityId );

	//nldebug( "--- %p from %p", this, _ForageSite );

	// Exit from forage site (the entering is done outside class, because a failure may prevent to create the source)
	if ( _ForageSite )
		_ForageSite->removeActiveSource();

	if ( _IsAutoSpawned )
		--NbAutoSpawnedForageSources;

	// End forage sessions and calculate XP and give result
	if ( ! _Foragers.empty() )
	{
		// The first forager is the only one who can extract. Give result & dispatch XP
		CForagers::const_iterator it = _Foragers.begin();
		CCharacter *player = PlayerManager.getChar( *it );
		if ( player && player->forageProgress() )
		{
			if ( player->forageProgress()->sourceRowId() == _DataSetRow ) // check if he has not changed his target
			{
				player->giveForageSessionResult( this );
			}
		}

		// End sessions of care takers (all excluding the first element)
		for ( ++it; it!=_Foragers.end(); ++it )
		{
			player = PlayerManager.getChar( *it );
			if ( player && player->forageProgress() )
			{
				if ( player->forageProgress()->sourceRowId() == _DataSetRow ) // check if he has not changed his target
				{
					player->endForageSession();
				}
			}
		}
	}
}


/*
 * Helper for updateVisiblePostPos()
 */
inline void updateBarValueAtTick( float& destValue, float& currentValue )
{
	float diff = destValue - currentValue;
	if ( diff > 0 )
	{
		currentValue = std::min( destValue, currentValue + DeltaMoveBarPerTick );
	}
	else if ( diff < 0 )
	{
		float delta = (currentValue == 0) ? DeltaResetBarPerTick : DeltaMoveBarPerTick;
		currentValue = std::max( destValue, currentValue - delta );
	}
}


/*
 * Update
 */
bool CHarvestSource::update()
{
	H_AUTO(CHarvestSource_update);
	
	if ( _IsExtractionInProgress )
	{
		// Make the bar transitions smooth (needs to be done on server to match timing on client)
		updateBarValueAtTick( _TargetRTProps[TargetD], _D );
		updateBarValueAtTick( _TargetRTProps[TargetE], _E );

		// Test damaging event risk
		if ( _E > ThresholdE )
		{
			makeDamagingEvent();
			setEventTriggered();
			impactRTProp( TargetE, 0 );
		}
		// Test spawn risk
		/*if ( _C > ThresholdC )
		{
			//sendMessageToExtractors( "CREATURE_SPAWN" );
			// TODO
			//setEventTriggered();
			_C = 0;
		}*/

		// Test depletion risk (if the bar transition is still in progress, wait)
		if ( (_D > ThresholdD1) )
		{
			// if high risk value, deplete all the forage site (if exist and allow depletion)
			if ( _ForageSite && _ForageSite->allowDepletionRisk() && _TargetRTProps[TargetD] > ThresholdD2 )
			{
				sendMessageToExtractors( "FORAGE_SOURCE_SITE_DEPLETED" );
				_ForageSite->depleteAll();
			}
			// else will just kill the current source (send appropriate message)
			else
				sendMessageToExtractors( "FORAGE_SOURCE_DEPLETED" );
			// in all case kill the current source, and add bad event
			setEventTriggered();
			despawn();
			return false;
		}
		// Test remaining time
		else if ( _T == 0 )
		{
			despawn();
			return false;
		}
		else
		{
			--_T;
			float naturalMoveThreshold = CommonRiskThreshold - 2.0f;
			if ( _TargetRTProps[TargetD]+ForageExtractionNaturalDDeltaPerTick.get() < naturalMoveThreshold ) // don't auto-move if it makes it trigger the event
				impactRTProp( TargetD, _TargetRTProps[TargetD] + ForageExtractionNaturalDDeltaPerTick.get() );
			if (!_SafeSource)
			{
				if ( _TargetRTProps[TargetE]+ForageExtractionNaturalEDeltaPerTick.get() < naturalMoveThreshold )
					impactRTProp( TargetE, _TargetRTProps[TargetE] + ForageExtractionNaturalEDeltaPerTick.get() );
			}
			if ( _DataSetRow.getIndex() == (TDataSetIndex)ForageSourceDisplay )
				nldebug( "T: %u", _T );
			updateVisuals();
			return true;
		}
	}
	else
	{
		// Remain locked if the source is not fully spanwed yet
		if ( _T == Locked )
			return true;

		// Test end of lifetime
		if ( _LifeTime == 0 )
		{
			despawn();
			return false;
		}
		else
		{
			--_LifeTime;
			if ( _DataSetRow.getIndex() == (TDataSetIndex)ForageSourceDisplay )
				nldebug( "_LifeTime: %u", _LifeTime );
			return true;
		}
	}
}


/*
 * Update visual properties & related stuff
 */
void CHarvestSource::updateVisuals()
{
	H_AUTO(CHarvestSource_updateVisuals);
	
	// Set the bars on the entity
	TYPE_BARS statusBar;
	float d = (_TargetRTProps[TargetD] > ForageCareBeginZone.get()) ? _TargetRTProps[TargetD] : 0;
	if ( d > CommonRiskThreshold )
		d = CommonRiskThreshold;
	float e = (_TargetRTProps[TargetE] > ForageCareBeginZone.get()) ? _TargetRTProps[TargetE] : 0;
	if ( e > CommonRiskThreshold )
		e = CommonRiskThreshold;
	statusBar = (_T==IniTime) ? 127 : uint32((_T*127/_ExtractionTime/2)*2); // time progression (round off to 2 to reduce flooding by 30% (taking D & E into account))
	if ( _N != 0 )
		statusBar = statusBar | ((uint32(_N)+1) << 7); // round off to next integer (TODO: ratio qtty/initial_qtty)
	statusBar = statusBar | (uint32((127.0f-d)/**127.0f*/) << 14);
	if (!_SafeSource) // If source is safe let 0 (client will display it full and with a special color)
		statusBar = statusBar | (uint32((127.0f-e)/**127.0f*/) << 21);
	statusBar = statusBar | (((uint32)(_IsExtractionInProgress)) << 28);
	//statusBar = statusBar | (uint32(_C/**127.0f*/) << 28);
	CMirrorPropValue<TYPE_BARS> statusBarProp( TheDataset, _DataSetRow, DSPropertyBARS );
	statusBarProp = statusBar;

	/*if ( (_N < 0) || (_N > 127) )
		nlwarning( "FG: N = %g", _N );
	if ( (_D < 0) || (_D > 127) )
		nlwarning( "FG: N = %g", _D );
	if ( (_E < 0) || (_E > 127) )
		nlwarning( "FG: N = %g", _E );*/

	// Set kami angry level information & extra time state (store in orientation!)
	float angryLevel7 = 127.0f - (127.0f * _DepositForK->kamiAnger() / ForageKamiAngerThreshold2.get());
	uint extraTime7 = _ExtraExtractionTime * 127 / _ExtractionTime;
	uint inclBonusExtraTime7 = _IncludedBonusExtractionTime * 127 / _ExtractionTime;

	CMirrorPropValue<TYPE_ORIENTATION> angryLevelExtraTimeProp( TheDataset, _DataSetRow, DSPropertyORIENTATION );
	TYPE_ORIENTATION angryLevelExtraTimePropV = angryLevel7;
	if ( _IsExtractionInProgress )
		angryLevelExtraTimePropV += (( ((float)inclBonusExtraTime7) * 128.0f + (float)extraTime7) * 128.0f);
	angryLevelExtraTimeProp = angryLevelExtraTimePropV; // stored as float, should be converted to 21b uint by FS

	// Reset explosion visual fx if needed
	if ( _ExplosionResetCounter == 0 )
	{
		CMirrorPropValue<TYPE_VISUAL_FX> visualFx( TheDataset, _DataSetRow, DSPropertyVISUAL_FX );
		visualFx = (visualFx() & 0x3FF); // unset bit 10
		_ExplosionResetCounter = -1;
	}
	else if ( _ExplosionResetCounter > 0 )
	{
		--_ExplosionResetCounter;
	}
}


/*
 *
 */
void CHarvestSource::sendMessageToExtractors( const char *msg )
{
	H_AUTO(CHarvestSource_sendMessageToExtractors);
	
	CForagers::const_iterator it;
	for ( it=_Foragers.begin(); it!=_Foragers.end(); ++it )
	{
		const TDataSetRow& extRowId = (*it);
		PHRASE_UTILITIES::sendDynamicSystemMessage( extRowId, msg );
	}
}


/*
 *
 */
void CHarvestSource::sendMessageToExtractors( const char *msg, sint32 param )
{
	H_AUTO(CHarvestSource_sendMessageToExtractors);
	
	CForagers::const_iterator it;
	for ( it=_Foragers.begin(); it!=_Foragers.end(); ++it )
	{
		const TDataSetRow& extRowId = (*it);
		SM_STATIC_PARAMS_1(params, STRING_MANAGER::integer);
		params[0].Int = param;
		PHRASE_UTILITIES::sendDynamicSystemMessage( extRowId, msg, params );
	}
}


CVariable<sint32> ForageForceImpactScheme( "egs", "ForageForceImpactScheme", "", -1 );

/*
 * Begin an extraction action. Once the extraction process is started, the source remains in
 * extraction mode until the extraction time is elapsed (even if players stop/restart
 * extracting).
 * Return true if the forager is the extractor (the first one on the source)
 */
bool CHarvestSource::beginExtraction( const TDataSetRow& forager, bool isNewbie )
{
	H_AUTO(CHarvestSource_beginExtraction);
	
	bool foragerIsFirstExtractor = false;
	if ( ! _IsExtractionInProgress )
	{
		_IsExtractionInProgress = true;
		foragerIsFirstExtractor = true;
		_IsInNewbieMode = isNewbie; // only the first one sets the mode

		// Tell him the max quality
		SM_STATIC_PARAMS_1(params, STRING_MANAGER::integer);
		params[0].Int = (sint32)_MaxQuality;
		PHRASE_UTILITIES::sendDynamicSystemMessage( forager, "FORAGE_SOURCE_MAXLEVEL", params );

		// Set the impact scheme
		setNewImpactScheme(); // at this time, _Foragers is empty so nobody is told yet
	}

	// Add player to extractor to list (if new)
	CForagers::iterator it = find( _Foragers.begin(), _Foragers.end(), forager );
	if ( it == _Foragers.end() )
	{
		_Foragers.push_back( forager );

		// Tell him the impact mode
		SM_STATIC_PARAMS_1(params, STRING_MANAGER::integer);
		params[0].Int = (sint32)_IImpactMappingScheme;
		PHRASE_UTILITIES::sendDynamicSystemMessage( forager, "FORAGE_SOURCE_IMPACT_MODE", params );
	}
	else if ( it == _Foragers.begin() )
	{
		foragerIsFirstExtractor = true;
	}

	return foragerIsFirstExtractor;
}


/*
 * Set a new mapping scheme of property impact
 */
void CHarvestSource::setNewImpactScheme()
{
	H_AUTO(CHarvestSource_setNewImpactScheme);
	
	// Set mapping scheme of property impact
	if ( _IsInNewbieMode )
	{
		// Force "low dangers" for 1 newbie extractor
		_IImpactMappingScheme = (uint16)LowDangerMappings[RandomGenerator.rand( 1 )];
	}
	else
	{
		// Normal dangers
		if ( ForageForceImpactScheme.get() == -1 )
			_IImpactMappingScheme = (uint16)RandomGenerator.rand( 5 );
		else
			_IImpactMappingScheme = (uint16)ForageForceImpactScheme.get();
	}

	sendMessageToExtractors( "FORAGE_SOURCE_IMPACT_MODE", (sint32)_IImpactMappingScheme );

#ifdef NL_DEBUG
	nldebug( "FG: map scheme: %u", _IImpactMappingScheme );
#endif
}


bool ForceDropProp = false;
NLMISC_VARIABLE( bool, ForceDropProp, "" );

CVariable<float> ForceAbsorption( "egs", "ForceAbsorption", "", 0 );


/*
 * Update the source state with an extraction (see doc in .h).
 */
void CHarvestSource::extractMaterial( float *reqPosProps, float *absPosProps, float qualityCeilingFactor, float qualitySlowFactor, float *results, float successFactor, uint8 lifeAbsorberRatio, const TDataSetRow& extractingEntityRow, CHarvestSource::TRealTimeProp& propDrop )
{
	H_AUTO(CHarvestSource_extractMaterial);

	CCharacter* player = PlayerManager.getChar( extractingEntityRow );
	
	++_NbExtractions; // it's 1 at the first call, so that the initial value is used
	float nbe = (float)_NbExtractions;

	if ( (successFactor < 0.1f) || ForceDropProp )
	{
		if ( _NbExtractions < 6 )
			propDrop = Q; // don't drop A at the beginning (wait to reach 1 (cumulated) would be better)
		else
			propDrop = (TRealTimeProp)(RandomGenerator.rand(1)+1);
		nldebug( "Prop drop %u", propDrop );
	}

	// Aperture: converges towards the requested value, except when a drop occurs (0 at this step)
//	if ( reqPosProps[A] > 0 )
	{
		float obtainedQuantity = (propDrop == A) ? 0.0f : (results[A]*ForageQuantitySlowFactor.get() + reqPosProps[A]) / (ForageQuantitySlowFactor.get()+1);

		// Apply possible aperture bonus
		if ( _BonusForAPct != 0 )
		{
			obtainedQuantity += obtainedQuantity * (float)((uint)_BonusForAPct) * 0.01f;
		}
		
		// Extract material
		if ( _ForageSite )
			obtainedQuantity = _ForageSite->consume( obtainedQuantity ); // consume (and limit) in forage site & deposit
		if ( obtainedQuantity > _N ) // should not occur because _N uses the deposit quantity
			obtainedQuantity = _N;
		_N -= obtainedQuantity;
		_A = (_A*nbe + obtainedQuantity) / (nbe + 1.0f); // average per source
		_DepositForK->incKamiAnger( obtainedQuantity, _Foragers );
		if ( (obtainedQuantity == 0) && (results[A] != 0) && (! (propDrop == A)) )
			PHRASE_UTILITIES::sendDynamicSystemMessage( _Foragers[0], "FORAGE_DEPOSIT_IS_EMPTY" );
		results[A] = obtainedQuantity;
		
		// add spire effect ( quantity )
		if ( player )
		{
			const CSEffect* pEffect = player->lookForActiveEffect( EFFECT_FAMILIES::TotemHarvestQty );
			if ( pEffect != NULL )
			{
				results[A] *= ( 1.0f + pEffect->getParamValue() / 100.0f );
			}
		}
		// add item special effect
		if ( player )
		{
			std::vector<SItemSpecialEffect> effects = player->lookForSpecialItemEffects(ITEM_SPECIAL_EFFECT::ISE_FORAGE_ADD_RM);
			std::vector<SItemSpecialEffect>::const_iterator it, itEnd;
			double addedQty = 0.;
			for (it=effects.begin(), itEnd=effects.end(); it!=itEnd; ++it)
			{
				float rnd = RandomGenerator.frand();
				if (rnd<it->EffectArgFloat[0])
				{
					addedQty += it->EffectArgFloat[1];
					PHRASE_UTILITIES::sendItemSpecialEffectProcMessage(ITEM_SPECIAL_EFFECT::ISE_FORAGE_ADD_RM, player, NULL, (sint32)(it->EffectArgFloat[1]*100.));
				}
			}
			results[A] *= 1.0f + (float)addedQty;
		}
	}
//	else
//	{
//		results[A] = 0;
//	}

	// Speed: always the requested speed (otherwise, looks like a bug for the player when it's the speed of the action)
	results[S] = reqPosProps[S];
	_S = (_S*nbe + results[S]) / (nbe + 1.0f); // average per source

	// Quality: converges towards the requested value, except when a drop occurs (0 at this step)
	float usedReqQ = (propDrop == Q) ? 0.0f : reqPosProps[Q] * qualityCeilingFactor;
	float resQ = (results[Q]*qualitySlowFactor + usedReqQ) / (qualitySlowFactor+1);
	float maxQOfSource = (float)_MaxQuality;
	if ( resQ > maxQOfSource )
	{
		resQ = maxQOfSource;
		//if ( results[Q] < (float)_MaxQuality )
		//	nldebug( "Quality limited by source to %hu", _MaxQuality ); // TODO: tell the player(s)
	}
	if ( (resQ < _Q) || (resQ < reqPosProps[Q]) || (! ForageQualityCeilingClamp.get()) )
	{
		// Set Q only if not increasing and exceeding requested quality
		results[Q] = resQ;
	}
	else
	{
		// Clamp Q to the max required by the player
		results[Q] = reqPosProps[Q];
	}
	float prevQ = _Q;
	_Q = results[Q]; // now there is only one extractor => the Q of the source is the resulting Q
	if ( ((prevQ < reqPosProps[Q]) && (_Q == reqPosProps[Q])) || ((prevQ < maxQOfSource) && (_Q == maxQOfSource)) )
	{
		setNewImpactScheme(); // we just reached the max quality
	}

	// Calc impact of the new average values

	// Previously, the impact depended on the level of the extraction:
	// float quantityBaseImpact = _A * _S * ForageQuantityImpactFactor.get();
	// float qualityBaseImpact = (_Q - oldQ) * ForageQualityImpactFactor.get();
	//
	// Now it's constant (=max), but the amount of damage depends on the level of the extraction:
	float quantityBaseImpact = MaxAS * ForageQuantityImpactFactor.get();
	float qualityBaseImpact = MaxDeltaQ * ForageQualityImpactFactor.get();
	uint impactScheme = _IImpactMappingScheme;
	if ( impactScheme >= SpecialNewbieImpactSchemeD)
	{
		// Lower impacts for newbies
		impactScheme -= SpecialNewbieImpactSchemeD;
		quantityBaseImpact *= 0.5f;
		qualityBaseImpact *= 0.5f;
	}
	if ( ForceAbsorption.get() != 0 )
	{
		absPosProps[A] = ForceAbsorption.get();
		absPosProps[Q] = ForceAbsorption.get();
		absPosProps[S] = ForceAbsorption.get();
	}
	for ( uint i=D; i!=NbRTProps; ++i )
	{
		if (i==E && _SafeSource)
			break;
		uint impactType = ImpactSchemes[impactScheme][i-NbPosRTProps];
		float impact;
		switch ( impactType )
		{
		case 0 : impact = quantityBaseImpact * (1.0f - absPosProps[A]); break;
		case 1 : impact = qualityBaseImpact * (1.0f - absPosProps[Q]); break;
		default: impact = (quantityBaseImpact + qualityBaseImpact) / 2.0f * (1.0f - absPosProps[S]); break; // bound on the average of both, absorption of S
		}

		impact += RandomGenerator.frandPlusMinus( impact ); // result impact from 0 to impact*2
		
		// add spire effect ( aggressivity )
		if ( player )
		{
			const CSEffect* pEffect = player->lookForActiveEffect( EFFECT_FAMILIES::TotemHarvestAgg );
			if ( pEffect != NULL )
			{
				impact *= ( 1.0f - pEffect->getParamValue() / 100.0f );
			}
		}

		if ( impact < 0 ) impact = 0; // impact can't be negative
		if ( (i==D) && (lifeAbsorberRatio != 0) )
		{
			// Damage the life absorber, instead of impacting D
			CEntityBase *entity = CEntityBaseManager::getEntityBasePtr( extractingEntityRow ); // getEntityBasePtr() tests TheDataset.isAccessible( extractingEntity )
			if ( entity )
			{
				float impactOnHP = ((float)lifeAbsorberRatio) * impact * 0.01f;
				impact -= impactOnHP;
				float dmgRatio = impactOnHP * ForageHPRatioPerSourceLifeImpact.get();
				sint32 dmg = (sint32)((float)entity->maxHp() * dmgRatio);
				if ( dmg != 0 )
					CHarvestSource::hitEntity( RYZOMID::forageSource, entity, dmg, dmg, true );
			}
		}
		if ( (_TargetRTProps[i-D] < CommonRiskThreshold*0.90f) && (_TargetRTProps[i-D] + impact > CommonRiskThreshold) )
		{
			// Avoid a brutal unnatural end, make a step just before reaching threshold
			impactRTProp( (TTargetRTProp)(i-D), CommonRiskThreshold - 2.0f );
		}
		else
		{
			// Normal impact
			impactRTProp( (TTargetRTProp)(i-D), _TargetRTProps[i-D] + impact );
		}
	}
}


/*
 * Update the source state with a care (see doc in .h)
 */
void CHarvestSource::takeCare( float *deltas, bool *isUseful )
{
	H_AUTO(CHarvestSource_takeCare);
	
	// Do not count care if from the "begin zone"
	if ( _TargetRTProps[TargetD] > ForageCareBeginZone.get() )
		*isUseful = true;
	if ( _TargetRTProps[TargetE] > ForageCareBeginZone.get() )
		*isUseful = true;
	//if ( deltas[DeltaD] > ForageCareBeginZone.get() )
	//	*isUseful = true;

	// Calc actual deltas
	deltas[DeltaD] += RandomGenerator.frandPlusMinus( deltas[DeltaD]*0.05f );
	deltas[DeltaE] += RandomGenerator.frandPlusMinus( deltas[DeltaE]*0.05f );
	//deltas[DeltaC] += RandomGenerator.frandPlusMinus( deltas[DeltaC]*0.05f );

	// TODO: impact on S,A,Q

	// Apply deltas
	float targetValue = _TargetRTProps[TargetD] - (deltas[DeltaD] * ForageCareFactor.get());
	if ( targetValue < 0 )
		targetValue = 0;
	impactRTProp( TargetD, targetValue );
	if (!_SafeSource)
	{
		targetValue = _TargetRTProps[TargetE] - (deltas[DeltaE] * ForageCareFactor.get());
		if ( targetValue < 0 )
			targetValue = 0;
		impactRTProp( TargetE, targetValue );
	}
	//_C -= (deltas[DeltaC] * ForageCareFactor.get());
	//if ( _C < 0 ) _C = 0;
}


/*
 * When the threshold of E is reached.
 */
void CHarvestSource::makeDamagingEvent()
{
	H_AUTO(CHarvestSource_makeDamagingEvent);
	
	sint32 r = RandomGenerator.rand( 1 );
	if ( r == 0 )
	{
		spawnToxicCloud();
	}
	else
	{
		explode();
	}

	_Events.clear();
	setNewImpactScheme();
}


/*
 *
 */
class CForageDamagingEventRangeSelector : public CRangeSelector
{
public:
	void buildTargetList( sint32 x, sint32 y, float radius /*, float minFactor*/ )
	{
		H_AUTO(CForageDamagingEventRangeSelector_buildTargetList);
		
		buildDisc( 0, x, y, radius, EntityMatrix, true );
	}

	float getFactor( uint entityIdx )
	{
		return 1.0f; // every entity in the radius gets the same damage, not depending of his location
	}				 // improvement note: for explosion, could be decreasing with the distance
};


/*
 * A continuous damaging event 
 */
void CHarvestSource::spawnToxicCloud()
{
	H_AUTO(CHarvestSource_spawnToxicCloud);
	
	sendMessageToExtractors( "SOURCE_TOXIC_CLOUD" );

	// Get random cloud params near the source (TODO: Z)
	float dmgFactor = getDamageFactor();
	sint32 iRadius = min( (sint32)2, (sint32)(dmgFactor * 3.0f) ); // => mapping [0..1] to {0, 1, 2}
	float Radiuses [3] = { 1.5f, 3.0f, 5.0f }; // corresponding to the 3 sheets
	float radius = Radiuses[iRadius];
	CVector cloudPos( _Pos.x, _Pos.y, 0.0f );
	if ( iRadius != 0 )
	{
		// For a big toxic cloud, shift the centre in a axis-aligned square of 4 m width (max dist = 2.8 m)
		const float MaxAxisDistFromSource = 2.0f;
		float dX = RandomGenerator.frand( MaxAxisDistFromSource*2.0f );
		float dY = RandomGenerator.frand( MaxAxisDistFromSource*2.0f );
		cloudPos.x += dX - MaxAxisDistFromSource;
		cloudPos.y += dY - MaxAxisDistFromSource;
	}

	// Spawn the toxic cloud
	CToxicCloud *tc = new CToxicCloud();
	tc->init( cloudPos, radius, (sint32)(dmgFactor * ToxicCloudDamage.get()), ToxicCloudUpdateFrequency );

	CSheetId sheet( toString( "toxic_cloud_%d.fx", iRadius ));
	if ( tc->spawn( sheet ) )
	{
		CEnvironmentalEffectManager::getInstance()->addEntity( tc );
#ifdef NL_DEBUG
		nldebug( "FG: Toxic cloud spawned (radius %g)", radius );
#endif
	}
	else
	{
		nlwarning( "FG: Unable to spawn toxic cloud (mirror range full?)" );
		delete tc;
	}
}


/*
 * Test which entities to hit (all entities except NPC and non-pets creatures)
 */
inline bool isAffectedByForageDamage( CEntityBase *entity )
{
	uint8 entityType = entity->getId().getType();
	return ! ((entityType == RYZOMID::npc) ||
			  ((entityType == RYZOMID::creature) &&
			   (entity->getRace() != EGSPD::CPeople::MektoubMount) &&
			   (entity->getRace() != EGSPD::CPeople::MektoubPacker)));
}


/*
 * A one-time damaging event
 */
void CHarvestSource::explode()
{
	H_AUTO(CHarvestSource_explode);

	sendMessageToExtractors( "SOURCE_EXPLOSION" );

	// Set the FX
	CMirrorPropValue<TYPE_VISUAL_FX> visualFx( TheDataset, _DataSetRow, DSPropertyVISUAL_FX );
	visualFx = (visualFx() | 0x400); // set bit 10
	_ExplosionResetCounter = ExplosionResetPeriod;

	// Get entities around the source, and hit them
	if ( HarvestAreaEffectOn )
	{
		// Calculate damage
		float fDmg = getDamageFactor() * ForageExplosionDamage.get();
		float dmgAvoided = fDmg;
		for ( CRDEvents::const_iterator iev=_Events.begin(); iev!=_Events.end(); ++iev )
		{
			const CReduceDamageEvent& event = (*iev);
			if ( CTickEventHandler::getGameCycle() - event.Time < ForageReduceDamageTimeWindow.get() )
			{
				//nldebug( "Damage %.1f x %.1f", fDmg, event.Ratio );
				fDmg *= event.Ratio; // multiple events are multiplied (e.g. 50% and 50% again do 25%)
			}
		}
		dmgAvoided = dmgAvoided - fDmg;
		bool wereAllEventsMissed = (! _Events.empty()) && (dmgAvoided == 0);

		// Make area of effect
		const float explosionRadius = 4.0f;
		CForageDamagingEventRangeSelector targetSelector;
		targetSelector.buildTargetList( (sint32)(_Pos.x * 1000.0f), (sint32)(_Pos.y * 1000.0f), explosionRadius );
		const vector<CEntityBase*>& targets = targetSelector.getEntities();
		for ( vector<CEntityBase*>::const_iterator it=targets.begin(); it!=targets.end(); ++it )
		{
			CEntityBase *entity = (*it);
			if ( entity && isAffectedByForageDamage( entity ) )
			{
				sint32 dmg = (sint32)(entity->getActualDamageFromExplosionWithArmor( fDmg ));
				CHarvestSource::hitEntity( RYZOMID::forageSource, entity, dmg, (sint32)(fDmg+dmgAvoided), false, (sint32)dmgAvoided );  // is not blocked by any armor

				if ( wereAllEventsMissed && (entity->getId().getType() == RYZOMID::player) )
				{
					PHRASE_UTILITIES::sendDynamicSystemMessage( entity->getEntityRowId(), "SOURCE_DMG_REDUX_MISSED" );
				}
			}
		}
	}
}


/*
 * Reduce the damage of the next blowing up (if it is in near time delta)
 */
void	CHarvestSource::reduceBlowingUpDmg( float ratio )
{
	H_AUTO(CHarvestSource_reduceBlowingUpDmg);
	
	CReduceDamageEvent event;
	event.Time = CTickEventHandler::getGameCycle();
	event.Ratio = ratio;
	_Events.push_back( event );
}


/*
 * Get the damage factor of a source (for explosion or toxic cloud)
 */
float	CHarvestSource::getDamageFactor() const
{
	H_AUTO(CHarvestSource_getDamageFactor);

	// Map linearly using 5 -> 0.5, 80 -> 1.0 (to match previous algorithm)
	float statQualityFactor = ((((float)getStatQuality())+70.0f) / 150.0f);
	switch ( ImpactSchemes[_IImpactMappingScheme][E] )
	{
	case 0 : return _A * _S * statQualityFactor / MaxAS; break;
	case 1 : return _Q * statQualityFactor / MaxQ; break; // not using DeltaQ but Q
	default: return (_A*_S/MaxAS + _Q/MaxQ) * statQualityFactor / 2; break;
	}
}


/*
 * Return the stat quality of the raw material
 */
/*CHarvestSource::TStatClassForage	CHarvestSource::getStatQuality() const
{
	H_AUTO(CHarvestSource_getStatQuality);
	
	const CStaticItem *itemInfo = CSheets::getForm( _MaterialSheet );
	if ( itemInfo && itemInfo->Mp )
	{
		// (0..20 - 1) / 20 = 0
		// (21..40 - 1) / 20 = 1
		// (41..51 - 1) / 20 = 2;
		// (52..59) / 20 = 2
		// (61..79) / 20 = 3
		// (80..99) / 20 = 4
		// (100...) -> 4
		sint16 statEnergy = (sint16)(itemInfo->Mp->StatEnergy);
		TStatClassForage sq =
			(statEnergy < 51) ? (statEnergy - 1) / 20 :
			((statEnergy < 100) ? statEnergy / 20 : SupremeMagnificient);
		return sq;
	}
	nlwarning( "Invalid raw material %s", _MaterialSheet.toString().c_str() );
	return BasicPlainAverage;
}*/


/*
 * Return the stat quality of the raw material [0..100]
 * (Frequent values: 20 35 50 65 80)
 */
uint16	CHarvestSource::getStatQuality() const
{
	H_AUTO(CHarvestSource_getStatQuality);
	
	const CStaticItem *itemInfo = CSheets::getForm( _MaterialSheet );
	if ( itemInfo && itemInfo->Mp )
	{
		return itemInfo->Mp->StatEnergy;
	}
	nlwarning( "Invalid raw material %s", _MaterialSheet.toString().c_str() );
	return 0;
}


/*
 * Damage an entity
 */
void	CHarvestSource::hitEntity( RYZOMID::TTypeId aggressorType, CEntityBase *entity, sint32 hpDamageAmount, sint32 hpDamageAmountWithoutArmour, bool isIntentional, sint32 hpAvoided )
{
	H_AUTO(CHarvestSource_hitEntity);

	if ( entity->isDead())
		return;

	bool killed = entity->changeCurrentHp( -hpDamageAmount );
	if ( isIntentional )
	{
		SM_STATIC_PARAMS_1(params, STRING_MANAGER::integer);
		params[0].Int = hpDamageAmount;
		PHRASE_UTILITIES::sendDynamicSystemMessage( entity->getEntityRowId(), "FORAGE_ABSORB_DMG", params );
	}
	else
		PHRASE_UTILITIES::sendNaturalEventHitMessages( aggressorType, entity->getEntityRowId(), hpDamageAmount, hpDamageAmountWithoutArmour, hpAvoided );
	if ( killed )
		PHRASE_UTILITIES::sendDeathMessages( TDataSetRow(), entity->getEntityRowId() );
}


NLMISC_VARIABLE( sint32, ForageSourceDisplay, "Row index of source to verbose" );


/*
 * Testing
 */

TDataSetRow TestSourceRow;

void forageTestDoBegin()
{
	CHarvestSource templateSource, *testSource;
	templateSource.setLifetime( 1140 );
	templateSource.setProspectionExtraExtractionTime( 1140 );
	CStaticDepositRawMaterial rm;

	testSource = new CHarvestSource;
	CDeposit deposit;
	testSource->init( templateSource, CVector2f(1000.0f,1000.0f), NULL, &deposit, &rm, 1.0f );
	TDataSetRow dsr;
	if ( testSource->spawnBegin( 0, dsr, false ) )
	{
		TestSourceRow = testSource->rowId();
	}
	else
	{
		delete testSource;
	}
}

bool forageTestDoExtract(
	NLMISC::CLog& log,
	uint nbIterations,
	float reqPeriod,
	float reqA,
	float reqQ,
	float absorption,
	float successFactor )
{
	CHarvestSource *testSource = CHarvestSourceManager::getInstance()->getEntity( TestSourceRow );
	if ( ! testSource )
	{
		log.displayNL( "Call forageTestBegin first" );
		return true;
	}

	// Request and output results
	FILE *f = fopen( std::string(getLogDirectory() + "forage_test.csv").c_str(), "at" );
	FILE *f2 = fopen( std::string(getLogDirectory() + "forage_test.log").c_str(), "at" );
	float reqS = 1.0f / (reqPeriod * 10.0f);
	float req [CHarvestSource::NbPosRTProps];
	float abs [CHarvestSource::NbPosRTProps];
	float res [CHarvestSource::NbPosRTProps];
	static bool FirstTime = true;
	req[CHarvestSource::S] = reqS;
	req[CHarvestSource::A] = reqA;
	req[CHarvestSource::Q] = reqQ;
	abs[CHarvestSource::S] = absorption;
	abs[CHarvestSource::A] = absorption;
	abs[CHarvestSource::Q] = absorption;
	res[CHarvestSource::S] = 0.025f;
	res[CHarvestSource::A] = 0.0f;
	res[CHarvestSource::Q] = 0.0f;
	if ( FirstTime )
	{
		FirstTime = false;
		fprintf( f, "A;Q;D;E;C;reqS;reqA;reqQ;qty;scheme;limit;\n" );
	}
	testSource->beginExtraction( TDataSetRow::createFromRawIndex( INVALID_DATASET_INDEX ), false );
	bool eventD = false, eventE = false, eventC = false;
	for ( uint i=0; i!=nbIterations; ++i )
	{
		TDataSetRow row;
		CHarvestSource::TRealTimeProp propDrop;
		testSource->extractMaterial( req, abs, ForageQualityCeilingFactor.get(), ForageQualitySlowFactor.get(), res, successFactor, 0, row, propDrop );
		fprintf( f, "%g;%g;%g;%g;%g;%g;%g;%g;%g;%u;%u;\n",
			res[CHarvestSource::A], res[CHarvestSource::Q],
			testSource->getD(), testSource->getE(), 0 /*testSource->getC()*/,
			reqS, reqA, reqQ,
			testSource->quantity(), testSource->getImpactScheme()*5, 127 );
		if ( (!eventD) && (testSource->getD() > 127) )
		{
			fprintf( f2, "D: %u\n", i );
			eventD = true;
		}
		if ( (!eventE) && (testSource->getE() > 127) )
		{
			fprintf( f2, "E: %u\n", i );
			eventE = true;
		}
		/*if ( (!eventC) && (testSource->getC() > 127) )
		{
			fprintf( f2, "C: %u\n", i );
			eventC = true;
		}*/
	}
	if ( !eventD )
		fprintf( f2, "D---\n" );
	if ( !eventE )
		fprintf( f2, "E---\n" );
	if ( !eventC )
		fprintf( f2, "C---\n" );
	fclose( f );
	fclose( f2 );

	return true;
}

void forageTestDoEnd()
{
	CHarvestSource *testSource = CHarvestSourceManager::getInstance()->getEntity( TestSourceRow );
	if ( ! testSource )
		return;

	CHarvestSourceManager::getInstance()->destroyEntity( testSource->rowId() );
	testSource = NULL;
}

NLMISC_COMMAND( forageTestBegin, "Start forage test", "" )
{
	forageTestDoBegin();
	return true;
}

NLMISC_COMMAND( forageTestExtract, "Make a test extraction (floats in percent)",
	"<nbIterations> <reqPeriod=2> <reqA=2> <reqQ=50> <absorption=10> <successFactor=100>" )
{
	// Read args
	sint n = (sint)args.size();
	uint nbIterations = 1;
	float reqPeriod = 2.0f;
	float reqA = 2.0f;
	float reqQ = 50.0f;
	float absorption = 0.1f;
	float successFactor = 1.0f;
	if ( n > 0 )
	{
		NLMISC::fromString(args[0], nbIterations);
		if ( n > 1 )
		{
			NLMISC::fromString(args[1], reqPeriod);
			if ( n > 2)
			{
				NLMISC::fromString(args[2], reqA);
				if ( n > 3 )
				{
					NLMISC::fromString(args[3], reqQ);
					if ( n > 4)
					{
						NLMISC::fromString(args[4], absorption);
						absorption /= 100.0f;
						if ( n > 5 )
						{
							NLMISC::fromString(args[5], successFactor);
							successFactor /= 100.0f;
						}
					}
				}
			}
		}
	}

	return forageTestDoExtract( log, nbIterations, reqPeriod, reqA, reqQ, absorption, successFactor );
}

NLMISC_COMMAND( forageTestBatch, "Batch forage tests", "" )
{
	uint nbIterations = 15;
	float reqPeriod;
	float reqA;
	float reqQ;
	float absorption;
	float successFactor = 1.0f;

	for ( absorption=0.1f; absorption<=0.8f; absorption+=0.7f )
	{
		forageTestDoBegin();
		for ( reqQ=1.0f; reqQ<=251.0f; reqQ+=50.0f )
		{
			for ( reqA=1.0f; reqA<=5.0f; reqA+=2.0f )
			{
				for ( reqPeriod=2.2f; reqPeriod>=0.2f; reqPeriod-=0.5f )
				{
					forageTestDoExtract( log, nbIterations, reqPeriod, reqA, reqQ, absorption, successFactor );
					CHarvestSource *testSource = CHarvestSourceManager::getInstance()->getEntity( TestSourceRow );
					if ( testSource )
					{
						CHarvestSource templateSource;
						templateSource.setLifetime( 1140 );
						templateSource.setProspectionExtraExtractionTime( 1140 );
						testSource->resetSource( templateSource );
						testSource->setN( 120 );
						testSource->setD( 0 );
						testSource->setE( 0 );
						//testSource->setC( 0 );
					}
				}
			}
		}
		forageTestDoEnd();
	}
	
	return true;
}

NLMISC_COMMAND( forageTestEnd, "End forage test", "" )
{
	// TODO: despawn spawned source!
	forageTestDoEnd();
	return true;
}



NLMISC_DYNVARIABLE( uint, NbForageSources, "Number of forage sources" )
{
	if ( get )
		*pointer = CHarvestSourceManager::getInstance()->nbEntities();
}

NLMISC_VARIABLE( uint, NbAutoSpawnedForageSources, "Number of auto-spawned forage sources" );