Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 

NLLOGIC::CLogicCounter Class Reference

#include <logic_variable.h>

Inheritance diagram for NLLOGIC::CLogicCounter:

NLLOGIC::CLogicVariable

Detailed Description

CLogicCounter

Author:
Stephane Coutelas

Nevrax France

Date:
2001

Definition at line 132 of file logic_variable.h.

Public Types

enum  TLogicCounterRule {
  STOP_AT_LIMIT = 0, LOOP, SHUTTLE, DOWN_UP,
  UP_DOWN
}
 counter running mode More...

enum  TLogicCounterRunningMode { STOPPED = 0, RUN, REWIND, FAST_FORWARD }
 counter running state More...


Public Member Functions

void applyModification (std::string op, sint64 value)
 CLogicCounter ()
std::string getName () const
sint64 getValue () const
void manageRunningMode ()
virtual void processLogic ()
virtual void read (xmlNodePtr node)
void setName (std::string name)
void setValue (sint64 value)
void setVerbose (bool b)
void update ()
virtual void write (xmlNodePtr node) const

Data Fields

CLogicVariable Control
 running state

CLogicVariable HighLimit
 higher limit for counter

CLogicVariable LowLimit
 lower limit for counter

CLogicVariable Mode
 running mode

CLogicVariable Period
 period between inc( measured in game ticks )

CLogicVariable Phase
 time offset to apply with period

CLogicVariable Step
 regular increment value( normally 1 or -1 )


Protected Attributes

std::string _Name
 variable name

sint64 _Value
 variable value

bool _Verbose
 true if verbose mode is active


Private Attributes

uint _TickCount

Member Enumeration Documentation

enum NLLOGIC::CLogicCounter::TLogicCounterRule
 

counter running mode

Enumeration values:
STOP_AT_LIMIT 
LOOP 
SHUTTLE 
DOWN_UP 
UP_DOWN 

Definition at line 139 of file logic_variable.h. 

00140         { 
00141                 STOP_AT_LIMIT = 0,
00142                 LOOP,
00143                 SHUTTLE,
00144                 DOWN_UP, // bounce at low end, stop at high end
00145                 UP_DOWN, // bounce at high end, stop at low end
00146         };

enum NLLOGIC::CLogicCounter::TLogicCounterRunningMode
 

counter running state

Enumeration values:
STOPPED 
RUN 
REWIND 
FAST_FORWARD 

Definition at line 149 of file logic_variable.h. 

00150         { 
00151                 STOPPED = 0,
00152                 RUN,
00153                 REWIND,
00154                 FAST_FORWARD, 
00155         };

Constructor & Destructor Documentation

NLLOGIC::CLogicCounter::CLogicCounter (   ) 
 

Default constructor

Definition at line 160 of file logic_variable.cpp.

References _TickCount, Control, HighLimit, LowLimit, Period, RUN, NLLOGIC::CLogicVariable::setName(), NLLOGIC::CLogicVariable::setValue(), and STOP_AT_LIMIT. 

00161 {
00162         _TickCount = 0;
00163         _Value = 0;
00164         _Name = "unamed_counter";
00165 
00166         Period.setValue( 10 );
00167         Period.setName("Period");
00168         
00169         Phase.setValue( 0 );
00170         Phase.setName("Phase");
00171         
00172         Step.setValue( 1 );
00173         Step.setName("Step");
00174         
00175         LowLimit.setValue( 0 );
00176         LowLimit.setName("LowLimit");
00177         
00178         HighLimit.setValue( 100 );
00179         HighLimit.setName("HighLimit");
00180         
00181         Mode.setValue( STOP_AT_LIMIT );
00182         Mode.setName("Mode");
00183         
00184         Control.setValue( RUN );
00185         Control.setName("Control");
00186 
00187 } // CLogicCounter //

Member Function Documentation

void NLLOGIC::CLogicVariable::applyModification (  std::string  op,
sint64  value
)  [inherited]
 

Apply modifications on a variable

Parameters:
op can be one of these operators :"SET"("set"),"ADD"("add"),"SUB"("sub"),"MUL"("mul"),"DIV"("div")
value is the value to use along with the modificator

Definition at line 73 of file logic_variable.cpp.

References NLLOGIC::CLogicVariable::_Verbose, nlinfo, nlwarning, sint64, and value. 

