ryzom/server/src/sabrina/harvest_phrase.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18
  19 #include "stdpch.h"
  20 #include "harvest_phrase.h"
  21 #include "game_share/brick_families.h"
  22 #include "s_phrase_factory.h"
  23 #include "entity_manager.h"
  24 #include "phrase_manager.h"
  25 #include "creature_manager.h"
  26 #include "player_manager.h"
  27 #include "character.h"
  28 #include "phrase_utilities_functions.h"
  29
  30 extern CPlayerManager   PlayerManager;
  31 extern CCreatureManager CreatureManager;
  32
  33 DEFAULT_SPHRASE_FACTORY( CHarvestPhrase, BRICK_TYPE::HARVEST );
  34
  35 using namespace std;
  36 using namespace NLMISC;
  37 using namespace NLNET;
  38
  39 //-----------------------------------------------
  40 // ctor
  41 //-----------------------------------------------
  42 CHarvestPhrase::CHarvestPhrase()
  43 {
  44         _SabrinaCost = 0;
  45         _SabrinaCredit = 0;
  46         _StaminaCost = 0;
  47         _HPCost = 0;
  48         _HarvestTime = 25; // 2.5s for DEBUG ONLY
  49 //      _HarvestTime = 0; // 0s for DEBUG ONLY
  50         _IsStatic = true;
  51 }
  52
  53
  54 //-----------------------------------------------
  55 // CHarvestPhrase build
  56 //-----------------------------------------------
  57 bool CHarvestPhrase::build( const TDataSetRow & actorRowId, const std::vector< const CStaticBrick* >& bricks )
  58 {
  59         // we are sure there is at least one brick and that there are non NULL;
  60         nlassert( !bricks.empty() );
  61
  62         _ActorRowId = actorRowId;
  63
  64         // compute cost and credit and parse other params
  65         for ( uint i = 0; i < bricks.size(); ++i )
  66         {
  67                 const CStaticBrick & brick = *bricks[i];
  68
  69                 if ( i == 0)
  70                         _RootSheetId = brick.SheetId;
  71
  72                 if ( brick.SabrinaValue < 0 )
  73                         _SabrinaCredit -= brick.SabrinaValue;
  74                 else
  75                         _SabrinaCost += brick.SabrinaValue;
  76
  77                 switch( brick.Family )
  78                 {
  79                         /* TempYoyo: case BRICK_FAMILIES::RootHarvest:
  80                                 break;*/
  81                         default:
  82                         for ( uint i=0 ; i<brick.Params.size() ; ++i)
  83                         {
  84                                 switch(brick.Params[i]->id())
  85                                 {
  86                                         case TBrickParam::SAP:
  87                                                 return false;
  88                                         case TBrickParam::HP:
  89                                                 INFOLOG("HP: %i",((CSBrickParamHp *)brick.Params[i])->Hp);
  90                                                 _HPCost += ((CSBrickParamHp *)brick.Params[i])->Hp;
  91                                                 break;
  92                                         case TBrickParam::STA:
  93                                                 INFOLOG("STA: %i",((CSBrickParamSta *)brick.Params[i])->Sta);
  94                                                 _StaminaCost += ((CSBrickParamSta *)brick.Params[i])->Sta;
  95                                                 break;
  96                                         default:
  97                                                 // unused param ?
  98                                                 break;
  99                                 }
 100                         }
 101                         break;
 102                 }
 103         }
 104
 105         return true;
 106 }// CHarvestPhrase build
 107
 108
 109 //-----------------------------------------------
 110 // CHarvestPhrase evaluate
 111 //-----------------------------------------------
 112 bool CHarvestPhrase::evaluate(CEvalReturnInfos *msg)
 113 {
 114         // update state
 115         _State = CSPhrase::Evaluated;
 116         return true;
 117 }// CHarvestPhrase evaluate
 118
 119
 120 //-----------------------------------------------
 121 // CHarvestPhrase validate
 122 //-----------------------------------------------
 123 bool CHarvestPhrase::validate()
 124 {
 125         // entities cant harvest if in combat
 126         TDataSetRow entityRowId = CPhraseManager::getInstance()->getEntityEngagedMeleeBy( _ActorRowId );
 127         if (entityRowId.isValid())
 128         {
 129                 ///\todo david : send message
 130                 return false;
 131         }
 132         CEntityBase * entity = CEntityBaseManager::getEntityBasePtr( _ActorRowId );
 133         const sint32 hp = entity->getScores()._PhysicalScores[ SCORES::hit_points ].Current;
 134         if ( hp < _HPCost  )
 135         {
 136                 ///\todo david : send message
 137                 return false;
 138         }
 139         const sint32 sta = entity->getScores()._PhysicalScores[ SCORES::stamina ].Current;
 140         if ( sta < _StaminaCost  )
 141         {
 142                 ///\todo david : send message
 143                 return false;
 144         }
 145         if (hp <= 0     ||      entity->getMode()==MBEHAV::DEATH)
 146         {
 147                 ///\todo david : send message
 148                 return false;
 149         }
 150
 151         /// todo david : test if on mount
 152
 153         // update state
 154         if (_State == Evaluated)
 155                 _State = Validated;
 156         else if (_State == ExecutionInProgress)
 157                 _State = SecondValidated;
 158         return true;
 159 }// CHarvestPhrase validate
 160
 161
 162 //-----------------------------------------------
 163 // CHarvestPhrase update
 164 //-----------------------------------------------
 165 bool  CHarvestPhrase::update()
 166 {
 167         const NLMISC::TGameCycle time = CTickEventHandler::getGameCycle();
 168
 169         // if the sentence execution delay time has ended, apply sentence effects
 170         if ( _State == SecondValidated && _ExecutionEndDate <= time && _NbWaitingRequests == 0)
 171         {
 172                 apply();
 173         }
 174         else if ( _State == Latent /*&& _LatencyEndDate <= time*/ )
 175         {
 176                 end();
 177         }
 178
 179         return true;
 180 }// CHarvestPhrase update
 181
 182
 183 //-----------------------------------------------
 184 // CHarvestPhrase execute
 185 //-----------------------------------------------
 186 void  CHarvestPhrase::execute()
 187 {
 188         if( _NbWaitingRequests != 0)
 189                 return;
 190
 191         const NLMISC::TGameCycle time = CTickEventHandler::getGameCycle();
 192         _State = CSPhrase::ExecutionInProgress;
 193         _ExecutionEndDate  = time + _HarvestTime ;
 194
 195         CCharacter* player = PlayerManager.getChar(_ActorRowId);
 196         if (player)
 197         {
 198                 player->setCurrentAction(CLIENT_ACTION_TYPE::Harvest,_ExecutionEndDate);
 199
 200                 const CStaticItem *item = CSheets::getForm(_RawMaterialId);
 201                 if (item != 0)
 202                 {
 203                 /*      string msgName = "BS_HARVEST_BEGIN_S";
 204                         CMessage msg("STATIC_STRING");
 205                         msg.serial( const_cast<CEntityId&> (player->getId()) );
 206                         set<CEntityId> excluded;
 207                         msg.serialCont( excluded );
 208                         msg.serial( msgName );
 209                         msg.serial( const_cast<string&> (item->Name));
 210
 211                         sendMessageViaMirror ("IOS", msg);
 212                 */
 213
 214                         string msgName = "WOS_HARVEST_SEARCHING";
 215                         CMessage msg("STATIC_STRING");
 216                         msg.serial( const_cast<CEntityId&> (player->getId()) );
 217                         set<CEntityId> excluded;
 218                         msg.serialCont( excluded );
 219                         msg.serial( msgName );
 220                         sendMessageViaMirror ("IOS", msg);
 221                 }
 222
 223                 player->_PropertyDatabase.setProp( "EXECUTE_PHRASE:SHEET", _RootSheetId.asInt() );
 224         }
 225
 226         // set behaviour
 227         PHRASE_UTILITIES::sendUpdateBehaviour( _ActorRowId, MBEHAV::HARVESTING );
 228 }// CHarvestPhrase execute
 229
 230
 231 //-----------------------------------------------
 232 // CHarvestPhrase apply
 233 //-----------------------------------------------
 234 void CHarvestPhrase::apply()
 235 {
 236         _State = CSPhrase::Latent;
 237
 238         ///\todo behaviour
 239
 240         // spend energies
 241         CEntityBase* entity = PHRASE_UTILITIES::entityPtrFromId( _ActorRowId );
 242         if (entity == NULL)
 243         {
 244                 nlwarning("<CHarvestPhrase::apply> Invalid entity Id %s", TheDataset.getEntityId(_ActorRowId).toString().c_str() );
 245                 return;
 246         }
 247         RY_GAME_SHARE::SCharacteristicsAndScores &sta = entity->getScores()._PhysicalScores[SCORES::stamina];
 248         if ( sta.Current != 0)
 249         {
 250                 sta.Current = sta.Current - _StaminaCost;
 251                 if (sta.Current < 0)
 252                         sta.Current = 0;
 253         }
 254
 255         RY_GAME_SHARE::SCharacteristicsAndScores &hp = entity->getScores()._PhysicalScores[SCORES::hit_points];
 256         if ( hp.Current != 0)
 257         {
 258                 hp.Current = hp.Current - _HPCost;
 259                 if (hp.Current < 0)
 260                         hp.Current = 0;
 261         }
 262
 263 // Harvest the raw materials
 264
 265
 266 }//CHarvestPhrase apply
 267
 268
 269 //-----------------------------------------------
 270 // CHarvestPhrase end
 271 //-----------------------------------------------
 272 void CHarvestPhrase::end()
 273 {
 274         _State = CSPhrase::LatencyEnded;
 275
 276         CCharacter* player = PlayerManager.getChar(_ActorRowId);
 277         if (player)
 278         {
 279                 player->clearCurrentAction();
 280         }
 281
 282         vector<uint16> qualities;
 283
 284         // set behaviour
 285         PHRASE_UTILITIES::sendUpdateBehaviour( _ActorRowId, MBEHAV::HARVESTING_END );
 286
 287         if (_Deposit)
 288                 //player->harvestResultDeposit( _MinQuality, false);
 289                 player->harvestDepositResult( _MinQuality );
 290         else
 291                 //harvestCorpseResult();
 292                 player->harvestCorpseResult( qualities );
 293
 294 } // end //
 295
 296 //-----------------------------------------------
 297 // CHarvestPhrase stop
 298 //-----------------------------------------------
 299 void CHarvestPhrase::stop()
 300 {
 301         CCharacter* player = PlayerManager.getChar(_ActorRowId);
 302         if (player)
 303         {
 304                 player->clearCurrentAction();
 305 //              if (_Deposit)
 306 //                      PHRASE_UTILITIES::sendSimpleMessage( _ActorRowId, "EGS_FORAGE_INTERRUPTED");
 307 //              else
 308 //                      PHRASE_UTILITIES::sendSimpleMessage( _ActorRowId, "EGS_QUARTER_INTERRUPTED");
 309         }
 310
 311         _State = CSPhrase::LatencyEnded;
 312
 313         // set behaviour
 314         PHRASE_UTILITIES::sendUpdateBehaviour( _ActorRowId, MBEHAV::HARVESTING_END );
 315 } // stop //
 316
 317
 318 //-----------------------------------------------
 319 // CHarvestPhrase harvestCorpseResult
 320 //-----------------------------------------------
 321 void CHarvestPhrase::harvestCorpseResult()
 322 {
 323         // get harvester character
 324         CCharacter *character = PlayerManager.getChar( _ActorRowId );
 325         if (character == NULL)
 326         {
 327                 //nlwarning("<cbHarvestResult> Invalid player Id %s", playerId.toString().c_str() );
 328                 return;
 329         }
 330
 331         // get harvested corpse
 332         const CEntityId &harvestedEntity = character->harvestedEntity();
 333
 334         CCreature *creature = CreatureManager.getCreature( harvestedEntity );
 335         if (creature == NULL)
 336         {
 337                 nlwarning("<cbHarvestResult> Invalid creature Id %s", harvestedEntity.toString().c_str() );
 338                 // reset harvest info
 339                 character->resetHarvestInfos();
 340                 character->endHarvest();
 341                 return;
 342         }
 343
 344         const vector< CCreatureRawMaterial> &mps = creature->getMps();
 345         if ( character->harvestedMpIndex() >= mps.size() || character->harvestedMpQuantity() > mps[character->harvestedMpIndex()].Quantity )
 346         {
 347                 // reset harvest info
 348                 character->resetHarvestInfos();
 349                 return;
 350         }
 351
 352         uint16 quality = _MaxQuality;
 353
 354         // create the mp items if any
 355         if (quality > 0)
 356         {
 357                 if ( character->createItemInBag( (uint8) quality, character->harvestedMpQuantity(), _RawMaterialId) == false)
 358                 {
 359         //              CMissionEventItem event(CMissionEvent::Harvest,playerId,harvestedEntity,_RawMaterialId,quality,character->harvestedMpQuantity());
 360         //              character->processMissionEvent(event);
 361                         // error creating the object, hand probably not empty
 362                 //      character->resetHarvestInfos();
 363                 //      return;
 364                 }
 365                 else
 366                 {
 367                         const CStaticItem *item = CSheets::getForm(_RawMaterialId);
 368                         if (item)
 369                         {
 370                                 CMissionEventHarvest event(_RawMaterialId ,character->harvestedMpQuantity(),quality);
 371                                 character->processMissionEvent( event );
 372                                 string msgName = "OPS_HARVEST_SUCESS_ISI";
 373
 374                                 CMessage msg("STATIC_STRING");
 375                                 msg.serial( const_cast<CEntityId&>(character->getId()) );
 376                                 set<CEntityId> excluded;
 377                                 msg.serialCont( excluded );
 378                                 msg.serial( msgName );
 379
 380                                 uint32 value = uint32(character->harvestedMpQuantity());
 381                                 msg.serial( value );//qty
 382                                 msg.serial( const_cast<string&> (item->Name) );//mp name
 383
 384                                 value = uint32(quality);
 385                                 msg.serial( value );//quality
 386
 387                                 sendMessageViaMirror ("IOS", msg);
 388                         }
 389                 }
 390         }
 391         // the mp have been destroyed -> do nothing
 392         else
 393         {
 394         }
 395
 396         // remove the quantity of mp harvested from the ressource
 397         creature->removeMp( character->harvestedMpIndex(), character->harvestedMpQuantity() );
 398
 399         // reset harvest info
 400         character->resetHarvestInfos();
 401 } // harvestCorpseResult //
 402