ryzom/server/src/ai_service/ai_script_comp.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 #include "stdpch.h"
  18 #include "ai_generic_fight.h"
  19 #include "ai_script_comp.h"
  20 #include "server_share/msg_brick_service.h"
  21
  22 using   namespace       std;
  23 using   namespace       NLMISC;
  24
  25 //      renvoie le bout de la string jusqu'au prochain ',' en respectant les priorités des parenthèses.
  26 void    explodeSubStrings(const std::string     &str, vector<std::string>       &strings, sint32 parenthesis=0)
  27 {
  28         const   std::string     separators("(),");
  29         string::size_type       current=0;
  30         string::size_type       nextCurrent=current;
  31         strings.clear();
  32
  33         nextCurrent=str.find_first_of(separators.c_str(), current);
  34         while (nextCurrent!=std::string::npos)
  35         {
  36                 switch(str.at(nextCurrent))
  37                 {
  38                 case '(':
  39                         parenthesis++;
  40                         if (parenthesis==0)
  41                         {
  42                                 current=nextCurrent+1;
  43                         }
  44                         break;
  45                 case ')':
  46                         if (parenthesis==0)
  47                         {
  48                                 strings.push_back(str.substr(current, nextCurrent-current));
  49                                 current=nextCurrent+1;
  50                         }
  51                         parenthesis--;
  52                         break;
  53                 case ',':
  54                         if (parenthesis==0)
  55                         {
  56                                 strings.push_back(str.substr(current, nextCurrent-current));
  57                                 current=nextCurrent+1;
  58                         }
  59                         break;
  60                 default:
  61                         break;
  62                 }
  63                 nextCurrent=str.find_first_of(separators.c_str(), nextCurrent+1);
  64         }
  65
  66 }
  67
  68
  69
  70 //////////////////////////////////////////////////////////////////////////
  71 //      Select Filter
  72
  73 bool    CFightSelectFilter::update      (CSpawnBot      &bot)   const
  74 {
  75         return  _CustomComp->update(bot);
  76 //      nlassert("a filter is not designed to be updated");
  77 }
  78
  79 std::string     CFightSelectFilter::toString() const
  80 {
  81         return  "SELECT("+_Param+","+_CustomComp->toString()+")";
  82 }
  83
  84
  85
  86 CFightScriptComp        *CFightSelectFilterReader::create       (const  std::string     &inStr)
  87 {
  88         std::vector<std::string>        params;
  89         explodeSubStrings(inStr, params, -1);
  90
  91         if      (params.size()!=2)
  92                 throw   ReadFightActionException("SELECT Needs 2 Params: <Filter>,<ScriptComp>");
  93
  94         CSmartPtr<CFightScriptComp>     scriptComp;
  95         try
  96         {
  97                 scriptComp=createScriptComp(params[1]);
  98         }
  99         catch (const ReadFightActionException &ex)
 100         {
 101                 throw   ReadFightActionException("cannot create sub ScriptComp : "+std::string(ex.what()));
 102         }
 103         return  new     CFightSelectFilter(scriptComp, params[0]);
 104 }
 105
 106
 107 //////////////////////////////////////////////////////////////////////////
 108 //      Once
 109
 110
 111 class   CFightOnce
 112                 :public CFightScriptComp
 113 {
 114 public:
 115         CFightOnce(CFightScriptComp     *customComp)
 116                 :_CustomComp(customComp)
 117         {
 118                 nlassert(customComp);   //      the creature is hitting, we cannot do anything ..
 119         }
 120
 121         virtual ~CFightOnce()
 122         {}
 123         bool    update  (CSpawnBot      &bot)   const
 124         {
 125                 uint32  dummy;
 126                 if (bot.getProp((size_t)this,dummy))    // check if we already go there (for once).
 127                         return  true;
 128
 129                 if      (!_CustomComp->update(bot))
 130                         return  false;
 131
 132                 bot.setProp((size_t)this,1);
 133                 return  true;
 134         }
 135
 136         string  toString() const
 137         {
 138                 return  "ONCE("+_CustomComp->toString()+")";
 139         }
 140
 141 protected:
 142 private:
 143         NLMISC::CSmartPtr<CFightScriptComp>     _CustomComp;
 144 };
 145
 146
 147 class   CFightOnceReader
 148                 :public CFightScriptCompReader
 149 {
 150 public:
 151         CFightOnceReader()                      {}
 152         virtual ~CFightOnceReader()     {}
 153
 154         CFightScriptComp        *create (const  std::string     &inStr)
 155         {
 156                 vector<string>  params;
 157                 explodeSubStrings(inStr, params, -1);
 158
 159                 if      (params.size()!=1)
 160                         throw   ReadFightActionException("ONCE Needs 1 Param: <ScriptComp>");
 161
 162                 CSmartPtr<CFightScriptComp>     scriptComp;
 163                 try
 164                 {
 165                         scriptComp=createScriptComp(params[0]);
 166                 }
 167                 catch (const ReadFightActionException &ex)
 168                 {
 169                         throw   ReadFightActionException("cannot create sub ScriptComp : "+string(ex.what()));
 170                 }
 171                 return  new     CFightOnce(scriptComp);
 172         }
 173         std::string     getName () const
 174         {
 175                 return  std::string("ONCE");
 176         }
 177
 178 };
 179
 180
 181
 182 //////////////////////////////////////////////////////////////////////////
 183 //      Timed Filter
 184
 185
 186 class   CFightTimedFilter
 187                 :public CFightScriptComp
 188 {
 189 public:
 190         CFightTimedFilter(CFightScriptComp      *customComp, uint32     deltaTime)
 191                 :_CustomComp(customComp)
 192                 ,_DeltaTime(deltaTime)
 193         {
 194                 nlassert(customComp);   //      the creature is hitting, we cannot do anything ..
 195         }
 196
 197         virtual ~CFightTimedFilter()
 198         {}
 199         bool    update  (CSpawnBot      &bot)   const
 200         {
 201                 uint32  decTime=0;
 202                 if      (bot.getProp((size_t)this, decTime))
 203                         if (CTimeInterface::gameCycle()<decTime)
 204                                 return  true;
 205
 206                 if      (!_CustomComp->update(bot))
 207                         return  false;
 208
 209                 bot.setProp((size_t)this, CTimeInterface::gameCycle()+(uint32)_DeltaTime);
 210                 return  true;
 211         }
 212
 213         string  toString() const
 214         {
 215                 return  "EVERY_SEC("+NLMISC::toString(_DeltaTime/10)+","+_CustomComp->toString()+")";
 216         }
 217
 218 protected:
 219 private:
 220         NLMISC::CSmartPtr<CFightScriptComp>     _CustomComp;
 221         uint32  _DeltaTime;
 222 };
 223
 224
 225 class   CFightTimedFilterReader
 226                 :public CFightScriptCompReader
 227 {
 228 public:
 229         CFightTimedFilterReader()                       {}
 230         virtual ~CFightTimedFilterReader()      {}
 231
 232         CFightScriptComp        *create (const  std::string     &inStr)
 233         {
 234                 vector<string>  params;
 235                 explodeSubStrings(inStr, params, -1);
 236
 237                 if      (params.size()!=2)
 238                         throw   ReadFightActionException("EVERY_SEC Needs 2 Params: <time in seconds>,<ScriptComp>");
 239
 240                 sint time;
 241                 NLMISC::fromString(params[0], time);
 242                 time *= 10;
 243
 244                 CSmartPtr<CFightScriptComp>     scriptComp;
 245                 try
 246                 {
 247                         scriptComp=createScriptComp(params[1]);
 248                 }
 249                 catch (const ReadFightActionException &ex)
 250                 {
 251                         throw   ReadFightActionException("cannot create sub ScriptComp : "+string(ex.what()));
 252                 }
 253                 return  new     CFightTimedFilter(scriptComp, time);
 254         }
 255         std::string     getName () const
 256         {
 257                 return  std::string("EVERY_SEC");
 258         }
 259
 260 };
 261
 262
 263 //////////////////////////////////////////////////////////////////////////
 264 //      HP Less Filter
 265
 266 class   CFightHPLessFilter
 267                 :public CFightScriptComp
 268 {
 269 public:
 270         CFightHPLessFilter(CFightScriptComp     *customComp, float      hpLimit)
 271                 :_CustomComp(customComp)
 272                 ,_HPLimit(hpLimit)
 273         {
 274                 nlassert(customComp);   //      comportment needed.
 275         }
 276
 277         virtual ~CFightHPLessFilter()
 278         {}
 279         bool    update  (CSpawnBot      &bot)   const
 280         {
 281                 if      (bot.hpPercentage()>=_HPLimit)
 282                         return  true;
 283                 return  _CustomComp->update(bot);
 284         }
 285
 286         string  toString() const
 287         {
 288                 return  "HP%LESS("+NLMISC::toString(_HPLimit)+","+_CustomComp->toString()+")";
 289         }
 290
 291 protected:
 292 private:
 293         NLMISC::CSmartPtr<CFightScriptComp>     _CustomComp;
 294         float   _HPLimit;
 295 };
 296
 297
 298 class   CFightHPLessFilterReader
 299                 :public CFightScriptCompReader
 300 {
 301 public:
 302         CFightHPLessFilterReader()                      {}
 303         virtual ~CFightHPLessFilterReader()     {}
 304
 305         CFightScriptComp        *create (const  std::string     &inStr)
 306         {
 307                 vector<string>  params;
 308                 explodeSubStrings(inStr, params, -1);
 309
 310                 if      (params.size()!=2)
 311                         throw   ReadFightActionException("HP%LESS Needs 2 Params: <hp limit>,<ScriptComp>");
 312
 313                 float   hpLimit=(float)atof(params[0].c_str());
 314
 315                 CSmartPtr<CFightScriptComp>     scriptComp;
 316                 try
 317                 {
 318                         scriptComp=createScriptComp(params[1]);
 319                 }
 320                 catch (const ReadFightActionException &ex)
 321                 {
 322                         throw   ReadFightActionException("cannot create sub ScriptComp : "+string(ex.what()));
 323                 }
 324                 return  new     CFightHPLessFilter(scriptComp, hpLimit);
 325         }
 326         std::string     getName () const
 327         {
 328                 return  std::string("HP%LESS");
 329         }
 330
 331 };
 332
 333 //////////////////////////////////////////////////////////////////////////
 334 //      HP More Filter
 335
 336 class   CFightHPMoreFilter
 337                 :public CFightScriptComp
 338 {
 339 public:
 340         CFightHPMoreFilter(CFightScriptComp     *customComp, float      hpLimit)
 341                 :_CustomComp(customComp)
 342                 ,_HPLimit(hpLimit)
 343         {
 344                 nlassert(customComp);   //      comportment needed.
 345         }
 346
 347         virtual ~CFightHPMoreFilter()
 348         {}
 349         bool    update  (CSpawnBot      &bot)   const
 350         {
 351                 if      (bot.hpPercentage()<=_HPLimit)
 352                         return  true;
 353                 return  _CustomComp->update(bot);
 354         }
 355
 356         string  toString() const
 357         {
 358                 return  "HP%MORE("+NLMISC::toString(_HPLimit)+","+_CustomComp->toString()+")";
 359         }
 360
 361 protected:
 362 private:
 363         NLMISC::CSmartPtr<CFightScriptComp>     _CustomComp;
 364         float   _HPLimit;
 365 };
 366
 367
 368 class   CFightHPMoreFilterReader
 369                 :public CFightScriptCompReader
 370 {
 371 public:
 372         CFightHPMoreFilterReader()                      {}
 373         virtual ~CFightHPMoreFilterReader()     {}
 374
 375         CFightScriptComp        *create (const  std::string     &inStr)
 376         {
 377                 vector<string>  params;
 378                 explodeSubStrings(inStr, params, -1);
 379
 380                 if      (params.size()!=2)
 381                         throw   ReadFightActionException("HP%MORE Needs 2 Params: <hp limit>,<ScriptComp>");
 382
 383                 float   hpLimit=(float)atof(params[0].c_str());
 384
 385                 CSmartPtr<CFightScriptComp>     scriptComp;
 386                 try
 387                 {
 388                         scriptComp=createScriptComp(params[1]);
 389                 }
 390                 catch (const ReadFightActionException &ex)
 391                 {
 392                         throw   ReadFightActionException("cannot create sub ScriptComp : "+string(ex.what()));
 393                 }
 394                 return  new     CFightHPMoreFilter(scriptComp, hpLimit);
 395         }
 396         std::string     getName () const
 397         {
 398                 return  std::string("HP%MORE");
 399         }
 400
 401 };
 402
 403
 404 //////////////////////////////////////////////////////////////////////////
 405 //      Random Filter
 406
 407 class   CFightRandomFilter
 408                 :public CFightScriptComp
 409 {
 410 public:
 411         CFightRandomFilter(CFightScriptComp     *customComp, float      random)
 412                 :_CustomComp(customComp)
 413                 ,_Random(random)
 414         {
 415                 nlassert(customComp);   //      comportment needed.
 416         }
 417
 418         virtual ~CFightRandomFilter()
 419         {}
 420         bool    update  (CSpawnBot      &bot)   const
 421         {
 422                 if      (CAIS::rand16(32767)>=(_Random*32767))
 423                         return  true;
 424                 return  _CustomComp->update(bot);
 425         }
 426
 427         string  toString() const
 428         {
 429                 return  "RANDOM("+NLMISC::toString(_Random)+","+_CustomComp->toString()+")";
 430         }
 431
 432 protected:
 433 private:
 434         NLMISC::CSmartPtr<CFightScriptComp>     _CustomComp;
 435         float   _Random;
 436 };
 437
 438
 439 class   CFightRandomFilterReader
 440                 :public CFightScriptCompReader
 441 {
 442 public:
 443         CFightRandomFilterReader()                      {}
 444         virtual ~CFightRandomFilterReader()     {}
 445
 446         CFightScriptComp        *create (const  std::string     &inStr)
 447         {
 448                 vector<string>  params;
 449                 explodeSubStrings(inStr, params, -1);
 450
 451                 if      (params.size()!=2)
 452                         throw   ReadFightActionException("RANDOM Needs 2 Params: <proba>,<ScriptComp>");
 453
 454                 float   random=(float)atof(params[0].c_str());
 455
 456                 CSmartPtr<CFightScriptComp>     scriptComp;
 457                 try
 458                 {
 459                         scriptComp=createScriptComp(params[1]);
 460                 }
 461                 catch (const ReadFightActionException &ex)
 462                 {
 463                         throw   ReadFightActionException("cannot create sub ScriptComp : "+string(ex.what()));
 464                 }
 465                 return  new     CFightRandomFilter(scriptComp, random);
 466         }
 467         std::string     getName () const
 468         {
 469                 return  std::string("RANDOM");
 470         }
 471
 472 };
 473
 474 //////////////////////////////////////////////////////////////////////////
 475 //      Send Action
 476
 477 class   CFightSendAction
 478                 :public CFightScriptComp
 479 {
 480 public:
 481         CFightSendAction(AISHEETS::IAIActionCPtr action, string const& actionName)
 482         : _Action(action)
 483         , _ActionName(actionName)
 484         {
 485         }
 486
 487         virtual ~CFightSendAction() { }
 488         bool    update(CSpawnBot        &bot)   const
 489         {
 490                 if      (!bot.getAIProfile())
 491                         return  true;
 492
 493                 CBotProfileFight        *profile=dynamic_cast<CBotProfileFight*>(bot.getAIProfile());
 494                 if      (!profile)
 495                         return  true;
 496
 497                 if      (!profile->atAttackDist())
 498                         return  false;
 499
 500                 TDataSetRow     dataSetRow;
 501                 if      ((CAIEntityPhysical*)bot.getTarget())
 502                         dataSetRow=bot.getTarget()->dataSetRow();
 503
 504                 CEGSExecuteAiActionMsg  msg(bot.dataSetRow(), dataSetRow, _Action->SheetId(), bot._DamageCoef, bot._DamageSpeedCoef);
 505                 msg.send(egsString);
 506                 bot.setActionFlags(RYZOMACTIONFLAGS::Attacks);
 507                 return  true;
 508         }
 509         string  toString() const
 510         {
 511                 return  "SEND_ACTION("+_ActionName+")";
 512         }
 513 protected:
 514 private:
 515         string  _ActionName;
 516         AISHEETS::IAIActionCPtr _Action;
 517 };
 518
 519 class   CFightSendActionReader
 520                 :public CFightScriptCompReader
 521 {
 522 public:
 523         CFightSendActionReader()                        {}
 524         virtual ~CFightSendActionReader()       {}
 525
 526         CFightScriptComp        *create (const  std::string     &inStr)
 527         {
 528                 vector<string>  strings;
 529                 explodeSubStrings(inStr, strings, -1);
 530
 531                 if      (strings.size()!=1)
 532                         throw   ReadFightActionException("SEND_ACTION Needs 1 param");
 533
 534                 NLMISC::CSheetId        sheetId(strings[0].c_str());
 535                 if      (sheetId==NLMISC::CSheetId::Unknown)
 536                         throw   ReadFightActionException("SheetId Unknown "+inStr);
 537
 538                 AISHEETS::IAIActionCPtr action = AISHEETS::CSheets::getInstance()->lookupAction(sheetId);
 539                 if (action.isNull())
 540                         throw   ReadFightActionException("SheetId Unknown "+inStr);
 541
 542                 return  new     CFightSendAction(action, strings[0]);
 543         }
 544
 545         std::string     getName () const
 546         {
 547                 return  std::string("SEND_ACTION");
 548         }
 549
 550 };
 551
 552
 553 //////////////////////////////////////////////////////////////////////////
 554 //      Send Self Action
 555
 556 class   CFightSendSelfAction
 557 :public CFightScriptComp
 558 {
 559 public:
 560         CFightSendSelfAction(AISHEETS::IAIActionCPtr action, string const& actionName)
 561         : _Action(action)
 562         , _ActionName(actionName)
 563         {
 564         }
 565
 566         virtual ~CFightSendSelfAction() { }
 567         bool    update(CSpawnBot        &bot)   const
 568         {
 569                 CEGSExecuteAiActionMsg  msg(bot.dataSetRow(), bot.dataSetRow(), _Action->SheetId(), bot._DamageCoef, bot._DamageSpeedCoef);
 570                 msg.send(egsString);
 571                 bot.setActionFlags(RYZOMACTIONFLAGS::Attacks);
 572                 return  true;
 573         }
 574         string  toString() const
 575         {
 576                 return  "SEND_SELF_ACTION("+_ActionName+")";
 577         }
 578 protected:
 579 private:
 580         string  _ActionName;
 581         AISHEETS::IAIActionCPtr _Action;
 582 };
 583
 584 class   CFightSendSelfActionReader
 585 :public CFightScriptCompReader
 586 {
 587 public:
 588         CFightSendSelfActionReader()                    {}
 589         virtual ~CFightSendSelfActionReader()   {}
 590
 591         CFightScriptComp        *create (const  std::string     &inStr)
 592         {
 593                 vector<string>  strings;
 594                 explodeSubStrings(inStr, strings, -1);
 595
 596                 if      (strings.size()!=1)
 597                         throw   ReadFightActionException("SEND_SELF_ACTION Needs 1 param");
 598
 599                 NLMISC::CSheetId        sheetId(strings[0].c_str());
 600                 if      (sheetId==NLMISC::CSheetId::Unknown)
 601                         throw   ReadFightActionException("SheetId Unknown "+inStr);
 602
 603                 AISHEETS::IAIActionCPtr action = AISHEETS::CSheets::getInstance()->lookupAction(sheetId);
 604                 if (action.isNull())
 605                         throw   ReadFightActionException("SheetId Unknown "+inStr);
 606
 607                 return  new     CFightSendSelfAction(action, strings[0]);
 608         }
 609
 610         std::string     getName () const
 611         {
 612                 return  std::string("SEND_SELF_ACTION");
 613         }
 614
 615 };
 616
 617 //////////////////////////////////////////////////////////////////////////
 618 //      AggroBlock
 619
 620 class   CFightAggroBlock
 621                 :public CFightScriptComp
 622 {
 623 public:
 624         CFightAggroBlock(const  uint32 time):_Time(time)
 625         {}
 626
 627         virtual ~CFightAggroBlock()
 628         {}
 629         bool    update(CSpawnBot        &bot)   const
 630         {
 631                 bot.blockAggro(_Time);
 632                 return  true;
 633         }
 634         string  toString() const
 635         {
 636                 return  "AGGRO_BLOCK("+NLMISC::toString(_Time/10)+")";
 637         }
 638 protected:
 639 private:
 640         uint32  _Time;
 641 };
 642
 643 class   CFightAggroBlockReader
 644                 :public CFightScriptCompReader
 645 {
 646 public:
 647         CFightAggroBlockReader()                        {}
 648         virtual ~CFightAggroBlockReader()       {}
 649
 650         CFightScriptComp        *create (const  std::string     &inStr)
 651         {
 652                 vector<string>  strings;
 653                 explodeSubStrings(inStr, strings, -1);
 654
 655                 if      (strings.size()!=1)
 656                         throw   ReadFightActionException("AGGRO_BLOCK Needs 1 param");
 657
 658                 uint32  time;
 659                 NLMISC::fromString(strings[0], time);
 660                 time *= 10;
 661                 return  new     CFightAggroBlock(time);
 662         }
 663
 664         std::string     getName () const
 665         {
 666                 return  std::string("AGGRO_BLOCK");
 667         }
 668
 669 };
 670
 671
 672 //////////////////////////////////////////////////////////////////////////
 673 //      AggroChange
 674
 675 class   CFightAggroChange
 676                 :public CFightScriptComp
 677 {
 678 public:
 679         CFightAggroChange()
 680         {}
 681
 682         virtual ~CFightAggroChange()
 683         {}
 684         bool    update(CSpawnBot        &bot)   const
 685         {
 686                 CAIEntityPhysical       *target=bot.getTarget();
 687                 if      (!target)
 688                         return  true;
 689
 690                 bot.minimizeAggroFor(target->dataSetRow());
 691                 return  true;
 692         }
 693         string  toString() const
 694         {
 695                 return  "AGGRO_CHANGE()";
 696         }
 697 protected:
 698 private:
 699 };
 700
 701 class   CFightAggroChangeReader
 702                 :public CFightScriptCompReader
 703 {
 704 public:
 705         CFightAggroChangeReader()                       {}
 706         virtual ~CFightAggroChangeReader()      {}
 707
 708         CFightScriptComp        *create (const  std::string     &inStr)
 709         {
 710                 return  new     CFightAggroChange();
 711         }
 712
 713         std::string     getName () const
 714         {
 715                 return  std::string("AGGRO_CHANGE");
 716         }
 717
 718 };
 719
 720
 721 //////////////////////////////////////////////////////////////////////////
 722 //      DamageCoef
 723
 724 class   CFightDamageCoef
 725                 :public CFightScriptComp
 726 {
 727 public:
 728         CFightDamageCoef(const  float coef)     :_Coef(coef)
 729         {}
 730
 731         virtual ~CFightDamageCoef()
 732         {}
 733         bool    update(CSpawnBot        &bot)   const
 734         {
 735                 bot._DamageCoef=_Coef;
 736                 return  true;
 737         }
 738         string  toString() const
 739         {
 740                 return  "DAMAGE_COEF("+NLMISC::toString(_Coef)+")";
 741         }
 742 protected:
 743 private:
 744         float   _Coef;
 745 };
 746
 747 class   CFightDamageCoefReader
 748                 :public CFightScriptCompReader
 749 {
 750 public:
 751         CFightDamageCoefReader()                        {}
 752         virtual ~CFightDamageCoefReader()       {}
 753
 754         CFightScriptComp        *create (const  std::string     &inStr)
 755         {
 756                 vector<string>  strings;
 757                 explodeSubStrings(inStr, strings, -1);
 758
 759                 if      (strings.size()!=1)
 760                         throw   ReadFightActionException("DAMAGE_COEF Needs 1 param");
 761
 762                 const   float   coef=(float)atof(strings[0].c_str());
 763                 return  new     CFightDamageCoef(coef);
 764         }
 765
 766         std::string     getName () const
 767         {
 768                 return  std::string("DAMAGE_COEF");
 769         }
 770
 771 };
 772
 773
 774
 775 //////////////////////////////////////////////////////////////////////////
 776 //      GroupDamageCoef
 777
 778 class   CFightGroupDamageCoef
 779 :public CFightScriptComp
 780 {
 781 public:
 782         CFightGroupDamageCoef(const     float coef)     :_Coef(coef)
 783         {}
 784
 785         virtual ~CFightGroupDamageCoef()
 786         {}
 787         bool    update(CSpawnBot        &bot)   const
 788         {
 789                 CSpawnGroup                     &spawnGroup=bot.spawnGrp();
 790                 CAliasCont<CBot>        &bots=spawnGroup.getPersistent().bots();
 791
 792                 float   damageCoef=1.f;
 793                 for     (sint32 nbRec=bots.size()-(spawnGroup.nbSpawnedBot()+spawnGroup.nbBotToDespawn());nbRec>=0;nbRec--)
 794                         damageCoef*=_Coef;
 795
 796                 for (CCont<CBot>::iterator      it=bots.begin(), itEnd=bots.end(); it!=itEnd; ++it)
 797                 {
 798                         CSpawnBot       *spawnBot=it->getSpawnObj();
 799                         if      (spawnBot)
 800                                 spawnBot->_DamageCoef=damageCoef;
 801                 }
 802
 803                 return  true;
 804         }
 805         string  toString() const
 806         {
 807                 return  "UPDATE_GROUP_DAMAGE_COEF("+NLMISC::toString(_Coef)+")";
 808         }
 809 protected:
 810 private:
 811         float   _Coef;
 812 };
 813
 814 class   CFightGroupDamageCoefReader
 815 :public CFightScriptCompReader
 816 {
 817 public:
 818         CFightGroupDamageCoefReader()                   {}
 819         virtual ~CFightGroupDamageCoefReader()  {}
 820
 821         CFightScriptComp        *create (const  std::string     &inStr)
 822         {
 823                 vector<string>  strings;
 824                 explodeSubStrings(inStr, strings, -1);
 825
 826                 if      (strings.size()!=1)
 827                         throw   ReadFightActionException("UPDATE_GROUP_DAMAGE_COEF Needs 1 param");
 828
 829                 const   float   coef=(float)atof(strings[0].c_str());
 830                 return  new     CFightGroupDamageCoef(coef);
 831         }
 832
 833         std::string     getName () const
 834         {
 835                 return  std::string("UPDATE_GROUP_DAMAGE_COEF");
 836         }
 837
 838 };
 839
 840
 841 //////////////////////////////////////////////////////////////////////////
 842 //      DamageSpeedCoef
 843
 844 class   CFightDamageSpeedCoef
 845                 :public CFightScriptComp
 846 {
 847 public:
 848         CFightDamageSpeedCoef(const     float coef)     :_Coef(coef)
 849         {}
 850
 851         virtual ~CFightDamageSpeedCoef()
 852         {}
 853         bool    update(CSpawnBot        &bot)   const
 854         {
 855                 bot._DamageSpeedCoef=_Coef;
 856                 return  true;
 857         }
 858         string  toString() const
 859         {
 860                 return  "DAMAGE_SPEED_COEF("+NLMISC::toString(_Coef)+")";
 861         }
 862 protected:
 863 private:
 864         float   _Coef;
 865 };
 866
 867 class   CFightDamageSpeedCoefReader
 868                 :public CFightScriptCompReader
 869 {
 870 public:
 871         CFightDamageSpeedCoefReader()                   {}
 872         virtual ~CFightDamageSpeedCoefReader()  {}
 873
 874         CFightScriptComp        *create (const  std::string     &inStr)
 875         {
 876                 vector<string>  strings;
 877                 explodeSubStrings(inStr, strings, -1);
 878
 879                 if      (strings.size()!=1)
 880                         throw   ReadFightActionException("DAMAGE_SPEED_COEF Needs 1 param");
 881
 882                 const   float   coef=(float)atof(strings[0].c_str());
 883                 return  new     CFightDamageSpeedCoef(coef);
 884         }
 885
 886         std::string     getName () const
 887         {
 888                 return  std::string("DAMAGE_SPEED_COEF");
 889         }
 890
 891 };
 892
 893 //////////////////////////////////////////////////////////////////////////
 894 //      SetRandomTarget
 895
 896 class   CFightSetRandomTarget
 897 :public CFightScriptComp
 898 {
 899 public:
 900         CFightSetRandomTarget(const     float coef)     :_Coef(coef)
 901         {}
 902
 903         virtual ~CFightSetRandomTarget()
 904         {}
 905         bool    update(CSpawnBot        &bot)   const
 906         {
 907                 const   CBotAggroOwner::TBotAggroList   &list=bot.getBotAggroList();
 908                 size_t size = list.size();
 909                 if (size>0)
 910                 {
 911                         CBotAggroOwner::TBotAggroList::const_iterator it = list.begin();
 912                         for (size_t i=0; i<size; ++i)
 913                                 ++it;
 914                         if (it!=list.end())
 915                                 bot.maximizeAggroFor(it->first);
 916                 }
 917
 918                 return  true;
 919         }
 920         string  toString() const
 921         {
 922                 return  "SET_RANDOM_TARGET()";
 923         }
 924 protected:
 925 private:
 926         float   _Coef;
 927 };
 928
 929 class   CFightSetRandomTargetReader
 930 :public CFightScriptCompReader
 931 {
 932 public:
 933         CFightSetRandomTargetReader()                   {}
 934         virtual ~CFightSetRandomTargetReader()  {}
 935
 936         CFightScriptComp        *create (const  std::string     &inStr)
 937         {
 938                 vector<string>  strings;
 939                 explodeSubStrings(inStr, strings, -1);
 940
 941                 if      (       strings.size()!=1
 942                         ||      strings[0]!="")
 943                         throw   ReadFightActionException("SET_RANDOM_TARGET Needs 0 param");
 944
 945                 const   float   coef=(float)atof(strings[0].c_str());
 946                 return  new     CFightSetRandomTarget(coef);
 947         }
 948
 949         std::string     getName () const
 950         {
 951                 return  std::string("SET_RANDOM_TARGET");
 952         }
 953
 954 };
 955
 956
 957 //////////////////////////////////////////////////////////////////////////
 958 //      Once
 959
 960
 961 class   CFightMult
 962 :public CFightScriptComp
 963 {
 964 public:
 965         CFightMult(const        std::vector<CSmartPtr<CFightScriptComp> >       &customComps)
 966                 :_CustomComps(customComps)
 967         {
 968         }
 969
 970         virtual ~CFightMult()
 971         {}
 972         bool    update  (CSpawnBot      &bot)   const
 973         {
 974                 for     (uint32 i=0;i<_CustomComps.size();i++)
 975                         _CustomComps[i]->update(bot);
 976                 return  true;
 977         }
 978
 979         string  toString() const
 980         {
 981                 string  outputString="MULT(";
 982
 983                 for     (uint32 i=0;i<_CustomComps.size();i++)
 984                 {
 985                         if (i>0)
 986                                 outputString+=",";                      // add a "," to separate this param from previous ..
 987                         outputString+=_CustomComps[i]->toString();
 988                 }
 989
 990                 return  outputString+")";
 991         }
 992
 993 protected:
 994 private:
 995         const   std::vector<CSmartPtr<CFightScriptComp> >       _CustomComps;
 996 };
 997
 998
 999 class   CFightMultReader