00074 {
00075         if( op == "SET" || op == "set" )
00076         {
00077                 _Value = value;
00078         }
00079         else
00080         if( op == "ADD" || op == "add" )
00081         {
00082                 _Value += value;
00083         }
00084         else
00085         if( op == "SUB" || op == "sub" )
00086         {
00087                 _Value -= value;
00088         }
00089         else
00090         if( op == "MUL" || op == "mul")
00091         {
00092                 _Value *= value;
00093         }
00094         else
00095         if( op == "DIV" || op == "div")
00096         {
00097                 if( value != 0 ) _Value /= value;
00098         }
00099         else
00100         {
00101                 nlwarning("(LGCS)<CLogicVariable::applyModification> The operator \"%s\" is unknown",op.c_str());
00102                 return;
00103         }
00104 
00105         if( _Verbose )
00106         {
00107                 nlinfo("variable \"%s\" value is now %f",_Name.c_str(),(double)_Value);
00108         }
00109 
00110 } // applyModification //

std::string NLLOGIC::CLogicVariable::getName (  void   )  const [inline, inherited]
 

Get the variable name

Returns:
the name of the variable

Definition at line 76 of file logic_variable.h.

Referenced by NLLOGIC::CLogicStateMachine::addCounter(), and NLLOGIC::CLogicStateMachine::addVariable(). 

00076 { return _Name; }

sint64 NLLOGIC::CLogicVariable::getValue (   )  const [inline, inherited]
 

Get the variable value

Returns:
the variable's value

Definition at line 90 of file logic_variable.h.

References sint64.

Referenced by manageRunningMode(), NLLOGIC::CLogicComparisonBlock::testLogic(), update(), and write(). 

00090 { return _Value; }

void NLLOGIC::CLogicCounter::manageRunningMode (   ) 
 

check the counter value according to the running mode

Definition at line 248 of file logic_variable.cpp.

References DOWN_UP, NLLOGIC::CLogicVariable::getValue(), HighLimit, LOOP, LowLimit, NLLOGIC::CLogicVariable::setValue(), SHUTTLE, STOP_AT_LIMIT, and UP_DOWN.

Referenced by update(). 

00249 {
00250         // loop on one value
00251         if( HighLimit.getValue() == LowLimit.getValue() )
00252         {
00253                 _Value = HighLimit.getValue();
00254                 return;
00255         }
00256 
00257         switch( Mode.getValue() )
00258         {
00259                 case STOP_AT_LIMIT :
00260                 {
00261                         if( _Value > HighLimit.getValue() )
00262                         {
00263                                 _Value = HighLimit.getValue();
00264                         }
00265                         if( _Value < LowLimit.getValue() )
00266                         {
00267                                 _Value = LowLimit.getValue();
00268                         }
00269                 }
00270                 break;
00271 
00272                 case LOOP :
00273                 {
00274                         // value is higher than high limit
00275                         if( _Value > HighLimit.getValue() )
00276                         {
00277                                 _Value = LowLimit.getValue() + _Value - HighLimit.getValue() - 1;
00278                         }
00279                         // value is lower than low limit
00280                         else
00281                         {
00282                                 if( _Value < LowLimit.getValue() )
00283                                 {
00284                                         _Value = HighLimit.getValue() - (LowLimit.getValue() -_Value) + 1;
00285                                 }
00286                         }
00287                 }
00288                 break;
00289 
00290                 case SHUTTLE :
00291                 {
00292                         // value is higher than high limit
00293                         if( _Value > HighLimit.getValue() )
00294                         {
00295                                 _Value = HighLimit.getValue() - (_Value - HighLimit.getValue());
00296                                 Step.setValue( -Step.getValue() );
00297                         }
00298                         // value is lower than low limit
00299                         else
00300                         {
00301                                 if( _Value < LowLimit.getValue() )
00302                                 {
00303                                         _Value = LowLimit.getValue() + LowLimit.getValue() - _Value;
00304                                         Step.setValue( -Step.getValue() );
00305                                 }
00306                         }
00307                 }
00308                 break;
00309 
00310                 case DOWN_UP :
00311                 {
00312                         // low limit reached, we go up
00313                         if( _Value < LowLimit.getValue() )
00314                         {
00315                                 _Value = LowLimit.getValue() + LowLimit.getValue() - _Value;
00316                                 Step.setValue( -Step.getValue() );
00317                         }
00318                         else
00319                         {
00320                                 // high limit reached we stop
00321                                 if( _Value > HighLimit.getValue() )
00322                                 {
00323                                         _Value = HighLimit.getValue();
00324                                 }
00325                         }
00326                 }
00327                 break;
00328 
00329                 case UP_DOWN :
00330                 {
00331                         // high limit reached, we go down
00332                         if( _Value > HighLimit.getValue() )
00333                         {
00334                                 _Value = HighLimit.getValue() - (_Value - HighLimit.getValue());
00335                                 Step.setValue( -Step.getValue() );
00336                         }
00337                         else
00338                         {
00339                                 // low limit reached, we stop
00340                                 if( _Value < LowLimit.getValue() )
00341                                 {
00342                                         _Value = LowLimit.getValue();
00343                                 }
00344                         }
00345                 }
00346         }
00347 
00348 } // manageRunningMode //

