ryzom/server/src/sabrina/phrase_utilities_functions.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
  20 #include "stdpch.h"
  21
  22 #include "phrase_utilities_functions.h"
  23 #include "egs_mirror.h"
  24
  25 // game share
  26 #include "game_share/mode_and_behaviour.h"
  27 #include "game_share/tick_event_handler.h"
  28 #include "game_share/msg_combat_move_service.h"
  29 #include "game_share/characteristics.h"
  30 // georges
  31 #include "nel/georges/u_form.h"
  32 #include "nel/georges/u_form_elm.h"
  33 #include "nel/georges/u_form_loader.h"
  34 // misc
  35 #include "nel/misc/command.h"
  36 // std
  37 #include <map>
  38
  39 //
  40 #include "player_manager.h"
  41 #include "phrase_manager.h"
  42 #include "creature_manager.h"
  43 #include "egs_globals.h"
  44
  45
  46 extern uint8                                    CMSIsUp;
  47 extern CPlayerManager                   PlayerManager;
  48 extern CCreatureManager                 CreatureManager;
  49 extern CGameItemManager                 GameItemManager;
  50 extern CPhraseManager                   *PhraseManager;
  51 extern bool                                             AllowPVP;
  52
  53
  54 extern uint8                                    EntityForcedDefaultLevel; // 0 by default, it's the level of an entity when it has a level 0 (for tests purposes only)
  55
  56 extern CGenericXmlMsgHeaderManager      GenericMsgManager;
  57
  58 using namespace std;
  59 using namespace NLGEORGES;
  60 using namespace NLMISC;
  61 using namespace NLNET;
  62
  63
  64 bool VerboseBrickManagerInfo = false;
  65 bool VerboseBrickManagerDbg = false;
  66 bool AggroLog = false;
  67
  68 NLMISC_COMMAND(verboseBrickManagerInfo,"Turn on or off or check the state of verbose brick manager logging (for info)","")
  69 {
  70         if(args.size()>1)
  71                 return false;
  72         if(args.size()==1)
  73         {
  74                 if(args[0]==string("on")||args[0]==string("ON")||args[0]==string("true")||args[0]==string("TRUE")||args[0]==string("1"))
  75                         VerboseBrickManagerInfo=true;
  76
  77                 if(args[0]==string("off")||args[0]==string("OFF")||args[0]==string("false")||args[0]==string("FALSE")||args[0]==string("0"))
  78                         VerboseBrickManagerInfo=false;
  79         }
  80
  81         log.displayNL("VerboseBrickManagerInfo is %s",VerboseBrickManagerInfo?"ON":"OFF");
  82         return true;
  83 }
  84
  85 // debug msg
  86 NLMISC_COMMAND(verboseBrickManagerDbg,"Turn on or off or check the state of verbose brick manager logging (for debug)","")
  87 {
  88         if(args.size()>1)
  89                 return false;
  90         if(args.size()==1)
  91         {
  92                 if(args[0]==string("on")||args[0]==string("ON")||args[0]==string("true")||args[0]==string("TRUE")||args[0]==string("1"))
  93                         VerboseBrickManagerDbg=true;
  94
  95                 if(args[0]==string("off")||args[0]==string("OFF")||args[0]==string("false")||args[0]==string("FALSE")||args[0]==string("0"))
  96                         VerboseBrickManagerDbg=false;
  97         }
  98
  99         log.displayNL("VerboseBrickManagerDbg is %s",VerboseBrickManagerDbg?"ON":"OFF");
 100         return true;
 101 }
 102
 103 // aggro msg
 104 NLMISC_COMMAND(aggroLog,"Turn on or off aggro log display or check the state of the flag","")
 105 {
 106         if(args.size()>1)
 107                 return false;
 108         if(args.size()==1)
 109         {
 110                 if(args[0]==string("on")||args[0]==string("ON")||args[0]==string("true")||args[0]==string("TRUE")||args[0]==string("1"))
 111                         AggroLog=true;
 112
 113                 if(args[0]==string("off")||args[0]==string("OFF")||args[0]==string("false")||args[0]==string("FALSE")||args[0]==string("0"))
 114                         AggroLog=false;
 115         }
 116
 117         log.displayNL("AggroLog is %s",AggroLog?"ON":"OFF");
 118         return true;
 119 }
 120
 121
 122
 123 namespace PHRASE_UTILITIES
 124 {
 125 std::string toString(ERange range)
 126 {
 127         switch(range)
 128         {
 129         case POINT_BLANK:
 130                 return std::string("POINT_BLANK");
 131         case SHORT_RANGE:
 132                 return std::string("SHORT_RANGE");
 133         case MEDIUM_RANGE:
 134                 return std::string("MEDIUM_RANGE");
 135         case LONG_RANGE:
 136                 return std::string("LONG_RANGE");
 137         default:
 138                 return std::string("UNDEFINED");
 139         };
 140 }
 141
 142 typedef set< SLocalisation >                            TLocalisationSet;
 143
 144 /// table of damage localisation (take shield into account)
 145 TLocalisationSet                LocalisationTable;
 146
 147 /// the table giving the localisation adjustement for the specified attacker and defender size
 148 sint8                                   LocalisationAdjustments[CREATURE_SIZE::NB_SIZE][CREATURE_SIZE::NB_SIZE];
 149
 150
 151 static string OrientationStrings[]=
 152 {
 153         "W",
 154         "WSW",
 155         "SW",
 156         "SSW",
 157         "S",
 158         "SSE",
 159         "SE",
 160         "ESE",
 161         "E",
 162         "ENE",
 163         "NE",
 164         "NNE",
 165         "N",
 166         "NNW",
 167         "NW",
 168         "WNW",
 169 };
 170
 171
 172 //--------------------------------------------------------------
 173 //                      entityPtrFromId()
 174 //--------------------------------------------------------------
 175 CEntityBase* entityPtrFromId( const CEntityId &id )
 176 {
 177         switch( id.getType() )
 178         {
 179         case RYZOMID::player:
 180                 return PlayerManager.getChar( id );
 181                 break;
 182
 183         case RYZOMID::npc:
 184         case RYZOMID::creature:
 185         case RYZOMID::kami:
 186                 return CreatureManager.getCreature( id );
 187                 break;
 188
 189         default:
 190                 nlwarning( "<entityPtrFromId> entity type %d unknown", id.getType(), id.toString().c_str() );
 191                 return 0;
 192         }
 193 }
 194
 195 //--------------------------------------------------------------
 196 //                                      loadLocalisationTable()
 197 //--------------------------------------------------------------
 198 void loadLocalisationTable( const std::string &tableName )
 199 {
 200         UFormLoader *loader = UFormLoader::createLoader ();
 201
 202         CSmartPtr<UForm> form = loader->loadForm (tableName.c_str());
 203         if ( !form)
 204         {
 205                 nlwarning("<loadLocalisationTable> Failed to load the form %s", tableName.c_str() );
 206                 return;
 207         }
 208
 209         // Get the root node, always exist
 210     UFormElm &root = form->getRootNode ();
 211
 212         const UFormElm *array = NULL;
 213         // lines
 214         if (root.getNodeByName (&array, "Lines") && array)
 215     {
 216                  // Get array size
 217         uint size;
 218                 array->getArraySize (size);
 219
 220         // Get a array value
 221         for (uint i=0; i<size; ++i)
 222         {
 223                         const UFormElm *line = NULL;
 224                         if ( array->getArrayNode( &line, i) && line)
 225                         {
 226                                 SLocalisation localisation;
 227                                 // the localisation number
 228                                 line->getValueByName( localisation.LocalisationNumber, "ValueNumber" );
 229
 230                                 string shield;
 231                                 // the type of shield
 232                                 line->getValueByName( shield, "ShieldType" );
 233                                 localisation.ShieldType = SHIELDTYPE::stringToShieldType( shield );
 234
 235                                 string slot;
 236                                 line->getValueByName( slot, "Localisation" );
 237                                 localisation.Slot = SLOT_EQUIPMENT::stringToSlotEquipment( slot);
 238
 239                                 line->getValueByName( localisation.ShieldIsEffective, "ProtectionWorks" );
 240
 241                                 LocalisationTable.insert( localisation );
 242
 243 //nlinfo("loadLocalisationTable : for value %d and shield %s, localisation=%s, shield=%d",localisation.LocalisationNumber, shield.c_str(),  slot.c_str(),  localisation.ShieldIsEffective);
 244                         }
 245         }
 246         }
 247 } // loadLocalisationTable //
 248
 249
 250
 251
 252
 253 //--------------------------------------------------------------
 254 //                                      loadLocalisationSizeAdjusmentTable()
 255 //--------------------------------------------------------------
 256 void loadLocalisationSizeAdjusmentTable( const std::string &tableName )
 257 {
 258         UFormLoader *loader = UFormLoader::createLoader ();
 259
 260         CSmartPtr<UForm> form = loader->loadForm (tableName.c_str());
 261         if ( !form)
 262         {
 263                 nlwarning("<loadLocalisationSizeAdjusmentTable> Failed to load the form %s", tableName.c_str() );
 264                 return;
 265         }
 266
 267         // Get the root node, always exist
 268     UFormElm &root = form->getRootNode ();
 269
 270         const UFormElm *array = NULL;
 271         // lines
 272         if (root.getNodeByName (&array, "Table") && array)
 273     {
 274                  // Get array size
 275         uint size;
 276                 array->getArraySize (size);
 277
 278         // Get a array value
 279         for (uint i=0; i<size; ++i)
 280         {
 281                         const UFormElm *line = NULL;
 282                         if ( array->getArrayNode( &line, i) && line)
 283                         {
 284                                 string attacker;
 285                                 line->getValueByName( attacker, "AttackerSize" );
 286                                 CREATURE_SIZE::ECreatureSize attackerSize = CREATURE_SIZE::stringToCreatureSize( attacker );
 287
 288                                 string defender;
 289                                 line->getValueByName( defender, "DefenderSize" );
 290                                 CREATURE_SIZE::ECreatureSize defenderSize = CREATURE_SIZE::stringToCreatureSize( defender );
 291
 292                                 sint8 modifier;
 293                                 line->getValueByName( modifier, "Adjustment" );
 294
 295                                 if ( attackerSize > CREATURE_SIZE::NB_SIZE || defenderSize > CREATURE_SIZE::NB_SIZE || attackerSize < 0 || defenderSize < 0)
 296                                 {
 297                                         nlwarning("<loadLocalisationSizeAdjusmentTable> Invalid line, attacker size = %s, defender size = %s", attacker.c_str(), defender.c_str() );
 298                                         continue;
 299                                 }
 300
 301                                 ///
 302                                 LocalisationAdjustments[attackerSize][defenderSize] = modifier;
 303                         }
 304                 }
 305         }
 306 } // loadLocalisationSizeAdjusmentTable //
 307
 308
 309 //--------------------------------------------------------------
 310 //                                      getSuccessChance()
 311 //--------------------------------------------------------------
 312 uint8 getSuccessChance( sint32 playerRelativeLevel )
 313 {
 314         // clip delta level to min / max value
 315         if( playerRelativeLevel > MAX_DELTA_LVL ) playerRelativeLevel = MAX_DELTA_LVL;
 316         if( playerRelativeLevel < MIN_DELTA_LVL ) playerRelativeLevel = MIN_DELTA_LVL;
 317
 318         return (uint8) CEntityBaseManager::_SuccessXpTable[ MIDDLE_DELTA_LVL - playerRelativeLevel ].SuccessProbability;
 319 } // getSuccessChance //
 320
 321
 322 //--------------------------------------------------------------
 323 //                                      getSuccessFactor()
 324 // Return SF (Success Factor) > 1 if critical success
 325 // Return SF = 1 if success
 326 // Return  1 < SF < 0 if partial success
 327 // Return SF = 0 if Failure
 328 // Return SF < 0 if Critical Failure
 329 //--------------------------------------------------------------
 330 float getSucessFactor( uint8 chances, uint8 tirage )
 331 {
 332         // Check if critical success
 333         if( float(CEntityBaseManager::_SuccessTable.CriticalSuccess * chances) / float( CEntityBaseManager::_SuccessTable.CriticalSuccess + CEntityBaseManager::_SuccessTable.Success ) > float(tirage) ) return 1.1f;
 334
 335         // Check if Success
 336         if( chances > tirage ) return 1.0f;
 337
 338         // Check if Partial Success
 339         const uint8 pSChance = (uint8) (float(CEntityBaseManager::_SuccessTable.PartialSuccess) / float(CEntityBaseManager::_SuccessTable.PartialSuccess + CEntityBaseManager::_SuccessTable.Failure + CEntityBaseManager::_SuccessTable.CriticalFailure) * (100.0f-chances));
 340         if ( pSChance > (tirage-chances) )
 341         {
 342                 return ( float(pSChance - tirage + chances) / float(pSChance));
 343         }
 344
 345         // Check if Failure
 346         if( ( float(CEntityBaseManager::_SuccessTable.PartialSuccess + CEntityBaseManager::_SuccessTable.Failure ) / float(CEntityBaseManager::_SuccessTable.PartialSuccess + CEntityBaseManager::_SuccessTable.Failure + CEntityBaseManager::_SuccessTable.CriticalFailure ) * (100.0f-chances) ) > float(tirage-chances) )
 347                 return 0.0f;
 348
 349         // stay Critical Failure
 350         return -1.0f;
 351 }
 352
 353
 354 //--------------------------------------------------------------
 355 //                                      testTargetValidityForCombat()
 356 //--------------------------------------------------------------
 357 bool testTargetValidityForCombat( const CEntityId &targetId, string &errorCode )
 358 {
 359         switch ( targetId.getType() )
 360         {
 361         case RYZOMID::player:
 362                 break;
 363
 364         case RYZOMID::creature:
 365         case RYZOMID::kami:
 366         case RYZOMID::npc:
 367         case RYZOMID::mount:
 368                 {
 369                         CCreature* entity = CreatureManager.getCreature( targetId );
 370                         if (entity == NULL)
 371                         {
 372                                 nlwarning("<testTargetValidityForCombat> Invalid entity Id %s", targetId.toString().c_str() );
 373                                 errorCode = "BS_INVALID_TARGET";
 374                                 return false;
 375                         }
 376
 377                         /*
 378                         // get creature form
 379                         const CSheetId &sheet = entity->getType();
 380
 381                         const CStaticCreatures *creature = CSheets::getCreaturesForm( sheet );
 382                         if ( ! creature)
 383                         {
 384                                 nlwarning("<testTargetValidityForCombat> can't found CStaticCreature for entity %s", targetId.toString().c_str() );
 385                                 errorCode = "BS_INVALID_TARGET";
 386                                 return false;
 387                         }
 388                         */
 389
 390                         if ( ! entity->getContextualProperty().getValue().attackable() )
 391                         {
 392                                 errorCode = "BS_TARGET_NOT_ATTACKABLE";
 393                                 return false;
 394                         }
 395
 396                 }
 397                 break;
 398
 399         default:
 400                 break;
 401
 402         };
 403
 404         return true;
 405 } // testTargetValidityForCombat //
 406
 407
 408
 409 //--------------------------------------------------------------
 410 //                                      getLocalisation()
 411 //--------------------------------------------------------------
 412 TPairSlotShield  getLocalisation( SHIELDTYPE::EShieldType shield, sint8 adjustement, SLOT_EQUIPMENT::TSlotEquipment forcedSlot)
 413 {
 414         TPairSlotShield slotShield;
 415         SLocalisation local;
 416
 417         if ( forcedSlot == SLOT_EQUIPMENT::UNDEFINED)
 418         {
 419                 sint32 randVal = RandomGenerator.rand() + adjustement;
 420                 if (randVal < 0)
 421                         randVal = 0;
 422
 423                 local.LocalisationNumber = randVal%10 + 1;
 424                 local.ShieldType = shield;
 425
 426                 TLocalisationSet::iterator it = LocalisationTable.find( local );
 427                 if (it != LocalisationTable.end() )
 428                 {
 429                         slotShield.first = (*it).Slot;
 430                         slotShield.second = (*it).ShieldIsEffective;
 431                 }
 432                 else
 433                 {
 434                         slotShield.first = SLOT_EQUIPMENT::UNDEFINED;
 435                         slotShield.second = false;
 436                 }
 437         }
 438         else
 439         {
 440                 TLocalisationSet subTable;
 441                 TLocalisationSet::iterator it;
 442                 for (it = LocalisationTable.begin() ; it != LocalisationTable.end() ; ++it)
 443                 {
 444                         uint8 val = 0;
 445                         if ( (*it).ShieldType == shield && (*it).Slot == forcedSlot )
 446                         {
 447                                 SLocalisation local;
 448                                 local.LocalisationNumber = ++val;
 449                                 local.ShieldType = shield;
 450                                 local.ShieldIsEffective = (*it).ShieldIsEffective;
 451                                 local.Slot = forcedSlot;
 452
 453                                 subTable.insert( local );
 454                         }
 455                 }
 456
 457                 if ( subTable.empty() == true )
 458                 {
 459                         slotShield.first = SLOT_EQUIPMENT::UNDEFINED;
 460                         slotShield.second = false;
 461                 }
 462                 else
 463                 {
 464                         local.LocalisationNumber = 1 + (uint8)RandomGenerator.rand(subTable.size()-1);
 465                         local.ShieldType = shield;
 466
 467                         it = subTable.find( local );
 468                         if (it != subTable.end() )
 469                         {
 470                                 slotShield.first = (*it).Slot;
 471                                 slotShield.second = (*it).ShieldIsEffective;
 472                         }
 473                         else
 474                         {
 475                                 slotShield.first = SLOT_EQUIPMENT::UNDEFINED;
 476                                 slotShield.second = false;
 477                         }
 478                 }
 479         }
 480
 481         INFOLOG("<getLocalisation> with shield %d, with forced slot %d, localisation is slot %d, and shield is %d (0=inactive) (random value is %u)", shield, forcedSlot, slotShield.first, slotShield.second, local.LocalisationNumber );
 482
 483         return slotShield;
 484 } // getLocalisation //
 485
 486
 487
 488 //--------------------------------------------------------------
 489 //                                      getLocalisationSizeAdjustement()
 490 //--------------------------------------------------------------
 491 sint8 getLocalisationSizeAdjustement(  const CEntityId &attacker,  const CEntityId &defender )
 492 {
 493         CREATURE_SIZE::ECreatureSize attackerSize, defenderSize;
 494
 495         CEntityBase* entity = entityPtrFromId( attacker );
 496         if (entity == NULL)
 497         {
 498                 nlwarning("<getLocalisationSizeAdjustement> Invalid entity Id %s", attacker.toString().c_str() );
 499                 return 0;
 500         }
 501
 502         attackerSize = entity->getSize();
 503
 504         entity = entityPtrFromId( defender );
 505         if (entity == NULL)
 506         {
 507                 nlwarning("<getLocalisationSizeAdjustement> Invalid entity Id %s", defender.toString().c_str() );
 508                 return 0;
 509         }
 510
 511         defenderSize = entity->getSize();
 512
 513         if ( attackerSize > CREATURE_SIZE::NB_SIZE || defenderSize > CREATURE_SIZE::NB_SIZE || attackerSize < 0 || defenderSize < 0)
 514         {
 515                 return 0;
 516         }
 517
 518         return LocalisationAdjustments[attackerSize][defenderSize];
 519 } // getLocalisationSizeAdjustement //
 520
 521
 522 //--------------------------------------------------------------
 523 //                                      getWeaponDamageFactor()
 524 //--------------------------------------------------------------
 525 float getWeaponDamageFactor( WEAPONTYPE::EWeaponType type, uint16 quality, uint16 entityLevel )
 526 {
 527         if (quality > 21)
 528                 quality = 21;
 529
 530         if (quality == 0)
 531                 return float(0);
 532
 533         switch(type)
 534         {
 535         case WEAPONTYPE::LIGHT:
 536         case WEAPONTYPE::LIGHT_GUN:
 537                 {
 538                         if ( entityLevel > 0 && entityLevel > quality)
 539                                 return TableLightMeleeWeaponGenerics[quality-1].secondaryDamageFactor;
 540                         else
 541                                 return TableLightMeleeWeaponGenerics[quality-1].damageFactor;
 542                 }
 543                 break;
 544
 545         case WEAPONTYPE::MEDIUM:
 546         case WEAPONTYPE::MEDIUM_GUN:
 547                 {
 548                         if ( entityLevel > 0 && entityLevel > quality)
 549                                 return TableMediumMeleeWeaponGenerics[quality-1].secondaryDamageFactor;
 550                         else
 551                                 return TableMediumMeleeWeaponGenerics[quality-1].damageFactor;
 552                 }
 553                 break;
 554
 555         case WEAPONTYPE::HEAVY:
 556         case WEAPONTYPE::HEAVY_GUN:
 557                 {
 558                         if ( entityLevel > 0 && entityLevel > quality)
 559                                 return TableHeavyMeleeWeaponGenerics[quality-1].secondaryDamageFactor;
 560                         else
 561                                 return TableHeavyMeleeWeaponGenerics[quality-1].damageFactor;
 562                 }
 563                 break;
 564
 565         case WEAPONTYPE::HANDS:
 566                 return TableLightMeleeWeaponGenerics[quality-1].damageFactor * (float) HANDS_DAMAGE_FACTOR_MULTIPLIER;
 567
 568         default:
 569                 nlwarning("<getWeaponDamageFactor> Unknown weapon type %d, return 0", type);
 570                 return 0;
 571         };
 572 } // getWeaponDamageFactor //
 573
 574
 575
 576
 577
 578
 579 //--------------------------------------------------------------
 580 //                                      getArmorCharacteristics()
 581 //--------------------------------------------------------------
 582 TPairUInt8UInt16 getArmorCharacteristics( ARMORTYPE::EArmorType type, uint16 quality )
 583 {
 584         if (quality > 21)
 585                 quality = 21;
 586
 587         TPairUInt8UInt16 ret;
 588
 589         switch(type)
 590         {
 591         case ARMORTYPE::LIGHT:
 592                 ret.first = TableLightArmorGenerics[quality-1].percentProtection;
 593                 ret.second = TableLightArmorGenerics[quality-1].maxProtection;
 594                 break;
 595
 596         case ARMORTYPE::MEDIUM:
 597                 ret.first = TableMediumArmorGenerics[quality-1].percentProtection;
 598                 ret.second = TableMediumArmorGenerics[quality-1].maxProtection;
 599                 break;
 600
 601         case ARMORTYPE::HEAVY:
 602                 ret.first = TableHeavyArmorGenerics[quality-1].percentProtection;
 603                 ret.second = TableHeavyArmorGenerics[quality-1].maxProtection;
 604                 break;
 605
 606         default:
 607                 nlwarning("<getArmorCharacteristics> Unknown armor type %d, return 0", type);
 608                 ret.first = 0;
 609                 ret.second = 0;
 610
 611         };
 612
 613         return ret;
 614 } // getArmorCharacteristics //
 615
 616
 617 //--------------------------------------------------------------
 618 //                                      getEntityLevel()
 619 //--------------------------------------------------------------
 620 uint32 getEntityLevel( const CEntityId &entityId, SKILLS::ESkills skill, sint32 skillModifier, float skillMultiplier )
 621 {
 622         CEntityBase* entity = entityPtrFromId( entityId );
 623         if (entity == NULL)
 624         {
 625                 nlwarning("<getEntityLevel> Invalid entity Id %s", entityId.toString().c_str() );
 626                 return 0;
 627         }
 628
 629         sint32 level = 0;
 630
 631 //      skillModifier += entity->getGlobalSkillModifier();
 632
 633         if ( skill < SKILLS::NUM_SKILLS )
 634         {
 635                 level = (sint32) ( skillMultiplier * float(entity->getSkills()._Skills[ skill ].Current) );
 636                 level += skillModifier;
 637                 if (level < 0)
 638                         level = 0;
 639         }
 640
 641         level = getLevelFromSkill(level);
 642
 643         if (level == 0 && EntityForcedDefaultLevel > 0)
 644         {
 645                 DEBUGLOG("<getEntityLevel> ONLY DEBUG : For entity %s, returns a level of %d instead of 0 for skill %s", entityId.toString().c_str(),EntityForcedDefaultLevel, SKILLS::toString(skill).c_str());
 646                 return EntityForcedDefaultLevel;
 647         }
 648
 649         return (uint32)level;
 650
 651 } // getEntityLevel //
 652
 653 //--------------------------------------------------------------
 654 //                                      getEntityLevel()
 655 //--------------------------------------------------------------
 656 uint32 getEntityLevel( const CEntityId &entityId, SCORES::TScores score, sint32 scoreModifier, float scoreMultiplier )
 657 {
 658         CEntityBase* entity = entityPtrFromId( entityId );
 659         if (entity == NULL)
 660         {
 661                 nlwarning("<getEntityLevel> Invalid entity Id %s", entityId.toString().c_str() );
 662                 return 0;
 663         }
 664
 665         uint32 level = 0;
 666
 667
 668         if ( score != SCORES::unknown )
 669         {
 670                 level = (sint32) ( scoreMultiplier * float(entity->getScores()._PhysicalScores[ score ].Current ) );
 671                 level += scoreModifier;
 672                 if (score < 0)
 673                         level = 0;
 674         }
 675
 676         level = getLevelFromScore(level);
 677
 678         if (level == 0 && EntityForcedDefaultLevel > 0)
 679         {
 680                 DEBUGLOG("<getEntityLevel> ONLY DEBUG : For entity %s, returns a level of %d instead of 0 for score %s", entityId.toString().c_str(),EntityForcedDefaultLevel, SCORES::toString(score).c_str() );
 681                 return EntityForcedDefaultLevel;
 682         }
 683
 684         return level;
 685
 686 } // getEntityLevel //
 687
 688
 689 //--------------------------------------------------------------
 690 //                                      getDistance()
 691 //--------------------------------------------------------------
 692 double getDistance( const CEntityId &entity1, const CEntityId &entity2 )
 693 {
 694         TDataSetRow entityIndex1 = TheDataset.getDataSetRow( entity1 );
 695         if ( !entityIndex1.isValid() || !TheDataset.isDataSetRowStillValid(entityIndex1) )
 696                 return -1;
 697         CMirrorPropValueRO<TYPE_POSX> posX( TheDataset, entityIndex1, DSPropertyPOSX );
 698         const double playerX = (double)posX / 1000.0f;
 699         CMirrorPropValueRO<TYPE_POSY> posY( TheDataset, entityIndex1, DSPropertyPOSY );
 700         const double playerY = (double)posY / 1000.0f;
 701
 702         double targetX, targetY;//, targetZ;
 703         // get second entity position
 704 /*      if (entity2.Type != RYZOMID::position)
 705         {*/
 706
 707         TDataSetRow entityIndex2 = TheDataset.getDataSetRow( entity2 );
 708         if ( !entityIndex2.isValid() || !TheDataset.isDataSetRowStillValid(entityIndex2) )
 709                 return -1;
 710         CMirrorPropValueRO<TYPE_POSX> targX( TheDataset, entityIndex2, DSPropertyPOSX );
 711         targetX = (double)targX() / 1000.0f;
 712         CMirrorPropValueRO<TYPE_POSY> targY( TheDataset, entityIndex2, DSPropertyPOSY );
 713         targetY = (double)targY() / 1000.0f;
 714
 715         //
 716         INFOLOG("Player position (in meters) : X = %g, Y = %g", playerX, playerY );
 717         INFOLOG("Target position (in meters) : X = %g, Y = %g", targetX, targetY );
 718
 719         const double d = sqrt( sqr(playerX-targetX) + sqr(playerY-targetY) ); //+sqr (playerZ-targetZ) );
 720         INFOLOG("Distance = %g meters", d);
 721
 722         return d;
 723 } // getDistance //
 724
 725
 726 //--------------------------------------------------------------
 727 //                                      sendUpdateBehaviour()
 728 //--------------------------------------------------------------
 729 void sendUpdateBehaviour( const CEntityId &entityId, const MBEHAV::CBehaviour &behaviour, bool forceUpdate )
 730 {
 731         MBEHAV::CBehaviour b = behaviour;
 732
 733         b.Combat.Time = uint16(CTickEventHandler::getGameCycle() >>3);
 734
 735         if (behaviour.Behaviour > MBEHAV::COMBAT_BEHAVIOUR_BEGIN && behaviour.Behaviour < MBEHAV::COMBAT_BEHAVIOUR_END)
 736         {
 737                 INFOLOG("<sendUpdateBehaviour>  entity %s param : attackintensity = %u, impact intensity = %u, behaviour %s",entityId.toString().c_str(), behaviour.Combat.AttackIntensity, behaviour.Combat.ImpactIntensity,  MBEHAV::behaviourToString(behaviour.Behaviour).c_str() );
 738         }
 739         else if (behaviour.Behaviour > MBEHAV::MAGIC_CASTING_BEHAVIOUR_BEGIN && behaviour.Behaviour < MBEHAV::MAGIC_END_CASTING_BEHAVIOUR_END)
 740         {
 741                 INFOLOG("<sendUpdateBehaviour>  entity %s param : SpellPower = %u, resist = %d, impact intensity = %u, behaviour %s", entityId.toString().c_str(), behaviour.Magic.TargetResists, behaviour.Magic.SpellPower, behaviour.Magic.ImpactIntensity,  MBEHAV::behaviourToString(behaviour.Behaviour).c_str() );
 742         }
 743         else
 744         {
 745                 INFOLOG("<sendUpdateBehaviour> entity %s, behaviour %s",entityId.toString().c_str(), MBEHAV::behaviourToString(behaviour.Behaviour).c_str() );
 746         }
 747
 748 /*      switch( entityId.getType() )
 749         {
 750         case RYZOMID::player:
 751                 {
 752                         //CMessage msgout("SET_BEHAVIOUR");
 753                         //msgout.serial( const_cast<CEntityId&> (entityId) );
 754                         //msgout.serial( b );
 755                         //sendMessageViaMirror ("OPS", msgout);
 756                 }
 757                 break;
 758
 759         case RYZOMID::npc:
 760         case RYZOMID::creature:
 761         case RYZOMID::kami:
 762                 {
 763                         //----------TEMP
 764 //                      CMessage msg("SET_BEHAVIOUR");
 765 //                      msg.serial( const_cast<CEntityId&> (entityId) );
 766 //                      msg.serial( b );
 767 //                      sendMessageViaMirror ("OPS", msg);
 768                         //----------TEMP
 769
 770 //                      CMessage msgout("U_FIGHT_BEHAVIOUR");
 771 //                      msgout.serial( const_cast<CEntityId&> (entityId) );
 772 //                      string bes = MBEHAV::behaviourToString( behaviour.Behaviour );
 773                         //msgout.serialEnum( behaviour );
 774 //                      msgout.serial( bes );
 775 //                      sendMessageViaMirror ("AIS", msgout);
 776                 }
 777                 break;
 778
 779         default:
 780                 nlwarning( "<sendUpdateBehaviour> entity type %d unknown, fail to send update behaviour msg", entityId.getType() );
 781         }
 782 */
 783         CEntityBase* entity = PHRASE_UTILITIES::entityPtrFromId( entityId );
 784         if (entity == NULL)
 785         {
 786                 nlwarning("<sendUpdateBehaviour> Invalid entity Id %s", entityId.toString().c_str() );
 787                 return;
 788         }
 789
 790         entity->setBehaviour( b, forceUpdate );
 791 } // sendUpdateBehaviour //
 792
 793
 794
 795 //--------------------------------------------------------------
 796 //                                      sendSimpleMessage()
 797 //--------------------------------------------------------------
 798 void sendSimpleMessage( const CEntityId &entityId, const std::string &msgName )
 799 {
 800         if ( entityId.getType() != RYZOMID::player && entityId.getType() != RYZOMID::chatGroup && entityId.getType() != RYZOMID::dynChatGroup )
 801                 return;
 802
 803         CMessage msg("STATIC_STRING");
 804
 805         msg.serial( const_cast<CEntityId&> (entityId) );
 806
 807         set<CEntityId> excluded;
 808         msg.serialCont( excluded );
 809
 810         msg.serial( const_cast<string&> (msgName) );
 811
 812         sendMessageViaMirror ("IOS", msg);
 813
 814         INFOLOG("<sendSimpleMessage>send %s for entity %s",msgName.c_str(), entityId.toString().c_str());
 815 } // sendSimpleMessage //
 816
 817
 818 //--------------------------------------------------------------
 819 //                                      sendMessage()
 820 //--------------------------------------------------------------
 821 void sendMessage( const NLMISC::CEntityId &entityId, const std::string &msgName, const ucstring &txt )
 822 {
 823         if ( entityId.getType() != RYZOMID::player && entityId.getType() != RYZOMID::chatGroup && entityId.getType() != RYZOMID::dynChatGroup )
 824                 return;
 825
 826         /// TEMP : convert the uctring to a string
 827         const string txtStr = txt.toString();
 828
 829         CMessage msg("STATIC_STRING");
 830
 831         msg.serial( const_cast<CEntityId&> (entityId) );
 832
 833         set<CEntityId> excluded;
 834         msg.serialCont( excluded );
 835
 836         msg.serial( const_cast<string&> (msgName) );
 837         msg.serial( const_cast<string&> (txtStr) );
 838
 839         sendMessageViaMirror ("IOS", msg);
 840
 841         INFOLOG("<sendMessage>send %s (param %s) for entity %s",msgName.c_str(), txt.toString().c_str(), entityId.toString().c_str());
 842 } // sendMessage //
 843
 844 //--------------------------------------------------------------
 845 //                                      sendMessage()
 846 //--------------------------------------------------------------
 847 void sendMessage( const NLMISC::CEntityId &entityId, const std::string &msgName, const NLMISC::CEntityId &entityIdForText )
 848 {
 849         if ( entityId.getType() != RYZOMID::player && entityId.getType() != RYZOMID::chatGroup && entityId.getType() != RYZOMID::dynChatGroup )
 850                 return;
 851
 852         CMessage msg("STATIC_STRING");
 853
 854         msg.serial( const_cast<CEntityId&> (entityId) );
 855
 856         set<CEntityId> excluded;
 857         msg.serialCont( excluded );
 858
 859         msg.serial( const_cast<string&> (msgName) );
 860         msg.serial( const_cast<CEntityId&> (entityIdForText) );
 861
 862         sendMessageViaMirror ("IOS", msg);
 863
 864         INFOLOG("<sendMessage>send %s (param entity %s) for entity %s",msgName.c_str(), entityIdForText.toString().c_str(), entityId.toString().c_str());
 865 } // sendMessage //
 866
 867
 868 //--------------------------------------------------------------
 869 //                                      sendSimpleDynamicChatMessage()
 870 //--------------------------------------------------------------
 871 void sendDynamicChatMessage( const CEntityId &entityId, const string &msgText )
 872 {
 873         if ( msgText.empty() )
 874                 return;
 875
 876         if ( entityId.getType() != RYZOMID::player && entityId.getType() != RYZOMID::chatGroup && entityId.getType() != RYZOMID::dynChatGroup )
 877                 return;
 878
 879         CMessage msg("CHAT_MESSAGE");
 880
 881         TDataSetRow dsr = TheDataset.getDataSetRow(entityId)
 882         msg.serial( dsr );
 883         msg.serial( const_cast<string&> (msgText) );
 884
 885         sendMessageViaMirror ("IOS", msg);
 886
 887         INFOLOG("<sendSimpleDynamicChatMessage>send %s for entity %s",msgText.c_str(), entityId.toString().c_str());
 888 } // sendSimpleDynamicChatMessage //
 889
 890
 891
 892 //--------------------------------------------------------------
 893 //                                      sendCombatResistMessages()
 894 //--------------------------------------------------------------
 895 void sendCombatResistMessages( const NLMISC::CEntityId &aggressorId, const NLMISC::CEntityId &victimId )
 896 {
 897         // at least the victim or the agressor must be a player, otherwise do not send any messages
 898         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
 899                 return;
 900
 901         string msgName;
 902
 903         if ( victimId.getType() == RYZOMID::player)
 904         {
 905                 msgName ="BS_MISSES_YOU_E";
 906                 CMessage msgVictim("STATIC_STRING");
 907
 908                 msgVictim.serial( const_cast<CEntityId&> (victimId) );
 909                 set<CEntityId> excluded;
 910                 msgVictim.serialCont( excluded );
 911                 msgVictim.serial( msgName );
 912
 913                 msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
 914
 915                 sendMessageViaMirror ("IOS", msgVictim);
 916
 917                 INFOLOG("<sendCombatResistMessages>send BS_MISSES_YOU_E with param e=%s for entity %s",aggressorId.toString().c_str(), victimId.toString().c_str());
 918         }
 919
 920         if ( aggressorId.getType() == RYZOMID::player)
 921         {
 922                 msgName ="BS_YOU_MISS_E";
 923                 CMessage msgAggressor("STATIC_STRING");
 924
 925                 msgAggressor.serial( const_cast<CEntityId&> (aggressorId) );
 926                 set<CEntityId> excluded;
 927                 msgAggressor.serialCont( excluded );
 928                 msgAggressor.serial( msgName );
 929
 930                 msgAggressor.serial( const_cast<CEntityId&> (victimId) );
 931
 932                 sendMessageViaMirror ("IOS", msgAggressor);
 933
 934                 INFOLOG("<sendCombatResistMessages>send BS_YOU_MISS with for entity %s", aggressorId.toString().c_str());
 935         }
 936
 937 // spectators
 938         // Send to 'speech' group
 939         msgName = "BS_MISSES_EE";
 940
 941         CEntityId speechGroupId;
 942         if ( aggressorId.getType() == RYZOMID::player )
 943         {
 944                 speechGroupId = aggressorId;
 945         }
 946         else if ( victimId.getType() == RYZOMID::player )
 947         {
 948                 speechGroupId = victimId;
 949         }
 950         else
 951                 return;
 952
 953         speechGroupId.setType( RYZOMID::dynChatGroup );
 954
 955         CMessage msgVictim("STATIC_STRING");
 956         msgVictim.serial( speechGroupId );
 957
 958         set<CEntityId> excluded;
 959         excluded.insert( aggressorId );
 960         excluded.insert( victimId );
 961
 962         msgVictim.serialCont( excluded );
 963         msgVictim.serial( msgName );
 964         msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
 965         msgVictim.serial( const_cast<CEntityId&> (victimId) );
 966
 967         sendMessageViaMirror ("IOS", msgVictim);
 968 } // sendCombatResistMessages //
 969
 970
 971 //--------------------------------------------------------------
 972 //                                      sendDeathMessages()
 973 //--------------------------------------------------------------
 974 void sendDeathMessages( const NLMISC::CEntityId &killerId, const NLMISC::CEntityId &deadId )
 975 {
 976         // at least the victim or the agressor must be a player, otherwise do not send any messages
 977         if ( (killerId.getType() != RYZOMID::player) && ( deadId.getType() != RYZOMID::player ))
 978                 return;
 979
 980         string msgName;
 981
 982         if ( killerId.getType() == RYZOMID::player )
 983         {
 984                 msgName = "OPS_DEATH_KILLER_E";
 985                 CMessage msgAggressor("STATIC_STRING");
 986
 987                 msgAggressor.serial( const_cast<CEntityId&> (killerId) );
 988                 set<CEntityId> excluded;
 989                 msgAggressor.serialCont( excluded );
 990                 msgAggressor.serial( msgName );
 991
 992                 msgAggressor.serial( const_cast<CEntityId&> (deadId) );
 993
 994                 sendMessageViaMirror ("IOS", msgAggressor);
 995         }
 996
 997         if ( deadId.getType() == RYZOMID::player )
 998         {
 999                 msgName = "OPS_DEATH_KILLED_E";
1000                 CMessage msgVictim("STATIC_STRING");
1001
1002                 msgVictim.serial( const_cast<CEntityId&> (deadId) );
1003                 set<CEntityId> excluded;
1004                 msgVictim.serialCont( excluded );
1005                 msgVictim.serial( msgName );
1006                 msgVictim.serial( const_cast<CEntityId&> (killerId) );
1007                 sendMessageViaMirror ("IOS", msgVictim);
1008         }
1009
1010 // spectators
1011         // Send to 'speech' group
1012         msgName = "OPS_DEATH_KILL_EE";
1013
1014         CEntityId speechGroupId;
1015         if ( deadId.getType() == RYZOMID::player )
1016         {
1017                 speechGroupId = deadId;
1018         }
1019         else
1020         {
1021                 speechGroupId = killerId;
1022         }
1023         speechGroupId.setType( RYZOMID::dynChatGroup );
1024
1025         CMessage msgSpectators("STATIC_STRING");
1026
1027         msgSpectators.serial( speechGroupId );
1028
1029         set<CEntityId> excluded;
1030         excluded.insert( deadId );
1031         excluded.insert( killerId );
1032         msgSpectators.serialCont( excluded );
1033         msgSpectators.serial( msgName );
1034
1035         msgSpectators.serial( const_cast<CEntityId&> (killerId) );
1036         msgSpectators.serial( const_cast<CEntityId&> (deadId) );
1037         sendMessageViaMirror ("IOS", msgSpectators);
1038
1039 } // sendDeathMessages //
1040
1041 //--------------------------------------------------------------
1042 //                                      sendHitMessages()
1043 //--------------------------------------------------------------
1044 void sendHitMessages( const CEntityId &aggressorId, const CEntityId &victimId, sint32 amount, sint32 lostStamina, sint32 lostSap)
1045 {
1046         // at least the victim or the agressor must be a player, otherwise do not send any messages
1047         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
1048                 return;
1049
1050         if ( !amount && !lostStamina && !lostSap)
1051                 return;
1052
1053         amount = abs(amount);
1054         lostStamina = abs(lostStamina);
1055         lostSap = abs(lostSap);
1056
1057         string msgName;
1058
1059         if ( aggressorId.getType() == RYZOMID::player )
1060         {
1061                 msgName = "BS_YOU_HIT_EI";
1062
1063                 CMessage msgAggressor("STATIC_STRING");
1064
1065                 msgAggressor.serial( const_cast<CEntityId&> (aggressorId) );
1066                 set<CEntityId> excluded;
1067                 msgAggressor.serialCont( excluded );
1068                 msgAggressor.serial( msgName );
1069
1070                 msgAggressor.serial( const_cast<CEntityId&> (victimId) );
1071                 msgAggressor.serial( amount );
1072
1073                 sendMessageViaMirror ("IOS", msgAggressor);
1074                 INFOLOG("<sendHitMessages>send BS_YOU_HIT_EI with param e=%s and i=%i for entity %s",victimId.toString().c_str(), amount, aggressorId.toString().c_str());
1075
1076                 // lost stamina
1077                 if (lostStamina>0)
1078                 {
1079                         msgName = "EGS_LOSE_STA_EI";
1080                         CMessage msgSta("STATIC_STRING");
1081                         msgSta.serial( const_cast<CEntityId&> (aggressorId) );
1082                         msgSta.serialCont( excluded );
1083                         msgSta.serial( msgName );
1084                         msgSta.serial( const_cast<CEntityId&> (victimId) );
1085                         msgSta.serial( lostStamina );
1086                         sendMessageViaMirror ("IOS", msgSta);
1087                 }
1088                 // lost sap
1089                 if (lostSap>0)
1090                 {
1091                         msgName = "EGS_LOSE_SAP_EI";
1092                         CMessage msgSap("STATIC_STRING");
1093                         msgSap.serial( const_cast<CEntityId&> (aggressorId) );
1094                         msgSap.serialCont( excluded );
1095                         msgSap.serial( msgName );
1096                         msgSap.serial( const_cast<CEntityId&> (victimId) );
1097                         msgSap.serial( lostSap );
1098                         sendMessageViaMirror ("IOS", msgSap);
1099                 }
1100         }
1101
1102         if ( victimId.getType() == RYZOMID::player )
1103         {
1104                 msgName = "BS_HITS_YOU_EI";
1105
1106                 CMessage msgVictim("STATIC_STRING");
1107
1108                 msgVictim.serial( const_cast<CEntityId&> (victimId) );
1109                 set<CEntityId> excluded;
1110                 msgVictim.serialCont( excluded );
1111                 msgVictim.serial( msgName );
1112                 msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1113                 msgVictim.serial( amount );
1114
1115                 sendMessageViaMirror ("IOS", msgVictim);
1116
1117                 INFOLOG("<sendHitMessages>send BS_HITS_YOU_EI with param e=%s and i=%i for entity %s",aggressorId.toString().c_str(), amount, victimId.toString().c_str());
1118
1119                 // lost stamina
1120                 if (lostStamina>0)
1121                 {
1122                         msgName = "EGS_U_LOSE_STA_EI";
1123                         CMessage msgSta("STATIC_STRING");
1124                         msgSta.serial( const_cast<CEntityId&> (victimId) );
1125                         msgSta.serialCont( excluded );
1126                         msgSta.serial( msgName );
1127                         msgSta.serial( const_cast<CEntityId&> (aggressorId) );
1128                         msgSta.serial( lostStamina );
1129                         sendMessageViaMirror ("IOS", msgSta);
1130                 }
1131                 // lost sap
1132                 if (lostSap>0)
1133                 {
1134                         msgName = "EGS_U_LOSE_SAP_EI";
1135                         CMessage msgSap("STATIC_STRING");
1136                         msgSap.serial( const_cast<CEntityId&> (victimId) );
1137                         msgSap.serialCont( excluded );
1138                         msgSap.serial( msgName );
1139                         msgSap.serial( const_cast<CEntityId&> (aggressorId) );
1140                         msgSap.serial( lostSap );
1141                         sendMessageViaMirror ("IOS", msgSap);
1142                 }
1143         }
1144
1145 // spectators
1146         // Send to 'speech' group
1147         msgName = "BS_HIT_EEI";
1148
1149
1150         CEntityId speechGroupId;
1151         if ( aggressorId.getType() == RYZOMID::player )
1152         {
1153                 speechGroupId = aggressorId;
1154         }
1155         else
1156         {
1157                 speechGroupId = victimId;
1158         }
1159         speechGroupId.setType( RYZOMID::dynChatGroup );
1160
1161         CMessage msgVictim("STATIC_STRING");
1162
1163         msgVictim.serial( speechGroupId );
1164
1165         set<CEntityId> excluded;
1166         excluded.insert( aggressorId );
1167         excluded.insert( victimId );
1168         msgVictim.serialCont( excluded );
1169
1170         msgVictim.serial( msgName );
1171
1172         msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1173         msgVictim.serial( const_cast<CEntityId&> (victimId) );
1174         msgVictim.serial( amount );
1175
1176         sendMessageViaMirror ("IOS", msgVictim);
1177 } // sendHitMessages //
1178
1179
1180
1181 //--------------------------------------------------------------
1182 //                                      sendCriticalHitMessage()
1183 //--------------------------------------------------------------
1184 void sendCriticalHitMessage( const NLMISC::CEntityId &aggressorId, const NLMISC::CEntityId &victimId )
1185 {
1186         // at least the victim or the agressor must be a player, otherwise do not send any messages
1187         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
1188                 return;
1189
1190         string msgName;
1191
1192         if ( aggressorId.getType() == RYZOMID::player )
1193         {
1194                 msgName = "EGS_YOU_CRITICAL_HIT_E";
1195                 CMessage msgAggressor("STATIC_STRING");
1196
1197                 msgAggressor.serial( const_cast<CEntityId&> (aggressorId) );
1198                 set<CEntityId> excluded;
1199                 msgAggressor.serialCont( excluded );
1200                 msgAggressor.serial( msgName );
1201
1202                 msgAggressor.serial( const_cast<CEntityId&> (victimId) );
1203
1204                 sendMessageViaMirror ("IOS", msgAggressor);
1205         }
1206
1207         if ( victimId.getType() == RYZOMID::player )
1208         {
1209                 msgName = "EGS_CRITICAL_HIT_YOU_E";
1210                 CMessage msgVictim("STATIC_STRING");
1211
1212                 msgVictim.serial( const_cast<CEntityId&> (victimId) );
1213                 set<CEntityId> excluded;
1214                 msgVictim.serialCont( excluded );
1215                 msgVictim.serial( msgName );
1216                 msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1217                 sendMessageViaMirror ("IOS", msgVictim);
1218         }
1219
1220 // spectators
1221         // Send to 'speech' group
1222         msgName = "EGS_CRITICAL_HIT_EE";
1223
1224         CEntityId speechGroupId;
1225         if ( aggressorId.getType() == RYZOMID::player )
1226         {
1227                 speechGroupId = aggressorId;
1228         }
1229         else
1230         {
1231                 speechGroupId = victimId;
1232         }
1233         speechGroupId.setType( RYZOMID::dynChatGroup );
1234
1235         CMessage msgVictim("STATIC_STRING");
1236
1237         msgVictim.serial( speechGroupId );
1238
1239         set<CEntityId> excluded;
1240         excluded.insert( aggressorId );
1241         excluded.insert( victimId );
1242         msgVictim.serialCont( excluded );
1243
1244         msgVictim.serial( msgName );
1245
1246         msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1247         msgVictim.serial( const_cast<CEntityId&> (victimId) );
1248
1249         sendMessageViaMirror ("IOS", msgVictim);
1250
1251 } // sendCriticalHitMessage //
1252
1253 //--------------------------------------------------------------
1254 //                                      sendHitNullMessages()
1255 //--------------------------------------------------------------
1256 void sendHitNullMessages( const CEntityId &aggressorId, const CEntityId &victimId )
1257 {
1258         // at least the victim or the agressor must be a player, otherwise do not send any messages
1259         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
1260                 return;
1261
1262         string msgName;
1263
1264         if ( aggressorId.getType() == RYZOMID::player )
1265         {
1266                 msgName = "BS_YOU_HIT_NULL_E";
1267                 CMessage msgAggressor("STATIC_STRING");
1268
1269                 msgAggressor.serial( const_cast<CEntityId&> (aggressorId) );
1270                 set<CEntityId> excluded;
1271                 msgAggressor.serialCont( excluded );
1272                 msgAggressor.serial( msgName );
1273
1274                 msgAggressor.serial( const_cast<CEntityId&> (victimId) );
1275
1276                 sendMessageViaMirror ("IOS", msgAggressor);
1277
1278                 INFOLOG("<sendHitMessages>send BS_YOU_HIT_NULL_E with param e=%s for entity %s",victimId.toString().c_str(), aggressorId.toString().c_str());
1279         }
1280
1281         if ( victimId.getType() == RYZOMID::player )
1282         {
1283                 msgName = "BS_HITS_YOU_NULL_E";
1284                 CMessage msgVictim("STATIC_STRING");
1285
1286                 msgVictim.serial( const_cast<CEntityId&> (victimId) );
1287                 set<CEntityId> excluded;
1288                 msgVictim.serialCont( excluded );
1289                 msgVictim.serial( msgName );
1290                 msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1291                 sendMessageViaMirror ("IOS", msgVictim);
1292
1293                 INFOLOG("<sendHitMessages>send BS_HITS_YOU_EI with param e=%s for entity %s",aggressorId.toString().c_str(), victimId.toString().c_str());
1294         }
1295
1296 // spectators
1297         // Send to 'speech' group
1298         msgName = "BS_HIT_NULL_EE";
1299
1300         CEntityId speechGroupId;
1301         if ( aggressorId.getType() == RYZOMID::player )
1302         {
1303                 speechGroupId = aggressorId;
1304         }
1305         else
1306         {
1307                 speechGroupId = victimId;
1308         }
1309         speechGroupId.setType( RYZOMID::dynChatGroup );
1310
1311         CMessage msgVictim("STATIC_STRING");
1312
1313         msgVictim.serial( speechGroupId );
1314
1315         set<CEntityId> excluded;
1316         excluded.insert( aggressorId );
1317         excluded.insert( victimId );
1318         msgVictim.serialCont( excluded );
1319
1320         msgVictim.serial( msgName );
1321
1322         msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1323         msgVictim.serial( const_cast<CEntityId&> (victimId) );
1324
1325         sendMessageViaMirror ("IOS", msgVictim);
1326 } // sendHitNullMessages //
1327
1328
1329
1330 //--------------------------------------------------------------
1331 //                                      sendFumbleMessage()
1332 //--------------------------------------------------------------
1333 void sendFumbleMessage( const NLMISC::CEntityId &aggressorId, const NLMISC::CEntityId &victimId )
1334 {
1335         // at least the victim or the agressor must be a player, otherwise do not send any messages
1336         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
1337                 return;
1338
1339         string msgName;
1340
1341         if ( aggressorId.getType() == RYZOMID::player )
1342         {
1343                 msgName = "EGS_YOU_FUMBLE";
1344                 CMessage msgAggressor("STATIC_STRING");
1345
1346                 msgAggressor.serial( const_cast<CEntityId&> (aggressorId) );
1347                 set<CEntityId> excluded;
1348                 msgAggressor.serialCont( excluded );
1349                 msgAggressor.serial( msgName );
1350
1351                 sendMessageViaMirror ("IOS", msgAggressor);
1352         }
1353
1354         if ( victimId.getType() == RYZOMID::player )
1355         {
1356                 msgName = "EGS_ENEMY_FUMBLE_E";
1357                 CMessage msgVictim("STATIC_STRING");
1358
1359                 msgVictim.serial( const_cast<CEntityId&> (victimId) );
1360                 set<CEntityId> excluded;
1361                 msgVictim.serialCont( excluded );
1362                 msgVictim.serial( msgName );
1363                 msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1364                 sendMessageViaMirror ("IOS", msgVictim);
1365         }
1366
1367 // spectators
1368         // Send to 'speech' group
1369         msgName = "EGS_FUMBLE_E";
1370
1371         CEntityId speechGroupId;
1372         if ( aggressorId.getType() == RYZOMID::player )
1373         {
1374                 speechGroupId = aggressorId;
1375         }
1376         else
1377         {
1378                 speechGroupId = victimId;
1379         }
1380         speechGroupId.setType( RYZOMID::dynChatGroup );
1381
1382         CMessage msgVictim("STATIC_STRING");
1383
1384         msgVictim.serial( speechGroupId );
1385
1386         set<CEntityId> excluded;
1387         excluded.insert( aggressorId );
1388         excluded.insert( victimId );
1389         msgVictim.serialCont( excluded );
1390
1391         msgVictim.serial( msgName );
1392
1393         sendMessageViaMirror ("IOS", msgVictim);
1394
1395 } // sendFumbleMessage //
1396
1397 //--------------------------------------------------------------
1398 //                                      sendEngageMessages()
1399 //--------------------------------------------------------------
1400 void sendEngageMessages( const NLMISC::CEntityId &aggressorId, const NLMISC::CEntityId &victimId )
1401 {
1402         // at least the victim or the agressor must be a player, otherwise do not send any messages
1403         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
1404                 return;
1405
1406         string msgName;
1407
1408         if ( aggressorId.getType() == RYZOMID::player )
1409         {
1410                 msgName = "BS_YOU_ATTACK_E";
1411                 CMessage msgAggressor("STATIC_STRING");
1412
1413                 msgAggressor.serial( const_cast<CEntityId&> (aggressorId) );
1414                 set<CEntityId> excluded;
1415                 msgAggressor.serialCont( excluded );
1416                 msgAggressor.serial( msgName );
1417
1418                 msgAggressor.serial( const_cast<CEntityId&> (victimId) );
1419
1420                 sendMessageViaMirror ("IOS", msgAggressor);
1421         }
1422
1423         if ( victimId.getType() == RYZOMID::player )
1424         {
1425                 msgName = "BS_ATTACKS_YOU_E";
1426                 CMessage msgVictim("STATIC_STRING");
1427
1428                 msgVictim.serial( const_cast<CEntityId&> (victimId) );
1429                 set<CEntityId> excluded;
1430                 msgVictim.serialCont( excluded );
1431                 msgVictim.serial( msgName );
1432                 msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1433                 sendMessageViaMirror ("IOS", msgVictim);
1434         }
1435
1436 // spectators
1437         // Send to 'speech' group
1438         msgName = "BS_ATTACKS_EE";
1439
1440         CEntityId speechGroupId;
1441         if ( aggressorId.getType() == RYZOMID::player )
1442         {
1443                 speechGroupId = aggressorId;
1444         }
1445         else
1446         {
1447                 speechGroupId = victimId;
1448         }
1449         speechGroupId.setType( RYZOMID::dynChatGroup );
1450
1451         CMessage msgVictim("STATIC_STRING");
1452
1453         msgVictim.serial( speechGroupId );
1454
1455         set<CEntityId> excluded;
1456         excluded.insert( aggressorId );
1457         excluded.insert( victimId );
1458         msgVictim.serialCont( excluded );
1459
1460         msgVictim.serial( msgName );
1461
1462         msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1463         msgVictim.serial( const_cast<CEntityId&> (victimId) );
1464
1465         sendMessageViaMirror ("IOS", msgVictim);
1466
1467 } // sendEngageMessages //
1468
1469
1470 //--------------------------------------------------------------
1471 //                                      sendDisengageMessages()
1472 //--------------------------------------------------------------
1473 void sendDisengageMessages( const NLMISC::CEntityId &aggressorId, const NLMISC::CEntityId &victimId )
1474 {
1475         // at least the victim or the agressor must be a player, otherwise do not send any messages
1476         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
1477                 return;
1478
1479         string msgName;
1480
1481         if ( aggressorId.getType() == RYZOMID::player )
1482         {
1483                 msgName = "BS_YOU_END_ATTACK_E";
1484                 CMessage msgAggressor("STATIC_STRING");
1485
1486                 msgAggressor.serial( const_cast<CEntityId&> (aggressorId) );
1487                 set<CEntityId> excluded;
1488                 msgAggressor.serialCont( excluded );
1489                 msgAggressor.serial( msgName );
1490
1491                 msgAggressor.serial( const_cast<CEntityId&> (victimId) );
1492
1493                 sendMessageViaMirror ("IOS", msgAggressor);
1494         }
1495
1496         if ( victimId.getType() == RYZOMID::player )
1497         {
1498                 msgName = "BS_END_ATTACKS_YOU_E";
1499                 CMessage msgVictim("STATIC_STRING");
1500
1501                 msgVictim.serial( const_cast<CEntityId&> (victimId) );
1502                 set<CEntityId> excluded;
1503                 msgVictim.serialCont( excluded );
1504                 msgVictim.serial( msgName );
1505                 msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1506                 sendMessageViaMirror ("IOS", msgVictim);
1507         }
1508
1509 // spectators
1510         // Send to 'speech' group
1511         msgName = "BS_END_ATTACKS_EE";
1512
1513         CEntityId speechGroupId;
1514         if ( aggressorId.getType() == RYZOMID::player )
1515         {
1516                 speechGroupId = aggressorId;
1517         }
1518         else
1519         {
1520                 speechGroupId = victimId;
1521         }
1522         speechGroupId.setType( RYZOMID::dynChatGroup );
1523
1524         CMessage msgVictim("STATIC_STRING");
1525
1526         msgVictim.serial( speechGroupId );
1527
1528         set<CEntityId> excluded;
1529         excluded.insert( aggressorId );
1530         excluded.insert( victimId );
1531         msgVictim.serialCont( excluded );
1532
1533         msgVictim.serial( msgName );
1534
1535         msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1536         msgVictim.serial( const_cast<CEntityId&> (victimId) );
1537
1538         sendMessageViaMirror ("IOS", msgVictim);
1539
1540 } // sendDisengageMessages //
1541
1542
1543 //--------------------------------------------------------------
1544 //                                      engageTargetInMelee()
1545 //--------------------------------------------------------------
1546 bool engageTargetInMelee( const CEntityId &entityId , const CEntityId &targetId , sint8 mode)
1547 {
1548         if ( targetId == CEntityId::Unknown )
1549         {
1550                 return false;
1551         }
1552
1553         // check target is alive??
1554
1555         // indicate the new engaged target (for player only)
1556         if ( entityId.getType() == RYZOMID::player)
1557         {
1558                 CCharacter *ch = PlayerManager.getChar( entityId );
1559                 if (ch == NULL)
1560                 {
1561                         nlwarning("<engageTargetInMelee> Invalid char Id %s", entityId.toString().c_str() );
1562                         return false;
1563                 }
1564                 ch->setFightingTarget( targetId );
1565         }
1566
1567         //CBrickSentenceManager::engageMelee( entityId, targetId );
1568         PhraseManager->engageMelee( TheDataset.getDataSetRow(entityId), TheDataset.getDataSetRow(targetId) );
1569         return true;
1570
1571 } // engageTargetInMelee //
1572
1573
1574
1575
1576
1577 //--------------------------------------------------------------
1578 //                                      engageTargetRange()
1579 //--------------------------------------------------------------
1580 bool engageTargetRange( const CEntityId &entityId , const CEntityId &targetId )
1581 {
1582         if ( targetId == CEntityId::Unknown )
1583         {
1584                 return false;
1585         }
1586
1587         // check target is alive??
1588
1589         //CBrickSentenceManager::engageRange( entityId, targetId );
1590         PhraseManager->engageRange( TheDataset.getDataSetRow(entityId), TheDataset.getDataSetRow(targetId) );
1591
1592         //
1593         INFOLOG("<engageTargetRange> entity %s engage entity %s in range combat",entityId.toString().c_str(),targetId.toString().c_str() );
1594
1595         // indicate the new engaged target (for player only)
1596         if ( entityId.getType() == RYZOMID::player)
1597         {
1598                 CCharacter *ch = PlayerManager.getChar( entityId );
1599                 if (ch == NULL)
1600                 {
1601                         nlwarning("<engageTargetRange> Invalid char Id %s", entityId.toString().c_str() );
1602                         return false;
1603                 }
1604                 ch->setFightingTarget( targetId );
1605         }
1606
1607         return true;
1608 } // engageTargetRange //
1609
1610
1611
1612 //--------------------------------------------------------------
1613 //                                      getImpactIntensity()
1614 //--------------------------------------------------------------
1615 INTENSITY_TYPE::TImpactIntensity getImpactIntensity( sint32 impact, const TDataSetRow &victimRowId, SCORES::TScores score )
1616 {
1617         if (impact == 0)
1618                 return INTENSITY_TYPE::IMPACT_NONE;
1619
1620         if (impact < 0)
1621                 impact = impact * (-1);
1622
1623         if ( score >= SCORES::NUM_SCORES)
1624         {
1625                 nlwarning("<getImpactIntensity> Unknown score %d", score);
1626                 return INTENSITY_TYPE::IMPACT_NONE;
1627         }
1628
1629         CEntityBase* entity = CEntityBaseManager::getEntityBasePtr( victimRowId );
1630         if (entity == NULL)
1631         {
1632                 nlwarning("<getImpactIntensity> Invalid entity row %u", victimRowId.getIndex() );
1633                 return INTENSITY_TYPE::IMPACT_NONE;
1634         }
1635
1636         const sint32 scoreMax = entity->getScores()._PhysicalScores[ score ].Max;
1637
1638         // percentage
1639         uint32 percent = (uint32) fabs(100 * (double)impact / (double)scoreMax );
1640
1641         if (percent < 2)
1642                 return INTENSITY_TYPE::IMPACT_INSIGNIFICANT;
1643         else if (percent < 5)
1644                 return INTENSITY_TYPE::IMPACT_VERY_WEAK;
1645         else if (percent < 10)
1646                 return INTENSITY_TYPE::IMPACT_WEAK;
1647         else if (percent < 20)
1648                 return INTENSITY_TYPE::IMPACT_AVERAGE;
1649         else if (percent < 30)
1650                 return INTENSITY_TYPE::IMPACT_STRONG;
1651         else if (percent < 40)
1652                 return INTENSITY_TYPE::IMPACT_VERY_STRONG;
1653         else
1654                 return INTENSITY_TYPE::IMPACT_HUGE;
1655 } // getImpactIntensity //
1656
1657
1658 //--------------------------------------------------------------
1659 //                                      getAttackIntensity()
1660 //--------------------------------------------------------------
1661 INTENSITY_TYPE::TAttackIntensity getAttackIntensity( uint32 attackLevel )
1662 {
1663         if (attackLevel < 2)
1664                 return INTENSITY_TYPE::NONE;
1665         else if (attackLevel < 5)
1666                 return INTENSITY_TYPE::WEAK;
1667         else if (attackLevel < 10)
1668                 return INTENSITY_TYPE::STANDARD;
1669         else
1670                 return INTENSITY_TYPE::STRONG;
1671 } // getAttackIntensity //
1672
1673 //--------------------------------------------------------------
1674 //                                      getOrientationString()
1675 //--------------------------------------------------------------
1676 std::string getOrientationString( const NLMISC::CVector &dir)
1677 {
1678         return getOrientationString( (sint32)dir.x, (sint32)dir.y );
1679 } // getOrientationString //
1680
1681
1682 //--------------------------------------------------------------
1683 //                                      getOrientationString()
1684 //--------------------------------------------------------------
1685 std::string getOrientationString( sint32 x, sint32 y)
1686 {
1687         float angle = (float)(atan2(y, x));
1688
1689         //get the direction
1690         uint direction =(uint) ( 8.0f* (angle + Pi)/(Pi) );
1691
1692         if (direction>15)
1693         {
1694                 nlwarning("Direction for compass should never be >15");
1695                 return "";
1696         }
1697
1698         return OrientationStrings[direction];
1699 } // getOrientationString //
1700
1701
1702 //--------------------------------------------------------------
1703 //                                      getEntityCurrentAction()
1704 //--------------------------------------------------------------
1705 ENTITY_ACTION::EEntityAction getEntityCurrentAction( const NLMISC::CEntityId &entityId)
1706 {
1707         // test melee combat
1708         TDataSetRow targetRowId = PhraseManager->getEntityEngagedMeleeBy( TheDataset.getDataSetRow(entityId) );
1709         //if (targetId != CEntityId::Unknown )
1710         if (targetRowId.isValid() && TheDataset.isDataSetRowStillValid(targetRowId))
1711         {
1712                 return ENTITY_ACTION::MELEE_COMBAT;
1713         }
1714
1715         // test range combat
1716         //targetId = CBrickSentenceManager::getEntityEngagedRangeBy( targetId );
1717         targetRowId = PhraseManager->getEntityEngagedRangeBy( TheDataset.getDataSetRow(entityId) );
1718         //if (targetId != CEntityId::Unknown )
1719         if (targetRowId.isValid() && TheDataset.isDataSetRowStillValid(targetRowId))
1720         {
1721                 return ENTITY_ACTION::RANGE_COMBAT;
1722         }
1723
1724
1725         /// \todo Malkav : test faber/tracking/casting/walking and running
1726         CEntityBase* entity = entityPtrFromId( entityId );
1727         if (entity == NULL)
1728         {
1729                 nlwarning("<getEntityCurrentAction> Invalid entity Id %s", entityId.toString().c_str() );
1730                 return ENTITY_ACTION::IDLE;
1731         }
1732
1733         const MBEHAV::CBehaviour &behaviour = entity->getBehaviour();
1734         switch( behaviour.Behaviour )
1735         {
1736                 case MBEHAV::HARVESTING:
1737                         return ENTITY_ACTION::HARVESTING;
1738                         break;
1739
1740                 case MBEHAV::FABER:
1741                 case MBEHAV::REPAIR:
1742                 case MBEHAV::REFINE:
1743                         return ENTITY_ACTION::DOING_FABER;
1744                         break;
1745
1746                 default:
1747                         {
1748                                 /// Problem : how to detect a casting entity when this entity use the suffix tryker brick 'hide' ??? :'(
1749                                 if (behaviour.Behaviour >= MBEHAV::MAGIC_CASTING_BEHAVIOUR_BEGIN && behaviour.Behaviour < MBEHAV::MAGIC_END_CASTING_BEHAVIOUR_BEGIN)
1750                                         return ENTITY_ACTION::CASTING;
1751                         }
1752                         break;
1753         };
1754
1755
1756         // by default : return IDLE
1757         return ENTITY_ACTION::IDLE;
1758
1759 } // getEntityCurrentAction //
1760
1761
1762 //--------------------------------------------------------------
1763 //                                              testOffensiveActionAllowed
1764 //--------------------------------------------------------------
1765 bool testOffensiveActionAllowed( const NLMISC::CEntityId &actorId, const NLMISC::CEntityId &targetId, string &errorCode )
1766 {
1767         switch ( targetId.getType() )
1768         {
1769         case RYZOMID::player:
1770                 {
1771                         if (actorId.getType() == RYZOMID::player)
1772                         {
1773                                 if (!AllowPVP)
1774                                         errorCode = "EGS_PVP_NOT_ALLOWED";
1775
1776                                 return AllowPVP;
1777                         }
1778                 }
1779                 break;
1780
1781         case RYZOMID::creature:
1782         case RYZOMID::mount:
1783         case RYZOMID::kami:
1784         case RYZOMID::npc:
1785                 {
1786                         CEntityBase* entity = CreatureManager.getCreature( targetId );
1787                         if (entity == NULL)
1788                         {
1789                                 nlwarning("<testOffensiveActionAllowed> Invalid entity Id %s", targetId.toString().c_str() );
1790                                 errorCode = "BS_INVALID_TARGET";
1791                                 return false;
1792                         }
1793
1794                         /*// get creature form
1795                         const CSheetId &sheet = entity->getType();
1796
1797                         const CStaticCreatures *creature = CSheets::getCreaturesForm( sheet );
1798                         if ( ! creature)
1799                         {
1800                                 nlwarning("<testOffensiveActionAllowed> can't found CStaticCreature for entity %s", targetId.toString().c_str() );
1801                                 errorCode = "BS_INVALID_TARGET";
1802                                 return false;
1803                         }
1804
1805                         if ( ! creature->properties.attackable() )
1806                         {
1807                                 errorCode = "BS_TARGET_NOT_ATTACKABLE";
1808                                 return false;
1809                         }
1810                         */
1811
1812                         if (!entity->getContextualProperty().getValue().attackable())
1813                         {
1814                                 errorCode = "BS_TARGET_NOT_ATTACKABLE";
1815                                 return false;
1816                         }
1817                 }
1818                 break;
1819
1820         default:
1821                 break;
1822
1823         };
1824         return true;
1825 } // testOffensiveActionAllowed //
1826
1827 //--------------------------------------------------------------
1828 //                                      sendScoreModifierSpellMessage
1829 //--------------------------------------------------------------
1830 void sendScoreModifierSpellMessage( CEntityBase * aggressor, CEntityBase* victim, sint32 value, SCORES::TScores score, ACTNATURE::EActionNature nature )
1831 {
1832         nlassert(aggressor);
1833         nlassert(victim);
1834
1835         // at least the victim or the agressor must be a player, otherwise do not send any messages
1836         if ( (aggressor->getId().getType() != RYZOMID::player) && ( victim->getId().getType() != RYZOMID::player ))
1837                 return;
1838
1839         string msgAgressor;
1840         string msgVictim;
1841
1842         switch (nature )
1843         {
1844         case ACTNATURE::OFFENSIVE:
1845                 switch(score)
1846                 {
1847                 case SCORES::sap:
1848                         msgVictim       = "MAGIC_U_SUFFER_OFFENSIVE_SPELL_E_SAP";
1849                         msgAgressor = "MAGIC_U_CAST_OFFENSIVE_SPELL_E_SAP";
1850                         break;
1851                 case SCORES::stamina:
1852                         msgVictim       = "MAGIC_U_SUFFER_OFFENSIVE_SPELL_E_STA";
1853                         msgAgressor = "MAGIC_U_CAST_OFFENSIVE_SPELL_E_STA";
1854                         break;
1855                 case SCORES::hit_points:
1856                         msgVictim       = "MAGIC_U_SUFFER_OFFENSIVE_SPELL_E_HP";
1857                         msgAgressor = "MAGIC_U_CAST_OFFENSIVE_SPELL_E_HP";
1858                         break;
1859                 default:
1860                         nlwarning("<PHRASE_UTILITIES sendScoreModifierSpellMessage> invalid scrore %s", SCORES::toString(score).c_str() );
1861                 }
1862                 break;
1863                 case ACTNATURE::DEFENSIVE:
1864                 switch(score)
1865                 {
1866                 case SCORES::sap:
1867                         msgVictim       = "MAGIC_U_SUFFER_HEAL_SPELL_E_SAP";
1868                         msgAgressor = "MAGIC_U_CAST_HEAL_SPELL_E_SAP";
1869                         break;
1870                         case SCORES::stamina:
1871                         msgVictim       = "MAGIC_U_SUFFER_HEAL_SPELL_E_STA";
1872                         msgAgressor = "MAGIC_U_CAST_HEAL_SPELL_E_STA";
1873                         break;
1874                 case SCORES::hit_points:
1875                         msgVictim       = "MAGIC_U_SUFFER_HEAL_SPELL_E_HP";
1876                         msgAgressor = "MAGIC_U_CAST_HEAL_SPELL_E_HP";
1877                         break;
1878                 default:
1879                         nlwarning("<PHRASE_UTILITIES sendScoreModifierSpellMessage> invalid scrore %s", SCORES::toString(score).c_str() );
1880                 }
1881                 break;
1882         };
1883
1884         if ( aggressor->getId().getType() == RYZOMID::player )
1885         {
1886                 CCharacter::sendMessageToClient(aggressor->getId(),msgAgressor,victim->getId(),(uint32)value );
1887         }
1888         if ( victim->getId().getType() == RYZOMID::player )
1889         {
1890                 CCharacter::sendMessageToClient(victim->getId(),msgVictim,aggressor->getId(),(uint32)value );
1891         }
1892 } // sendScoreModifierSpellMessage //
1893
1894
1895
1896
1897 //--------------------------------------------------------------
1898 //                                      sendSpellResistMessages()
1899 //--------------------------------------------------------------
1900 void sendSpellResistMessages( const TDataSetRow &aggressorRowId, const TDataSetRow &victimRowId  )
1901 {
1902         if ( !aggressorRowId.isValid() || !TheDataset.isDataSetRowStillValid(aggressorRowId) || !victimRowId.isValid() || !TheDataset.isDataSetRowStillValid(victimRowId) )
1903                 return;
1904
1905         CEntityId victimId = TheDataset.getEntityId(victimRowId);
1906         CEntityId aggressorId = TheDataset.getEntityId(aggressorRowId);
1907
1908         // at least the victim or the agressor must be a player, otherwise do not send any messages
1909         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
1910                 return;
1911
1912         string msgName;
1913
1914         if ( victimId.getType() == RYZOMID::player)
1915         {
1916                 msgName ="EGS_TARGET_CASTING_RESIST_E";
1917                 CMessage msgVictim("STATIC_STRING");
1918
1919                 msgVictim.serial( const_cast<CEntityId&> (victimId) );
1920                 set<CEntityId> excluded;
1921                 msgVictim.serialCont( excluded );
1922                 msgVictim.serial( msgName );
1923                 msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
1924                 sendMessageViaMirror ("IOS", msgVictim);
1925         }
1926
1927         if ( aggressorId.getType() == RYZOMID::player)
1928         {
1929                 msgName ="EGS_ACTOR_CASTING_RESIST_E";
1930                 CMessage msgAggressor("STATIC_STRING");
1931
1932                 msgAggressor.serial( const_cast<CEntityId&> (aggressorId) );
1933                 set<CEntityId> excluded;
1934                 msgAggressor.serialCont( excluded );
1935                 msgAggressor.serial( msgName );
1936                 msgAggressor.serial( const_cast<CEntityId&> (victimId) );
1937                 sendMessageViaMirror ("IOS", msgAggressor);
1938         }
1939
1940 // send message to spectators
1941         // Send to 'speech' group
1942         msgName ="EGS_SPECT_CASTING_RESIST_EE";
1943
1944         CEntityId speechGroupId;
1945         if ( victimId.getType() == RYZOMID::player )
1946         {
1947                 speechGroupId = victimId;
1948         }
1949         else
1950         {
1951                 speechGroupId = aggressorId;
1952         }
1953         speechGroupId.setType( RYZOMID::dynChatGroup );
1954
1955         CMessage msg("STATIC_STRING");
1956
1957         msg.serial( speechGroupId );
1958
1959         set<CEntityId> excluded;
1960         excluded.insert( aggressorId );
1961         excluded.insert( victimId );
1962
1963         msg.serialCont( excluded );
1964         msg.serial( msgName );
1965
1966         msg.serial( const_cast<CEntityId&> (victimId) );
1967         msg.serial( const_cast<CEntityId&> (aggressorId) );
1968
1969         sendMessageViaMirror ("IOS", msg);
1970 } // sendSpellResistMessages //
1971
1972
1973 //--------------------------------------------------------------
1974 //                                      sendSpellBeginCastMessages()
1975 //--------------------------------------------------------------
1976 void sendSpellBeginCastMessages( const TDataSetRow &aggressorRowId, const TDataSetRow &victimRowId, ACTNATURE::EActionNature nature )
1977 {
1978         if ( !aggressorRowId.isValid() || !TheDataset.isDataSetRowStillValid(aggressorRowId) || !victimRowId.isValid() || !TheDataset.isDataSetRowStillValid(victimRowId) )
1979                 return;
1980
1981         CEntityId victimId = TheDataset.getEntityId(victimRowId);
1982         CEntityId aggressorId = TheDataset.getEntityId(aggressorRowId);
1983
1984         // at least the victim or the agressor must be a player, otherwise do not send any messages
1985         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
1986                 return;
1987
1988         string msgName;
1989         bool self = (aggressorId == victimId);
1990
1991         if ( aggressorId.getType() == RYZOMID::player)
1992         {
1993                 switch( nature )
1994                 {
1995                 case ACTNATURE::NEUTRAL:
1996                         msgName = self ? "EGS_ACTOR_BEGIN_SELFCAST_NEUTRAL" : "EGS_ACTOR_BEGIN_CASTING_NEUTRAL_E";
1997                         break;
1998                 case ACTNATURE::DEFENSIVE:
1999                         msgName = self ? "EGS_ACTOR_BEGIN_SELFCAST_GOOD" : "EGS_ACTOR_BEGIN_CASTING_GOOD_E";
2000                         break;
2001                 case ACTNATURE::OFFENSIVE:
2002                 default:
2003                         msgName ="EGS_ACTOR_BEGIN_CASTING_BAD_E";
2004                 };
2005
2006                 CMessage msgVictim("STATIC_STRING");
2007
2008                 msgVictim.serial( const_cast<CEntityId&> (aggressorId) );
2009                 set<CEntityId> excluded;
2010                 msgVictim.serialCont( excluded );
2011                 msgVictim.serial( msgName );
2012
2013                 if (!self)
2014                         msgVictim.serial( const_cast<CEntityId&> (victimId) );
2015
2016                 sendMessageViaMirror ("IOS", msgVictim);
2017         }
2018
2019         if (self)
2020                 return;
2021
2022         if ( victimId.getType() == RYZOMID::player)
2023         {
2024                 switch( nature )
2025                 {
2026                 case ACTNATURE::NEUTRAL:
2027                         msgName = "EGS_TARGET_BEGIN_CASTING_NEUTRAL_E";
2028                         break;
2029                 case ACTNATURE::DEFENSIVE:
2030                         msgName = "EGS_TARGET_BEGIN_CASTING_GOOD_E";
2031                         break;
2032                 case ACTNATURE::OFFENSIVE:
2033                 default:
2034                         msgName ="EGS_TARGET_BEGIN_CASTING_BAD_E";
2035                 };
2036
2037                 CMessage msgAggressor("STATIC_STRING");
2038
2039                 msgAggressor.serial( const_cast<CEntityId&> (victimId) );
2040                 set<CEntityId> excluded;
2041                 msgAggressor.serialCont( excluded );
2042                 msgAggressor.serial( msgName );
2043                 msgAggressor.serial( const_cast<CEntityId&> (aggressorId) );
2044                 sendMessageViaMirror ("IOS", msgAggressor);
2045         }
2046
2047 // send message to spectators
2048         // Send to 'speech' group
2049         switch( nature )
2050         {
2051         case ACTNATURE::NEUTRAL:
2052                 msgName = "EGS_SPECT_BEGIN_CASTING_NEUTRAL_EE";
2053                 break;
2054         case ACTNATURE::DEFENSIVE:
2055                 msgName = "EGS_SPECT_BEGIN_CASTING_GOOD_EE";
2056                 break;
2057         case ACTNATURE::OFFENSIVE:
2058         default:
2059                 msgName ="EGS_SPECT_BEGIN_CASTING_BAD_EE";
2060         };
2061
2062         CEntityId speechGroupId;
2063         if ( victimId.getType() == RYZOMID::player )
2064         {
2065                 speechGroupId = victimId;
2066         }
2067         else
2068         {
2069                 speechGroupId = aggressorId;
2070         }
2071         speechGroupId.setType( RYZOMID::dynChatGroup );
2072
2073         CMessage msg("STATIC_STRING");
2074
2075         msg.serial( speechGroupId );
2076
2077         set<CEntityId> excluded;
2078         excluded.insert( aggressorId );
2079         excluded.insert( victimId );
2080
2081         msg.serialCont( excluded );
2082         msg.serial( msgName );
2083
2084         msg.serial( const_cast<CEntityId&> (aggressorId) );
2085         msg.serial( const_cast<CEntityId&> (victimId) );
2086
2087         sendMessageViaMirror ("IOS", msg);
2088 } // sendSpellBeginCastMessages //
2089
2090
2091 //--------------------------------------------------------------
2092 //                                      sendSpellSuccessMessages()
2093 //--------------------------------------------------------------
2094 void sendSpellSuccessMessages( const TDataSetRow &aggressorRowId, const TDataSetRow &victimRowId  )
2095 {
2096         if ( !aggressorRowId.isValid() || !TheDataset.isDataSetRowStillValid(aggressorRowId) || !victimRowId.isValid() || !TheDataset.isDataSetRowStillValid(victimRowId) )
2097                 return;
2098
2099         CEntityId victimId = TheDataset.getEntityId(victimRowId);
2100         CEntityId aggressorId = TheDataset.getEntityId(aggressorRowId);
2101
2102         // at least the victim or the agressor must be a player, otherwise do not send any messages
2103         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
2104                 return;
2105
2106         sendSimpleMessage(aggressorRowId, "EGS_ACTOR_CAST_END_SUCCESS");
2107
2108         if ( aggressorRowId == victimRowId)
2109                 return;
2110
2111         sendMessage(victimRowId, "EGS_TARGET_CAST_END_SUCCESS_E", aggressorRowId);
2112
2113
2114 // send message to spectators
2115         // Send to 'speech' group
2116         string msgName ="EGS_SPECT_CAST_END_SUCCESS_EE";
2117         CEntityId speechGroupId;
2118         if ( victimId.getType() == RYZOMID::player )
2119                 speechGroupId = victimId;
2120         else
2121                 speechGroupId = aggressorId;
2122
2123         speechGroupId.setType( RYZOMID::dynChatGroup );
2124
2125         CMessage msg("STATIC_STRING");
2126         msg.serial( speechGroupId );
2127         set<CEntityId> excluded;
2128         excluded.insert( aggressorId );
2129         excluded.insert( victimId );
2130         msg.serialCont( excluded );
2131         msg.serial( msgName );
2132         msg.serial( const_cast<CEntityId&> (victimId) );
2133         msg.serial( const_cast<CEntityId&> (aggressorId) );
2134         sendMessageViaMirror ("IOS", msg);
2135 } // sendSpellSuccessMessages //
2136
2137
2138 //--------------------------------------------------------------
2139 //                                      sendSpellFailedMessages()
2140 //--------------------------------------------------------------
2141 void sendSpellFailedMessages( const TDataSetRow &aggressorRowId, const TDataSetRow &victimRowId  )
2142 {
2143         if ( !aggressorRowId.isValid() || !TheDataset.isDataSetRowStillValid(aggressorRowId) || !victimRowId.isValid() || !TheDataset.isDataSetRowStillValid(victimRowId) )
2144                 return;
2145
2146         CEntityId victimId = TheDataset.getEntityId(victimRowId);
2147         CEntityId aggressorId = TheDataset.getEntityId(aggressorRowId);
2148
2149         // at least the victim or the agressor must be a player, otherwise do not send any messages
2150         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
2151                 return;
2152
2153         sendSimpleMessage(aggressorRowId, "EGS_ACTOR_CAST_END_FAILED");
2154
2155         if ( aggressorRowId == victimRowId)
2156                 return;
2157
2158         sendMessage(victimRowId, "EGS_TARGET_CAST_END_FAILED_E", aggressorRowId);
2159
2160
2161 // send message to spectators
2162         // Send to 'speech' group
2163         string msgName ="EGS_SPECT_CAST_END_FAILED_E";
2164         CEntityId speechGroupId;
2165         if ( victimId.getType() == RYZOMID::player )
2166                 speechGroupId = victimId;
2167         else
2168                 speechGroupId = aggressorId;
2169
2170         speechGroupId.setType( RYZOMID::dynChatGroup );
2171
2172         CMessage msg("STATIC_STRING");
2173         msg.serial( speechGroupId );
2174         set<CEntityId> excluded;
2175         excluded.insert( aggressorId );
2176         excluded.insert( victimId );
2177         msg.serialCont( excluded );
2178         msg.serial( msgName );
2179         msg.serial( const_cast<CEntityId&> (aggressorId) );
2180         sendMessageViaMirror ("IOS", msg);
2181 } // sendSpellFailedMessages //
2182
2183 //--------------------------------------------------------------
2184 //                                      sendSpellFumbleMessages()
2185 //--------------------------------------------------------------
2186 void sendSpellFumbleMessages( const TDataSetRow &aggressorRowId, const TDataSetRow &victimRowId  )
2187 {
2188         if ( !aggressorRowId.isValid() || !TheDataset.isDataSetRowStillValid(aggressorRowId) || !victimRowId.isValid() || !TheDataset.isDataSetRowStillValid(victimRowId) )
2189                 return;
2190
2191         CEntityId victimId = TheDataset.getEntityId(victimRowId);
2192         CEntityId aggressorId = TheDataset.getEntityId(aggressorRowId);
2193
2194         // at least the victim or the agressor must be a player, otherwise do not send any messages
2195         if ( (aggressorId.getType() != RYZOMID::player) && ( victimId.getType() != RYZOMID::player ))
2196                 return;
2197
2198         sendSimpleMessage(aggressorRowId, "EGS_ACTOR_CAST_END_FUMBLE");
2199
2200         if ( aggressorRowId == victimRowId)
2201                 return;
2202
2203         sendMessage(victimRowId, "EGS_TARGET_CAST_END_FUMBLE_E", aggressorRowId);
2204
2205
2206 // send message to spectators
2207         // Send to 'speech' group
2208         string msgName ="EGS_SPECT_CAST_END_FUMBLE_E";
2209         CEntityId speechGroupId;
2210         if ( victimId.getType() == RYZOMID::player )
2211                 speechGroupId = victimId;
2212         else
2213                 speechGroupId = aggressorId;
2214
2215         speechGroupId.setType( RYZOMID::dynChatGroup );
2216
2217         CMessage msg("STATIC_STRING");
2218         msg.serial( speechGroupId );
2219         set<CEntityId> excluded;
2220         excluded.insert( aggressorId );
2221         excluded.insert( victimId );
2222         msg.serialCont( excluded );
2223         msg.serial( msgName );
2224         msg.serial( const_cast<CEntityId&> (aggressorId) );
2225         sendMessageViaMirror ("IOS", msg);
2226 } // sendSpellFumbleMessages //
2227
2228 }; // namespace PHRASE_UTILITIES
2229