nel/src/logic/logic_condition.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18 #include "stdlogic.h"
  19 #include "nel/logic/logic_condition.h"
  20
  21 #include "nel/logic/logic_variable.h"
  22 #include "nel/logic/logic_state_machine.h"
  23
  24 #include "nel/misc/o_xml.h"
  25
  26 using namespace NLMISC;
  27 using namespace std;
  28
  29 namespace NLLOGIC
  30 {
  31
  32 //-------------------------------------------------
  33 // setLogicStateMachine :
  34 //
  35 //-------------------------------------------------
  36 void CLogicComparisonBlock::setLogicStateMachine( CLogicStateMachine * logicStateMachine )
  37 {
  38         if( logicStateMachine == 0 )
  39         {
  40                 nlwarning("(LOGIC)<CLogicComparisonBlock::setLogicStateMachine> The state machine is null");
  41         }
  42         else
  43         {
  44                 _LogicStateMachine = logicStateMachine;
  45         }
  46
  47 } // setLogicStateMachine //
  48
  49
  50 //-------------------------------------------------
  51 // testLogic :
  52 //
  53 //-------------------------------------------------
  54 bool CLogicComparisonBlock::testLogic()
  55 {
  56         CLogicVariable var;
  57         if( _LogicStateMachine->getVariable( VariableName, var ) == false )
  58         {
  59                 nlwarning("(LOGIC)<CLogicComparisonBlock::testLogic> The variable %s is unknown in the state machine",VariableName.c_str());
  60                 return false;
  61         }
  62
  63         if( Operator == "<"  )  return ( var.getValue() <  Comparand );
  64         if( Operator == "<=" )  return ( var.getValue() <= Comparand );
  65         if( Operator == ">"  )  return ( var.getValue() >  Comparand );
  66         if( Operator == ">=" )  return ( var.getValue() >= Comparand );
  67         if( Operator == "==" )  return ( var.getValue() == Comparand );
  68         if( Operator == "!=" )  return ( var.getValue() != Comparand );
  69
  70         nlwarning("(LOGIC)<CLogicComparisonBlock::testLogic> The comparison block operator %s is unknown",Operator.c_str());
  71         return false;
  72
  73 } // testLogic //
  74
  75
  76 //-------------------------------------------------
  77 // serial :
  78 //
  79 //-------------------------------------------------
  80 /*void CLogicComparisonBlock::serial( IStream &f )
  81 {
  82         f.xmlPush("COMPARISON_BLOCK");
  83
  84         f.serial( VariableName );
  85         f.serial( Operator );
  86         f.serial( Comparand );
  87
  88         f.xmlPop();
  89
  90 } // serial //*/
  91
  92 void CLogicComparisonBlock::write (xmlNodePtr node) const
  93 {
  94         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"COMPARISON_BLOCK", NULL);
  95         xmlSetProp (elmPtr, (const xmlChar*)"VariableName", (const xmlChar*)VariableName.c_str());
  96         xmlSetProp (elmPtr, (const xmlChar*)"Operator", (const xmlChar*)Operator.c_str());
  97         xmlSetProp (elmPtr, (const xmlChar*)"Comparand", (const xmlChar*)toString(Comparand).c_str());
  98 }
  99
 100 void CLogicComparisonBlock::read (xmlNodePtr node)
 101 {
 102         xmlCheckNodeName (node, "COMPARISON_BLOCK");
 103
 104         VariableName = getXMLProp (node, "VariableName");
 105         Operator = getXMLProp (node, "Operator");
 106         Comparand = atoiInt64(getXMLProp (node, "Comparand").c_str());
 107 }
 108
 109
 110
 111
 112
 113
 114
 115 //-------------------------------------------------
 116 // setLogicStateMachine :
 117 //
 118 //-------------------------------------------------
 119 void CLogicConditionLogicBlock::setLogicStateMachine( CLogicStateMachine * logicStateMachine )
 120 {
 121         if( logicStateMachine == 0 )
 122         {
 123                 nlwarning("(LOGIC)<CCLogicConditionLogicBlock::setLogicStateMachine> The state machine is null");
 124         }
 125         else
 126         {
 127                 // set the state machine of this node
 128                 _LogicStateMachine = logicStateMachine;
 129
 130                 // set the state machine of the logic block
 131                 ComparisonBlock.setLogicStateMachine( logicStateMachine );
 132         }
 133
 134 } // setLogicStateMachine //
 135
 136
 137 //-------------------------------------------------
 138 // testLogic :
 139 //
 140 //-------------------------------------------------
 141 bool CLogicConditionLogicBlock::testLogic()
 142 {
 143         switch( Type )
 144         {
 145                 case NOT :
 146                 {
 147                         return true;
 148                 }
 149                 break;
 150
 151                 case COMPARISON :
 152                 {
 153                         return ComparisonBlock.testLogic();
 154                 }
 155                 break;
 156
 157                 case SUB_CONDITION :
 158                 {
 159                         CLogicCondition condition;
 160                         if( _LogicStateMachine->getCondition(SubCondition,condition) )
 161                         {
 162                                 return condition.testLogic();
 163                         }
 164                         else
 165                         {
 166                                 nlwarning("(LOGIC)<CLogicConditionLogicBlock::testLogic> The subcondition \"%s\" is unknown in the state machine \"%s\"",
 167                                         SubCondition.c_str(),_LogicStateMachine->getName().c_str());
 168                         }
 169
 170                 }
 171
 172                 default :
 173                         nlerror("(LOGIC)<CLogicConditionLogicBlock::testLogic> logic block type %d is unknown",Type);
 174         }
 175
 176         return false;
 177
 178 } // testLogic //
 179
 180
 181
 182 //-------------------------------------------------
 183 // fillVarSet :
 184 //
 185 //-------------------------------------------------
 186 void CLogicConditionLogicBlock::fillVarSet( set<string>& condVars )
 187 {
 188         if( Type == COMPARISON )
 189         {
 190                 condVars.insert( ComparisonBlock.VariableName );
 191         }
 192         else
 193         {
 194                 if( Type == SUB_CONDITION )
 195                 {
 196                         CLogicCondition condition;
 197                         if( _LogicStateMachine->getCondition(SubCondition,condition) )
 198                         {
 199                                 condition.fillVarSet( condVars );
 200                         }
 201                 }
 202         }
 203
 204 } // fillVarSet //
 205
 206
 207 //-------------------------------------------------
 208 // serial :
 209 //
 210 //-------------------------------------------------
 211 /*void CLogicConditionLogicBlock::serial( IStream &f )
 212 {
 213         f.xmlPush("CONDITION_LOGIC_BLOCK");
 214
 215         f.serialEnum( Type );
 216         switch( Type )
 217         {
 218                 case NOT : break;
 219
 220                 case COMPARISON :
 221                 {
 222                         f.serial( ComparisonBlock );
 223                 }
 224                 break;
 225
 226                 case SUB_CONDITION :
 227                 {
 228                         f.serial( SubCondition );
 229                 }
 230                 break;
 231         };
 232
 233         f.xmlPop();
 234 };*/
 235
 236 void CLogicConditionLogicBlock::write (xmlNodePtr node) const
 237 {
 238         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"CONDITION_LOGIC_NODE", NULL);
 239         xmlSetProp (elmPtr, (const xmlChar*)"Type", (const xmlChar*)toString((uint32)Type).c_str());
 240         switch( Type )
 241         {
 242                 case NOT : break;
 243
 244                 case COMPARISON :
 245                 {
 246                         ComparisonBlock.write(elmPtr);
 247                 }
 248                 break;
 249
 250                 case SUB_CONDITION :
 251                 {
 252                         xmlSetProp (elmPtr, (const xmlChar*)"SubCondition", (const xmlChar*)SubCondition.c_str());
 253                 }
 254                 break;
 255         };
 256 }
 257
 258 void CLogicConditionLogicBlock::read (xmlNodePtr node)
 259 {
 260         xmlCheckNodeName (node, "CONDITION_LOGIC_NODE");
 261         uint32 uType;
 262         NLMISC::fromString(getXMLProp(node, "Type"), uType);
 263         Type = (TLogicConditionLogicBlockType)uType;
 264         switch( Type )
 265         {
 266                 case NOT : break;
 267
 268                 case COMPARISON :
 269                 {
 270                         ComparisonBlock.read (node);
 271                 }
 272                 break;
 273
 274                 case SUB_CONDITION :
 275                 {
 276                         SubCondition = getXMLProp (node, "SubCondition");
 277                 }
 278                 break;
 279         };
 280 }
 281
 282 //-----------------------------------------
 283
 284
 285
 286 //-------------------------------------------------
 287 // setLogicStateMachine :
 288 //
 289 //-------------------------------------------------
 290 void CLogicConditionNode::setLogicStateMachine( CLogicStateMachine * logicStateMachine )
 291 {
 292         if( logicStateMachine == 0 )
 293         {
 294                 nlwarning("(LOGIC)<CLogicConditionNode::setLogicStateMachine> The state machine is null");
 295         }
 296         else
 297         {
 298                 // set the state machine of this node
 299                 _LogicStateMachine = logicStateMachine;
 300
 301                 // set the state machine of the logic block
 302                 LogicBlock.setLogicStateMachine( logicStateMachine );
 303
 304                 // set the state machine for the sub nodes
 305                 vector<CLogicConditionNode *>::iterator itNodes;
 306                 for( itNodes = _Nodes.begin(); itNodes != _Nodes.end(); ++itNodes )
 307                 {
 308                         (*itNodes)->setLogicStateMachine( logicStateMachine );
 309                 }
 310         }
 311
 312 } // setLogicStateMachine //
 313
 314
 315 //-------------------------------------------------
 316 // addNode :
 317 //
 318 //-------------------------------------------------
 319 void CLogicConditionNode::addNode( CLogicConditionNode * node )
 320 {
 321         node->setLogicStateMachine( _LogicStateMachine );
 322         _Nodes.push_back( node );
 323
 324 } // addToSubNodes //
 325
 326
 327 //-------------------------------------------------
 328 // testLogic :
 329 //
 330 //-------------------------------------------------
 331 bool CLogicConditionNode::testLogic()
 332 {
 333         // test the logic block
 334         if( LogicBlock.testLogic() == false )
 335         {
 336                 return false;
 337         }
 338
 339         // if there's no subtree we assess the subtree is true
 340         if( _Nodes.empty() )
 341         {
 342                 return true;
 343         }
 344
 345         // test the subtree
 346         if( LogicBlock.isNotBlock() )
 347         {
 348                 // the subtree is false if at least one node is true
 349                 vector<CLogicConditionNode *>::iterator itNodes;
 350                 for( itNodes = _Nodes.begin(); itNodes != _Nodes.end(); ++itNodes )
 351                 {
 352                         if( (*itNodes)->testLogic() == true )
 353                         {
 354                                 return false;
 355                         }
 356                 }
 357
 358                 return true;
 359         }
 360         else
 361         {
 362                 // the subtree is true if at least one node is true
 363                 vector<CLogicConditionNode *>::iterator itNodes;
 364                 for( itNodes = _Nodes.begin(); itNodes != _Nodes.end(); ++itNodes )
 365                 {
 366                         if( (*itNodes)->testLogic() == true )
 367                         {
 368                                 return true;
 369                         }
 370                 }
 371
 372                 return false;
 373         }
 374
 375 } // testLogic //
 376
 377
 378 //-------------------------------------------------
 379 // fillVarSet :
 380 //
 381 //-------------------------------------------------
 382 void CLogicConditionNode::fillVarSet( set<string>& condVars )
 383 {
 384         if( Type == LOGIC_NODE )
 385         {
 386                 LogicBlock.fillVarSet( condVars );
 387         }
 388
 389         vector<CLogicConditionNode *>::iterator itNode;
 390         for( itNode = _Nodes.begin(); itNode != _Nodes.end(); ++itNode )
 391         {
 392                 (*itNode)->fillVarSet( condVars );
 393         }
 394
 395 } // fillVarSet //
 396
 397
 398 //-------------------------------------------------
 399 // serial :
 400 //
 401 //-------------------------------------------------
 402 /*void CLogicConditionNode::serial( IStream &f )
 403 {
 404         f.xmlPush("CONDITION_NODE");
 405
 406         f.serialEnum( Type );
 407         switch( Type )
 408         {
 409                 case TERMINATOR : break;
 410                 case LOGIC_NODE :
 411                 {
 412                         f.serial( LogicBlock );
 413                         if( f.isReading() )
 414                         {
 415                                 uint32 sz;
 416                                 f.serial( sz );
 417                                 uint i;
 418                                 for( i = 0; i < sz; i++ )
 419                                 {
 420                                         CLogicConditionNode * node = new CLogicConditionNode();
 421                                         f.serial( *node );
 422                                         _Nodes.push_back( node );
 423                                 }
 424                         }
 425                         else
 426                         {
 427                                 uint32 sz = _Nodes.size();
 428                                 f.serial( sz );
 429                                 vector<CLogicConditionNode *>::iterator itNode;
 430                                 for( itNode = _Nodes.begin(); itNode != _Nodes.end(); ++itNode )
 431                                 {
 432                                         f.serial( **itNode );
 433                                 }
 434                         }
 435                 }
 436                 break;
 437         };
 438
 439         f.xmlPop();
 440
 441 } // serial //*/
 442
 443 void CLogicConditionNode::write (xmlNodePtr node) const
 444 {
 445         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"CONDITION_NODE", NULL);
 446         xmlSetProp (elmPtr, (const xmlChar*)"Type", (const xmlChar*)toString((uint32)Type).c_str());
 447
 448         switch( Type )
 449         {
 450                 case TERMINATOR : break;
 451                 case LOGIC_NODE :
 452                 {
 453                         LogicBlock.write(elmPtr);
 454                         vector<CLogicConditionNode *>::const_iterator itNode = _Nodes.begin();
 455                         for( ; itNode != _Nodes.end(); ++itNode )
 456                         {
 457                                 (*itNode)->write(elmPtr);
 458                         }
 459                 }
 460                 break;
 461         };
 462 }
 463
 464 void CLogicConditionNode::read (xmlNodePtr node)
 465 {
 466         xmlCheckNodeName (node, "CONDITION_NODE");
 467         uint32 uType;
 468         NLMISC::fromString(getXMLProp(node, "Type"), uType);
 469         Type = (TConditionNodeType )uType;
 470         switch( Type )
 471         {
 472                 case TERMINATOR : break;
 473                 case LOGIC_NODE :
 474                 {
 475                         LogicBlock.read (node);
 476
 477                         {
 478                                 // Count the parent
 479                                 uint nb = CIXml::countChildren (node, "CONDITION_NODE");
 480                                 uint i = 0;
 481                                 xmlNodePtr parent = CIXml::getFirstChildNode (node, "CONDITION_NODE");
 482                                 while (i<nb)
 483                                 {
 484                                         CLogicConditionNode *v = new CLogicConditionNode();
 485                                         v->read(parent);
 486                                         _Nodes.push_back (v);
 487
 488                                         // Next parent
 489                                         parent = CIXml::getNextChildNode (parent, "CONDITION_NODE");
 490                                         i++;
 491                                 }
 492                         }
 493                 }
 494                 break;
 495         };
 496 }
 497
 498 //-------------------------------------------------
 499 // ~CLogicConditionNode :
 500 //
 501 //-------------------------------------------------
 502 CLogicConditionNode::~CLogicConditionNode()
 503 {
 504         vector<CLogicConditionNode *>::iterator itNodes;
 505         for( itNodes = _Nodes.begin(); itNodes != _Nodes.end(); ++itNodes )
 506         {
 507                 delete (*itNodes);
 508         }
 509
 510 } // ~CLogicConditionNode //
 511
 512
 513
 514
 515
 516
 517
 518 //-------------------------------------------------
 519 // setLogicStateMachine :
 520 //
 521 //-------------------------------------------------
 522 void CLogicCondition::setLogicStateMachine( CLogicStateMachine * logicStateMachine )
 523 {
 524         if( logicStateMachine == 0 )
 525         {
 526                 nlwarning("(LOGIC)<CLogicCondition::setLogicStateMachine> The state machine is null");
 527         }
 528         else
 529         {
 530                 // init the logic state machine for each node
 531                 vector<CLogicConditionNode>::iterator itNodes;
 532                 for( itNodes = Nodes.begin(); itNodes != Nodes.end(); ++itNodes )
 533                 {
 534                         (*itNodes).setLogicStateMachine( logicStateMachine );
 535                 }
 536         }
 537
 538 } // setLogicStateMachine //
 539
 540
 541 //-------------------------------------------------
 542 // testLogic :
 543 //
 544 //-------------------------------------------------
 545 bool CLogicCondition::testLogic()
 546 {
 547         vector<CLogicConditionNode>::iterator itNodes;
 548         for( itNodes = Nodes.begin(); itNodes != Nodes.end(); ++itNodes )
 549         {
 550                 if( (*itNodes).testLogic() == false )
 551                 {
 552                         return false;
 553                 }
 554         }
 555
 556         return true;
 557
 558 } // testLogic //
 559
 560
 561
 562 //-------------------------------------------------
 563 // fillVarSet :
 564 //
 565 //-------------------------------------------------
 566 void CLogicCondition::fillVarSet( set<string>& condVars )
 567 {
 568         vector<CLogicConditionNode>::iterator itNode;
 569         for( itNode = Nodes.begin(); itNode != Nodes.end(); ++itNode )
 570         {
 571                 (*itNode).fillVarSet( condVars );
 572         }
 573
 574 } // fillVarSet //
 575
 576
 577
 578 //-------------------------------------------------
 579 // serial :
 580 //
 581 //-------------------------------------------------
 582 /*void CLogicCondition::serial( IStream &f )
 583 {
 584         f.xmlPush("CONDITION");
 585
 586         f.serial( _ConditionName );
 587         f.serialCont( Nodes );
 588
 589         f.xmlPop();
 590
 591 } // serial //*/
 592
 593 void CLogicCondition::write (xmlNodePtr node) const
 594 {
 595         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"CONDITION", NULL);
 596         xmlSetProp (elmPtr, (const xmlChar*)"Name", (const xmlChar*)_ConditionName.c_str());
 597
 598         uint i;
 599         for (i = 0; i < Nodes.size(); i++)
 600         {
 601                 Nodes[i].write(elmPtr);
 602         }
 603 }
 604
 605 void CLogicCondition::read (xmlNodePtr node)
 606 {
 607         xmlCheckNodeName (node, "CONDITION");
 608
 609         _ConditionName = getXMLProp (node, "Name");
 610
 611         {
 612                 // Count the parent
 613                 uint nb = CIXml::countChildren (node, "CONDITION_NODE");
 614                 uint i = 0;
 615                 xmlNodePtr parent = CIXml::getFirstChildNode (node, "CONDITION_NODE");
 616                 while (i<nb)
 617                 {
 618                         CLogicConditionNode v;
 619                         v.read(parent);
 620                         Nodes.push_back (v);
 621
 622                         // Next parent
 623                         parent = CIXml::getNextChildNode (parent, "CONDITION_NODE");
 624                         i++;
 625                 }
 626         }
 627 }
 628
 629
 630 } // NLLOGIC