void NLLOGIC::CLogicVariable::processLogic (   )  [virtual, inherited]
 

update the variable

Definition at line 117 of file logic_variable.cpp. 

00118 {
00119 
00120 
00121 } // processLogic //

void NLLOGIC::CLogicCounter::read (  xmlNodePtr  node  )  [virtual]
 

Reimplemented from NLLOGIC::CLogicVariable.

Definition at line 387 of file logic_variable.cpp.

References Control, NLLOGIC::getXMLProp(), HighLimit, LowLimit, Period, NLLOGIC::CLogicVariable::setValue(), and NLLOGIC::xmlCheckNodeName(). 

00388 {
00389         xmlCheckNodeName (node, "COUNTER");
00390 
00391         _Name = getXMLProp (node, "Name");
00392         _Value = atoiInt64 (getXMLProp (node, "Value").c_str());
00393         _Verbose = atoi(getXMLProp (node, "Verbose").c_str()) == 1;
00394         Period.setValue(atoiInt64(getXMLProp (node, "Period").c_str()));
00395         Phase.setValue(atoiInt64(getXMLProp (node, "Phase").c_str()));
00396         Step.setValue(atoiInt64(getXMLProp (node, "Step").c_str()));
00397         LowLimit.setValue(atoiInt64(getXMLProp (node, "LowLimit").c_str()));
00398         HighLimit.setValue(atoiInt64(getXMLProp (node, "HighLimit").c_str()));
00399         Mode.setValue(atoiInt64(getXMLProp (node, "Mode").c_str()));
00400         Control.setValue(atoiInt64(getXMLProp (node, "Control").c_str()));
00401 }

void NLLOGIC::CLogicVariable::setName (  std::string  name  )  [inline, inherited]
 

Set the variable name

Parameters:
name is the name of the variable

Definition at line 69 of file logic_variable.h.

Referenced by CLogicCounter(). 

00069 { _Name = name; }

void NLLOGIC::CLogicVariable::setValue (  sint64  value  )  [inherited]
 

Set the variable value

Parameters:
value is the new value of the variable

Definition at line 56 of file logic_variable.cpp.

References NLLOGIC::CLogicVariable::_Verbose, nlinfo, sint64, and value.

Referenced by CLogicCounter(), manageRunningMode(), read(), and update(). 

00057 { 
00058         _Value = value;
00059         
00060         if( _Verbose )
00061         {
00062                 nlinfo("variable \"%s\" value is now %f",_Name.c_str(),(double)_Value);
00063         }
00064 
00065 } // setValue //

void NLLOGIC::CLogicVariable::setVerbose (  bool  b  )  [inline, inherited]
 

Set the verbose mode active or inactive

Parameters:
varName is the name of the variable
b is true to activate the verbose mode, false else

Definition at line 98 of file logic_variable.h.

References NLLOGIC::CLogicVariable::_Verbose. 

00098 { _Verbose = b; }

void NLLOGIC::CLogicCounter::update (   ) 
 

update the counter

Definition at line 194 of file logic_variable.cpp.

References _TickCount, Control, FAST_FORWARD, NLLOGIC::CLogicVariable::getValue(), HighLimit, LowLimit, manageRunningMode(), nlinfo, Period, REWIND, RUN, NLLOGIC::CLogicVariable::setValue(), and STOPPED. 

00195 {
00196         if( Control.getValue() == STOPPED )
00197         {
00198                 return;
00199         }
00200 
00201         _TickCount++;
00202         if( _TickCount < Period.getValue() )
00203         {
00204                 return;
00205         }
00206         else
00207         {
00208                 _TickCount = 0;
00209         }
00210 
00211         switch( Control.getValue() )
00212         {
00213                 case RUN :
00214                 {
00215                         _Value += Step.getValue();
00216                         manageRunningMode();
00217                 }
00218                 break;
00219 
00220                 case REWIND :
00221                 {
00222                         _Value = LowLimit.getValue();
00223                         Control.setValue( RUN );
00224                 }
00225                 break;
00226 
00227                 case FAST_FORWARD :
00228                 {
00229                         _Value = HighLimit.getValue();
00230                         Control.setValue( RUN );
00231                 }
00232                 break;
00233                 
00234         }
00235 
00236         if( _Verbose )
00237         {
00238                 nlinfo("variable \"%s\" value is now %f",_Name.c_str(),(double)_Value);
00239         }
00240 
00241 } // update //

