nel/src/logic/logic_variable.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_variable.h"
  20
  21 #include "nel/logic/logic_state_machine.h"
  22
  23 using namespace std;
  24 using namespace NLMISC;
  25
  26
  27 namespace NLLOGIC
  28 {
  29
  30
  31 //---------------------------------------------------
  32 // CLogicVariable :
  33 //
  34 //---------------------------------------------------
  35 CLogicVariable::CLogicVariable()
  36 {
  37         _Value = 0;
  38         _Name = "unamed_var";
  39         _Verbose = false;
  40
  41 } // CLogicVariable //
  42
  43
  44
  45 //---------------------------------------------------
  46 // setValue :
  47 //
  48 //---------------------------------------------------
  49 void CLogicVariable::setValue( sint64 value )
  50 {
  51         _Value = value;
  52
  53         if( _Verbose )
  54         {
  55                 nlinfo("variable \"%s\" value is now %f",_Name.c_str(),(double)_Value);
  56         }
  57
  58 } // setValue //
  59
  60
  61
  62 //---------------------------------------------------
  63 // applyModification :
  64 //
  65 //---------------------------------------------------
  66 void CLogicVariable::applyModification( string op, sint64 value )
  67 {
  68         if( op == "SET" || op == "set" )
  69         {
  70                 _Value = value;
  71         }
  72         else
  73         if( op == "ADD" || op == "add" )
  74         {
  75                 _Value += value;
  76         }
  77         else
  78         if( op == "SUB" || op == "sub" )
  79         {
  80                 _Value -= value;
  81         }
  82         else
  83         if( op == "MUL" || op == "mul")
  84         {
  85                 _Value *= value;
  86         }
  87         else
  88         if( op == "DIV" || op == "div")
  89         {
  90                 if( value != 0 ) _Value /= value;
  91         }
  92         else
  93         {
  94                 nlwarning("(LGCS)<CLogicVariable::applyModification> The operator \"%s\" is unknown",op.c_str());
  95                 return;
  96         }
  97
  98         if( _Verbose )
  99         {
 100                 nlinfo("variable \"%s\" value is now %f",_Name.c_str(),(double)_Value);
 101         }
 102
 103 } // applyModification //
 104
 105
 106 //---------------------------------------------------
 107 // processLogic :
 108 //
 109 //---------------------------------------------------
 110 void CLogicVariable::processLogic()
 111 {
 112
 113
 114 } // processLogic //
 115
 116
 117 //---------------------------------------------------
 118 // serial :
 119 //
 120 //---------------------------------------------------
 121 /*void CLogicVariable::serial( IStream &f )
 122 {
 123         f.xmlPush( "VARIABLE");
 124
 125         f.serial( _Value );
 126         f.serial( _Name );
 127
 128         f.xmlPop();
 129
 130 } // serial //*/
 131
 132 void CLogicVariable::write (xmlNodePtr node) const
 133 {
 134         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"VARIABLE", NULL);
 135         xmlSetProp (elmPtr, (const xmlChar*)"Name", (const xmlChar*)_Name.c_str());
 136         xmlSetProp (elmPtr, (const xmlChar*)"Value", (const xmlChar*)toString(_Value).c_str());
 137         xmlSetProp (elmPtr, (const xmlChar*)"Verbose", (const xmlChar*)toString(_Verbose).c_str());
 138 }
 139
 140 void CLogicVariable::read (xmlNodePtr node)
 141 {
 142         xmlCheckNodeName (node, "VARIABLE");
 143
 144         _Name = getXMLProp (node, "Name");
 145         _Value = atoiInt64 (getXMLProp (node, "Value").c_str());
 146         NLMISC::fromString(getXMLProp(node, "Verbose"), _Verbose);
 147 }
 148
 149 //---------------------------------------------------
 150 // CLogicCounter :
 151 //
 152 //---------------------------------------------------
 153 CLogicCounter::CLogicCounter()
 154 {
 155         _TickCount = 0;
 156         _Value = 0;
 157         _Name = "unamed_counter";
 158
 159         Period.setValue( 10 );
 160         Period.setName("Period");
 161
 162         Phase.setValue( 0 );
 163         Phase.setName("Phase");
 164
 165         Step.setValue( 1 );
 166         Step.setName("Step");
 167
 168         LowLimit.setValue( 0 );
 169         LowLimit.setName("LowLimit");
 170
 171         HighLimit.setValue( 100 );
 172         HighLimit.setName("HighLimit");
 173
 174         Mode.setValue( STOP_AT_LIMIT );
 175         Mode.setName("Mode");
 176
 177         Control.setValue( RUN );
 178         Control.setName("Control");
 179
 180 } // CLogicCounter //
 181
 182
 183 //---------------------------------------------------
 184 // update :
 185 //
 186 //---------------------------------------------------
 187 void CLogicCounter::update()
 188 {
 189         if( Control.getValue() == STOPPED )
 190         {
 191                 return;
 192         }
 193
 194         _TickCount++;
 195         if( _TickCount < Period.getValue() )
 196         {
 197                 return;
 198         }
 199         else
 200         {
 201                 _TickCount = 0;
 202         }
 203
 204         switch( Control.getValue() )
 205         {
 206                 case RUN :
 207                 {
 208                         _Value += Step.getValue();
 209                         manageRunningMode();
 210                 }
 211                 break;
 212
 213                 case REWIND :
 214                 {
 215                         _Value = LowLimit.getValue();
 216                         Control.setValue( RUN );
 217                 }
 218                 break;
 219
 220                 case FAST_FORWARD :
 221                 {
 222                         _Value = HighLimit.getValue();
 223                         Control.setValue( RUN );
 224                 }
 225                 break;
 226
 227         }
 228
 229         if( _Verbose )
 230         {
 231                 nlinfo("variable \"%s\" value is now %f",_Name.c_str(),(double)_Value);
 232         }
 233
 234 } // update //
 235
 236
 237 //---------------------------------------------------
 238 // manageRunningMode :
 239 //
 240 //---------------------------------------------------
 241 void CLogicCounter::manageRunningMode()
 242 {
 243         // loop on one value
 244         if( HighLimit.getValue() == LowLimit.getValue() )
 245         {
 246                 _Value = HighLimit.getValue();
 247                 return;
 248         }
 249
 250         switch( Mode.getValue() )
 251         {
 252                 case STOP_AT_LIMIT :
 253                 {
 254                         if( _Value > HighLimit.getValue() )
 255                         {
 256                                 _Value = HighLimit.getValue();
 257                         }
 258                         if( _Value < LowLimit.getValue() )
 259                         {
 260                                 _Value = LowLimit.getValue();
 261                         }
 262                 }
 263                 break;
 264
 265                 case LOOP :
 266                 {
 267                         // value is higher than high limit
 268                         if( _Value > HighLimit.getValue() )
 269                         {
 270                                 _Value = LowLimit.getValue() + _Value - HighLimit.getValue() - 1;
 271                         }
 272                         // value is lower than low limit
 273                         else
 274                         {
 275                                 if( _Value < LowLimit.getValue() )
 276                                 {
 277                                         _Value = HighLimit.getValue() - (LowLimit.getValue() -_Value) + 1;
 278                                 }
 279                         }
 280                 }
 281                 break;
 282
 283                 case SHUTTLE :
 284                 {
 285                         // value is higher than high limit
 286                         if( _Value > HighLimit.getValue() )
 287                         {
 288                                 _Value = HighLimit.getValue() - (_Value - HighLimit.getValue());
 289                                 Step.setValue( -Step.getValue() );
 290                         }
 291                         // value is lower than low limit
 292                         else
 293                         {
 294                                 if( _Value < LowLimit.getValue() )
 295                                 {
 296                                         _Value = LowLimit.getValue() + LowLimit.getValue() - _Value;
 297                                         Step.setValue( -Step.getValue() );
 298                                 }
 299                         }
 300                 }
 301                 break;
 302
 303                 case DOWN_UP :
 304                 {
 305                         // low limit reached, we go up
 306                         if( _Value < LowLimit.getValue() )
 307                         {
 308                                 _Value = LowLimit.getValue() + LowLimit.getValue() - _Value;
 309                                 Step.setValue( -Step.getValue() );
 310                         }
 311                         else
 312                         {
 313                                 // high limit reached we stop
 314                                 if( _Value > HighLimit.getValue() )
 315                                 {
 316                                         _Value = HighLimit.getValue();
 317                                 }
 318                         }
 319                 }
 320                 break;
 321
 322                 case UP_DOWN :
 323                 {
 324                         // high limit reached, we go down
 325                         if( _Value > HighLimit.getValue() )
 326                         {
 327                                 _Value = HighLimit.getValue() - (_Value - HighLimit.getValue());
 328                                 Step.setValue( -Step.getValue() );
 329                         }
 330                         else
 331                         {
 332                                 // low limit reached, we stop
 333                                 if( _Value < LowLimit.getValue() )
 334                                 {
 335                                         _Value = LowLimit.getValue();
 336                                 }
 337                         }
 338                 }
 339         }
 340
 341 } // manageRunningMode //
 342
 343
 344 //---------------------------------------------------
 345 // serial :
 346 //
 347 //---------------------------------------------------
 348 /*void CLogicCounter::serial( IStream &f )
 349 {
 350         f.xmlPush( "COUNTER");
 351
 352         f.serial( _Value );
 353         f.serial( _Name );
 354         f.serial( Period );
 355         f.serial( Phase );
 356         f.serial( Step );
 357         f.serial( LowLimit );
 358         f.serial( HighLimit );
 359         f.serial( Mode );
 360
 361         f.xmlPop();
 362
 363 } // serial //*/
 364
 365 void CLogicCounter::write (xmlNodePtr node) const
 366 {
 367         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"COUNTER", NULL);
 368         xmlSetProp (elmPtr, (const xmlChar*)"Name", (const xmlChar*)_Name.c_str());
 369         xmlSetProp (elmPtr, (const xmlChar*)"Value", (const xmlChar*)toString(_Value).c_str());
 370         xmlSetProp (elmPtr, (const xmlChar*)"Verbose", (const xmlChar*)toString(_Verbose).c_str());
 371         xmlSetProp (elmPtr, (const xmlChar*)"Period", (const xmlChar*)toString(Period.getValue()).c_str());
 372         xmlSetProp (elmPtr, (const xmlChar*)"Phase", (const xmlChar*)toString(Phase.getValue()).c_str());
 373         xmlSetProp (elmPtr, (const xmlChar*)"Step", (const xmlChar*)toString(Step.getValue()).c_str());
 374         xmlSetProp (elmPtr, (const xmlChar*)"LowLimit", (const xmlChar*)toString(LowLimit.getValue()).c_str());
 375         xmlSetProp (elmPtr, (const xmlChar*)"HighLimit", (const xmlChar*)toString(HighLimit.getValue()).c_str());
 376         xmlSetProp (elmPtr, (const xmlChar*)"Mode", (const xmlChar*)toString(Mode.getValue()).c_str());
 377         xmlSetProp (elmPtr, (const xmlChar*)"Control", (const xmlChar*)toString(Control.getValue()).c_str());
 378 }
 379
 380 void CLogicCounter::read (xmlNodePtr node)
 381 {
 382         xmlCheckNodeName (node, "COUNTER");
 383
 384         _Name = getXMLProp (node, "Name");
 385         _Value = atoiInt64 (getXMLProp (node, "Value").c_str());
 386         NLMISC::fromString(getXMLProp (node, "Verbose"), _Verbose);
 387         Period.setValue(atoiInt64(getXMLProp (node, "Period").c_str()));
 388         Phase.setValue(atoiInt64(getXMLProp (node, "Phase").c_str()));
 389         Step.setValue(atoiInt64(getXMLProp (node, "Step").c_str()));
 390         LowLimit.setValue(atoiInt64(getXMLProp (node, "LowLimit").c_str()));
 391         HighLimit.setValue(atoiInt64(getXMLProp (node, "HighLimit").c_str()));
 392         Mode.setValue(atoiInt64(getXMLProp (node, "Mode").c_str()));
 393         Control.setValue(atoiInt64(getXMLProp (node, "Control").c_str()));
 394 }
 395
 396
 397 }