Add infos into target window

[ryzomcore.git] / 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 source file has been modified by the following contributors:
// Copyright (C) 2013  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
//
// 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.
uint16 SpecialNewbieImpactSchemeD = 10;
uint16 LowDangerMappings[2] = { (uint16)(SpecialNewbieImpactSchemeD + 1), (uint16)(SpecialNewbieImpactSchemeD + 4) };

sint8 ExplosionResetPeriod = 50; // 5 s

CHarvestSource AutoSpawnSourceIniProperties;

/*
 * Access to singleton
 */
CHarvestSourceManager *CHarvestSourceManager::getInstance()
{
        return (CHarvestSourceManager*)_Instance;
}

/*
 * 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 );
}

void CHarvestSourceManager::release()
{
        delete (CHarvestSourceManager*)_Instance;
}

/*
 * 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 = nlfopen(getLogDirectory() + "forage_test.csv", "at" );
        FILE *f2 = nlfopen(getLogDirectory() + "forage_test.log", "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.f /*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" );