void NLLOGIC::CLogicCounter::write (  xmlNodePtr  node  )  const [virtual]
 

serial

Reimplemented from NLLOGIC::CLogicVariable.

Definition at line 372 of file logic_variable.cpp.

References Control, NLLOGIC::CLogicVariable::getValue(), HighLimit, LowLimit, and Period. 

00373 {
00374         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"COUNTER", NULL);
00375         xmlSetProp (elmPtr, (const xmlChar*)"Name", (const xmlChar*)_Name.c_str());
00376         xmlSetProp (elmPtr, (const xmlChar*)"Value", (const xmlChar*)toString(_Value).c_str());
00377         xmlSetProp (elmPtr, (const xmlChar*)"Verbose", (const xmlChar*)toString(_Verbose).c_str());
00378         xmlSetProp (elmPtr, (const xmlChar*)"Period", (const xmlChar*)toString(Period.getValue()).c_str());
00379         xmlSetProp (elmPtr, (const xmlChar*)"Phase", (const xmlChar*)toString(Phase.getValue()).c_str());
00380         xmlSetProp (elmPtr, (const xmlChar*)"Step", (const xmlChar*)toString(Step.getValue()).c_str());
00381         xmlSetProp (elmPtr, (const xmlChar*)"LowLimit", (const xmlChar*)toString(LowLimit.getValue()).c_str());
00382         xmlSetProp (elmPtr, (const xmlChar*)"HighLimit", (const xmlChar*)toString(HighLimit.getValue()).c_str());
00383         xmlSetProp (elmPtr, (const xmlChar*)"Mode", (const xmlChar*)toString(Mode.getValue()).c_str());
00384         xmlSetProp (elmPtr, (const xmlChar*)"Control", (const xmlChar*)toString(Control.getValue()).c_str());
00385 }

Field Documentation

std::string NLLOGIC::CLogicVariable::_Name [protected, inherited]
 

variable name

Definition at line 52 of file logic_variable.h.

uint NLLOGIC::CLogicCounter::_TickCount [private]
 

Definition at line 134 of file logic_variable.h.

Referenced by CLogicCounter(), and update().

sint64 NLLOGIC::CLogicVariable::_Value [protected, inherited]
 

variable value

Definition at line 49 of file logic_variable.h.

bool NLLOGIC::CLogicVariable::_Verbose [protected, inherited]
 

true if verbose mode is active

Definition at line 55 of file logic_variable.h.

Referenced by NLLOGIC::CLogicVariable::applyModification(), NLLOGIC::CLogicVariable::CLogicVariable(), NLLOGIC::CLogicVariable::read(), NLLOGIC::CLogicVariable::setValue(), NLLOGIC::CLogicVariable::setVerbose(), and NLLOGIC::CLogicVariable::write().

CLogicVariable NLLOGIC::CLogicCounter::Control
 

running state

Definition at line 178 of file logic_variable.h.

Referenced by CLogicCounter(), read(), update(), and write().

CLogicVariable NLLOGIC::CLogicCounter::HighLimit
 

higher limit for counter

Definition at line 171 of file logic_variable.h.

Referenced by CLogicCounter(), manageRunningMode(), read(), update(), and write().

CLogicVariable NLLOGIC::CLogicCounter::LowLimit
 

lower limit for counter

Definition at line 168 of file logic_variable.h.

Referenced by CLogicCounter(), manageRunningMode(), read(), update(), and write().

CLogicVariable NLLOGIC::CLogicCounter::Mode
 

running mode

Definition at line 175 of file logic_variable.h.

CLogicVariable NLLOGIC::CLogicCounter::Period
 

period between inc( measured in game ticks )

Definition at line 159 of file logic_variable.h.

Referenced by CLogicCounter(), read(), update(), and write().

CLogicVariable NLLOGIC::CLogicCounter::Phase
 

time offset to apply with period

Definition at line 162 of file logic_variable.h.

CLogicVariable NLLOGIC::CLogicCounter::Step
 

regular increment value( normally 1 or -1 )

Definition at line 165 of file logic_variable.h.

The documentation for this class was generated from the following files:
Generated on Tue Mar 16 12:53:47 2004 for NeL by doxygen 1.3.6