ryzom/server/src/input_output_service/parameter_traits.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdpch.h"
  21 #include "nel/misc/variable.h"
  22 #include "nel/misc/path.h"
  23 #include "string_manager.h"
  24 #include "input_output_service.h"
  25 #include "game_share/skills.h"
  26 #include "game_share/body.h"
  27 #include "game_share/scores.h"
  28 #include "game_share/characteristics.h"
  29 #include "game_share/damage_types.h"
  30 #include "game_share/power_types.h"
  31 #include "game_share/ecosystem.h"
  32 #include "game_share/people.h"
  33 #include "game_share/roles.h"
  34 #include "game_share/fame.h"
  35 #include "game_share/ryzom_mirror_properties.h"
  36
  37
  38 using namespace STRING_MANAGER;
  39 using namespace NLMISC;
  40 using namespace NLNET;
  41 using namespace std;
  42
  43
  44 extern CVariable<bool> VerboseStringManager;
  45 #define LOG if (!VerboseStringManager) {} else nlinfo
  46
  47
  48 const char *OperatorNames[] =
  49 {
  50                 "equal",
  51                 "notEqual",
  52                 "greater",
  53                 "greaterEqual",
  54                 "less",
  55                 "lessEqual",
  56                 "nop"
  57 };
  58
  59
  60 // --------------- ParameterTraits class -------------------
  61
  62 void CStringManager::CParameterTraits::fillBitMemStream( const CCharacterInfos *charInfo,TLanguages language, const TReplacement &rep, NLMISC::CBitMemStream &bms)
  63 {
  64         const CStringManager::CEntityWords &ew = SM->getEntityWords(language, ParamId.Type);
  65         std::string rowName = NLMISC::strlwr(getParameterId());
  66         uint32 stringId;
  67         stringId = ew.getStringId(rowName, rep.Format);
  68         bms.serial(stringId);
  69 }
  70
  71 bool CStringManager::CParameterTraits::eval(CStringManager::TLanguages lang,const CCharacterInfos *charInfo, const TCondition &cond) const
  72 {
  73         // Default eval only check in words column as property
  74         const CStringManager::CEntityWords &ew = SM->getEntityWords(lang, ParamId.Type);
  75         uint32 colIndex = ew.getColumnId(cond.Property);
  76         if (colIndex == 0xffffffff)
  77         {
  78                 nlwarning("The column %s is unknown in words file for %s", cond.Property.c_str(), getParameterId().c_str());
  79                 return false;
  80         }
  81
  82         // ok, this column exist, retrieve the row
  83         uint32 rowIndex = ew.getRowId(NLMISC::strlwr(getParameterId()));
  84         if (rowIndex == 0xffffffff)
  85         {
  86                 nlwarning("The entry in table for %s is unknown in words.", getParameterId().c_str());
  87                 return false;
  88         }
  89
  90         uint32 stringId = ew.getStringId(rowIndex, colIndex);
  91         std::string str = NLMISC::toLowerAscii(SM->getString(stringId).toString());
  92
  93         LOG("SM : (paramTraits) eval condition for property %s [%s] %s [%s]", cond.Property.c_str(), str.c_str(), OperatorNames[cond.Operator], cond.ReferenceStr.c_str());
  94
  95         switch(cond.Operator)
  96         {
  97         case equal:
  98                 return str == cond.ReferenceStr;
  99         case notEqual:
 100                 return str != cond.ReferenceStr;
 101         case greater:
 102                 return str > cond.ReferenceStr;
 103         case greaterEqual:
 104                 return str >= cond.ReferenceStr;
 105         case less:
 106                 return str < cond.ReferenceStr;
 107         case lessEqual:
 108                 return str <= cond.ReferenceStr;
 109         default:
 110                 nlwarning("Operator %s is not applicable to property %s", OperatorNames[cond.Operator], cond.Property.c_str());
 111                 return false;
 112         }
 113 }
 114
 115
 116 class CParameterTraitsEntity : public CStringManager::CParameterTraits
 117 {
 118 public:
 119         CStringManager::CParameterTraits *clone()
 120         {
 121                 return new CParameterTraitsEntity(STRING_MANAGER::entity, "entity");
 122         }
 123
 124         CParameterTraitsEntity(STRING_MANAGER::TParamType type, const std::string &typeName)
 125                 : CParameterTraits(type, typeName)
 126         {}
 127         bool extractFromMessage(NLNET::CMessage &message, bool debug)
 128         {
 129                 TParam  param;
 130                 if (param.serialParam(debug, message, ParamId.Type))
 131                 {
 132                         EId = param.getEId();
 133                         _AIAlias = param.getAIAlias();
 134                         return true;
 135                 }
 136                 else
 137                 {
 138                         EId = CEntityId::Unknown;
 139                         _AIAlias = 0;
 140                         return false;
 141                 }
 142         }
 143         const std::string &getParameterId() const
 144         {
 145                 static std::string empty;
 146                 // special case for fauna entity
 147                 if (EId.getType() == RYZOMID::creature || EId.getType() == RYZOMID::npc)
 148                 {
 149                         const NLMISC::CSheetId &sheetId = SM->getSheetId(EId);
 150                         if (sheetId == NLMISC::CSheetId::Unknown)
 151                         {
 152                                 nlwarning("The sheet id for creature entity %s is unknown !", EId.toString().c_str());
 153                                 return empty;
 154                         }
 155
 156                         const CStringManager::TSheetInfo &si = SM->getSheetInfo(sheetId);
 157                         return si.SheetName;
 158                 }
 159
 160                 // TODO : We need to found the name of the entity.
 161                 return empty;
 162         }
 163         // just a wrapper to base class
 164         bool eval(CStringManager::TLanguages lang,const CCharacterInfos *charInfo, const CStringManager::TCondition &cond) const
 165         {
 166                 // Test unknown entity
 167                 if ((cond.ReferenceInt == 0) && (cond.Property.empty()))
 168                 {
 169                         if (cond.Operator == CStringManager::equal)
 170                                 return EId.isUnknownId();
 171                         else if (cond.Operator == CStringManager::notEqual)
 172                                 return !EId.isUnknownId();
 173                 }
 174
 175                 // test on race
 176                 const NLMISC::CSheetId &sheetId = SM->getSheetId(EId);
 177                 if (sheetId == NLMISC::CSheetId::Unknown)
 178                 {
 179                         nlwarning("The sheet id for entity entity %s is unknown !", EId.toString().c_str());
 180                         return false;
 181                 }
 182                 const CStringManager::TSheetInfo &si = SM->getSheetInfo(sheetId);
 183                 std::string op1;
 184
 185                 if (cond.Property == "race")
 186                 {
 187                         op1 = si.Race;
 188                 }
 189                 else if (cond.Property == "gender")
 190                 {
 191                         CCharacterInfos *playerInfo = IOS->getCharInfos(EId);
 192                         if (playerInfo != 0)
 193                         {
 194                                 op1 = GSGENDER::toString(playerInfo->getGender());
 195                         }
 196                 }
 197                 else
 198                 {
 199                         return CParameterTraits::eval(lang, charInfo, cond);
 200                 }
 201
 202                 NLMISC::strlwr(op1);
 203                 LOG("SM : (entity) eval condition for property %s [%s] %s [%s]", cond.Property.c_str(), op1.c_str(), OperatorNames[cond.Operator], cond.ReferenceStr.c_str());
 204
 205                 switch(cond.Operator)
 206                 {
 207                 case CStringManager::equal:
 208                         return op1 == cond.ReferenceStr;
 209                 case CStringManager::notEqual:
 210                         return op1 != cond.ReferenceStr;
 211                 case CStringManager::less:
 212                         return op1 < cond.ReferenceStr;
 213                 case CStringManager::lessEqual:
 214                         return op1 <= cond.ReferenceStr;
 215                 case CStringManager::greater:
 216                         return op1 > cond.ReferenceStr;
 217                 case CStringManager::greaterEqual:
 218                         return op1 >= cond.ReferenceStr;
 219                 default:
 220                         nlwarning("Operator %s not applicable to creature property %s", OperatorNames[cond.Operator], cond.Property.c_str());
 221                         return false;
 222                 }
 223                 nlerror("This point of code can never be reach !");
 224                 return CParameterTraits::eval(lang, charInfo, cond);
 225         }
 226
 227         void fillBitMemStream( const CCharacterInfos *charInfo,CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
 228         {
 229                 if ( EId == CEntityId::Unknown && _AIAlias != 0)
 230                 {
 231                         CAIAliasManager& aiAliasMgr = IOS->getAIAliasManager();
 232                         if (aiAliasMgr.is(_AIAlias))
 233                         {
 234
 235                                 static const string NAME("name");
 236                                 CSString format = rep.Format;
 237                                 if (format.left(4) != NAME)
 238                                 {
 239                                         // can't replace this parameter, write a del char
 240                                         const static string s("\010");
 241                                         uint32 index = SM->storeString(s);
 242                                         bms.serial(index);
 243                                         return;
 244                                 }
 245                                 else
 246                                 {
 247                                         uint32 index ;
 248                                         index = aiAliasMgr.getShortNameIndex(_AIAlias);
 249                                         if (index)
 250                                         {
 251                                                 bms.serial(index);
 252                                                 return;
 253                                         }
 254                                         index = aiAliasMgr.getTitleIndex(_AIAlias, language);
 255                                         if (index)
 256                                         {
 257                                                 bms.serial(index);
 258                                                 return;
 259                                         }
 260                                 }
 261                                 // No translated title or translated phrase found send ''
 262                                 //              ucstring temp(EId.toString());
 263                                 const ucstring NoName("''");
 264                                 uint32 index = SM->storeString(NoName);
 265                                 bms.serial(index);
 266                                 return;
 267                         }
 268                 }
 269
 270                 if (EId.getType() == RYZOMID::player || EId.getType() == RYZOMID::npc)
 271                 {
 272                         CCharacterInfos *playerInfo = IOS->getCharInfos(EId);
 273                         if (playerInfo != 0)
 274                         {
 275                                 static const string NAME("name");
 276                                 CSString format = rep.Format;
 277                                 if (format.left(4) != NAME)
 278                                 {
 279                                         // can't replace this parameter, write a del char
 280                                         const static string s("\010");
 281                                         uint32 index = SM->storeString(s);
 282                                         bms.serial(index);
 283                                         return;
 284                                 }
 285                                 else
 286                                 {
 287                                         if (!playerInfo->ShortName.empty())
 288                                         {
 289                                                 uint32 index = playerInfo->ShortNameIndex;
 290                                                 bms.serial(index);
 291                                                 return;
 292                                         }
 293                                         if (!playerInfo->Title.empty())
 294                                         {
 295                                                 uint32 index = SM->translateTitle(playerInfo->Title, language);
 296                                                 // we must match this index against the function table
 297                                                 bms.serial(index);
 298                                                 return;
 299                                         }
 300                                 }
 301                         }
 302                 }
 303
 304                 // special case fauna entity or unnamed npc (i.e. npc not registered with a character name, like fauna in npc state machine)
 305                 if (EId.getType() == RYZOMID::creature || EId.getType() == RYZOMID::npc)
 306                 {
 307                         // a big FAKE
 308                         STRING_MANAGER::TParamType realType = ParamId.Type;
 309                         ParamId.Type = STRING_MANAGER::creature;
 310                         CParameterTraits::fillBitMemStream(charInfo, language, rep, bms);
 311
 312                         // restore normal type
 313                         ParamId.Type = realType;
 314                         return;
 315                 }
 316
 317                 // no info on the name, just send the EID as string.
 318 //              ucstring temp(EId.toString());
 319                 const ucstring NoName("''");
 320                 uint32 index = SM->storeString(NoName);
 321                 bms.serial(index);
 322         }
 323
 324         void setDefaultValue()
 325         {
 326                 EId = NLMISC::CEntityId::Unknown;
 327                 _AIAlias = 0;
 328         }
 329
 330 };
 331 class CParameterTraitsEnum : public CStringManager::CParameterTraits
 332 {
 333 public:
 334         CParameterTraitsEnum(STRING_MANAGER::TParamType type, const std::string &typeName)
 335                 : CParameterTraits(type, typeName)
 336         {}
 337         bool extractFromMessage(NLNET::CMessage &message, bool debug)
 338         {
 339                 TParam  param;
 340                 if (param.serialParam(debug, message, ParamId.Type))
 341                 {
 342                         Enum = param.Enum;
 343                         return true;
 344                 }
 345                 else
 346                 {
 347                         setDefaultValue();
 348                         return false;
 349                 }
 350         }
 351 };
 352
 353 class CParameterTraitsIdentifier : public CStringManager::CParameterTraits
 354 {
 355 public:
 356         CParameterTraitsIdentifier(STRING_MANAGER::TParamType type, const std::string &typeName)
 357                 : CParameterTraits(type, typeName)
 358         {}
 359         bool extractFromMessage(NLNET::CMessage &message, bool debug)
 360         {
 361                 TParam  param;
 362                 if (param.serialParam(debug, message, ParamId.Type))
 363                 {
 364                         Identifier = param.Identifier;
 365                         return true;
 366                 }
 367                 else
 368                 {
 369                         setDefaultValue();
 370                         return false;
 371                 }
 372         }
 373
 374         const std::string &getParameterId() const
 375         {
 376                 return Identifier;
 377         }
 378
 379         void setDefaultValue()
 380         {
 381                 Identifier.clear();
 382         }
 383 };
 384
 385 class CParameterTraitsSheet : public CStringManager::CParameterTraits
 386 {
 387 public:
 388         CParameterTraitsSheet(STRING_MANAGER::TParamType type, const std::string &typeName)
 389                 : CParameterTraits(type, typeName)
 390         {}
 391         bool extractFromMessage(NLNET::CMessage &message, bool debug)
 392         {
 393                 TParam  param;
 394                 if (param.serialParam(debug, message, ParamId.Type))
 395                 {
 396                         SheetId = param.SheetId;
 397                         return true;
 398                 }
 399                 else
 400                 {
 401                         setDefaultValue();
 402                         return false;
 403                 }
 404 //              message.serial(SheetId);
 405         }
 406
 407         const std::string &getParameterId() const
 408         {
 409 //              const CStringManager::TSheetInfo &si = SM->getSheetInfo(SheetId);
 410
 411                 static string sheetName;
 412                 sheetName = SheetId.toString();
 413                 sheetName = CFile::getFilenameWithoutExtension(sheetName);
 414
 415                 return sheetName;
 416         }
 417
 418         void setDefaultValue()
 419         {
 420                 SheetId = NLMISC::CSheetId::Unknown;
 421         }
 422
 423 };
 424
 425
 426 class CParameterTraitsItem : public CParameterTraitsSheet
 427 {
 428 public:
 429         CParameterTraitsItem() : CParameterTraitsSheet(STRING_MANAGER::item, "item")
 430         {}
 431
 432         CStringManager::CParameterTraits *clone()
 433         {
 434                 return new CParameterTraitsItem();
 435         }
 436
 437         /// fill overloaded to deals with ring user defined item with custom names
 438         void fillBitMemStream( const CCharacterInfos *charInfo, CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
 439         {
 440                 // check if SheetId if in the table or user item
 441                 const CStringManager::TRingUserItemInfos &itemInfos = SM->getUserItems();
 442                 CStringManager::TRingUserItemInfos::const_iterator it(itemInfos.find(SheetId));
 443                 if (it != itemInfos.end() && !it->second.empty())
 444                 {
 445                         // this item has some user name, check the aiInstance
 446                         const vector<CStringManager::TRingUserItemInfo> &userItemInfos = it->second;
 447                         for (uint i=0; i<userItemInfos.size(); ++i)
 448                         {
 449                                 if (userItemInfos[i].AIInstance == charInfo->AIInstance)
 450                                 {
 451                                         // ok, this item is renamed !
 452
 453                                         // use the user name for a list a predefined column :
 454                                         //    name, named, nameda, p, pd
 455                                         if (    rep.Format == "name"
 456                                                 ||      rep.Format == "named"
 457                                                 ||      rep.Format == "nameda"
 458                                                 ||      rep.Format == "p"
 459                                                 ||      rep.Format == "pd")
 460                                         {
 461                                                 nlWrite(bms, serial, userItemInfos[i].ItemNameId);
 462                                         }
 463                                         else
 464                                         {
 465                                                 // not a valid replacement, return a 'backspace' character
 466                                                 static uint32 noString = SM->storeString(ucstring()+ucchar(8));
 467                                                 bms.serial(noString);
 468                                         }
 469
 470                                         /// return here ---------------------
 471                                         return;
 472                                 }
 473                         }
 474                 }
 475
 476                 // normal item name, use the base function instead
 477                 CParameterTraitsSheet::fillBitMemStream( charInfo, language, rep, bms);
 478         }
 479
 480 };
 481
 482 class CParameterTraitsSPhrase : public CParameterTraitsSheet
 483 {
 484 public:
 485         CParameterTraitsSPhrase() : CParameterTraitsSheet(STRING_MANAGER::sphrase, "sphrase")
 486         {}
 487
 488         CStringManager::CParameterTraits *clone()
 489         {
 490                 return new CParameterTraitsSPhrase();
 491         }
 492 };
 493
 494 class CParameterTraitsBotName : public CParameterTraitsIdentifier
 495 {
 496 public:
 497         CParameterTraitsBotName() : CParameterTraitsIdentifier(STRING_MANAGER::bot_name, "bot_name")
 498         {}
 499
 500         CStringManager::CParameterTraits *clone()
 501         {
 502                 return new CParameterTraitsBotName();
 503         }
 504
 505         void fillBitMemStream( const CCharacterInfos *charInfo, CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
 506         {
 507
 508                 uint32 nameId1 = SM->storeString(Identifier);
 509                 uint32 nameId2 = SM->translateShortName(nameId1);
 510                 const ucstring &name = SM->getString(nameId2);
 511                 if (!name.empty() && name[0] == '$')
 512                 {
 513                         // this name is a generic name, translate the title
 514                         ucstring title = name.substr(1, name.size()-2);
 515                         nameId2 = SM->translateTitle(title.toString(), language);
 516                 }
 517                 // serial the string ID
 518                 bms.serial(nameId2);
 519         }
 520
 521 };
 522
 523
 524 class CParameterTraitsPlace : public CParameterTraitsIdentifier
 525 {
 526 public:
 527         CParameterTraitsPlace() : CParameterTraitsIdentifier(STRING_MANAGER::place, "place")
 528         {}
 529
 530         CStringManager::CParameterTraits *clone()
 531         {
 532                 return new CParameterTraitsPlace();
 533         }
 534
 535 };
 536
 537 class CParameterTraitsCreature : public CParameterTraitsEntity
 538 {
 539 public:
 540         CStringManager::CParameterTraits *clone()
 541         {
 542                 return new CParameterTraitsCreature();
 543         }
 544
 545         CParameterTraitsCreature() : CParameterTraitsEntity(STRING_MANAGER::creature, "creature")
 546         {}
 547         const std::string &getParameterId() const
 548         {
 549                 const NLMISC::CSheetId &sheetId = SM->getSheetId(EId);
 550                 if (sheetId == NLMISC::CSheetId::Unknown)
 551                 {
 552                         nlwarning("The sheet id for creature entity %s is unknown !", EId.toString().c_str());
 553                         static std::string empty;
 554                         return empty;
 555                 }
 556
 557
 558                 const CStringManager::TSheetInfo &si = SM->getSheetInfo(sheetId);
 559
 560                 return si.SheetName;
 561 //              return si.Race;
 562
 563         }
 564         bool eval(CStringManager::TLanguages lang, const CCharacterInfos *charInfo, const CStringManager::TCondition &cond) const
 565         {
 566                 // Test unknown entity
 567                 if ((cond.ReferenceInt == 0) && (cond.Property.empty()))
 568                 {
 569                         if (cond.Operator == CStringManager::equal)
 570                                 return EId.isUnknownId();
 571                         else if (cond.Operator == CStringManager::notEqual)
 572                                 return !EId.isUnknownId();
 573                 }
 574
 575                 // creature can test model name, model gender
 576
 577                 // 1st, I need to retreive the sheetId from the mirror
 578                 const NLMISC::CSheetId &sheetId = SM->getSheetId(EId);
 579                 if (sheetId == NLMISC::CSheetId::Unknown)
 580                 {
 581                         nlwarning("The sheet id for creature entity %s is unknown !", EId.toString().c_str());
 582                         return false;
 583                 }
 584
 585                 const CStringManager::TSheetInfo &si = SM->getSheetInfo(sheetId);
 586                 std::string op1;
 587                 if (cond.Property == "name")
 588                 {
 589                         op1 = NLMISC::toLowerAscii(si.SheetName);
 590                 }
 591                 else if (cond.Property == "gender")
 592                 {
 593                         op1 = NLMISC::toLowerAscii(GSGENDER::toString(si.Gender));
 594                 }
 595                 else
 596                 {
 597                         return CParameterTraitsEntity::eval(lang,charInfo, cond);
 598                 }
 599
 600                 LOG("SM : (creature) eval condition for property %s [%s] %s [%s]", cond.Property.c_str(), op1.c_str(), OperatorNames[cond.Operator], cond.ReferenceStr.c_str());
 601
 602                 switch(cond.Operator)
 603                 {
 604                 case CStringManager::equal:
 605                         return op1 == cond.ReferenceStr;
 606                 case CStringManager::notEqual:
 607                         return op1 != cond.ReferenceStr;
 608                 case CStringManager::less:
 609                         return op1 < cond.ReferenceStr;
 610                 case CStringManager::lessEqual:
 611                         return op1 <= cond.ReferenceStr;
 612                 case CStringManager::greater:
 613                         return op1 > cond.ReferenceStr;
 614                 case CStringManager::greaterEqual:
 615                         return op1 >= cond.ReferenceStr;
 616                 default:
 617                         nlwarning("Operator %s not applicable to creature property %s", OperatorNames[cond.Operator], cond.Property.c_str());
 618                         return false;
 619                 }
 620                 nlerror("This point of code can never be reach !");
 621         }
 622 /*      void fillBitMemStream(CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
 623         {
 624                 // need to evaluate the name of the creature : name from the sheet id
 625                 ucstring temp;
 626                 NLMISC::CSheetId sid = SM->getSheetId(EId);
 627                 if (sid != NLMISC::CSheetId::Unknown)
 628                 {
 629                         const CStringManager::TSheetInfo &si = SM->getSheetInfo(sid);
 630
 631                         temp =  si.DisplayName;
 632                         if (!temp.empty())
 633                         {
 634                                 uint32 index = SM->storeString(temp);
 635                                 bms.serial(index);
 636                                 return;
 637                         }
 638                 }
 639                 // hum, no name available
 640                 CParameterTraitsEntity::fillBitMemStream(charInfo, rep, bms);
 641         }
 642 */
 643 };
 644 class CParameterTraitsSkill : public CParameterTraitsEnum
 645 {
 646 public:
 647         CStringManager::CParameterTraits *clone()
 648         {
 649                 return new CParameterTraitsSkill();
 650         }
 651         CParameterTraitsSkill() : CParameterTraitsEnum(STRING_MANAGER::skill, "skill")
 652         {}
 653         const std::string &getParameterId() const
 654         {
 655                 return SKILLS::toString(SKILLS::ESkills(Enum));
 656         }
 657         void setDefaultValue()
 658         {
 659                 Enum = SKILLS::unknown;
 660         }
 661 };
 662
 663 class CParameterTraitsBodyPart : public CParameterTraitsEnum
 664 {
 665 public:
 666         CStringManager::CParameterTraits *clone()
 667         {
 668                 return new CParameterTraitsBodyPart();
 669         }
 670         CParameterTraitsBodyPart() : CParameterTraitsEnum(STRING_MANAGER::body_part, "bodypart")
 671         {}
 672         const std::string &getParameterId() const
 673         {
 674                 return BODY::toString(BODY::TBodyPart(Enum));
 675         }
 676         void setDefaultValue()
 677         {
 678                 Enum = BODY::UnknownBodyPart;
 679         }
 680 };
 681
 682 class CParameterTraitsScore : public CParameterTraitsEnum
 683 {
 684 public:
 685         CStringManager::CParameterTraits *clone()
 686         {
 687                 return new CParameterTraitsScore();
 688         }
 689         CParameterTraitsScore() : CParameterTraitsEnum(STRING_MANAGER::score, "score")
 690         {}
 691         const std::string &getParameterId() const
 692         {
 693                 return SCORES::toString(SCORES::TScores(Enum));
 694         }
 695         void setDefaultValue()
 696         {
 697                 Enum = SCORES::unknown;
 698         }
 699 };
 700
 701 class CParameterTraitsCharacteristic : public CParameterTraitsEnum
 702 {
 703 public:
 704         CStringManager::CParameterTraits *clone()
 705         {
 706                 return new CParameterTraitsCharacteristic();
 707         }
 708         CParameterTraitsCharacteristic() : CParameterTraitsEnum(STRING_MANAGER::characteristic, "characteristic")
 709         {}
 710         const std::string &getParameterId() const
 711         {
 712                 return CHARACTERISTICS::toString(CHARACTERISTICS::TCharacteristics(Enum));
 713         }
 714         void setDefaultValue()
 715         {
 716                 Enum = CHARACTERISTICS::Unknown;
 717         }
 718 };
 719
 720 class CParameterTraitsDamageType : public CParameterTraitsEnum
 721 {
 722 public:
 723         CStringManager::CParameterTraits *clone()
 724         {
 725                 return new CParameterTraitsDamageType();
 726         }
 727         CParameterTraitsDamageType() : CParameterTraitsEnum(STRING_MANAGER::damage_type, "damagetype")
 728         {}
 729         const std::string &getParameterId() const
 730         {
 731                 return DMGTYPE::toString(DMGTYPE::EDamageType(Enum));
 732         }
 733         void setDefaultValue()
 734         {
 735                 Enum = DMGTYPE::UNDEFINED;
 736         }
 737 };
 738
 739 class CParameterTraitsClassificationType : public CParameterTraitsEnum
 740 {
 741 public:
 742         CStringManager::CParameterTraits *clone()
 743         {
 744                 return new CParameterTraitsClassificationType ();
 745         }
 746         CParameterTraitsClassificationType () : CParameterTraitsEnum(STRING_MANAGER::classification_type, "classificationtype")
 747         {}
 748         const std::string &getParameterId() const
 749         {
 750                 return DMGTYPE::toString(DMGTYPE::EDamageType(Enum));
 751         }
 752         void setDefaultValue()
 753         {
 754                 Enum = EGSPD::CClassificationType::Unknown;
 755         }
 756 };
 757
 758
 759 class CParameterTraitsPowerType : public CParameterTraitsEnum
 760 {
 761 public:
 762         CStringManager::CParameterTraits *clone()
 763         {
 764                 return new CParameterTraitsPowerType();
 765         }
 766         CParameterTraitsPowerType() : CParameterTraitsEnum(STRING_MANAGER::power_type, "powertype")
 767         {}
 768         const std::string &getParameterId() const
 769         {
 770                 return POWERS::toString(POWERS::TPowerType(Enum));
 771         }
 772         void setDefaultValue()
 773         {
 774                 Enum = POWERS::UnknownType;
 775         }
 776 };
 777
 778 class CParameterTraitsRole : public CParameterTraitsEnum
 779 {
 780 public:
 781         CStringManager::CParameterTraits *clone()
 782         {
 783                 return new CParameterTraitsRole();
 784         }
 785         CParameterTraitsRole() : CParameterTraitsEnum(STRING_MANAGER::role, "role")
 786         {}
 787         const std::string &getParameterId() const
 788         {
 789                 return ROLES::toString(ROLES::ERole(Enum));
 790         }
 791         void setDefaultValue()
 792         {
 793                 // TODO : set a default value
 794                 Enum = ROLES::role_unknown;
 795         }
 796 };
 797
 798 /*
 799 class CParameterTraitsCareer : public CParameterTraitsEnum
 800 {
 801 public:
 802         CStringManager::CParameterTraits *clone()
 803         {
 804                 return new CParameterTraitsCareer();
 805         }
 806         CParameterTraitsCareer() : CParameterTraitsEnum(STRING_MANAGER::career, "career")
 807         {}
 808         const std::string &getParameterId() const
 809         {
 810                 // TODO : use the career enum when it exist !
 811                 return ROLES::toString(ROLES::ERole(Enum));
 812         }
 813         void setDefaultValue()
 814         {
 815                 Enum = ROLES::role_unknown;
 816         }
 817 };
 818 */
 819 /*
 820 class CParameterTraitsJob : public CParameterTraitsEnum
 821 {
 822 public:
 823         CStringManager::CParameterTraits *clone()
 824         {
 825                 return new CParameterTraitsJob();
 826         }
 827         CParameterTraitsJob() : CParameterTraitsEnum(STRING_MANAGER::job, "job")
 828         {}
 829         const std::string &getParameterId() const
 830         {
 831                 return JOBS::toString(JOBS::TJob(Enum));
 832         }
 833         void setDefaultValue()
 834         {
 835                 Enum = JOBS::Unknown;
 836         }
 837 };
 838 */
 839 class CParameterTraitsEcosystem : public CParameterTraitsEnum
 840 {
 841 public:
 842         CStringManager::CParameterTraits *clone()
 843         {
 844                 return new CParameterTraitsEcosystem();
 845         }
 846         CParameterTraitsEcosystem() : CParameterTraitsEnum(STRING_MANAGER::ecosystem, "ecosystem")
 847         {}
 848         const std::string &getParameterId() const
 849         {
 850                 return ECOSYSTEM::toString(ECOSYSTEM::EECosystem(Enum));
 851         }
 852         void setDefaultValue()
 853         {
 854                 Enum = ECOSYSTEM::unknown;
 855         }
 856 };
 857 class CParameterTraitsRace : public CParameterTraitsEnum
 858 {
 859 public:
 860         CStringManager::CParameterTraits *clone()
 861         {
 862                 return new CParameterTraitsRace();
 863         }
 864         CParameterTraitsRace() : CParameterTraitsEnum(STRING_MANAGER::race, "race")
 865         {}
 866         const std::string &getParameterId() const
 867         {
 868                 return EGSPD::CPeople::toString(EGSPD::CPeople::TPeople(Enum));
 869         }
 870         void setDefaultValue()
 871         {
 872                 Enum = EGSPD::CPeople::EndPeople;
 873         }
 874 };
 875
 876 class CParameterTraitsBrick : public CParameterTraitsSheet
 877 {
 878 public:
 879         CParameterTraitsBrick() : CParameterTraitsSheet(STRING_MANAGER::sbrick, "sbrick")
 880         {}
 881
 882         CStringManager::CParameterTraits *clone()
 883         {
 884                 return new CParameterTraitsBrick();
 885         }
 886 };
 887
 888 class CParameterTraitsOutpostWord : public CParameterTraitsSheet
 889 {
 890 public:
 891         CParameterTraitsOutpostWord() : CParameterTraitsSheet(STRING_MANAGER::outpost, "outpost")
 892         {}
 893
 894         CStringManager::CParameterTraits *clone()
 895         {
 896                 return new CParameterTraitsOutpostWord();
 897         }
 898         const std::string &getParameterId() const
 899         {
 900                 static string sheetName;
 901                 sheetName = SheetId.toString();
 902                 return sheetName;
 903         }
 904 };
 905
 906 /*
 907 class CParameterTraitsBrick : public CParameterTraitsEnum
 908 {
 909 public:
 910         CStringManager::CParameterTraits *clone()
 911         {
 912                 return new CParameterTraitsBrick();
 913         }
 914         CParameterTraitsBrick() : CParameterTraitsEnum(STRING_MANAGER::sbrick, "sbrick")
 915         {}
 916         const std::string &getParameterId() const
 917         {
 918 //              return BRICK_FAMILIES::toString(BRICK_FAMILIES::TBrickFamily(Enum));
 919                 return SheetId.toString();
 920         }
 921         void setDefaultValue()
 922         {
 923                 Enum = BRICK_FAMILIES::Unknown;
 924         }
 925 };
 926 */
 927 class CParameterTraitsFaction : public CParameterTraitsEnum
 928 {
 929 public:
 930         CStringManager::CParameterTraits *clone()
 931         {
 932                 return new CParameterTraitsFaction();
 933         }
 934         CParameterTraitsFaction() : CParameterTraitsEnum(STRING_MANAGER::faction, "faction")
 935         {}
 936         const std::string &getParameterId() const
 937         {
 938                 return CStaticFames::getInstance().getFactionName(Enum);
 939         }
 940         void setDefaultValue()
 941         {
 942                 // TODO : set a default value
 943                 Enum = 0;
 944         }
 945 };
 946 class CParameterTraitsGuild : public CParameterTraitsEntity
 947 {
 948 public:
 949         CStringManager::CParameterTraits *clone()
 950         {
 951                 return new CParameterTraitsGuild();
 952         }
 953         CParameterTraitsGuild() : CParameterTraitsEntity(STRING_MANAGER::guild, "guild")
 954         {}
 955 };
 956
 957 class CParameterTraitsPlayer : public CParameterTraitsEntity
 958 {
 959 public:
 960         CStringManager::CParameterTraits *clone()
 961         {
 962                 return new CParameterTraitsPlayer();
 963         }
 964         CParameterTraitsPlayer() : CParameterTraitsEntity(STRING_MANAGER::player, "player")
 965         {}
 966
 967         bool eval(CStringManager::TLanguages lang, const CCharacterInfos *charInfo, const CStringManager::TCondition &cond) const
 968         {
 969                 // Test unknown entity
 970                 if ((cond.ReferenceInt == 0) && (cond.Property.empty()))
 971                 {
 972                         if (cond.Operator == CStringManager::equal)
 973                                 return EId.isUnknownId();
 974                         else if (cond.Operator == CStringManager::notEqual)
 975                                 return !EId.isUnknownId();
 976                 }
 977
 978                 // player can test model name, entity name, entity gender
 979                 // 1st, I need to retrieve the sheetId from the mirror
 980                 std::string op1;
 981                 if (cond.Property == "name")
 982                 {
 983                         const NLMISC::CSheetId &sheetId = SM->getSheetId(EId);
 984                         if (sheetId == NLMISC::CSheetId::Unknown)
 985                         {
 986                                 nlwarning("The sheet id for creature entity %s is unknown !", EId.toString().c_str());
 987                                 return false;
 988                         }
 989                         const CStringManager::TSheetInfo &si = SM->getSheetInfo(sheetId);
 990                         op1 = NLMISC::toLowerAscii(si.SheetName);
 991                 }
 992                 else if (cond.Property == "gender")
 993                 {
 994                         CCharacterInfos *charInfo = IOS->getCharInfos(EId);
 995                         if (charInfo == NULL)
 996                         {
 997                                 nlwarning("Could not find character info for EId %s to check property %s", EId.toString().c_str(), cond.Property.c_str());
 998                                 return false;
 999                         }
1000                         op1 = NLMISC::toLowerAscii(GSGENDER::toString(charInfo->getGender()));
1001                 }
1002                 else
1003                 {
1004                         return CParameterTraitsEntity::eval(lang,charInfo, cond);
1005                 }
1006
1007                 LOG("SM : (player) eval condition for property %s [%s] %s [%s]", cond.Property.c_str(), op1.c_str(), OperatorNames[cond.Operator], cond.ReferenceStr.c_str());
1008
1009                 switch(cond.Operator)
1010                 {
1011                 case CStringManager::equal:
1012                         return op1 == cond.ReferenceStr;
1013                 case CStringManager::notEqual:
1014                         return op1 != cond.ReferenceStr;
1015                 case CStringManager::less:
1016                         return op1 < cond.ReferenceStr;
1017                 case CStringManager::lessEqual:
1018                         return op1 <= cond.ReferenceStr;
1019                 case CStringManager::greater:
1020                         return op1 > cond.ReferenceStr;
1021                 case CStringManager::greaterEqual:
1022                         return op1 >= cond.ReferenceStr;
1023                 default:
1024                         nlwarning("Operator %s not applicable to player property %s", OperatorNames[cond.Operator], cond.Property.c_str());
1025                         return false;
1026                 }
1027                 nlerror("This point of code can never be reach !");
1028         }
1029         void fillBitMemStream( const CCharacterInfos *charInfo,CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
1030         {
1031                 ucstring temp;
1032
1033                 CCharacterInfos *playerInfo = IOS->getCharInfos(EId);
1034                 if (playerInfo != 0)
1035                 {
1036                         if (!playerInfo->ShortName.empty())
1037                         {
1038                                 uint32 index = playerInfo->ShortNameIndex;
1039                                 bms.serial(index);
1040                                 return;
1041                         }
1042                 }
1043                 // hum, no name available
1044                 CParameterTraitsEntity::fillBitMemStream(charInfo,language, rep, bms);
1045         }
1046 };
1047 class CParameterTraitsBot : public CParameterTraitsEntity
1048 {
1049 public:
1050         CStringManager::CParameterTraits *clone()
1051         {
1052                 return new CParameterTraitsBot();
1053         }
1054         CParameterTraitsBot() : CParameterTraitsEntity(STRING_MANAGER::bot, "bot")
1055         {}
1056         bool eval(CStringManager::TLanguages lang, const CCharacterInfos *charInfo, const CStringManager::TCondition &cond) const
1057         {
1058                 // Test unknown entity
1059                 if ((cond.ReferenceInt == 0) && (cond.Property.empty()))
1060                 {
1061                         if (cond.Operator == CStringManager::equal)
1062                                 return EId.isUnknownId();
1063                         else if (cond.Operator == CStringManager::notEqual)
1064                                 return !EId.isUnknownId();
1065                 }
1066
1067                 // bot can test career and role
1068                 // 1st, I need to retrieve the sheetId from the mirror
1069                 // TODO : reuse sheet server when AI fill in correctly !
1070                 const NLMISC::CSheetId &sheetId = SM->getSheetServerId(EId);
1071                 if (sheetId == NLMISC::CSheetId::Unknown)
1072                 {
1073                         nlwarning("The sheet id for creature bot %s is unknown !", EId.toString().c_str());
1074                         return false;
1075                 }
1076
1077                 LOG("Bot %s use server sheet %s", EId.toString().c_str(), sheetId.toString().c_str());
1078                 const CStringManager::TSheetInfo &si = SM->getSheetInfo(sheetId);
1079                 std::string op1;
1080                 if (cond.Property == "career")
1081                 {
1082                         op1 = si.Profile;
1083                 }
1084                 else if (cond.Property == "role")
1085                 {
1086                         op1 = NLMISC::toLowerAscii(si.ChatProfile);
1087                 }
1088                 else if (cond.Property == "title")
1089                 {
1090                         // we need to retrieve the charInfo
1091                         CCharacterInfos *ci = IOS->getCharInfos(EId);
1092                         if (ci != NULL)
1093                                 op1 = NLMISC::toLowerAscii(ci->Title);
1094                         else
1095                         {
1096                                 nlwarning("No character info for bot %s, can't test property 'title' !", EId.toString().c_str());
1097                                 return false;
1098                         }
1099                 }
1100                 else
1101                 {
1102                         return CParameterTraitsEntity::eval(lang, charInfo, cond);
1103                 }
1104
1105                 LOG("SM : (bot) eval condition for property %s [%s] %s [%s]", cond.Property.c_str(), op1.c_str(), OperatorNames[cond.Operator], cond.ReferenceStr.c_str());
1106
1107                 switch(cond.Operator)
1108                 {
1109                 case CStringManager::equal:
1110                         return op1 == cond.ReferenceStr;
1111                 case CStringManager::notEqual:
1112                         return op1 != cond.ReferenceStr;
1113                 case CStringManager::less:
1114                         return op1 < cond.ReferenceStr;
1115                 case CStringManager::lessEqual:
1116                         return op1 <= cond.ReferenceStr;
1117                 case CStringManager::greater:
1118                         return op1 > cond.ReferenceStr;
1119                 case CStringManager::greaterEqual:
1120                         return op1 >= cond.ReferenceStr;
1121                 default:
1122                         nlwarning("Operator %s not applicable to player property %s", OperatorNames[cond.Operator], cond.Property.c_str());
1123                         return false;
1124                 }
1125                 nlerror("This point of code can never be reach !");
1126         }
1127
1128         void fillBitMemStream( const CCharacterInfos *charInfo,CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
1129         {
1130                 // need to evaluate the name of the bot : should be in the charinfo
1131                 ucstring temp;
1132
1133                 CCharacterInfos *botInfo = IOS->getCharInfos(EId);
1134                 if (botInfo != 0)
1135                 {
1136                         if (!botInfo->ShortName.empty())
1137                         {
1138                                 uint32 index = botInfo->ShortNameIndex;
1139                                 bms.serial(index);
1140                                 return;
1141                         }
1142                         if (!botInfo->Title.empty())
1143                         {
1144                                 uint32 index = SM->translateTitle(botInfo->Title, language);
1145                                 bms.serial(index);
1146                                 return;
1147                         }
1148                 }
1149                 // hum, no name available
1150                 CParameterTraitsEntity::fillBitMemStream(charInfo, language, rep, bms);
1151         }
1152 };
1153 class CParameterTraitsInteger : public CStringManager::CParameterTraits
1154 {
1155 public:
1156         CStringManager::CParameterTraits *clone()
1157         {
1158                 return new CParameterTraitsInteger();
1159         }
1160         CParameterTraitsInteger() : CParameterTraits(STRING_MANAGER::integer, "integer")
1161         {}
1162         bool extractFromMessage(NLNET::CMessage &message, bool debug)
1163         {
1164                 TParam  param;
1165                 if (param.serialParam(debug, message, ParamId.Type))
1166                 {
1167                         Int = param.Int;
1168                         return true;
1169                 }
1170                 else
1171                 {
1172                         setDefaultValue();
1173                         return false;
1174                 }
1175 //              message.serial(Int);
1176         }
1177
1178         void fillBitMemStream( const CCharacterInfos *charInfo,CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
1179         {
1180                 bms.serial(Int);
1181         }
1182
1183         const std::string &getParameterId() const
1184         {
1185                 nlstopex(("Never call this !"));
1186                 static std::string temp = "";
1187                 return temp;
1188         }
1189
1190         bool eval(CStringManager::TLanguages lang, const CCharacterInfos *charInfo, const CStringManager::TCondition &cond) const
1191         {
1192                 switch(cond.Operator)
1193                 {
1194                 case CStringManager::equal:
1195                         return Int == cond.ReferenceInt;
1196                 case CStringManager::notEqual:
1197                         return Int != cond.ReferenceInt;
1198                 case CStringManager::greater:
1199                         return Int > cond.ReferenceInt;
1200                 case CStringManager::greaterEqual:
1201                         return Int >= cond.ReferenceInt;
1202                 case CStringManager::less:
1203                         return Int < cond.ReferenceInt;
1204                 case CStringManager::lessEqual:
1205                         return Int <= cond.ReferenceInt;
1206                 default:
1207                         nlwarning("Operator not valid (%d)", cond.Operator);
1208                         return false;
1209                 }
1210         }
1211         void setDefaultValue()
1212         {
1213                 Int = 0;
1214         }
1215 };
1216 class CParameterTraitsTime : public CStringManager::CParameterTraits
1217 {
1218 public:
1219         CStringManager::CParameterTraits *clone()
1220         {
1221                 return new CParameterTraitsTime();
1222         }
1223         CParameterTraitsTime() : CParameterTraits(STRING_MANAGER::time, "time")
1224         {}
1225         bool extractFromMessage(NLNET::CMessage &message, bool debug)
1226         {
1227                 TParam  param;
1228                 if (param.serialParam(debug, message, ParamId.Type))
1229                 {
1230                         Time = param.Time;
1231                         return true;
1232                 }
1233                 else
1234                 {
1235                         setDefaultValue();
1236                         return false;
1237                 }
1238 //              message.serial(Time);
1239         }
1240         void fillBitMemStream( const CCharacterInfos *charInfo,CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
1241         {
1242                 bms.serial(Time);
1243         }
1244         const std::string &getParameterId() const
1245         {
1246                 nlstopex(("Never call this !"));
1247                 static std::string temp = "";
1248                 return temp;
1249         }
1250         bool eval(CStringManager::TLanguages lang, const CCharacterInfos *charInfo, const CStringManager::TCondition &cond) const
1251         {
1252                 nlwarning("Time parameter can't be conditional");
1253                 return false;
1254         }
1255         void setDefaultValue()
1256         {
1257                 Time = 0;
1258         }
1259 };
1260 class CParameterTraitsMoney : public CStringManager::CParameterTraits
1261 {
1262 public:
1263         CStringManager::CParameterTraits *clone()
1264         {
1265                 return new CParameterTraitsMoney();
1266         }
1267         CParameterTraitsMoney() : CParameterTraits(STRING_MANAGER::money, "money")
1268         {}
1269         bool extractFromMessage(NLNET::CMessage &message, bool debug)
1270         {
1271                 TParam  param;
1272                 if (param.serialParam(debug, message, ParamId.Type))
1273                 {
1274                         Money = param.Money;
1275                         return true;
1276                 }
1277                 else
1278                 {
1279                         setDefaultValue();
1280                         return false;
1281                 }
1282 //              message.serial(Money);
1283         }
1284         void fillBitMemStream( const CCharacterInfos *charInfo,CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
1285         {
1286                 // TODO : serial only 48 bits
1287                 bms.serial(Money);
1288         }
1289         const std::string &getParameterId() const
1290         {
1291                 nlstopex(("Never call this !"));
1292                 static std::string temp = "";
1293                 return temp;
1294         }
1295         bool eval(CStringManager::TLanguages lang, const CCharacterInfos *charInfo, const CStringManager::TCondition &cond) const
1296         {
1297                 nlwarning("Money parameter can't be conditional");
1298                 return false;
1299         }
1300         void setDefaultValue()
1301         {
1302                 Money = 0;
1303         }
1304 };
1305 class CParameterTraitsCompass : public CParameterTraitsEnum
1306 {
1307 public:
1308         CStringManager::CParameterTraits *clone()
1309         {
1310                 return new CParameterTraitsCompass();
1311         }
1312         CParameterTraitsCompass() : CParameterTraitsEnum(STRING_MANAGER::compass, "compass")
1313         {}
1314         const std::string &getParameterId() const
1315         {
1316                 // TODO : add an enum for compass dir in game_share
1317                 static std::string temp = "";
1318                 return temp;
1319         }
1320         void setDefaultValue()
1321         {
1322                 // TODO : set a default value
1323                 Enum = 0;
1324         }
1325 };
1326 class CParameterTraitsStringId : public CStringManager::CParameterTraits
1327 {
1328 public:
1329         CStringManager::CParameterTraits *clone()
1330         {
1331                 return new CParameterTraitsStringId();
1332         }
1333         CParameterTraitsStringId() : CParameterTraits(STRING_MANAGER::string_id, "string_id")
1334         {}
1335         bool extractFromMessage(NLNET::CMessage &message, bool debug)
1336         {
1337                 TParam  param;
1338                 if (param.serialParam(debug, message, ParamId.Type))
1339                 {
1340                         StringId = param.StringId;
1341                         return true;
1342                 }
1343                 else
1344                 {
1345                         setDefaultValue();
1346                         return false;
1347                 }
1348 //              message.serial(StringId);
1349         }
1350         void fillBitMemStream( const CCharacterInfos *charInfo,CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
1351         {
1352                 bms.serial(StringId);
1353         }
1354         const std::string &getParameterId() const
1355         {
1356                 nlstop;
1357                 static std::string temp = "";
1358                 return temp;
1359         }
1360         bool eval(CStringManager::TLanguages lang, const CCharacterInfos *charInfo, const CStringManager::TCondition &cond) const
1361         {
1362                 switch(cond.Operator)
1363                 {
1364                 case CStringManager::equal:
1365                         return StringId == uint32(cond.ReferenceInt);
1366                 case CStringManager::notEqual:
1367                         return StringId != uint32(cond.ReferenceInt);
1368                 default:
1369                         nlwarning("Operator %s not applicable to self property %s", OperatorNames[cond.Operator], cond.Property.c_str());
1370                         return false;
1371                 }
1372         }
1373         void setDefaultValue()
1374         {
1375                 StringId = 0;
1376         }
1377 };
1378 class CParameterTraitsdyn_string_id : public CStringManager::CParameterTraits
1379 {
1380 public:
1381         CStringManager::CParameterTraits *clone()
1382         {
1383                 return new CParameterTraitsdyn_string_id();
1384         }
1385         CParameterTraitsdyn_string_id() : CParameterTraits(STRING_MANAGER::dyn_string_id, "dyn_string_id")
1386         {}
1387         bool extractFromMessage(NLNET::CMessage &message, bool debug)
1388         {
1389                 TParam  param;
1390                 if (param.serialParam(debug, message, ParamId.Type))
1391                 {
1392                         StringId = param.StringId;
1393                         return true;
1394                 }
1395                 else
1396                 {
1397                         setDefaultValue();
1398                         return false;
1399                 }
1400 //              message.serial(StringId);
1401         }
1402         void fillBitMemStream( const CCharacterInfos *charInfo,CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
1403         {
1404                 bms.serial(StringId);
1405         }
1406         const std::string &getParameterId() const
1407         {
1408                 nlstop;
1409                 static std::string temp = "";
1410                 return temp;
1411         }
1412         bool eval(CStringManager::TLanguages lang, const CCharacterInfos *charInfo, const CStringManager::TCondition &cond) const
1413         {
1414                 switch(cond.Operator)
1415                 {
1416                 case CStringManager::equal:
1417                         return StringId == uint32(cond.ReferenceInt);
1418                 case CStringManager::notEqual:
1419                         return StringId != uint32(cond.ReferenceInt);
1420                 default:
1421                         nlwarning("Operator %s not applicable to self property %s", OperatorNames[cond.Operator], cond.Property.c_str());
1422                         return false;
1423                 }
1424         }
1425         void setDefaultValue()
1426         {
1427                 StringId = 0;
1428         }
1429 };
1430 class CParameterTraitsSelf : public CParameterTraitsEntity
1431 {
1432 public:
1433         CStringManager::CParameterTraits *clone()
1434         {
1435                 return new CParameterTraitsSelf();
1436         }
1437         CParameterTraitsSelf() : CParameterTraitsEntity(STRING_MANAGER::self, "self")
1438         {}
1439         bool extractFromMessage(NLNET::CMessage &message, bool debug)
1440         {
1441                 nlwarning("CParameterTraitsSelf can't be received !");
1442                 return false;
1443         }
1444         const std::string &getParameterId() const
1445         {
1446                 // TODO : retreive the entity name...
1447                 static std::string temp = "";
1448                 return temp;
1449         }
1450         bool eval(CStringManager::TLanguages lang, const CCharacterInfos *charInfo, const CStringManager::TCondition &cond) const
1451         {
1452                 if ( !charInfo )
1453                         return false;
1454                 std::string value;
1455
1456                 // check if checked property is gender or name
1457                 if (cond.Property == "gender")
1458                 {
1459                         value = NLMISC::toLowerAscii(GSGENDER::toString(charInfo->getGender()));
1460                 }
1461                 else if (cond.Property == "name")
1462                 {
1463                         value = NLMISC::toLowerAscii(charInfo->ShortName.toString());
1464                 }
1465                 else
1466                 {
1467                         return CParameterTraitsEntity::eval(lang,charInfo, cond);
1468                 }
1469
1470                 LOG("SM : (self) eval condition for property %s [%s] %s [%s]", cond.Property.c_str(), value.c_str(), OperatorNames[cond.Operator], cond.ReferenceStr.c_str());
1471
1472                 switch(cond.Operator)
1473                 {
1474                 case CStringManager::equal:
1475                         return value == cond.ReferenceStr;
1476                 case CStringManager::notEqual:
1477                         return value != cond.ReferenceStr;
1478                 case CStringManager::less:
1479                         return value < cond.ReferenceStr;
1480                 case CStringManager::lessEqual:
1481                         return value <= cond.ReferenceStr;
1482                 case CStringManager::greater:
1483                         return value > cond.ReferenceStr;
1484                 case CStringManager::greaterEqual:
1485                         return value >= cond.ReferenceStr;
1486                 default:
1487                         nlwarning("Operator %s not applicable to self property %s", OperatorNames[cond.Operator], cond.Property.c_str());
1488                         return false;
1489                 }
1490         }
1491         void fillBitMemStream( const CCharacterInfos *charInfo,CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
1492         {
1493                 // need to evaluate the name of the bot : should be in the charinfo
1494                 ucstring temp;
1495
1496                 if (charInfo != 0)
1497                 {
1498                         if (!charInfo->Name.empty())
1499                         {
1500                                 uint32 index = charInfo->ShortNameIndex;
1501                                 bms.serial(index);
1502                                 return;
1503                         }
1504                 }
1505                 // hum, no name available
1506                 CParameterTraitsEntity::fillBitMemStream(charInfo, language, rep, bms);
1507         }
1508 };
1509
1510 class CParameterTraitsCreatureModel : public CParameterTraitsSheet
1511 {
1512 public:
1513         CParameterTraitsCreatureModel() : CParameterTraitsSheet(STRING_MANAGER::creature_model, "creature")
1514         {}
1515
1516         CStringManager::CParameterTraits *clone()
1517         {
1518                 return new CParameterTraitsItem();
1519         }
1520 };
1521
1522 class CParameterTraitsLiteral : public CStringManager::CParameterTraits
1523 {
1524 public:
1525         CParameterTraitsLiteral() : CParameterTraits(STRING_MANAGER::literal, "literal")
1526         {}
1527
1528         CStringManager::CParameterTraits *clone()
1529         {
1530                 return new CParameterTraitsLiteral();
1531         }
1532
1533         /// Return parameter id, ie, the name that is use to identity the data row in the csv file.
1534         virtual const std::string &getParameterId() const
1535         {
1536                 nlstop;
1537                 static const string s;
1538                 return s;
1539         }
1540         /// Extract the parameter value from a message.
1541         virtual bool extractFromMessage(NLNET::CMessage &message, bool debug)
1542         {
1543                 TParam  param;
1544                 if (param.serialParam(debug, message, ParamId.Type))
1545                 {
1546                         Literal = param.Literal;
1547                         return true;
1548                 }
1549                 else
1550                 {
1551                         setDefaultValue();
1552                         return false;
1553                 }
1554         }
1555         /// Fill a bitmem strean with the parameter value.
1556         virtual void fillBitMemStream( const CCharacterInfos *charInfo, CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
1557         {
1558                 uint32 id = SM->storeString(Literal);
1559                 bms.serial(id);
1560         }
1561         /// Eval a condition with this parameter.
1562 //      virtual bool eval(TLanguages lang, const CCharacterInfos *charInfo, const TCondition &cond) const;
1563         /// set a default value
1564         virtual void setDefaultValue()
1565         {
1566                 Literal = ucstring();
1567         }
1568
1569 };
1570
1571 class CParameterTraitsTitle : public CParameterTraitsIdentifier
1572 {
1573 public:
1574         CParameterTraitsTitle() : CParameterTraitsIdentifier(STRING_MANAGER::title, "title")
1575         {}
1576
1577         CStringManager::CParameterTraits *clone()
1578         {
1579                 return new CParameterTraitsTitle();
1580         }
1581
1582 };
1583
1584 class CParameterTraitsEventFaction : public CParameterTraitsIdentifier
1585 {
1586 public:
1587         CParameterTraitsEventFaction() : CParameterTraitsIdentifier(STRING_MANAGER::event_faction, "event_faction")
1588         {}
1589
1590         CStringManager::CParameterTraits *clone()
1591         {
1592                 return new CParameterTraitsEventFaction();
1593         }
1594
1595         void fillBitMemStream( const CCharacterInfos *charInfo, CStringManager::TLanguages language, const CStringManager::TReplacement &rep, NLMISC::CBitMemStream &bms)
1596         {
1597                 uint32 eventFactionId = SM->translateEventFaction(Identifier);
1598
1599                 // serial the string ID
1600                 bms.serial(eventFactionId);
1601         }
1602
1603 };
1604
1605 /**
1606  * WARNING: the order in this array is very important, and MUST match exactly
1607  * the order in the TParamType enum declared in string_manager_sender.h
1608  */
1609 std::vector<CStringManager::CParameterTraits*>  CStringManager::CParameterTraits::_Models;
1610
1611 void    CStringManager::CParameterTraits::init()
1612 {
1613         _Models.push_back(new CParameterTraitsItem());
1614         _Models.push_back(new CParameterTraitsPlace());
1615         _Models.push_back(new CParameterTraitsCreature());
1616         _Models.push_back(new CParameterTraitsSkill());
1617         _Models.push_back(new CParameterTraitsRole());
1618         _Models.push_back(new CParameterTraitsEcosystem());
1619         _Models.push_back(new CParameterTraitsRace());
1620         _Models.push_back(new CParameterTraitsBrick());
1621         _Models.push_back(new CParameterTraitsFaction());
1622         _Models.push_back(new CParameterTraitsGuild());
1623         _Models.push_back(new CParameterTraitsPlayer());
1624         _Models.push_back(new CParameterTraitsBot());
1625         _Models.push_back(new CParameterTraitsInteger());
1626         _Models.push_back(new CParameterTraitsTime());
1627         _Models.push_back(new CParameterTraitsMoney());
1628         _Models.push_back(new CParameterTraitsCompass());
1629         _Models.push_back(new CParameterTraitsStringId());
1630         _Models.push_back(new CParameterTraitsdyn_string_id());
1631         _Models.push_back(new CParameterTraitsSelf());
1632         _Models.push_back(new CParameterTraitsCreatureModel());
1633         _Models.push_back(new CParameterTraitsEntity(STRING_MANAGER::entity, "entity"));
1634         _Models.push_back(new CParameterTraitsBodyPart());
1635         _Models.push_back(new CParameterTraitsScore());
1636         _Models.push_back(new CParameterTraitsSPhrase());
1637         _Models.push_back(new CParameterTraitsCharacteristic());
1638         _Models.push_back(new CParameterTraitsDamageType());
1639         _Models.push_back(new CParameterTraitsBotName());
1640         _Models.push_back(new CParameterTraitsPowerType());
1641         _Models.push_back(new CParameterTraitsLiteral());
1642         _Models.push_back(new CParameterTraitsTitle());
1643         _Models.push_back(new CParameterTraitsEventFaction());
1644         _Models.push_back(new CParameterTraitsClassificationType());
1645         _Models.push_back(new CParameterTraitsOutpostWord());
1646 }
1647
1648 CStringManager::CParameterTraits *CStringManager::CParameterTraits::createParameterTraits(STRING_MANAGER::TParamType type)
1649 {
1650         for (uint i=0; i<_Models.size(); ++i)
1651         {
1652                 if (_Models[i]->ParamId.Type == type)
1653                         return _Models[i]->clone();
1654         }
1655         nlstop;
1656
1657         return 0;
1658 }
1659
1660 std::vector<std::pair<STRING_MANAGER::TParamType, std::string> >        CStringManager::CParameterTraits::getParameterTraitsNames()
1661 {
1662         std::vector<std::pair<STRING_MANAGER::TParamType, std::string> > ret;
1663         for (uint i=0; i<_Models.size(); ++i)
1664         {
1665                 ret.push_back(std::make_pair(_Models[i]->ParamId.Type, _Models[i]->TypeName));
1666         }
1667         return ret;
1668 }
1669