nel/src/logic/logic_state.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_state.h"
  20 #include "nel/logic/logic_state_machine.h"
  21
  22
  23 using namespace std;
  24 using namespace NLMISC;
  25 using namespace NLNET;
  26
  27 namespace NLLOGIC
  28 {
  29
  30 //---------------------------------------------------
  31 //      CLogicState
  32 //
  33 //---------------------------------------------------
  34 CLogicState::CLogicState()
  35 {
  36         _StateName = "no_state";
  37         _LogicStateMachine = 0;
  38
  39 } // CLogicState //
  40
  41
  42 //---------------------------------------------------
  43 //      setLogicStateMachine
  44 //
  45 //---------------------------------------------------
  46 void CLogicState::setLogicStateMachine( CLogicStateMachine * logicStateMachine )
  47 {
  48         if( logicStateMachine == 0 )
  49         {
  50                 nlwarning("(LOGIC)<CLogicCondition::setLogicStateMachine> The state machine is null");
  51         }
  52         else
  53         {
  54                 // init the logic state machine for this state
  55                 _LogicStateMachine = logicStateMachine;
  56
  57                 // init the logic state machine in each event
  58                 vector<CLogicEvent>::iterator itEvent;
  59                 for( itEvent = _Events.begin(); itEvent != _Events.end(); ++itEvent )
  60                 {
  61                         (*itEvent).setLogicStateMachine( logicStateMachine );
  62                 }
  63         }
  64
  65 } // setLogicStateMachine //
  66
  67
  68
  69 //---------------------------------------------------
  70 // addEvent :
  71 //
  72 //---------------------------------------------------
  73 void CLogicState::addEvent( CLogicEvent event )
  74 {
  75         event.setLogicStateMachine( _LogicStateMachine );
  76         _Events.push_back( event );
  77
  78 } // addEvent //
  79
  80
  81
  82 //---------------------------------------------------
  83 // addSIdMap :
  84 //
  85 // looks in all the messages of the state if the
  86 // destination names can be associated with a sid.
  87 //---------------------------------------------------
  88 void CLogicState::addSIdMap( const TSIdMap& sIdMap )
  89 {
  90         vector<CLogicEventMessage>::iterator itMsg;
  91
  92         /// entry messages
  93         for( itMsg = _EntryMessages.begin(); itMsg != _EntryMessages.end(); ++itMsg )
  94         {
  95                 TSIdMap::const_iterator itId = sIdMap.find( (*itMsg).Destination );
  96                 // if message destination exists in the map we associate the sid with the message
  97                 if( itId != sIdMap.end() )
  98                 {
  99                         (*itMsg).DestinationId = (*itId).second;
 100                 }
 101         }
 102         /// send the entry messages that can be sent
 103         trySendEntryMessages();
 104
 105
 106         // event messages
 107         vector<CLogicEvent>::iterator itEvt;
 108         for( itEvt = _Events.begin(); itEvt != _Events.end(); ++itEvt )
 109         {
 110                 string dest = (*itEvt).EventAction.EventMessage.Destination;
 111                 TSIdMap::const_iterator itId = sIdMap.find( dest );
 112                 // if message destination exists in the map we associate the sid with the message
 113                 if( itId != sIdMap.end() )
 114                 {
 115                         (*itEvt).EventAction.EventMessage.DestinationId = (*itId).second;
 116                 }
 117         }
 118         /// send the event messages that can be sent
 119         trySendEventMessages();
 120
 121
 122         /// exit messages
 123         for( itMsg = _ExitMessages.begin(); itMsg != _ExitMessages.end(); ++itMsg )
 124         {
 125                 TSIdMap::const_iterator itId = sIdMap.find( (*itMsg).Destination );
 126                 // if message destination exists in the map we associate the sid with the message
 127                 if( itId != sIdMap.end() )
 128                 {
 129                         (*itMsg).DestinationId = (*itId).second;
 130                 }
 131         }
 132
 133 } // addSIdMap //
 134
 135
 136 //---------------------------------------------------
 137 // processLogic :
 138 //
 139 //---------------------------------------------------
 140 void CLogicState::processLogic()
 141 {
 142         // test all conditions managed by this state
 143         vector<CLogicEvent>::iterator itEvent;
 144         for( itEvent = _Events.begin(); itEvent != _Events.end(); ++itEvent )
 145         {
 146                 if( (*itEvent).testCondition() )
 147                 {
 148                         //nlinfo("The condition %s is valid",(*itEvent).ConditionName.c_str());
 149                         if( (*itEvent).EventAction.IsStateChange )
 150                         {
 151                                 _LogicStateMachine->setCurrentState( (*itEvent).EventAction.StateChange );
 152                         }
 153                         else
 154                         {
 155                                 // this message will be sent as soon as the dest id will be given
 156                                 (*itEvent).EventAction.enableSendMessage();
 157
 158                                 /// send the event messages that must and can be sent
 159                                 trySendEventMessages();
 160                         }
 161                 }
 162                 else
 163                 {
 164                         // reset message send status here to be able to send messages several times in the logic state
 165                         // --> this has to be done if we want messages to be sent every time the condition becomes verified
 166                 }
 167         }
 168
 169 } // processLogic //
 170
 171
 172 //---------------------------------------------------
 173 // enterState :
 174 //
 175 //---------------------------------------------------
 176 void CLogicState::enterState()
 177 {
 178         /// send the entry messages that can be sent
 179         trySendEntryMessages();
 180
 181 } // enterState //
 182
 183
 184 //---------------------------------------------------
 185 // exitState :
 186 //
 187 //---------------------------------------------------
 188 void CLogicState::exitState()
 189 {
 190         vector<CLogicEventMessage>::iterator itMsg;
 191         for( itMsg = _ExitMessages.begin(); itMsg != _ExitMessages.end(); ++itMsg )
 192         {
 193                 if( (*itMsg).DestinationId != CEntityId() )
 194                 {
 195                         CMessage msgOut( (*itMsg).MessageId );
 196                         msgOut.serial( (*itMsg).Arguments );
 197
 198                         _MessagesToSend.insert( make_pair((*itMsg).DestinationId,msgOut) );
 199                 }
 200         }
 201
 202         // reset the entry messages send status
 203         for( itMsg = _EntryMessages.begin(); itMsg != _EntryMessages.end(); ++itMsg )
 204         {
 205                 (*itMsg).ToSend = false;
 206                 (*itMsg).Sent = false;
 207         }
 208
 209         // reset all events
 210         vector<CLogicEvent>::iterator itEvent;
 211         for( itEvent = _Events.begin(); itEvent != _Events.end(); ++itEvent )
 212         {
 213                 (*itEvent).reset();
 214         }
 215
 216         // reset the exit messages send status
 217         for( itMsg = _ExitMessages.begin(); itMsg != _ExitMessages.end(); ++itMsg )
 218         {
 219                 (*itMsg).ToSend = false;
 220                 (*itMsg).Sent = false;
 221         }
 222
 223 } // exitState //
 224
 225
 226
 227 //---------------------------------------------------
 228 // trySendEntryMessages :
 229 //
 230 //---------------------------------------------------
 231 void CLogicState::trySendEntryMessages()
 232 {
 233         /// send the entry messages that can be sent
 234         vector<CLogicEventMessage>::iterator itMsg;
 235         for( itMsg = _EntryMessages.begin(); itMsg != _EntryMessages.end(); ++itMsg )
 236         {
 237                 if( !(*itMsg).Sent && (*itMsg).DestinationId.getType() != 0xfe )
 238                 {
 239                         CMessage msgOut( (*itMsg).MessageId );
 240                         msgOut.serial( (*itMsg).Arguments );
 241
 242                         _MessagesToSend.insert( make_pair((*itMsg).DestinationId,msgOut) );
 243
 244                         (*itMsg).ToSend = false;
 245                         (*itMsg).Sent = true;
 246                 }
 247         }
 248
 249 } // trySendEntryMessages //
 250
 251
 252
 253 //---------------------------------------------------
 254 // trySendEventMessages :
 255 //
 256 //---------------------------------------------------
 257 void CLogicState::trySendEventMessages()
 258 {
 259         // test all conditions managed by this state
 260         vector<CLogicEvent>::iterator itEvent;
 261         for( itEvent = _Events.begin(); itEvent != _Events.end(); ++itEvent )
 262         {
 263                 if( (*itEvent).EventAction.EventMessage.ToSend == true )
 264                 {
 265                         if( (*itEvent).EventAction.EventMessage.Sent == false )
 266                         {
 267                                 if( (*itEvent).EventAction.EventMessage.DestinationId.getType() != 0xfe )
 268                                 {
 269                                         CMessage msgOut( (*itEvent).EventAction.EventMessage.MessageId );
 270                                         msgOut.serial( (*itEvent).EventAction.EventMessage.Arguments );
 271
 272                                         _MessagesToSend.insert( make_pair((*itEvent).EventAction.EventMessage.DestinationId,msgOut) );
 273
 274                                         (*itEvent).EventAction.EventMessage.ToSend = false;
 275                                         (*itEvent).EventAction.EventMessage.Sent = true;
 276                                 }
 277                         }
 278                 }
 279         }
 280
 281 } // trySendEventMessages //
 282
 283
 284 //---------------------------------------------------
 285 // getMessagesToSend :
 286 //
 287 //---------------------------------------------------
 288 void CLogicState::getMessagesToSend( multimap<CEntityId,CMessage>& msgs )
 289 {
 290         multimap<CEntityId,CMessage>::iterator itMsg;
 291         for( itMsg = _MessagesToSend.begin(); itMsg != _MessagesToSend.end(); ++itMsg )
 292         {
 293                 msgs.insert( *itMsg );
 294         }
 295
 296         // erase all the messages
 297         _MessagesToSend.clear();
 298
 299 } // getMessagesToSend //
 300
 301
 302
 303 //---------------------------------------------------
 304 // fillVarMap :
 305 //
 306 //---------------------------------------------------
 307 void CLogicState::fillVarMap( multimap<CEntityId,string >& stateMachineVariables )
 308 {
 309         // events
 310         vector<CLogicEvent>::iterator itEvt;
 311         for( itEvt = _Events.begin(); itEvt != _Events.end(); ++itEvt )
 312         {
 313                 // get the condition used in the event
 314                 CLogicCondition condition;
 315                 if( _LogicStateMachine->getCondition((*itEvt).ConditionName,condition) )
 316                 {
 317                         // get vars used in the conditions
 318                         set<string> condVars;
 319                         condition.fillVarSet( condVars );
 320
 321                         // add var with related service
 322                         set<string>::iterator itCV;
 323                         for( itCV = condVars.begin(); itCV != condVars.end(); ++itCV )
 324                         {
 325                                 stateMachineVariables.insert( make_pair((*itEvt).EventAction.EventMessage.DestinationId,*itCV) );
 326                         }
 327                 }
 328         }
 329
 330 } // fillVarMap //
 331
 332
 333
 334 //---------------------------------------------------
 335 // serial :
 336 //
 337 //---------------------------------------------------
 338 /*void CLogicState::serial( IStream &f )
 339 {
 340         f.xmlPush( "STATE");
 341
 342         f.serial( _StateName );
 343         f.serialCont( _EntryMessages );
 344         f.serialCont( _ExitMessages );
 345         f.serialCont( _Events );
 346
 347         f.xmlPop();
 348
 349 } // serial //*/
 350
 351 void CLogicState::write (xmlNodePtr node) const
 352 {
 353         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"STATE", NULL);
 354         xmlSetProp (elmPtr, (const xmlChar*)"Name", (const xmlChar*)_StateName.c_str());
 355
 356         uint i;
 357         for (i = 0; i < _EntryMessages.size(); i++)
 358         {
 359                 _EntryMessages[i].write(elmPtr, "ENTRY_");
 360         }
 361         for (i = 0; i < _ExitMessages.size(); i++)
 362         {
 363                 _ExitMessages[i].write(elmPtr, "EXIT_");
 364         }
 365         for (i = 0; i < _Events.size(); i++)
 366         {
 367                 _Events[i].write(elmPtr);
 368         }
 369 }
 370
 371 void CLogicState::read (xmlNodePtr node)
 372 {
 373         xmlCheckNodeName (node, "STATE");
 374
 375         _StateName = getXMLProp (node, "Name");
 376
 377         {
 378                 // Count the parent
 379                 uint nb = CIXml::countChildren (node, "ENTRY_EVENT_MESSAGE");
 380                 uint i = 0;
 381                 xmlNodePtr parent = CIXml::getFirstChildNode (node, "ENTRY_EVENT_MESSAGE");
 382                 while (i<nb)
 383                 {
 384                         CLogicEventMessage v;
 385                         v.read(parent);
 386                         _EntryMessages.push_back(v);
 387
 388                         // Next parent
 389                         parent = CIXml::getNextChildNode (parent, "ENTRY_EVENT_MESSAGE");
 390                         i++;
 391                 }
 392         }
 393
 394         {
 395                 // Count the parent
 396                 uint nb = CIXml::countChildren (node, "EXIT_EVENT_MESSAGE");
 397                 uint i = 0;
 398                 xmlNodePtr parent = CIXml::getFirstChildNode (node, "EXIT_EVENT_MESSAGE");
 399                 while (i<nb)
 400                 {
 401                         CLogicEventMessage v;
 402                         v.read(parent);
 403                         _ExitMessages.push_back(v);
 404
 405                         // Next parent
 406                         parent = CIXml::getNextChildNode (parent, "EXIT_EVENT_MESSAGE");
 407                         i++;
 408                 }
 409         }
 410
 411         {
 412                 // Count the parent
 413                 uint nb = CIXml::countChildren (node, "EVENT");
 414                 uint i = 0;
 415                 xmlNodePtr parent = CIXml::getFirstChildNode (node, "EVENT");
 416                 while (i<nb)
 417                 {
 418                         CLogicEvent v;
 419                         v.read(parent);
 420                         _Events.push_back(v);
 421
 422                         // Next parent
 423                         parent = CIXml::getNextChildNode (parent, "EVENT");
 424                         i++;
 425                 }
 426         }
 427
 428 }
 429
 430
 431 } // NLLOGIC
 432