1000 :public CFightScriptCompReader
1001 {
1002 public:
1003         CFightMultReader()                      {}
1004         virtual ~CFightMultReader()     {}
1005
1006         CFightScriptComp        *create (const  std::string     &inStr)
1007         {
1008                 vector<string>  params;
1009                 explodeSubStrings(inStr, params, -1);
1010
1011                 const   uint32  nbSubScript=(uint32)params.size();
1012
1013                 std::vector<CSmartPtr<CFightScriptComp> >       scriptComps;
1014                 try
1015                 {
1016                         for (uint32 i=0;i<nbSubScript;i++)
1017                                 scriptComps.push_back(createScriptComp(params[i]));
1018                 }
1019                 catch (const ReadFightActionException &ex)
1020                 {
1021                         throw   ReadFightActionException("cannot create sub ScriptComp : "+string(ex.what()));
1022                 }
1023                 return  new     CFightMult(scriptComps);
1024         }
1025         std::string     getName () const
1026         {
1027                 return  std::string("MULT");
1028         }
1029
1030 };
1031
1032 //////////////////////////////////////////////////////////////////////////
1033 //      CFightScript
1034
1035
1036 CFightScript::TFightScriptMap   CFightScript::_ScriptCompList;
1037
1038 CFightScript    justInstanciatedToRegisterReaders;
1039
1040 CFightScript::CFightScript()
1041 {
1042         add(new CFightSelectFilterReader());
1043
1044         add(new CFightMultReader());
1045         add(new CFightOnceReader());
1046         add(new CFightTimedFilterReader());
1047         add(new CFightRandomFilterReader());
1048         add(new CFightHPLessFilterReader());
1049         add(new CFightHPMoreFilterReader());
1050
1051         add(new CFightAggroBlockReader());
1052         add(new CFightAggroChangeReader());
1053         add(new CFightDamageCoefReader());
1054         add(new CFightGroupDamageCoefReader());
1055         add(new CFightDamageSpeedCoefReader());
1056         add(new CFightSendActionReader());
1057         add(new CFightSendSelfActionReader());
1058         add(new CFightSetRandomTargetReader());
1059 }
1060
1061 void    CFightScript::add(CFightScriptCompReader        *reader)
1062 {
1063         nlassert(reader!=NULL);
1064         nlassert(_ScriptCompList.find(reader->getName())==_ScriptCompList.end());
1065         _ScriptCompList.insert(std::make_pair(reader->getName(),reader));
1066 }
1067
1068
1069 CFightScriptCompReader* CFightScriptCompReader::getScriptReader(const string &str)
1070 {
1071         CFightScript::TFightScriptMap::iterator it=CFightScript::_ScriptCompList.find(str);
1072         if      (it==CFightScript::_ScriptCompList.end())
1073                 throw   ReadFightActionException("Unknown ScriptComp "+str);
1074
1075         return  &(*(it->second));
1076 }
1077
1078 CFightScriptComp        *CFightScriptCompReader::createScriptComp       (const string &str)
1079 {
1080         string  scriptCompName;
1081         {
1082                 const   string::size_type       index=str.find_first_of("()", 0);
1083                 if      (index==string::npos)
1084                         throw   ReadFightActionException("ScriptComp Creation of :"+str+" Failed because of bad Syntax");
1085                 scriptCompName=str.substr(0,index);
1086         }
1087
1088         try
1089         {
1090                 return  getScriptReader (scriptCompName)->create(str);
1091         }
1092         catch (const ReadFightActionException &e)
1093         {
1094                 throw   ReadFightActionException(string("ScriptComp creation failed : ")+string(e.what()));
1095         }
1096
1097 }