|
@@ -11,3035 +11,3035 @@
|
|
|
#define getReturn zMemory->getVariable( "__return__" )
|
|
|
|
|
|
|
|
|
-Aktion::Aktion( AktionTyp typ, RCArray< Aktion > *subActions )
|
|
|
- : Variable( AKTION )
|
|
|
+Aktion::Aktion(AktionTyp typ, RCArray< Aktion >* subActions)
|
|
|
+ : Variable(AKTION)
|
|
|
{
|
|
|
- this->subActions = subActions;
|
|
|
- for( int i = 0; i < subActions->getEintragAnzahl(); i++ )
|
|
|
- erlaubteTypen.add( ALLE );
|
|
|
- this->typ = typ;
|
|
|
+ this->subActions = subActions;
|
|
|
+ for (int i = 0; i < subActions->getEintragAnzahl(); i++)
|
|
|
+ erlaubteTypen.add(ALLE);
|
|
|
+ this->typ = typ;
|
|
|
}
|
|
|
|
|
|
Aktion::~Aktion()
|
|
|
{
|
|
|
- subActions->release();
|
|
|
-}
|
|
|
-
|
|
|
-Variable *Aktion::zEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC )
|
|
|
-{
|
|
|
- return zMemory->zVariable( zPC->getUniqueString() + "R" + number + "__" );
|
|
|
-}
|
|
|
-
|
|
|
-Variable *Aktion::getEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC )
|
|
|
-{
|
|
|
- return zMemory->getVariable( zPC->getUniqueString() + "R" + number + "__" );
|
|
|
-}
|
|
|
-
|
|
|
-bool Aktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
-{
|
|
|
- if( waitCount > 0 )
|
|
|
- return 0;
|
|
|
- zPC->stepIn();
|
|
|
- // evaluate parameters
|
|
|
- for( int i = zPC->currentPosition(); i < subActions->getEintragAnzahl(); i++ )
|
|
|
- {
|
|
|
- if( !subActions->z( i )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 0;
|
|
|
- }
|
|
|
- Variable *result = zReturn;
|
|
|
- if( ( !result && erlaubteTypen.get( i ) != NICHTS ) || ( result && result->getVariableTyp() != erlaubteTypen.get( i ) ) )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 1;
|
|
|
- }
|
|
|
- if( result )
|
|
|
- zMemory->setVar( zPC->getUniqueString() + "R" + i + "__", dynamic_cast<Variable *>( result->getThis() ) );
|
|
|
- zPC->count();
|
|
|
- if( waitCount > 0 )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- if( zPC->currentPosition() == subActions->getEintragAnzahl() )
|
|
|
- {
|
|
|
- // evaluate result
|
|
|
- run( zSpiel, zEreignis, zMemory, zPC, waitCount );
|
|
|
- zPC->stepOut();
|
|
|
- return 1;
|
|
|
- }
|
|
|
- zPC->stepOut();
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-void Aktion::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+ subActions->release();
|
|
|
+}
|
|
|
+
|
|
|
+Variable* Aktion::zEvaluatedParam(int number, LocalMemory* zMemory, ProgramCounter* zPC)
|
|
|
+{
|
|
|
+ return zMemory->zVariable(zPC->getUniqueString() + "R" + number + "__");
|
|
|
+}
|
|
|
+
|
|
|
+Variable* Aktion::getEvaluatedParam(int number, LocalMemory* zMemory, ProgramCounter* zPC)
|
|
|
+{
|
|
|
+ return zMemory->getVariable(zPC->getUniqueString() + "R" + number + "__");
|
|
|
+}
|
|
|
+
|
|
|
+bool Aktion::runNext(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
+{
|
|
|
+ if (waitCount > 0)
|
|
|
+ return 0;
|
|
|
+ zPC->stepIn();
|
|
|
+ // evaluate parameters
|
|
|
+ for (int i = zPC->currentPosition(); i < subActions->getEintragAnzahl(); i++)
|
|
|
+ {
|
|
|
+ if (!subActions->z(i)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ Variable* result = zReturn;
|
|
|
+ if ((!result && erlaubteTypen.get(i) != NICHTS) || (result && result->getVariableTyp() != erlaubteTypen.get(i)))
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ if (result)
|
|
|
+ zMemory->setVar(zPC->getUniqueString() + "R" + i + "__", dynamic_cast<Variable*>(result->getThis()));
|
|
|
+ zPC->count();
|
|
|
+ if (waitCount > 0)
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (zPC->currentPosition() == subActions->getEintragAnzahl())
|
|
|
+ {
|
|
|
+ // evaluate result
|
|
|
+ run(zSpiel, zEreignis, zMemory, zPC, waitCount);
|
|
|
+ zPC->stepOut();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ zPC->stepOut();
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Aktion::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{}
|
|
|
|
|
|
-void Aktion::writeOptions( Datei &dat )
|
|
|
+void Aktion::writeOptions(Datei& dat)
|
|
|
{}
|
|
|
|
|
|
AktionTyp Aktion::getTyp() const
|
|
|
{
|
|
|
- return typ;
|
|
|
+ return typ;
|
|
|
}
|
|
|
|
|
|
-RCArray< Aktion > *Aktion::zSubActions() const
|
|
|
+RCArray< Aktion >* Aktion::zSubActions() const
|
|
|
{
|
|
|
- return subActions;
|
|
|
+ return subActions;
|
|
|
}
|
|
|
|
|
|
|
|
|
KonstantNichts::KonstantNichts()
|
|
|
- : Aktion( KONSTANT_NICHTS, new RCArray< Aktion >() )
|
|
|
+ : Aktion(KONSTANT_NICHTS, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void KonstantNichts::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void KonstantNichts::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Variable( NICHTS ) );
|
|
|
+ setReturn(new Variable(NICHTS));
|
|
|
}
|
|
|
|
|
|
|
|
|
-KonstantInteger::KonstantInteger( int val )
|
|
|
- : Aktion( KONSTANT_INTEGER, new RCArray< Aktion >() )
|
|
|
+KonstantInteger::KonstantInteger(int val)
|
|
|
+ : Aktion(KONSTANT_INTEGER, new RCArray< Aktion >())
|
|
|
{
|
|
|
- this->value = val;
|
|
|
+ this->value = val;
|
|
|
}
|
|
|
|
|
|
-void KonstantInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void KonstantInteger::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( value ) );
|
|
|
+ setReturn(new Integer(value));
|
|
|
}
|
|
|
|
|
|
-void KonstantInteger::writeOptions( Datei &dat )
|
|
|
+void KonstantInteger::writeOptions(Datei& dat)
|
|
|
{
|
|
|
- dat.schreibe( (char *)&value, 4 );
|
|
|
+ dat.schreibe((char*)&value, 4);
|
|
|
}
|
|
|
|
|
|
|
|
|
-KonstantGegenstandTyp::KonstantGegenstandTyp( GegenstandTyp val )
|
|
|
- : Aktion( KONSTANT_INTEGER, new RCArray< Aktion >() )
|
|
|
+KonstantGegenstandTyp::KonstantGegenstandTyp(GegenstandTyp val)
|
|
|
+ : Aktion(KONSTANT_INTEGER, new RCArray< Aktion >())
|
|
|
{
|
|
|
- this->value = val;
|
|
|
+ this->value = val;
|
|
|
}
|
|
|
|
|
|
-void KonstantGegenstandTyp::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void KonstantGegenstandTyp::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new GegenstandTypVar( value ) );
|
|
|
+ setReturn(new GegenstandTypVar(value));
|
|
|
}
|
|
|
|
|
|
-void KonstantGegenstandTyp::writeOptions( Datei &dat )
|
|
|
+void KonstantGegenstandTyp::writeOptions(Datei& dat)
|
|
|
{
|
|
|
- dat.schreibe( (char *)&value, 4 );
|
|
|
+ dat.schreibe((char*)&value, 4);
|
|
|
}
|
|
|
|
|
|
|
|
|
-KonstantTaste::KonstantTaste( unsigned char val )
|
|
|
- : Aktion( KONSTANT_TASTE, new RCArray< Aktion >() )
|
|
|
+KonstantTaste::KonstantTaste(unsigned char val)
|
|
|
+ : Aktion(KONSTANT_TASTE, new RCArray< Aktion >())
|
|
|
{
|
|
|
- this->value = val;
|
|
|
+ this->value = val;
|
|
|
}
|
|
|
|
|
|
-void KonstantTaste::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void KonstantTaste::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( (int)value, 1 ) );
|
|
|
+ setReturn(new Integer((int)value, 1));
|
|
|
}
|
|
|
|
|
|
-void KonstantTaste::writeOptions( Datei &dat )
|
|
|
+void KonstantTaste::writeOptions(Datei& dat)
|
|
|
{
|
|
|
- dat.schreibe( (char *)&value, 1 );
|
|
|
+ dat.schreibe((char*)&value, 1);
|
|
|
}
|
|
|
|
|
|
|
|
|
-KonstantBoolean::KonstantBoolean( bool val )
|
|
|
- : Aktion( KONSTANT_BOOLEAN, new RCArray< Aktion >() )
|
|
|
+KonstantBoolean::KonstantBoolean(bool val)
|
|
|
+ : Aktion(KONSTANT_BOOLEAN, new RCArray< Aktion >())
|
|
|
{
|
|
|
- value = val;
|
|
|
+ value = val;
|
|
|
}
|
|
|
|
|
|
-void KonstantBoolean::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void KonstantBoolean::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( value ) );
|
|
|
+ setReturn(new Boolean(value));
|
|
|
}
|
|
|
|
|
|
-void KonstantBoolean::writeOptions( Datei &dat )
|
|
|
+void KonstantBoolean::writeOptions(Datei& dat)
|
|
|
{
|
|
|
- dat.schreibe( (char *)&value, 1 );
|
|
|
+ dat.schreibe((char*)&value, 1);
|
|
|
}
|
|
|
|
|
|
|
|
|
-KonstantString::KonstantString( Text val )
|
|
|
- : Aktion( KONSTANT_STRING, new RCArray< Aktion >() )
|
|
|
+KonstantString::KonstantString(Text val)
|
|
|
+ : Aktion(KONSTANT_STRING, new RCArray< Aktion >())
|
|
|
{
|
|
|
- value = val;
|
|
|
+ value = val;
|
|
|
}
|
|
|
|
|
|
-void KonstantString::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void KonstantString::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( value ) );
|
|
|
+ setReturn(new String(value));
|
|
|
}
|
|
|
|
|
|
-void KonstantString::writeOptions( Datei &dat )
|
|
|
+void KonstantString::writeOptions(Datei& dat)
|
|
|
{
|
|
|
- char len = (char)value.getLength();
|
|
|
- dat.schreibe( (char *)&len, 1 );
|
|
|
- dat.schreibe( value, len );
|
|
|
+ char len = (char)value.getLength();
|
|
|
+ dat.schreibe((char*)&len, 1);
|
|
|
+ dat.schreibe(value, len);
|
|
|
}
|
|
|
|
|
|
|
|
|
-KonstantFloat::KonstantFloat( float val )
|
|
|
- : Aktion( KONSTANT_FLOAT, new RCArray< Aktion >() )
|
|
|
+KonstantFloat::KonstantFloat(float val)
|
|
|
+ : Aktion(KONSTANT_FLOAT, new RCArray< Aktion >())
|
|
|
{
|
|
|
- value = val;
|
|
|
+ value = val;
|
|
|
}
|
|
|
|
|
|
-void KonstantFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void KonstantFloat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( value ) );
|
|
|
+ setReturn(new Float(value));
|
|
|
}
|
|
|
|
|
|
-void KonstantFloat::writeOptions( Datei &dat )
|
|
|
+void KonstantFloat::writeOptions(Datei& dat)
|
|
|
{
|
|
|
- dat.schreibe( (char *)&value, 4 );
|
|
|
+ dat.schreibe((char*)&value, 4);
|
|
|
}
|
|
|
|
|
|
|
|
|
-KonstantVariable::KonstantVariable( Text name )
|
|
|
- : Aktion( KONSTANT_VARIABLE, new RCArray< Aktion >() )
|
|
|
+KonstantVariable::KonstantVariable(Text name)
|
|
|
+ : Aktion(KONSTANT_VARIABLE, new RCArray< Aktion >())
|
|
|
{
|
|
|
- this->name = name;
|
|
|
+ this->name = name;
|
|
|
}
|
|
|
|
|
|
-void KonstantVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void KonstantVariable::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- if( zMemory->zVariable( name ) )
|
|
|
- setReturn( zMemory->getVariable( name ) );
|
|
|
- else if( zEreignis->zParameter( name ) )
|
|
|
- setReturn( zEreignis->getParameter( name ) );
|
|
|
- else if( zSpiel->zVariable( name ) )
|
|
|
- setReturn( zSpiel->getVariable( name ) );
|
|
|
- else
|
|
|
- setReturn( new Variable( NICHTS ) );
|
|
|
+ if (zMemory->zVariable(name))
|
|
|
+ setReturn(zMemory->getVariable(name));
|
|
|
+ else if (zEreignis->zParameter(name))
|
|
|
+ setReturn(zEreignis->getParameter(name));
|
|
|
+ else if (zSpiel->zVariable(name))
|
|
|
+ setReturn(zSpiel->getVariable(name));
|
|
|
+ else
|
|
|
+ setReturn(new Variable(NICHTS));
|
|
|
}
|
|
|
|
|
|
-void KonstantVariable::writeOptions( Datei &dat )
|
|
|
+void KonstantVariable::writeOptions(Datei& dat)
|
|
|
{
|
|
|
- char len = (char)name.getLength();
|
|
|
- dat.schreibe( (char *)&len, 1 );
|
|
|
- dat.schreibe( name, len );
|
|
|
+ char len = (char)name.getLength();
|
|
|
+ dat.schreibe((char*)&len, 1);
|
|
|
+ dat.schreibe(name, len);
|
|
|
}
|
|
|
|
|
|
|
|
|
-Warten::Warten( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( WARTEN, subActions )
|
|
|
+Warten::Warten(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(WARTEN, subActions)
|
|
|
{
|
|
|
- this->erlaubteTypen.add( FLOAT );
|
|
|
+ this->erlaubteTypen.add(FLOAT);
|
|
|
}
|
|
|
|
|
|
-void Warten::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void Warten::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- waitCount += ( (Float *)zParam( 0 ) )->getValue();
|
|
|
+ waitCount += ((Float*)zParam(0))->getValue();
|
|
|
}
|
|
|
|
|
|
|
|
|
-WennDannSonst::WennDannSonst( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( WENN_DANN_SONST, subActions )
|
|
|
+WennDannSonst::WennDannSonst(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(WENN_DANN_SONST, subActions)
|
|
|
{}
|
|
|
|
|
|
-bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
-{
|
|
|
- zPC->stepIn();
|
|
|
- if( zPC->currentPosition() == 0 )
|
|
|
- {
|
|
|
- bool finished = subActions->z( 0 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
|
|
|
- if( finished )
|
|
|
- {
|
|
|
- Variable *ret = zReturn;
|
|
|
- zPC->count();
|
|
|
- if( !isTrue( ret ) )
|
|
|
- {
|
|
|
- zPC->count();
|
|
|
- if( !subActions->z( 2 ) )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 1;
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- if( !subActions->z( 1 ) )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 1;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if( zPC->currentPosition() == 1 && waitCount <= 0 )
|
|
|
- {
|
|
|
- bool finished = subActions->z( 1 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
|
|
|
- if( finished )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 1;
|
|
|
- }
|
|
|
- }
|
|
|
- if( zPC->currentPosition() == 2 && waitCount <= 0 )
|
|
|
- {
|
|
|
- bool finished = subActions->z( 2 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
|
|
|
- if( finished )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 1;
|
|
|
- }
|
|
|
- }
|
|
|
- zPC->stepOut();
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-SetVariable::SetVariable( Text name, RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SET_VARIABLE, subActions )
|
|
|
-{
|
|
|
- this->name = name;
|
|
|
-}
|
|
|
-
|
|
|
-void SetVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
-{
|
|
|
- if( zMemory->zVariable( name ) || zEreignis->zParameter( name ) || !zSpiel->zVariable( name ) )
|
|
|
- zMemory->setVar( name, getParam( 0 ) );
|
|
|
- else
|
|
|
- zSpiel->setVariable( name, getParam( 0 ) );
|
|
|
-}
|
|
|
-
|
|
|
-void SetVariable::writeOptions( Datei &dat )
|
|
|
-{
|
|
|
- char len = (char)name.getLength();
|
|
|
- dat.schreibe( (char *)&len, 1 );
|
|
|
- dat.schreibe( name, len );
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-TriggerAktion::TriggerAktion( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TRIGGER_AKTION, subActions )
|
|
|
+bool WennDannSonst::runNext(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
+{
|
|
|
+ zPC->stepIn();
|
|
|
+ if (zPC->currentPosition() == 0)
|
|
|
+ {
|
|
|
+ bool finished = subActions->z(0)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
|
|
|
+ if (finished)
|
|
|
+ {
|
|
|
+ Variable* ret = zReturn;
|
|
|
+ zPC->count();
|
|
|
+ if (!isTrue(ret))
|
|
|
+ {
|
|
|
+ zPC->count();
|
|
|
+ if (!subActions->z(2))
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (!subActions->z(1))
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (zPC->currentPosition() == 1 && waitCount <= 0)
|
|
|
+ {
|
|
|
+ bool finished = subActions->z(1)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
|
|
|
+ if (finished)
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (zPC->currentPosition() == 2 && waitCount <= 0)
|
|
|
+ {
|
|
|
+ bool finished = subActions->z(2)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
|
|
|
+ if (finished)
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ zPC->stepOut();
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+SetVariable::SetVariable(Text name, RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SET_VARIABLE, subActions)
|
|
|
+{
|
|
|
+ this->name = name;
|
|
|
+}
|
|
|
+
|
|
|
+void SetVariable::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
+{
|
|
|
+ if (zMemory->zVariable(name) || zEreignis->zParameter(name) || !zSpiel->zVariable(name))
|
|
|
+ zMemory->setVar(name, getParam(0));
|
|
|
+ else
|
|
|
+ zSpiel->setVariable(name, getParam(0));
|
|
|
+}
|
|
|
+
|
|
|
+void SetVariable::writeOptions(Datei& dat)
|
|
|
+{
|
|
|
+ char len = (char)name.getLength();
|
|
|
+ dat.schreibe((char*)&len, 1);
|
|
|
+ dat.schreibe(name, len);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+TriggerAktion::TriggerAktion(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TRIGGER_AKTION, subActions)
|
|
|
{}
|
|
|
|
|
|
-bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+bool TriggerAktion::runNext(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- zPC->stepIn();
|
|
|
- if( zPC->currentPosition() == 0 )
|
|
|
- {
|
|
|
- if( subActions->z( 0 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
|
|
|
- {
|
|
|
- Variable *t = zReturn;
|
|
|
- if( !t || t->getVariableTyp() != INTEGER )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 1;
|
|
|
- }
|
|
|
- zMemory->setVar( zPC->getUniqueString() + "R0__", dynamic_cast<Variable *>( t->getThis() ) );
|
|
|
- zPC->count();
|
|
|
- }
|
|
|
- }
|
|
|
- if( zPC->currentPosition() == 1 && waitCount <= 0 )
|
|
|
- {
|
|
|
- if( subActions->z( 1 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
|
|
|
- {
|
|
|
- Variable *t = zReturn;
|
|
|
- if( !t || t->getVariableTyp() != TRIGGER )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 1;
|
|
|
- }
|
|
|
- int id = ( (Integer *)zParam( 0 ) )->getValue();
|
|
|
- if( id >= ( (Trigger *)t )->getAktionAnzahl() )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 1;
|
|
|
- }
|
|
|
- zMemory->setVar( zPC->getUniqueString() + "R0__", ( (Trigger *)t )->getAktion( id ) );
|
|
|
- zPC->count();
|
|
|
- }
|
|
|
- }
|
|
|
- if( zPC->currentPosition() == 2 && waitCount <= 0 )
|
|
|
- {
|
|
|
- if( ( (Aktion *)zParam( 0 ) )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
|
|
|
- {
|
|
|
- zPC->stepOut();
|
|
|
- return 1;
|
|
|
- }
|
|
|
- }
|
|
|
- zPC->stepOut();
|
|
|
- return 0;
|
|
|
+ zPC->stepIn();
|
|
|
+ if (zPC->currentPosition() == 0)
|
|
|
+ {
|
|
|
+ if (subActions->z(0)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
|
|
|
+ {
|
|
|
+ Variable* t = zReturn;
|
|
|
+ if (!t || t->getVariableTyp() != INTEGER)
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ zMemory->setVar(zPC->getUniqueString() + "R0__", dynamic_cast<Variable*>(t->getThis()));
|
|
|
+ zPC->count();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (zPC->currentPosition() == 1 && waitCount <= 0)
|
|
|
+ {
|
|
|
+ if (subActions->z(1)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
|
|
|
+ {
|
|
|
+ Variable* t = zReturn;
|
|
|
+ if (!t || t->getVariableTyp() != TRIGGER)
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ int id = ((Integer*)zParam(0))->getValue();
|
|
|
+ if (id >= ((Trigger*)t)->getAktionAnzahl())
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ zMemory->setVar(zPC->getUniqueString() + "R0__", ((Trigger*)t)->getAktion(id));
|
|
|
+ zPC->count();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (zPC->currentPosition() == 2 && waitCount <= 0)
|
|
|
+ {
|
|
|
+ if (((Aktion*)zParam(0))->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
|
|
|
+ {
|
|
|
+ zPC->stepOut();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ zPC->stepOut();
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerNachricht::SpielerNachricht( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_NACHRICHT, subActions )
|
|
|
+SpielerNachricht::SpielerNachricht(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_NACHRICHT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
}
|
|
|
|
|
|
-void SpielerNachricht::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerNachricht::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- // this is handeld on client side directly (no need to send the message to the player)
|
|
|
+ // this is handeld on client side directly (no need to send the message to the player)
|
|
|
}
|
|
|
|
|
|
|
|
|
-DisplayText::DisplayText( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( DISPLAY_TEXT, subActions )
|
|
|
+DisplayText::DisplayText(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(DISPLAY_TEXT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
}
|
|
|
|
|
|
-void DisplayText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void DisplayText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- // do nothing because the server does not need to show text
|
|
|
+ // do nothing because the server does not need to show text
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielPause::SpielPause( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIEL_PAUSE, subActions )
|
|
|
+SpielPause::SpielPause(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIEL_PAUSE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BOOLEAN );
|
|
|
+ erlaubteTypen.add(BOOLEAN);
|
|
|
}
|
|
|
|
|
|
-void SpielPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielPause::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- zSpiel->setPausiert( ( (Boolean *)zParam( 0 ) )->getValue() );
|
|
|
+ zSpiel->setPausiert(((Boolean*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielEnde::SpielEnde( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIEL_ENDE, subActions )
|
|
|
+SpielEnde::SpielEnde(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIEL_ENDE, subActions)
|
|
|
{}
|
|
|
|
|
|
-void SpielEnde::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielEnde::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- Variable *t = zParam( 0 );
|
|
|
- if( t->getVariableTyp() != NICHTS && t->getVariableTyp() != TEAM )
|
|
|
- t = 0;
|
|
|
- zSpiel->setEnde( ( !t || t->getVariableTyp() == NICHTS ) ? 0 : (Team *)t );
|
|
|
+ Variable* t = zParam(0);
|
|
|
+ if (t->getVariableTyp() != NICHTS && t->getVariableTyp() != TEAM)
|
|
|
+ t = 0;
|
|
|
+ zSpiel->setEnde((!t || t->getVariableTyp() == NICHTS) ? 0 : (Team*)t);
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetLevel::SpielerSetLevel( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_LEVEL, subActions )
|
|
|
+SpielerSetLevel::SpielerSetLevel(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_LEVEL, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetLevel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setLevel( ( (Integer *)zParam( 0 ) )->getValue(), zSpiel );
|
|
|
+ ((Spieler*)zParam(1))->setLevel(((Integer*)zParam(0))->getValue(), zSpiel);
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerGiveItem::SpielerGiveItem( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_GIVE_ITEM, subActions )
|
|
|
+SpielerGiveItem::SpielerGiveItem(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_GIVE_ITEM, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GEGENSTAND_TYP );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(GEGENSTAND_TYP);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerGiveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerGiveItem::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 2 ) )->addItem( ( (GegenstandTypVar *)zParam( 0 ) )->getValue(),
|
|
|
- ( (Integer *)zParam( 1 ) )->getValue(), zSpiel );
|
|
|
+ ((Spieler*)zParam(2))->addItem(((GegenstandTypVar*)zParam(0))->getValue(),
|
|
|
+ ((Integer*)zParam(1))->getValue(), zSpiel);
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerRemoveItem::SpielerRemoveItem( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_REMOVE_ITEM, subActions )
|
|
|
+SpielerRemoveItem::SpielerRemoveItem(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_REMOVE_ITEM, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GEGENSTAND_TYP );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(GEGENSTAND_TYP);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerRemoveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerRemoveItem::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 2 ) )->removeItem( ( (GegenstandTypVar *)zParam( 0 ) )->getValue(),
|
|
|
- ( (Integer *)zParam( 1 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(2))->removeItem(((GegenstandTypVar*)zParam(0))->getValue(),
|
|
|
+ ((Integer*)zParam(1))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetLeben::SpielerSetLeben( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_LEBEN, subActions )
|
|
|
+SpielerSetLeben::SpielerSetLeben(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_LEBEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setLeben( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(1))->setLeben(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetMaxLeben::SpielerSetMaxLeben( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_LEBEN, subActions )
|
|
|
+SpielerSetMaxLeben::SpielerSetMaxLeben(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_LEBEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetMaxLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setMaxLeben( ( (Integer *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(1))->setMaxLeben(((Integer*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetErfahrung::SpielerSetErfahrung( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_ERFAHRUNG, subActions )
|
|
|
+SpielerSetErfahrung::SpielerSetErfahrung(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_ERFAHRUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setErfahrung( ( (Float *)zParam( 0 ) )->getValue(), zSpiel );
|
|
|
+ ((Spieler*)zParam(1))->setErfahrung(((Float*)zParam(0))->getValue(), zSpiel);
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetMaxErfahrung::SpielerSetMaxErfahrung( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_MAX_ERFAHRUNG, subActions )
|
|
|
+SpielerSetMaxErfahrung::SpielerSetMaxErfahrung(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_MAX_ERFAHRUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetMaxErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setMaxErfahrung( ( (Integer *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(1))->setMaxErfahrung(((Integer*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetTempo::SpielerSetTempo( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_TEMPO, subActions )
|
|
|
+SpielerSetTempo::SpielerSetTempo(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_TEMPO, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setLaufTempo( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(1))->setLaufTempo(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetWaffenTempo::SpielerSetWaffenTempo( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_GESCHOSS_TEMPO, subActions )
|
|
|
+SpielerSetWaffenTempo::SpielerSetWaffenTempo(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_GESCHOSS_TEMPO, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetWaffenTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetWaffenTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setGeschossTempo( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(1))->setGeschossTempo(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetArmor::SpielerSetArmor( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_ARMOR, subActions )
|
|
|
+SpielerSetArmor::SpielerSetArmor(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_ARMOR, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetArmor::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setArmor( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(1))->setArmor(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetSchadenBonus::SpielerSetSchadenBonus( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_SCHADEN_BONUS, subActions )
|
|
|
+SpielerSetSchadenBonus::SpielerSetSchadenBonus(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_SCHADEN_BONUS, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetSchadenBonus::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setSchadenBonus( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(1))->setSchadenBonus(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetLebensraub::SpielerSetLebensraub( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_LEBENSRAUB, subActions )
|
|
|
+SpielerSetLebensraub::SpielerSetLebensraub(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_LEBENSRAUB, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetLebensraub::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setLebensRaub( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(1))->setLebensRaub(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetLebensregeneration::SpielerSetLebensregeneration( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_LEBENSRAUB, subActions )
|
|
|
+SpielerSetLebensregeneration::SpielerSetLebensregeneration(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_LEBENSRAUB, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetLebensregeneration::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setLebensRegeneration( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(1))->setLebensRegeneration(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_SET_ABKLINGZEITVERRINGERUNG, subActions )
|
|
|
+SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_SET_ABKLINGZEITVERRINGERUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void SpielerSetAbklingzeitverringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerSetAbklingzeitverringerung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Spieler *)zParam( 1 ) )->setAbklingZeitVerringerung( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Spieler*)zParam(1))->setAbklingZeitVerringerung(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-DropSetTime::DropSetTime( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( DROP_SET_TIME, subActions )
|
|
|
+DropSetTime::DropSetTime(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(DROP_SET_TIME, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void DropSetTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void DropSetTime::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Drop *)zParam( 1 ) )->setTime( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Drop*)zParam(1))->setTime(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-DropSetMaxTime::DropSetMaxTime( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( DROP_SET_MAX_TIME, subActions )
|
|
|
+DropSetMaxTime::DropSetMaxTime(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(DROP_SET_MAX_TIME, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void DropSetMaxTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void DropSetMaxTime::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Drop *)zParam( 1 ) )->setMaxTime( ( (Integer *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Drop*)zParam(1))->setMaxTime(((Integer*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-DropSetArea::DropSetArea( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( DROP_SET_AREA, subActions )
|
|
|
+DropSetArea::DropSetArea(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(DROP_SET_AREA, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void DropSetArea::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void DropSetArea::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Drop *)zParam( 4 ) )->setMinX( ( (Integer *)zParam( 0 ) )->getValue() );
|
|
|
- ( (Drop *)zParam( 4 ) )->setMaxX( ( (Integer *)zParam( 1 ) )->getValue() );
|
|
|
- ( (Drop *)zParam( 4 ) )->setMinY( ( (Integer *)zParam( 2 ) )->getValue() );
|
|
|
- ( (Drop *)zParam( 4 ) )->setMaxY( ( (Integer *)zParam( 3 ) )->getValue() );
|
|
|
+ ((Drop*)zParam(4))->setMinX(((Integer*)zParam(0))->getValue());
|
|
|
+ ((Drop*)zParam(4))->setMaxX(((Integer*)zParam(1))->getValue());
|
|
|
+ ((Drop*)zParam(4))->setMinY(((Integer*)zParam(2))->getValue());
|
|
|
+ ((Drop*)zParam(4))->setMaxY(((Integer*)zParam(3))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-DropDoDrop::DropDoDrop( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( DROP_DO_DROP, subActions )
|
|
|
+DropDoDrop::DropDoDrop(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(DROP_DO_DROP, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void DropDoDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void DropDoDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Drop *)zParam( 0 ) )->doDrop( zSpiel );
|
|
|
+ ((Drop*)zParam(0))->doDrop(zSpiel);
|
|
|
}
|
|
|
|
|
|
|
|
|
-BariereBewegung::BariereBewegung( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BARIERE_BEWEGUNG, subActions )
|
|
|
+BariereBewegung::BariereBewegung(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BARIERE_BEWEGUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BARIERE );
|
|
|
+ erlaubteTypen.add(BARIERE);
|
|
|
}
|
|
|
|
|
|
-void BariereBewegung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BariereBewegung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Bariere *)zParam( 0 ) )->startAutoVerschiebung( zSpiel );
|
|
|
+ ((Bariere*)zParam(0))->startAutoVerschiebung(zSpiel);
|
|
|
}
|
|
|
|
|
|
|
|
|
-BariereSetEingeschaltet::BariereSetEingeschaltet( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BARIERE_SET_EINGESCHALTET, subActions )
|
|
|
+BariereSetEingeschaltet::BariereSetEingeschaltet(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BARIERE_SET_EINGESCHALTET, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BOOLEAN );
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(BOOLEAN);
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void BariereSetEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BariereSetEingeschaltet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Bariere *)zParam( 1 ) )->setStyle( Bariere::Style::Aktiv, ( (Boolean *)zParam( 0 ) )->getValue(), zSpiel );
|
|
|
+ ((Bariere*)zParam(1))->setStyle(Bariere::Style::Aktiv, ((Boolean*)zParam(0))->getValue(), zSpiel);
|
|
|
}
|
|
|
|
|
|
|
|
|
-GameObjektSetPosition::GameObjektSetPosition( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( GAME_OBJEKT_SET_POSITION, subActions )
|
|
|
+GameObjektSetPosition::GameObjektSetPosition(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(GAME_OBJEKT_SET_POSITION, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( GAME_OBJEKT );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(GAME_OBJEKT);
|
|
|
}
|
|
|
|
|
|
-void GameObjektSetPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GameObjektSetPosition::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (GameObject *)zParam( 2 ) )->setX( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
- ( (GameObject *)zParam( 2 ) )->setY( ( (Float *)zParam( 1 ) )->getValue() );
|
|
|
+ ((GameObject*)zParam(2))->setX(((Float*)zParam(0))->getValue());
|
|
|
+ ((GameObject*)zParam(2))->setY(((Float*)zParam(1))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-GameObjektSetSize::GameObjektSetSize( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( GAME_OBJEKT_SET_SIZE, subActions )
|
|
|
+GameObjektSetSize::GameObjektSetSize(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(GAME_OBJEKT_SET_SIZE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( GAME_OBJEKT );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(GAME_OBJEKT);
|
|
|
}
|
|
|
|
|
|
-void GameObjektSetSize::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GameObjektSetSize::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (GameObject *)zParam( 2 ) )->setWidth( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
- ( (GameObject *)zParam( 2 ) )->setHeight( ( (Float *)zParam( 1 ) )->getValue() );
|
|
|
+ ((GameObject*)zParam(2))->setWidth(((Float*)zParam(0))->getValue());
|
|
|
+ ((GameObject*)zParam(2))->setHeight(((Float*)zParam(1))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-BariereSetTeam::BariereSetTeam( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BARIERE_SET_TEAM, subActions )
|
|
|
+BariereSetTeam::BariereSetTeam(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BARIERE_SET_TEAM, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TEAM );
|
|
|
- erlaubteTypen.add( BARIERE );
|
|
|
+ erlaubteTypen.add(TEAM);
|
|
|
+ erlaubteTypen.add(BARIERE);
|
|
|
}
|
|
|
|
|
|
-void BariereSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BariereSetTeam::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Bariere *)zParam( 1 ) )->setTeam( ( (Team *)getParam( 0 ) ) );
|
|
|
+ ((Bariere*)zParam(1))->setTeam(((Team*)getParam(0)));
|
|
|
}
|
|
|
|
|
|
|
|
|
-SchalterSetErlaubt::SchalterSetErlaubt( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SCHALTER_SET_ERLAUBT, subActions )
|
|
|
+SchalterSetErlaubt::SchalterSetErlaubt(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SCHALTER_SET_ERLAUBT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BOOLEAN );
|
|
|
- erlaubteTypen.add( SCHALTER );
|
|
|
+ erlaubteTypen.add(BOOLEAN);
|
|
|
+ erlaubteTypen.add(SCHALTER);
|
|
|
}
|
|
|
|
|
|
-void SchalterSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SchalterSetErlaubt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Schalter *)zParam( 1 ) )->setAktive( ( (Boolean *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Schalter*)zParam(1))->setAktive(((Boolean*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SchalterAktivieren::SchalterAktivieren( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SCHALTER_AKTIVIEREN, subActions )
|
|
|
+SchalterAktivieren::SchalterAktivieren(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SCHALTER_AKTIVIEREN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SCHALTER );
|
|
|
+ erlaubteTypen.add(SCHALTER);
|
|
|
}
|
|
|
|
|
|
-void SchalterAktivieren::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SchalterAktivieren::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- zSpiel->activateShalter( ( (Schalter *)zParam( 0 ) )->getId() );
|
|
|
+ zSpiel->activateShalter(((Schalter*)zParam(0))->getId());
|
|
|
}
|
|
|
|
|
|
|
|
|
-TunnelSetZielPosition::TunnelSetZielPosition( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TUNNEL_SET_ZIEL_POSITION, subActions )
|
|
|
+TunnelSetZielPosition::TunnelSetZielPosition(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TUNNEL_SET_ZIEL_POSITION, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( TUNNEL );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(TUNNEL);
|
|
|
}
|
|
|
|
|
|
-void TunnelSetZielPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TunnelSetZielPosition::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Tunnel *)zParam( 2 ) )->setZielX( ( (Integer *)zParam( 0 ) )->getValue() );
|
|
|
- ( (Tunnel *)zParam( 2 ) )->setZielY( ( (Integer *)zParam( 1 ) )->getValue() );
|
|
|
+ ((Tunnel*)zParam(2))->setZielX(((Integer*)zParam(0))->getValue());
|
|
|
+ ((Tunnel*)zParam(2))->setZielY(((Integer*)zParam(1))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-TunnelSetErlaubt::TunnelSetErlaubt( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TUNNEL_SET_ERLAUBT, subActions )
|
|
|
+TunnelSetErlaubt::TunnelSetErlaubt(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TUNNEL_SET_ERLAUBT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BOOLEAN );
|
|
|
- erlaubteTypen.add( TUNNEL );
|
|
|
+ erlaubteTypen.add(BOOLEAN);
|
|
|
+ erlaubteTypen.add(TUNNEL);
|
|
|
}
|
|
|
|
|
|
-void TunnelSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TunnelSetErlaubt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Tunnel *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Tunnel*)zParam(1))->setAktiv(((Boolean*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-UmlenkungSetRichtung::UmlenkungSetRichtung( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( UMLENKUNG_SET_RICHTUNG, subActions )
|
|
|
+UmlenkungSetRichtung::UmlenkungSetRichtung(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(UMLENKUNG_SET_RICHTUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( RICHTUNG );
|
|
|
- erlaubteTypen.add( UMLENKUNG );
|
|
|
+ erlaubteTypen.add(RICHTUNG);
|
|
|
+ erlaubteTypen.add(UMLENKUNG);
|
|
|
}
|
|
|
|
|
|
-void UmlenkungSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void UmlenkungSetRichtung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Umlenkung *)zParam( 1 ) )->setRichtung( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) );
|
|
|
+ ((Umlenkung*)zParam(1))->setRichtung(getRichtungFromString(((String*)zParam(0))->getValue()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-UmlenkungSetMaxAbk::UmlenkungSetMaxAbk( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( UMLENKUNG_SET_MAX_ABK, subActions )
|
|
|
+UmlenkungSetMaxAbk::UmlenkungSetMaxAbk(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(UMLENKUNG_SET_MAX_ABK, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( UMLENKUNG );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(UMLENKUNG);
|
|
|
}
|
|
|
|
|
|
-void UmlenkungSetMaxAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void UmlenkungSetMaxAbk::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Umlenkung *)zParam( 1 ) )->setMaxAbklingzeit( ( (Integer *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Umlenkung*)zParam(1))->setMaxAbklingzeit(((Integer*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-UmlenkungSetEnabled::UmlenkungSetEnabled( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( UMLENKUNG_SET_ERLAUBT, subActions )
|
|
|
+UmlenkungSetEnabled::UmlenkungSetEnabled(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(UMLENKUNG_SET_ERLAUBT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BOOLEAN );
|
|
|
- erlaubteTypen.add( UMLENKUNG );
|
|
|
+ erlaubteTypen.add(BOOLEAN);
|
|
|
+ erlaubteTypen.add(UMLENKUNG);
|
|
|
}
|
|
|
|
|
|
-void UmlenkungSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void UmlenkungSetEnabled::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Umlenkung *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Umlenkung*)zParam(1))->setAktiv(((Boolean*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-BaseSetTeam::BaseSetTeam( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BASE_SET_TEAM, subActions )
|
|
|
+BaseSetTeam::BaseSetTeam(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BASE_SET_TEAM, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TEAM );
|
|
|
- erlaubteTypen.add( BASE );
|
|
|
+ erlaubteTypen.add(TEAM);
|
|
|
+ erlaubteTypen.add(BASE);
|
|
|
}
|
|
|
|
|
|
-void BaseSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BaseSetTeam::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Base *)zParam( 1 ) )->setTeam( ( (Team *)getParam( 0 ) ), zSpiel );
|
|
|
+ ((Base*)zParam(1))->setTeam(((Team*)getParam(0)), zSpiel);
|
|
|
}
|
|
|
|
|
|
|
|
|
-BaseStartTeamChange::BaseStartTeamChange( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BASE_START_TEAM_CHANGE, subActions )
|
|
|
+BaseStartTeamChange::BaseStartTeamChange(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BASE_START_TEAM_CHANGE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TEAM );
|
|
|
- erlaubteTypen.add( BASE );
|
|
|
+ erlaubteTypen.add(TEAM);
|
|
|
+ erlaubteTypen.add(BASE);
|
|
|
}
|
|
|
|
|
|
-void BaseStartTeamChange::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BaseStartTeamChange::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Base *)zParam( 1 ) )->startChange( ( (Team *)getParam( 0 ) ) );
|
|
|
+ ((Base*)zParam(1))->startChange(((Team*)getParam(0)));
|
|
|
}
|
|
|
|
|
|
|
|
|
-TriggerRunStart::TriggerRunStart( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TRIGGER_RUN_START, subActions )
|
|
|
+TriggerRunStart::TriggerRunStart(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TRIGGER_RUN_START, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TRIGGER );
|
|
|
+ erlaubteTypen.add(TRIGGER);
|
|
|
}
|
|
|
|
|
|
-void TriggerRunStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TriggerRunStart::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- zSpiel->addTriggerRun( ( (Trigger *)zParam( 0 ) )->runTrigger( dynamic_cast<Ereignis *>( zEreignis->getThis() ), zSpiel ) );
|
|
|
+ zSpiel->addTriggerRun(((Trigger*)zParam(0))->runTrigger(dynamic_cast<Ereignis*>(zEreignis->getThis()), zSpiel));
|
|
|
}
|
|
|
|
|
|
|
|
|
-TriggerSetEnabled::TriggerSetEnabled( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TRIGGER_SET_ENABLED, subActions )
|
|
|
+TriggerSetEnabled::TriggerSetEnabled(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TRIGGER_SET_ENABLED, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BOOLEAN );
|
|
|
- erlaubteTypen.add( TRIGGER );
|
|
|
+ erlaubteTypen.add(BOOLEAN);
|
|
|
+ erlaubteTypen.add(TRIGGER);
|
|
|
}
|
|
|
|
|
|
-void TriggerSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TriggerSetEnabled::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Trigger *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Trigger*)zParam(1))->setAktiv(((Boolean*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-TeamSetPunkte::TeamSetPunkte( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEAM_SET_PUNKTE, subActions )
|
|
|
+TeamSetPunkte::TeamSetPunkte(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEAM_SET_PUNKTE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( TEAM );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(TEAM);
|
|
|
}
|
|
|
|
|
|
-void TeamSetPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TeamSetPunkte::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Team *)zParam( 1 ) )->setPunkte( ( (Integer *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Team*)zParam(1))->setPunkte(((Integer*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-TimerSetPause::TimerSetPause( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TIMER_SET_PAUSE, subActions )
|
|
|
+TimerSetPause::TimerSetPause(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TIMER_SET_PAUSE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BOOLEAN );
|
|
|
- erlaubteTypen.add( TIMER );
|
|
|
+ erlaubteTypen.add(BOOLEAN);
|
|
|
+ erlaubteTypen.add(TIMER);
|
|
|
}
|
|
|
|
|
|
-void TimerSetPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TimerSetPause::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Timer *)zParam( 1 ) )->setPause( zSpiel, ( (Boolean *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Timer*)zParam(1))->setPause(zSpiel, ((Boolean*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-TimerStart::TimerStart( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TIMER_START, subActions )
|
|
|
+TimerStart::TimerStart(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TIMER_START, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TIMER );
|
|
|
+ erlaubteTypen.add(TIMER);
|
|
|
}
|
|
|
|
|
|
-void TimerStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TimerStart::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Timer *)zParam( 0 ) )->start( zSpiel );
|
|
|
+ ((Timer*)zParam(0))->start(zSpiel);
|
|
|
}
|
|
|
|
|
|
|
|
|
-TimerSetZeit::TimerSetZeit( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TIMER_SET_ZEIT, subActions )
|
|
|
+TimerSetZeit::TimerSetZeit(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TIMER_SET_ZEIT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( TIMER );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(TIMER);
|
|
|
}
|
|
|
|
|
|
-void TimerSetZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TimerSetZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Timer *)zParam( 1 ) )->setZeit( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Timer*)zParam(1))->setZeit(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-TimerSetSichtbar::TimerSetSichtbar( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TIMER_SET_SICHTBAR, subActions )
|
|
|
+TimerSetSichtbar::TimerSetSichtbar(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TIMER_SET_SICHTBAR, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BOOLEAN );
|
|
|
- erlaubteTypen.add( TIMER );
|
|
|
+ erlaubteTypen.add(BOOLEAN);
|
|
|
+ erlaubteTypen.add(TIMER);
|
|
|
}
|
|
|
|
|
|
-void TimerSetSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TimerSetSichtbar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Timer *)zParam( 1 ) )->setSichtbar( ( (Boolean *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Timer*)zParam(1))->setSichtbar(((Boolean*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-GeschossNeu::GeschossNeu( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( GESCHOSS_NEU, subActions )
|
|
|
+GeschossNeu::GeschossNeu(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(GESCHOSS_NEU, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( GESCHOSS_TYP );
|
|
|
- erlaubteTypen.add( RICHTUNG );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(GESCHOSS_TYP);
|
|
|
+ erlaubteTypen.add(RICHTUNG);
|
|
|
}
|
|
|
|
|
|
-void GeschossNeu::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossNeu::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- Geschoss *g = new Geschoss( zSpiel->getNextId(), 0,
|
|
|
- getGeschossTypFromString( ( (String *)zParam( 2 ) )->getValue() ),
|
|
|
- getRichtungFromString( ( (String *)zParam( 3 ) )->getValue() ),
|
|
|
- ( (Integer *)zParam( 0 ) )->getValue(),
|
|
|
- ( (Integer *)zParam( 1 ) )->getValue(), 0 );
|
|
|
- zSpiel->addGeschoss( dynamic_cast<Geschoss *>( g->getThis() ) );
|
|
|
- setReturn( g );
|
|
|
+ Geschoss* g = new Geschoss(zSpiel->getNextId(), 0,
|
|
|
+ getGeschossTypFromString(((String*)zParam(2))->getValue()),
|
|
|
+ getRichtungFromString(((String*)zParam(3))->getValue()),
|
|
|
+ ((Integer*)zParam(0))->getValue(),
|
|
|
+ ((Integer*)zParam(1))->getValue(), 0);
|
|
|
+ zSpiel->addGeschoss(dynamic_cast<Geschoss*>(g->getThis()));
|
|
|
+ setReturn(g);
|
|
|
}
|
|
|
|
|
|
|
|
|
-GeschossSetSpeed::GeschossSetSpeed( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( GESCHOSS_SET_SPEED, subActions )
|
|
|
+GeschossSetSpeed::GeschossSetSpeed(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(GESCHOSS_SET_SPEED, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( GESCHOSS );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(GESCHOSS);
|
|
|
}
|
|
|
|
|
|
-void GeschossSetSpeed::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossSetSpeed::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Geschoss *)zParam( 1 ) )->setSpeed( ( (Float *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Geschoss*)zParam(1))->setSpeed(((Float*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-GeschossSetPlayer::GeschossSetPlayer( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( GESCHOSS_SET_PLAYER, subActions )
|
|
|
+GeschossSetPlayer::GeschossSetPlayer(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(GESCHOSS_SET_PLAYER, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
- erlaubteTypen.add( GESCHOSS );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
+ erlaubteTypen.add(GESCHOSS);
|
|
|
}
|
|
|
|
|
|
-void GeschossSetPlayer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossSetPlayer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Geschoss *)zParam( 1 ) )->setBesitzer( ( (Spieler *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
|
|
|
+ ((Geschoss*)zParam(1))->setBesitzer(((Spieler*)zMemory->getVariable(zPC->getUniqueString() + "R0__")));
|
|
|
}
|
|
|
|
|
|
|
|
|
-GeschossSetRichtung::GeschossSetRichtung( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( GESCHOSS_SET_RICHTUNG, subActions )
|
|
|
+GeschossSetRichtung::GeschossSetRichtung(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(GESCHOSS_SET_RICHTUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( RICHTUNG );
|
|
|
- erlaubteTypen.add( GESCHOSS );
|
|
|
+ erlaubteTypen.add(RICHTUNG);
|
|
|
+ erlaubteTypen.add(GESCHOSS);
|
|
|
}
|
|
|
|
|
|
-void GeschossSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossSetRichtung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Geschoss *)zParam( 1 ) )->setRichtung( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) );
|
|
|
+ ((Geschoss*)zParam(1))->setRichtung(getRichtungFromString(((String*)zParam(0))->getValue()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-GeschossSetType::GeschossSetType( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( GESCHOSS_SET_TYPE, subActions )
|
|
|
+GeschossSetType::GeschossSetType(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(GESCHOSS_SET_TYPE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GESCHOSS_TYP );
|
|
|
- erlaubteTypen.add( GESCHOSS );
|
|
|
+ erlaubteTypen.add(GESCHOSS_TYP);
|
|
|
+ erlaubteTypen.add(GESCHOSS);
|
|
|
}
|
|
|
|
|
|
-void GeschossSetType::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossSetType::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Geschoss *)zParam( 1 ) )->setTyp( getGeschossTypFromString( ( (String *)zParam( 0 ) )->getValue() ) );
|
|
|
+ ((Geschoss*)zParam(1))->setTyp(getGeschossTypFromString(((String*)zParam(0))->getValue()));
|
|
|
}
|
|
|
|
|
|
|
|
|
TriggerZufall::TriggerZufall()
|
|
|
- : Aktion( TRIGGER_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(TRIGGER_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void TriggerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TriggerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomTrigger() );
|
|
|
+ setReturn(zSpiel->getRandomTrigger());
|
|
|
}
|
|
|
|
|
|
|
|
|
TriggerLastRunned::TriggerLastRunned()
|
|
|
- : Aktion( TRIGGER_LAST_RUNNED, new RCArray< Aktion >() )
|
|
|
+ : Aktion(TRIGGER_LAST_RUNNED, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void TriggerLastRunned::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TriggerLastRunned::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getLastRunnedTrigger() );
|
|
|
+ setReturn(zSpiel->getLastRunnedTrigger());
|
|
|
}
|
|
|
|
|
|
|
|
|
BariereZufall::BariereZufall()
|
|
|
- : Aktion( BARIERE_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(BARIERE_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void BariereZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BariereZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomBariere() );
|
|
|
+ setReturn(zSpiel->getRandomBariere());
|
|
|
}
|
|
|
|
|
|
|
|
|
BariereZuletztEingeschaltet::BariereZuletztEingeschaltet()
|
|
|
- : Aktion( BARIERE_ZULETZT_EINGESCHALTET, new RCArray< Aktion >() )
|
|
|
+ : Aktion(BARIERE_ZULETZT_EINGESCHALTET, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void BariereZuletztEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BariereZuletztEingeschaltet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getZuletztEingeschalteteBariere() );
|
|
|
+ setReturn(zSpiel->getZuletztEingeschalteteBariere());
|
|
|
}
|
|
|
|
|
|
|
|
|
BariereZuletztAusgeschaltet::BariereZuletztAusgeschaltet()
|
|
|
- : Aktion( BARIERE_ZULETZT_AUSGESCHALTET, new RCArray< Aktion >() )
|
|
|
+ : Aktion(BARIERE_ZULETZT_AUSGESCHALTET, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void BariereZuletztAusgeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BariereZuletztAusgeschaltet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getZuletztAusgeschalteteBariere() );
|
|
|
+ setReturn(zSpiel->getZuletztAusgeschalteteBariere());
|
|
|
}
|
|
|
|
|
|
|
|
|
BariereZuletztBewegt::BariereZuletztBewegt()
|
|
|
- : Aktion( BARIERE_ZULETZT_BEWEGT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(BARIERE_ZULETZT_BEWEGT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void BariereZuletztBewegt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BariereZuletztBewegt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getZuletztBewegteBariere() );
|
|
|
+ setReturn(zSpiel->getZuletztBewegteBariere());
|
|
|
}
|
|
|
|
|
|
|
|
|
BaseZufall::BaseZufall()
|
|
|
- : Aktion( BASE_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(BASE_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void BaseZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BaseZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomBase() );
|
|
|
+ setReturn(zSpiel->getRandomBase());
|
|
|
}
|
|
|
|
|
|
|
|
|
BaseZuletztBesitzerGewechselt::BaseZuletztBesitzerGewechselt()
|
|
|
- : Aktion( BASE_ZULETZT_BESITZER_GEWECHSELT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(BASE_ZULETZT_BESITZER_GEWECHSELT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void BaseZuletztBesitzerGewechselt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BaseZuletztBesitzerGewechselt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getLastTeamChangedBase() );
|
|
|
+ setReturn(zSpiel->getLastTeamChangedBase());
|
|
|
}
|
|
|
|
|
|
|
|
|
DropZufall::DropZufall()
|
|
|
- : Aktion( DROP_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(DROP_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void DropZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void DropZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomDrop() );
|
|
|
+ setReturn(zSpiel->getRandomDrop());
|
|
|
}
|
|
|
|
|
|
|
|
|
DropZuletztGedropt::DropZuletztGedropt()
|
|
|
- : Aktion( DROP_ZULETZT_GEDROPT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(DROP_ZULETZT_GEDROPT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void DropZuletztGedropt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
-{
|
|
|
- setReturn( zSpiel->getLastDrop() );
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-IntegerRechnen::IntegerRechnen( RCArray< Aktion > *subActions, Operator op )
|
|
|
- : Aktion( INTEGER_RECHNEN, subActions ),
|
|
|
- op()
|
|
|
-{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
-}
|
|
|
-
|
|
|
-void IntegerRechnen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
-{
|
|
|
- Integer *l = (Integer *)zParam( 0 );
|
|
|
- Integer *r = (Integer *)zParam( 1 );
|
|
|
- switch( op )
|
|
|
- {
|
|
|
- case PLUS:
|
|
|
- setReturn( new Integer( l->getValue() + r->getValue() ) );
|
|
|
- break;
|
|
|
- case MINUS:
|
|
|
- setReturn( new Integer( l->getValue() - r->getValue() ) );
|
|
|
- break;
|
|
|
- case MAHL:
|
|
|
- setReturn( new Integer( l->getValue() * r->getValue() ) );
|
|
|
- break;
|
|
|
- case GETEILT:
|
|
|
- setReturn( new Integer( l->getValue() / r->getValue() ) );
|
|
|
- break;
|
|
|
- case HOCH:
|
|
|
- setReturn( new Integer( (int)pow( l->getValue(), r->getValue() ) ) );
|
|
|
- break;
|
|
|
- case WURZEL:
|
|
|
- setReturn( new Integer( (int)pow( l->getValue(), 1.0 / r->getValue() ) ) );
|
|
|
- break;
|
|
|
- case BIT_ODER:
|
|
|
- setReturn( new Integer( l->getValue() | r->getValue() ) );
|
|
|
- break;
|
|
|
- case BIT_UND:
|
|
|
- setReturn( new Integer( l->getValue() & r->getValue() ) );
|
|
|
- break;
|
|
|
- case BIT_XOR:
|
|
|
- setReturn( new Integer( l->getValue() ^ r->getValue() ) );
|
|
|
- break;
|
|
|
- case BIT_FLIP:
|
|
|
- setReturn( new Integer( ~l->getValue() ) );
|
|
|
- break;
|
|
|
- case BIT_SHIFT_LEFT:
|
|
|
- setReturn( new Integer( l->getValue() << r->getValue() ) );
|
|
|
- break;
|
|
|
- case BIT_SHIFT_RIGHT:
|
|
|
- setReturn( new Integer( l->getValue() >> r->getValue() ) );
|
|
|
- break;
|
|
|
- case INVERT_SIGN:
|
|
|
- setReturn( new Integer( -l->getValue() ) );
|
|
|
- break;
|
|
|
- case PLUS_PLUS_LEFT:
|
|
|
- l->setValue( l->getValue() + 1 );
|
|
|
- setReturn( new Integer( l->getValue() ) );
|
|
|
- break;
|
|
|
- case PLUS_PLUS_RIGHT:
|
|
|
- {
|
|
|
- int tmp = l->getValue();
|
|
|
- l->setValue( l->getValue() + 1 );
|
|
|
- setReturn( new Integer( tmp ) );
|
|
|
- break;
|
|
|
- }
|
|
|
- case MINUS_MINUS_LEFT:
|
|
|
- l->setValue( l->getValue() - 1 );
|
|
|
- setReturn( new Integer( l->getValue() ) );
|
|
|
- break;
|
|
|
- case MINUS_MINUS_RIGHT:
|
|
|
- {
|
|
|
- int tmp = l->getValue();
|
|
|
- l->setValue( l->getValue() - 1 );
|
|
|
- setReturn( new Integer( tmp ) );
|
|
|
- break;
|
|
|
- }
|
|
|
- case LOGARITHM:
|
|
|
- setReturn( new Integer( (int)( log( l->getValue() ) / log( r->getValue() ) ) ) );
|
|
|
- break;
|
|
|
- case MODULO:
|
|
|
- setReturn( new Integer( l->getValue() % r->getValue() ) );
|
|
|
- break;
|
|
|
- default:
|
|
|
- break;
|
|
|
- }
|
|
|
+void DropZuletztGedropt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
+{
|
|
|
+ setReturn(zSpiel->getLastDrop());
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+IntegerRechnen::IntegerRechnen(RCArray< Aktion >* subActions, Operator op)
|
|
|
+ : Aktion(INTEGER_RECHNEN, subActions),
|
|
|
+ op()
|
|
|
+{
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+}
|
|
|
+
|
|
|
+void IntegerRechnen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
+{
|
|
|
+ Integer* l = (Integer*)zParam(0);
|
|
|
+ Integer* r = (Integer*)zParam(1);
|
|
|
+ switch (op)
|
|
|
+ {
|
|
|
+ case PLUS:
|
|
|
+ setReturn(new Integer(l->getValue() + r->getValue()));
|
|
|
+ break;
|
|
|
+ case MINUS:
|
|
|
+ setReturn(new Integer(l->getValue() - r->getValue()));
|
|
|
+ break;
|
|
|
+ case MAHL:
|
|
|
+ setReturn(new Integer(l->getValue() * r->getValue()));
|
|
|
+ break;
|
|
|
+ case GETEILT:
|
|
|
+ setReturn(new Integer(l->getValue() / r->getValue()));
|
|
|
+ break;
|
|
|
+ case HOCH:
|
|
|
+ setReturn(new Integer((int)pow(l->getValue(), r->getValue())));
|
|
|
+ break;
|
|
|
+ case WURZEL:
|
|
|
+ setReturn(new Integer((int)pow(l->getValue(), 1.0 / r->getValue())));
|
|
|
+ break;
|
|
|
+ case BIT_ODER:
|
|
|
+ setReturn(new Integer(l->getValue() | r->getValue()));
|
|
|
+ break;
|
|
|
+ case BIT_UND:
|
|
|
+ setReturn(new Integer(l->getValue() & r->getValue()));
|
|
|
+ break;
|
|
|
+ case BIT_XOR:
|
|
|
+ setReturn(new Integer(l->getValue() ^ r->getValue()));
|
|
|
+ break;
|
|
|
+ case BIT_FLIP:
|
|
|
+ setReturn(new Integer(~l->getValue()));
|
|
|
+ break;
|
|
|
+ case BIT_SHIFT_LEFT:
|
|
|
+ setReturn(new Integer(l->getValue() << r->getValue()));
|
|
|
+ break;
|
|
|
+ case BIT_SHIFT_RIGHT:
|
|
|
+ setReturn(new Integer(l->getValue() >> r->getValue()));
|
|
|
+ break;
|
|
|
+ case INVERT_SIGN:
|
|
|
+ setReturn(new Integer(-l->getValue()));
|
|
|
+ break;
|
|
|
+ case PLUS_PLUS_LEFT:
|
|
|
+ l->setValue(l->getValue() + 1);
|
|
|
+ setReturn(new Integer(l->getValue()));
|
|
|
+ break;
|
|
|
+ case PLUS_PLUS_RIGHT:
|
|
|
+ {
|
|
|
+ int tmp = l->getValue();
|
|
|
+ l->setValue(l->getValue() + 1);
|
|
|
+ setReturn(new Integer(tmp));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case MINUS_MINUS_LEFT:
|
|
|
+ l->setValue(l->getValue() - 1);
|
|
|
+ setReturn(new Integer(l->getValue()));
|
|
|
+ break;
|
|
|
+ case MINUS_MINUS_RIGHT:
|
|
|
+ {
|
|
|
+ int tmp = l->getValue();
|
|
|
+ l->setValue(l->getValue() - 1);
|
|
|
+ setReturn(new Integer(tmp));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case LOGARITHM:
|
|
|
+ setReturn(new Integer((int)(log(l->getValue()) / log(r->getValue()))));
|
|
|
+ break;
|
|
|
+ case MODULO:
|
|
|
+ setReturn(new Integer(l->getValue() % r->getValue()));
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-void IntegerRechnen::writeOptions( Datei &dat )
|
|
|
+void IntegerRechnen::writeOptions(Datei& dat)
|
|
|
{
|
|
|
- dat.schreibe( (char *)&this->op, 1 );
|
|
|
+ dat.schreibe((char*)&this->op, 1);
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerZufall::IntegerZufall( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( INTEGER_ZUFALL, subActions )
|
|
|
+IntegerZufall::IntegerZufall(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(INTEGER_ZUFALL, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
}
|
|
|
|
|
|
-void IntegerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- int mi = ( (Integer *)zParam( 0 ) )->getValue();
|
|
|
- int ma = ( (Integer *)zParam( 1 ) )->getValue();
|
|
|
- setReturn( new Integer( (int)( zSpiel->getRand() * ( (double)ma - mi ) + mi ) ) );
|
|
|
+ int mi = ((Integer*)zParam(0))->getValue();
|
|
|
+ int ma = ((Integer*)zParam(1))->getValue();
|
|
|
+ setReturn(new Integer((int)(zSpiel->getRand() * ((double)ma - mi) + mi)));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerAusText::IntegerAusText( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( INTEGER_AUS_TEXT, subActions )
|
|
|
+IntegerAusText::IntegerAusText(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(INTEGER_AUS_TEXT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
}
|
|
|
|
|
|
-void IntegerAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerAusText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (String *)zParam( 0 ) )->getValue() ) );
|
|
|
+ setReturn(new Integer((int)((String*)zParam(0))->getValue()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatXVonGameObjekt::FloatXVonGameObjekt( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( FLOAT_X_VON_GAME_OBJEKT, subActions )
|
|
|
+FloatXVonGameObjekt::FloatXVonGameObjekt(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(FLOAT_X_VON_GAME_OBJEKT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GAME_OBJEKT );
|
|
|
+ erlaubteTypen.add(GAME_OBJEKT);
|
|
|
}
|
|
|
|
|
|
-void FloatXVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatXVonGameObjekt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getX() ) );
|
|
|
+ setReturn(new Float(((GameObject*)zParam(0))->getX()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatYVonGameObjekt::FloatYVonGameObjekt( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( FLOAT_Y_VON_GAME_OBJEKT, subActions )
|
|
|
+FloatYVonGameObjekt::FloatYVonGameObjekt(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(FLOAT_Y_VON_GAME_OBJEKT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GAME_OBJEKT );
|
|
|
+ erlaubteTypen.add(GAME_OBJEKT);
|
|
|
}
|
|
|
|
|
|
-void FloatYVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatYVonGameObjekt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getY() ) );
|
|
|
+ setReturn(new Float(((GameObject*)zParam(0))->getY()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerXVonTunnelZiel::IntegerXVonTunnelZiel( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( INTEGER_X_VON_TUNNEL_ZIEL, subActions )
|
|
|
+IntegerXVonTunnelZiel::IntegerXVonTunnelZiel(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(INTEGER_X_VON_TUNNEL_ZIEL, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TUNNEL );
|
|
|
+ erlaubteTypen.add(TUNNEL);
|
|
|
}
|
|
|
|
|
|
-void IntegerXVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerXVonTunnelZiel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getZielX() ) );
|
|
|
+ setReturn(new Integer(((Tunnel*)zParam(0))->getZielX()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerYVonTunnelZiel::IntegerYVonTunnelZiel( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( INTEGER_Y_VON_TUNNEL_ZIEL, subActions )
|
|
|
+IntegerYVonTunnelZiel::IntegerYVonTunnelZiel(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(INTEGER_Y_VON_TUNNEL_ZIEL, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TUNNEL );
|
|
|
+ erlaubteTypen.add(TUNNEL);
|
|
|
}
|
|
|
|
|
|
-void IntegerYVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerYVonTunnelZiel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getZielY() ) );
|
|
|
+ setReturn(new Integer(((Tunnel*)zParam(0))->getZielY()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerMinXVonDrop::IntegerMinXVonDrop( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( INTEGER_MIN_X_VON_DROP, subActions )
|
|
|
+IntegerMinXVonDrop::IntegerMinXVonDrop(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(INTEGER_MIN_X_VON_DROP, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void IntegerMinXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerMinXVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMinX() ) );
|
|
|
+ setReturn(new Integer(((Drop*)zParam(0))->getMinX()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerMinYVonDrop::IntegerMinYVonDrop( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( INTEGER_MIN_Y_VON_DROP, subActions )
|
|
|
+IntegerMinYVonDrop::IntegerMinYVonDrop(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(INTEGER_MIN_Y_VON_DROP, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void IntegerMinYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerMinYVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMinY() ) );
|
|
|
+ setReturn(new Integer(((Drop*)zParam(0))->getMinY()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerMaxXVonDrop::IntegerMaxXVonDrop( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( INTEGER_MAX_X_VON_DROP, subActions )
|
|
|
+IntegerMaxXVonDrop::IntegerMaxXVonDrop(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(INTEGER_MAX_X_VON_DROP, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void IntegerMaxXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerMaxXVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxX() ) );
|
|
|
+ setReturn(new Integer(((Drop*)zParam(0))->getMaxX()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerMaxYVonDrop::IntegerMaxYVonDrop( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( INTEGER_MAX_Y_VON_DROP, subActions )
|
|
|
+IntegerMaxYVonDrop::IntegerMaxYVonDrop(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(INTEGER_MAX_Y_VON_DROP, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void IntegerMaxYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerMaxYVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxY() ) );
|
|
|
+ setReturn(new Integer(((Drop*)zParam(0))->getMaxY()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerLevel::IntegerSpielerLevel( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_LEVEL, subActions )
|
|
|
+IntegerSpielerLevel::IntegerSpielerLevel(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_LEVEL, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerLevel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getLevel() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getLevel()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerLeben::FloatSpielerLeben( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_LEBEN, subActions )
|
|
|
+FloatSpielerLeben::FloatSpielerLeben(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_LEBEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLeben() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getLeben()));
|
|
|
}
|
|
|
|
|
|
-bool isBinary( Operator op )
|
|
|
+bool isBinary(Operator op)
|
|
|
{
|
|
|
- return op != BIT_FLIP && op != INVERT_SIGN && op != PLUS_PLUS_LEFT && op != PLUS_PLUS_RIGHT &&
|
|
|
- op != MINUS_MINUS_LEFT && op != MINUS_MINUS_RIGHT && op != INVERT_BOOL;
|
|
|
+ return op != BIT_FLIP && op != INVERT_SIGN && op != PLUS_PLUS_LEFT && op != PLUS_PLUS_RIGHT &&
|
|
|
+ op != MINUS_MINUS_LEFT && op != MINUS_MINUS_RIGHT && op != INVERT_BOOL;
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerMaxLeben::IntegerSpielerMaxLeben( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_MAX_LEBEN, subActions )
|
|
|
+IntegerSpielerMaxLeben::IntegerSpielerMaxLeben(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_MAX_LEBEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerMaxLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getMaxLeben() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getMaxLeben()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerErfahrung::FloatSpielerErfahrung( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_ERFAHRUNG, subActions )
|
|
|
+FloatSpielerErfahrung::FloatSpielerErfahrung(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_ERFAHRUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getErfahrung() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getErfahrung()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerMaxErfahrung::IntegerSpielerMaxErfahrung( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_MAX_ERFAHRUNG, subActions )
|
|
|
+IntegerSpielerMaxErfahrung::IntegerSpielerMaxErfahrung(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_MAX_ERFAHRUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerMaxErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getMaxErfahrung() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getMaxErfahrung()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerTempo::FloatSpielerTempo( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_TEMPO, subActions )
|
|
|
+FloatSpielerTempo::FloatSpielerTempo(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_TEMPO, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLaufTempo() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getLaufTempo()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerGeschossTempo::FloatSpielerGeschossTempo( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_GESCHOSS_TEMPO, subActions )
|
|
|
+FloatSpielerGeschossTempo::FloatSpielerGeschossTempo(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_GESCHOSS_TEMPO, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerGeschossTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerGeschossTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGeschossTempo() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getGeschossTempo()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerArmor::FloatSpielerArmor( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_ARMOR, subActions )
|
|
|
+FloatSpielerArmor::FloatSpielerArmor(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_ARMOR, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerArmor::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getArmor() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getArmor()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerSchadenBonus::FloatSpielerSchadenBonus( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_SCHADEN_BONUS, subActions )
|
|
|
+FloatSpielerSchadenBonus::FloatSpielerSchadenBonus(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_SCHADEN_BONUS, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerSchadenBonus::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getSchadenBonus() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getSchadenBonus()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerLebensraub::FloatSpielerLebensraub( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_LEBENSRAUB, subActions )
|
|
|
+FloatSpielerLebensraub::FloatSpielerLebensraub(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_LEBENSRAUB, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerLebensraub::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLebensRaub() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getLebensRaub()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerLebensregeneration::FloatSpielerLebensregeneration( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_LEBENSREGENERATION, subActions )
|
|
|
+FloatSpielerLebensregeneration::FloatSpielerLebensregeneration(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_LEBENSREGENERATION, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerLebensregeneration::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLebensRegenneration() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getLebensRegenneration()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerAbklingzeitVerringerung::FloatSpielerAbklingzeitVerringerung( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG, subActions )
|
|
|
+FloatSpielerAbklingzeitVerringerung::FloatSpielerAbklingzeitVerringerung(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerAbklingzeitVerringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerAbklingzeitVerringerung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getAbklingZeitVerringerung() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getAbklingZeitVerringerung()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerTode::IntegerSpielerTode( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_TODE, subActions )
|
|
|
+IntegerSpielerTode::IntegerSpielerTode(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_TODE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerTode::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerTode::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTode() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getTode()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerKills::IntegerSpielerKills( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_KILLS, subActions )
|
|
|
+IntegerSpielerKills::IntegerSpielerKills(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_KILLS, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerKills::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerKills::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getKills() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getKills()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerTreffer::IntegerSpielerTreffer( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_TREFFER, subActions )
|
|
|
+IntegerSpielerTreffer::IntegerSpielerTreffer(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_TREFFER, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerTreffer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerTreffer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTreffer() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getTreffer()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerGetroffen::IntegerSpielerGetroffen( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_TREFFER, subActions )
|
|
|
+IntegerSpielerGetroffen::IntegerSpielerGetroffen(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_TREFFER, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerGetroffen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getGetroffen() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getGetroffen()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerErlittenerSchaden::FloatSpielerErlittenerSchaden( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions )
|
|
|
+FloatSpielerErlittenerSchaden::FloatSpielerErlittenerSchaden(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerErlittenerSchaden::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerErlittenerSchaden::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getErlittenerSchaden() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getErlittenerSchaden()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerSchaden::FloatSpielerSchaden( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions )
|
|
|
+FloatSpielerSchaden::FloatSpielerSchaden(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerSchaden::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerSchaden::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGemachterSchaden() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getGemachterSchaden()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatSpielerGeheiltesLeben::FloatSpielerGeheiltesLeben( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_SPIELER_GEHEILTES_LEBEN, subActions )
|
|
|
+FloatSpielerGeheiltesLeben::FloatSpielerGeheiltesLeben(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_SPIELER_GEHEILTES_LEBEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void FloatSpielerGeheiltesLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatSpielerGeheiltesLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGeheiltesLeben() ) );
|
|
|
+ setReturn(new Float(((Spieler*)zParam(0))->getGeheiltesLeben()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerItemsAufgehoben::IntegerSpielerItemsAufgehoben( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_ITEMS_AUFGEHOBEN, subActions )
|
|
|
+IntegerSpielerItemsAufgehoben::IntegerSpielerItemsAufgehoben(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_ITEMS_AUFGEHOBEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerItemsAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerItemsAufgehoben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsAufgehoben() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getItemsAufgehoben()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerItemsVerwendet::IntegerSpielerItemsVerwendet( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_ITEMS_VERWENDET, subActions )
|
|
|
+IntegerSpielerItemsVerwendet::IntegerSpielerItemsVerwendet(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_ITEMS_VERWENDET, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerItemsVerwendet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerItemsVerwendet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsVerwendet() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getItemsVerwendet()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerItemsInInventar::IntegerSpielerItemsInInventar( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR, subActions )
|
|
|
+IntegerSpielerItemsInInventar::IntegerSpielerItemsInInventar(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerItemsInInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerItemsInInventar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsInInventory() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getItemsInInventory()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerItemsTypeInInventar::IntegerSpielerItemsTypeInInventar( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP, subActions )
|
|
|
+IntegerSpielerItemsTypeInInventar::IntegerSpielerItemsTypeInInventar(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GEGENSTAND_TYP );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(GEGENSTAND_TYP);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerItemsTypeInInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerItemsTypeInInventar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 1 ) )->getItemsInInventory( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(1))->getItemsInInventory(((GegenstandTypVar*)zParam(0))->getValue())));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerTunnelBenutzt::IntegerSpielerTunnelBenutzt( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_TUNNEL_BENUTZT, subActions )
|
|
|
+IntegerSpielerTunnelBenutzt::IntegerSpielerTunnelBenutzt(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_TUNNEL_BENUTZT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerTunnelBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTunnelBenutzt() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getTunnelBenutzt()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerSchalterAktiviert::IntegerSpielerSchalterAktiviert( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_SCHALTER_AKTIVIERT, subActions )
|
|
|
+IntegerSpielerSchalterAktiviert::IntegerSpielerSchalterAktiviert(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_SCHALTER_AKTIVIERT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerSchalterAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerSchalterAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getSchalterAktiviert() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getSchalterAktiviert()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSpielerGeschossen::IntegerSpielerGeschossen( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SPIELER_GESCHOSSEN, subActions )
|
|
|
+IntegerSpielerGeschossen::IntegerSpielerGeschossen(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SPIELER_GESCHOSSEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSpielerGeschossen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSpielerGeschossen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getGeschossen() ) );
|
|
|
+ setReturn(new Integer(((Spieler*)zParam(0))->getGeschossen()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatDropZeit::FloatDropZeit( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_DROP_ZEIT, subActions )
|
|
|
+FloatDropZeit::FloatDropZeit(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_DROP_ZEIT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void FloatDropZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatDropZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Drop *)zParam( 0 ) )->getZeit() ) );
|
|
|
+ setReturn(new Float(((Drop*)zParam(0))->getZeit()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerDropMaxZeit::IntegerDropMaxZeit( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_DROP_MAX_ZEIT, subActions )
|
|
|
+IntegerDropMaxZeit::IntegerDropMaxZeit(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_DROP_MAX_ZEIT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( DROP );
|
|
|
+ erlaubteTypen.add(DROP);
|
|
|
}
|
|
|
|
|
|
-void IntegerDropMaxZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerDropMaxZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxTime() ) );
|
|
|
+ setReturn(new Integer(((Drop*)zParam(0))->getMaxTime()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatGameObjektBreite::FloatGameObjektBreite( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_GAME_OBJEKT_BREITE, subActions )
|
|
|
+FloatGameObjektBreite::FloatGameObjektBreite(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_GAME_OBJEKT_BREITE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GAME_OBJEKT );
|
|
|
+ erlaubteTypen.add(GAME_OBJEKT);
|
|
|
}
|
|
|
|
|
|
-void FloatGameObjektBreite::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatGameObjektBreite::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getWidth() ) );
|
|
|
+ setReturn(new Float(((GameObject*)zParam(0))->getWidth()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatGameObjektHeight::FloatGameObjektHeight( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_GAME_OBJEKT_HEIGHT, subActions )
|
|
|
+FloatGameObjektHeight::FloatGameObjektHeight(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_GAME_OBJEKT_HEIGHT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GAME_OBJEKT );
|
|
|
+ erlaubteTypen.add(GAME_OBJEKT);
|
|
|
}
|
|
|
|
|
|
-void FloatGameObjektHeight::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatGameObjektHeight::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getHeight() ) );
|
|
|
+ setReturn(new Float(((GameObject*)zParam(0))->getHeight()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerBariereVerschiebungen::IntegerBariereVerschiebungen( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_BARIERE_VERSCHIEBUNGEN, subActions )
|
|
|
+IntegerBariereVerschiebungen::IntegerBariereVerschiebungen(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_BARIERE_VERSCHIEBUNGEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BARIERE );
|
|
|
+ erlaubteTypen.add(BARIERE);
|
|
|
}
|
|
|
|
|
|
-void IntegerBariereVerschiebungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerBariereVerschiebungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Bariere *)zParam( 0 ) )->getVerschiebungAnzahl() ) );
|
|
|
+ setReturn(new Integer(((Bariere*)zParam(0))->getVerschiebungAnzahl()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerBariereSchaltungen::IntegerBariereSchaltungen( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_BARIERE_SCHALTUNGEN, subActions )
|
|
|
+IntegerBariereSchaltungen::IntegerBariereSchaltungen(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_BARIERE_SCHALTUNGEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BARIERE );
|
|
|
+ erlaubteTypen.add(BARIERE);
|
|
|
}
|
|
|
|
|
|
-void IntegerBariereSchaltungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerBariereSchaltungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Bariere *)zParam( 0 ) )->getSchaltungAnzahl() ) );
|
|
|
+ setReturn(new Integer(((Bariere*)zParam(0))->getSchaltungAnzahl()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerSchalterAktivierungen::IntegerSchalterAktivierungen( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_SCHALTER_AKTIVIERUNGEN, subActions )
|
|
|
+IntegerSchalterAktivierungen::IntegerSchalterAktivierungen(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_SCHALTER_AKTIVIERUNGEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SCHALTER );
|
|
|
+ erlaubteTypen.add(SCHALTER);
|
|
|
}
|
|
|
|
|
|
-void IntegerSchalterAktivierungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerSchalterAktivierungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Schalter *)zParam( 0 ) )->getAnzahlAktivierungen() ) );
|
|
|
+ setReturn(new Integer(((Schalter*)zParam(0))->getAnzahlAktivierungen()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerTunnelBenutzungen::IntegerTunnelBenutzungen( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_TUNNEL_BENUTZUNGEN, subActions )
|
|
|
+IntegerTunnelBenutzungen::IntegerTunnelBenutzungen(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_TUNNEL_BENUTZUNGEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TUNNEL );
|
|
|
+ erlaubteTypen.add(TUNNEL);
|
|
|
}
|
|
|
|
|
|
-void IntegerTunnelBenutzungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerTunnelBenutzungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getBenutzungen() ) );
|
|
|
+ setReturn(new Integer(((Tunnel*)zParam(0))->getBenutzungen()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerUmlenkungBenutzungen::IntegerUmlenkungBenutzungen( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_UMLENKUNG_BENUTZUNGEN, subActions )
|
|
|
+IntegerUmlenkungBenutzungen::IntegerUmlenkungBenutzungen(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_UMLENKUNG_BENUTZUNGEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( UMLENKUNG );
|
|
|
+ erlaubteTypen.add(UMLENKUNG);
|
|
|
}
|
|
|
|
|
|
-void IntegerUmlenkungBenutzungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerUmlenkungBenutzungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Umlenkung *)zParam( 0 ) )->getBenutzungen() ) );
|
|
|
+ setReturn(new Integer(((Umlenkung*)zParam(0))->getBenutzungen()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerTeamPunkte::IntegerTeamPunkte( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_TEAM_PUNKTE, subActions )
|
|
|
+IntegerTeamPunkte::IntegerTeamPunkte(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_TEAM_PUNKTE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TEAM );
|
|
|
+ erlaubteTypen.add(TEAM);
|
|
|
}
|
|
|
|
|
|
-void IntegerTeamPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerTeamPunkte::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Team *)zParam( 0 ) )->getPunkte() ) );
|
|
|
+ setReturn(new Integer(((Team*)zParam(0))->getPunkte()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerTeamKills::IntegerTeamKills( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_TEAM_KILLS, subActions )
|
|
|
+IntegerTeamKills::IntegerTeamKills(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_TEAM_KILLS, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TEAM );
|
|
|
+ erlaubteTypen.add(TEAM);
|
|
|
}
|
|
|
|
|
|
-void IntegerTeamKills::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerTeamKills::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Team *)zParam( 0 ) )->getKills() ) );
|
|
|
+ setReturn(new Integer(((Team*)zParam(0))->getKills()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerTeamTode::IntegerTeamTode( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_TEAM_TODE, subActions )
|
|
|
+IntegerTeamTode::IntegerTeamTode(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_TEAM_TODE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TEAM );
|
|
|
+ erlaubteTypen.add(TEAM);
|
|
|
}
|
|
|
|
|
|
-void IntegerTeamTode::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerTeamTode::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Team *)zParam( 0 ) )->getTode() ) );
|
|
|
+ setReturn(new Integer(((Team*)zParam(0))->getTode()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatTeamWiederbelegungszeit::FloatTeamWiederbelegungszeit( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_TEAM_WIEDERBELEBUNGSZEIT, subActions )
|
|
|
+FloatTeamWiederbelegungszeit::FloatTeamWiederbelegungszeit(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_TEAM_WIEDERBELEBUNGSZEIT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TEAM );
|
|
|
+ erlaubteTypen.add(TEAM);
|
|
|
}
|
|
|
|
|
|
-void FloatTeamWiederbelegungszeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatTeamWiederbelegungszeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Team *)zParam( 0 ) )->getMaxWiederbelebungsZeit() ) );
|
|
|
+ setReturn(new Float(((Team*)zParam(0))->getMaxWiederbelebungsZeit()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerTeamSpieleranzahl::IntegerTeamSpieleranzahl( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_TEAM_SPIELERANZAHL, subActions )
|
|
|
+IntegerTeamSpieleranzahl::IntegerTeamSpieleranzahl(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_TEAM_SPIELERANZAHL, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TEAM );
|
|
|
+ erlaubteTypen.add(TEAM);
|
|
|
}
|
|
|
|
|
|
-void IntegerTeamSpieleranzahl::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerTeamSpieleranzahl::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Team *)zParam( 0 ) )->getSpielerAnzahl() ) );
|
|
|
+ setReturn(new Integer(((Team*)zParam(0))->getSpielerAnzahl()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatTimerAktuelleZeit::FloatTimerAktuelleZeit( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( FLOAT_TIMER_AKTUELLE_ZEIT, subActions )
|
|
|
+FloatTimerAktuelleZeit::FloatTimerAktuelleZeit(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(FLOAT_TIMER_AKTUELLE_ZEIT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TIMER );
|
|
|
+ erlaubteTypen.add(TIMER);
|
|
|
}
|
|
|
|
|
|
-void FloatTimerAktuelleZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatTimerAktuelleZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( ( (Timer *)zParam( 0 ) )->getTimeLeft() ) );
|
|
|
+ setReturn(new Float(((Timer*)zParam(0))->getTimeLeft()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerTimerMaxZeit::IntegerTimerMaxZeit( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_TIMER_MAX_ZEIT, subActions )
|
|
|
+IntegerTimerMaxZeit::IntegerTimerMaxZeit(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_TIMER_MAX_ZEIT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TIMER );
|
|
|
+ erlaubteTypen.add(TIMER);
|
|
|
}
|
|
|
|
|
|
-void IntegerTimerMaxZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerTimerMaxZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Timer *)zParam( 0 ) )->getMaxTime() ) );
|
|
|
+ setReturn(new Integer(((Timer*)zParam(0))->getMaxTime()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerTriggerRunns::IntegerTriggerRunns( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( INTEGER_TRIGGER_RUNNS, subActions )
|
|
|
+IntegerTriggerRunns::IntegerTriggerRunns(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(INTEGER_TRIGGER_RUNNS, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TRIGGER );
|
|
|
+ erlaubteTypen.add(TRIGGER);
|
|
|
}
|
|
|
|
|
|
-void IntegerTriggerRunns::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerTriggerRunns::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( ( (Trigger *)zParam( 0 ) )->getRuns() ) );
|
|
|
+ setReturn(new Integer(((Trigger*)zParam(0))->getRuns()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-ItemSpielerInventar::ItemSpielerInventar( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( ITEM_SPIELER_INVENTAR, subActions )
|
|
|
+ItemSpielerInventar::ItemSpielerInventar(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(ITEM_SPIELER_INVENTAR, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void ItemSpielerInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void ItemSpielerInventar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new GegenstandTypVar( ( ( (Spieler *)zParam( 1 ) )->getInventorySlot( ( (Integer *)zParam( 0 ) )->getValue() ) ) ) );
|
|
|
+ setReturn(new GegenstandTypVar((((Spieler*)zParam(1))->getInventorySlot(((Integer*)zParam(0))->getValue()))));
|
|
|
}
|
|
|
|
|
|
|
|
|
ItemZuletztAufgehoben::ItemZuletztAufgehoben()
|
|
|
- : Aktion( ITEM_ZULETZT_AUFGEHOBEN, new RCArray< Aktion >() )
|
|
|
+ : Aktion(ITEM_ZULETZT_AUFGEHOBEN, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void ItemZuletztAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void ItemZuletztAufgehoben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new GegenstandTypVar( zSpiel->getItemZuletztAufgehoben() ) );
|
|
|
+ setReturn(new GegenstandTypVar(zSpiel->getItemZuletztAufgehoben()));
|
|
|
}
|
|
|
|
|
|
|
|
|
ItemZuletztAktiviert::ItemZuletztAktiviert()
|
|
|
- : Aktion( ITEM_ZULETZT_AKTIVIERT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(ITEM_ZULETZT_AKTIVIERT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void ItemZuletztAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void ItemZuletztAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new GegenstandTypVar( zSpiel->getItemZuletztAktiviert() ) );
|
|
|
+ setReturn(new GegenstandTypVar(zSpiel->getItemZuletztAktiviert()));
|
|
|
}
|
|
|
|
|
|
|
|
|
ItemZuletztGedropt::ItemZuletztGedropt()
|
|
|
- : Aktion( ITEM_ZULETZT_GEDROPT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(ITEM_ZULETZT_GEDROPT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void ItemZuletztGedropt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void ItemZuletztGedropt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new GegenstandTypVar( zSpiel->getItemZuletztGedropt() ) );
|
|
|
+ setReturn(new GegenstandTypVar(zSpiel->getItemZuletztGedropt()));
|
|
|
}
|
|
|
|
|
|
|
|
|
ItemZufall::ItemZufall()
|
|
|
- : Aktion( ITEM_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(ITEM_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void ItemZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void ItemZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new GegenstandTypVar( (GegenstandTyp)(int)( zSpiel->getRand() * ITEMANZAHL ) ) );
|
|
|
+ setReturn(new GegenstandTypVar((GegenstandTyp)(int)(zSpiel->getRand() * ITEMANZAHL)));
|
|
|
}
|
|
|
|
|
|
|
|
|
GeschossZufall::GeschossZufall()
|
|
|
- : Aktion( GESCHOSS_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(GESCHOSS_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void GeschossZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomGeschoss() );
|
|
|
+ setReturn(zSpiel->getRandomGeschoss());
|
|
|
}
|
|
|
|
|
|
|
|
|
GeschossZuletztAbgefeuert::GeschossZuletztAbgefeuert()
|
|
|
- : Aktion( GESCHOSS_ZULETZT_ABGEFEUERT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(GESCHOSS_ZULETZT_ABGEFEUERT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void GeschossZuletztAbgefeuert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossZuletztAbgefeuert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getGeschossZuletztAbgefeuert() );
|
|
|
+ setReturn(zSpiel->getGeschossZuletztAbgefeuert());
|
|
|
}
|
|
|
|
|
|
|
|
|
GeschossZuletztUmgelenkt::GeschossZuletztUmgelenkt()
|
|
|
- : Aktion( GESCHOSS_ZULETZT_UMGELENKT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(GESCHOSS_ZULETZT_UMGELENKT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void GeschossZuletztUmgelenkt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossZuletztUmgelenkt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getGeschossZuletztUmgelenkt() );
|
|
|
+ setReturn(zSpiel->getGeschossZuletztUmgelenkt());
|
|
|
}
|
|
|
|
|
|
|
|
|
GeschossZuletztBarjereGetroffen::GeschossZuletztBarjereGetroffen()
|
|
|
- : Aktion( GESCHOSS_ZULETZT_BARIERE_GETROFFEN, new RCArray< Aktion >() )
|
|
|
+ : Aktion(GESCHOSS_ZULETZT_BARIERE_GETROFFEN, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void GeschossZuletztBarjereGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossZuletztBarjereGetroffen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getGeschossZuletztBariereGetroffen() );
|
|
|
+ setReturn(zSpiel->getGeschossZuletztBariereGetroffen());
|
|
|
}
|
|
|
|
|
|
|
|
|
GeschossZuletztTunnelBenutzt::GeschossZuletztTunnelBenutzt()
|
|
|
- : Aktion( GESCHOSS_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(GESCHOSS_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void GeschossZuletztTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossZuletztTunnelBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getGeschossZuletztTunnelBenutzt() );
|
|
|
+ setReturn(zSpiel->getGeschossZuletztTunnelBenutzt());
|
|
|
}
|
|
|
|
|
|
|
|
|
GeschossZuletztGeschossGetroffen::GeschossZuletztGeschossGetroffen()
|
|
|
- : Aktion( GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN, new RCArray< Aktion >() )
|
|
|
+ : Aktion(GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void GeschossZuletztGeschossGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void GeschossZuletztGeschossGetroffen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getGeschossZuletztGeschossGetroffen() );
|
|
|
+ setReturn(zSpiel->getGeschossZuletztGeschossGetroffen());
|
|
|
}
|
|
|
|
|
|
|
|
|
RichtungZufall::RichtungZufall()
|
|
|
- : Aktion( RICHTUNG_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(RICHTUNG_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void RichtungZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void RichtungZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( (Richtung)(int)( zSpiel->getRand() * RICHTUNG_ANZAHL ) ) );
|
|
|
+ setReturn(new String((Richtung)(int)(zSpiel->getRand() * RICHTUNG_ANZAHL)));
|
|
|
}
|
|
|
|
|
|
|
|
|
-RichtungVonUmlenkung::RichtungVonUmlenkung( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( RICHTUNG_VON_UMLENKUNG, subActions )
|
|
|
+RichtungVonUmlenkung::RichtungVonUmlenkung(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(RICHTUNG_VON_UMLENKUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( UMLENKUNG );
|
|
|
+ erlaubteTypen.add(UMLENKUNG);
|
|
|
}
|
|
|
|
|
|
-void RichtungVonUmlenkung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void RichtungVonUmlenkung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( ( (Umlenkung *)zParam( 0 ) )->getRichtung() ) );
|
|
|
+ setReturn(new String(((Umlenkung*)zParam(0))->getRichtung()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-RichtungVonGeschoss::RichtungVonGeschoss( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( RICHTUNG_VON_GESCHOSS, subActions )
|
|
|
+RichtungVonGeschoss::RichtungVonGeschoss(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(RICHTUNG_VON_GESCHOSS, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GESCHOSS );
|
|
|
+ erlaubteTypen.add(GESCHOSS);
|
|
|
}
|
|
|
|
|
|
-void RichtungVonGeschoss::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void RichtungVonGeschoss::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( ( (Geschoss *)zParam( 0 ) )->getRichtung() ) );
|
|
|
+ setReturn(new String(((Geschoss*)zParam(0))->getRichtung()));
|
|
|
}
|
|
|
|
|
|
|
|
|
SchalterZufall::SchalterZufall()
|
|
|
- : Aktion( SCHALTER_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SCHALTER_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SchalterZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SchalterZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomSchalter() );
|
|
|
+ setReturn(zSpiel->getRandomSchalter());
|
|
|
}
|
|
|
|
|
|
|
|
|
SchalterZuletztAktiviert::SchalterZuletztAktiviert()
|
|
|
- : Aktion( SCHALTER_ZULETZT_AKTIVIERT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SCHALTER_ZULETZT_AKTIVIERT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SchalterZuletztAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SchalterZuletztAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSchalterZuletztAktiviert() );
|
|
|
+ setReturn(zSpiel->getSchalterZuletztAktiviert());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZufall::SpielerZufall()
|
|
|
- : Aktion( SPIELER_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomSpieler() );
|
|
|
+ setReturn(zSpiel->getRandomSpieler());
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerZufallAusTeam::SpielerZufallAusTeam( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SPIELER_ZUFALL_AUS_TEAM, subActions )
|
|
|
+SpielerZufallAusTeam::SpielerZufallAusTeam(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SPIELER_ZUFALL_AUS_TEAM, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TEAM );
|
|
|
+ erlaubteTypen.add(TEAM);
|
|
|
}
|
|
|
|
|
|
-void SpielerZufallAusTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZufallAusTeam::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomSpieler( (Team *)zParam( 0 ) ) );
|
|
|
+ setReturn(zSpiel->getRandomSpieler((Team*)zParam(0)));
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztSchadenGemacht::SpielerZuletztSchadenGemacht()
|
|
|
- : Aktion( SPIELER_ZULETZT_SCHADEN_GEMACHT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_SCHADEN_GEMACHT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztSchadenGemacht::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztSchadenGemacht::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztSchadenGemacht() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztSchadenGemacht());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztSchadenGenommen::SpielerZuletztSchadenGenommen()
|
|
|
- : Aktion( SPIELER_ZULETZT_SCHADEN_GENOMMEN, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_SCHADEN_GENOMMEN, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztSchadenGenommen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztSchadenGenommen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztSchadenGenommen() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztSchadenGenommen());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztGeheilt::SpielerZuletztGeheilt()
|
|
|
- : Aktion( SPIELER_ZULETZT_GEHEILT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_GEHEILT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztGeheilt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztGeheilt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztGeheilt() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztGeheilt());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztLevelUp::SpielerZuletztLevelUp()
|
|
|
- : Aktion( SPIELER_ZULETZT_LEVEL_UP, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_LEVEL_UP, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztLevelUp::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztLevelUp::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztLevelUp() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztLevelUp());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztErfahrungBekommen::SpielerZuletztErfahrungBekommen()
|
|
|
- : Aktion( SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztErfahrungBekommen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztErfahrungBekommen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztErfahrungBekommen() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztErfahrungBekommen());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztGegenstandAktiviert::SpielerZuletztGegenstandAktiviert()
|
|
|
- : Aktion( SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztGegenstandAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztGegenstandAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztGegenstandAktiviert() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztGegenstandAktiviert());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztGegenstandAufgehoben::SpielerZuletztGegenstandAufgehoben()
|
|
|
- : Aktion( SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztGegenstandAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztGegenstandAufgehoben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztGegenstandAufgehoben() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztGegenstandAufgehoben());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztSchalterAktiviert::SpielerZuletztSchalterAktiviert()
|
|
|
- : Aktion( SPIELER_ZULETZT_SCHALTER_AKTIVIERT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_SCHALTER_AKTIVIERT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztSchalterAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztSchalterAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztSchalterAktiviert() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztSchalterAktiviert());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztTunnelBenutzt::SpielerZuletztTunnelBenutzt()
|
|
|
- : Aktion( SPIELER_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztTunnelBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztTunnelBenutzt() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztTunnelBenutzt());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztGestorben::SpielerZuletztGestorben()
|
|
|
- : Aktion( SPIELER_ZULETZT_GESTORBEN, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_GESTORBEN, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztGestorben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztGestorben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztGestorben() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztGestorben());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztWiederbelebent::SpielerZuletztWiederbelebent()
|
|
|
- : Aktion( SPIELER_ZULETZT_WIEDERBELEBT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_WIEDERBELEBT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztWiederbelebent::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztWiederbelebent::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztWiederbelebt() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztWiederbelebt());
|
|
|
}
|
|
|
|
|
|
|
|
|
SpielerZuletztGeschossGeschossen::SpielerZuletztGeschossGeschossen()
|
|
|
- : Aktion( SPIELER_ZULETZT_GESCHOSSEN, new RCArray< Aktion >() )
|
|
|
+ : Aktion(SPIELER_ZULETZT_GESCHOSSEN, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void SpielerZuletztGeschossGeschossen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerZuletztGeschossGeschossen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getSpielerZuletztGeschossen() );
|
|
|
+ setReturn(zSpiel->getSpielerZuletztGeschossen());
|
|
|
}
|
|
|
|
|
|
|
|
|
-TextConcat::TextConcat( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEXT_CONCAT, subActions )
|
|
|
+TextConcat::TextConcat(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEXT_CONCAT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
}
|
|
|
|
|
|
-void TextConcat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TextConcat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- String *p1 = (String *)zParam( 0 );
|
|
|
- String *p2 = (String *)zParam( 1 );
|
|
|
- String *res = new String( p1->getValue().operator+( p2->getValue().getText() ) );
|
|
|
- setReturn( res );
|
|
|
+ String* p1 = (String*)zParam(0);
|
|
|
+ String* p2 = (String*)zParam(1);
|
|
|
+ String* res = new String(p1->getValue().operator+(p2->getValue().getText()));
|
|
|
+ setReturn(res);
|
|
|
}
|
|
|
|
|
|
|
|
|
-TextAusInteger::TextAusInteger( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEXT_AUS_INTEGER, subActions )
|
|
|
+TextAusInteger::TextAusInteger(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEXT_AUS_INTEGER, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
}
|
|
|
|
|
|
-void TextAusInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TextAusInteger::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( Text( ( (Integer *)zParam( 0 ) )->getValue() ) ) );
|
|
|
+ setReturn(new String(Text(((Integer*)zParam(0))->getValue())));
|
|
|
}
|
|
|
|
|
|
|
|
|
-TextAusRichtung::TextAusRichtung( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEXT_AUS_RICHTUNG, subActions )
|
|
|
+TextAusRichtung::TextAusRichtung(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEXT_AUS_RICHTUNG, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( RICHTUNG );
|
|
|
+ erlaubteTypen.add(RICHTUNG);
|
|
|
}
|
|
|
|
|
|
-void TextAusRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TextAusRichtung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( ( (String *)zParam( 0 ) )->getValue() ) );
|
|
|
+ setReturn(new String(((String*)zParam(0))->getValue()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-TextAusBoolean::TextAusBoolean( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEXT_AUS_BOOLEAN, subActions )
|
|
|
+TextAusBoolean::TextAusBoolean(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEXT_AUS_BOOLEAN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BOOLEAN );
|
|
|
+ erlaubteTypen.add(BOOLEAN);
|
|
|
}
|
|
|
|
|
|
-void TextAusBoolean::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TextAusBoolean::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( ( (Boolean *)zParam( 0 ) )->getValue() ? "true" : "false" ) );
|
|
|
+ setReturn(new String(((Boolean*)zParam(0))->getValue() ? "true" : "false"));
|
|
|
}
|
|
|
|
|
|
|
|
|
-TextSpielerName::TextSpielerName( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEXT_SPIELER_NAME, subActions )
|
|
|
+TextSpielerName::TextSpielerName(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEXT_SPIELER_NAME, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void TextSpielerName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TextSpielerName::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( ( (Spieler *)zParam( 0 ) )->getName() ) );
|
|
|
+ setReturn(new String(((Spieler*)zParam(0))->getName()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-TextItemName::TextItemName( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEXT_ITEM_NAME, subActions )
|
|
|
+TextItemName::TextItemName(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEXT_ITEM_NAME, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GEGENSTAND_TYP );
|
|
|
+ erlaubteTypen.add(GEGENSTAND_TYP);
|
|
|
}
|
|
|
|
|
|
-void TextItemName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TextItemName::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- switch( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() )
|
|
|
- {
|
|
|
- case PFEIL:
|
|
|
- setReturn( new String( "PFEIL" ) );
|
|
|
- break;
|
|
|
- case LEBEN:
|
|
|
- setReturn( new String( "LEBEN" ) );
|
|
|
- break;
|
|
|
- case SCHILD:
|
|
|
- setReturn( new String( "SCHILD" ) );
|
|
|
- break;
|
|
|
- case SCHUH:
|
|
|
- setReturn( new String( "SCHUH" ) );
|
|
|
- break;
|
|
|
- case GEIST:
|
|
|
- setReturn( new String( "GEIST" ) );
|
|
|
- break;
|
|
|
- case KUGEL:
|
|
|
- setReturn( new String( "KUGEL" ) );
|
|
|
- break;
|
|
|
- case ROLLE:
|
|
|
- setReturn( new String( "ROLLE" ) );
|
|
|
- break;
|
|
|
- case STURM:
|
|
|
- setReturn( new String( "STURM" ) );
|
|
|
- break;
|
|
|
- case DRACHENAUGE:
|
|
|
- setReturn( new String( "DRACHENAUGE" ) );
|
|
|
- break;
|
|
|
- case FEUERBALL:
|
|
|
- setReturn( new String( "FEUERBALL" ) );
|
|
|
- break;
|
|
|
- case ENTERHAKEN:
|
|
|
- setReturn( new String( "ENTERHAKEN" ) );
|
|
|
- break;
|
|
|
- case MINE:
|
|
|
- setReturn( new String( "MINE" ) );
|
|
|
- break;
|
|
|
- case RWEISHEIT:
|
|
|
- setReturn( new String( "RWEISHEIT" ) );
|
|
|
- break;
|
|
|
- case RSTRENGTH:
|
|
|
- setReturn( new String( "RSTRENGTH" ) );
|
|
|
- break;
|
|
|
- case RBOSHEIT:
|
|
|
- setReturn( new String( "RBOSHEIT" ) );
|
|
|
- break;
|
|
|
- case RLEBEN:
|
|
|
- setReturn( new String( "RLEBEN" ) );
|
|
|
- break;
|
|
|
- case RTEMPO:
|
|
|
- setReturn( new String( "RTEMPO" ) );
|
|
|
- break;
|
|
|
- default:
|
|
|
- setReturn( new String( "NICHTS" ) );
|
|
|
- break;
|
|
|
- }
|
|
|
+ switch (((GegenstandTypVar*)zParam(0))->getValue())
|
|
|
+ {
|
|
|
+ case PFEIL:
|
|
|
+ setReturn(new String("PFEIL"));
|
|
|
+ break;
|
|
|
+ case LEBEN:
|
|
|
+ setReturn(new String("LEBEN"));
|
|
|
+ break;
|
|
|
+ case SCHILD:
|
|
|
+ setReturn(new String("SCHILD"));
|
|
|
+ break;
|
|
|
+ case SCHUH:
|
|
|
+ setReturn(new String("SCHUH"));
|
|
|
+ break;
|
|
|
+ case GEIST:
|
|
|
+ setReturn(new String("GEIST"));
|
|
|
+ break;
|
|
|
+ case KUGEL:
|
|
|
+ setReturn(new String("KUGEL"));
|
|
|
+ break;
|
|
|
+ case ROLLE:
|
|
|
+ setReturn(new String("ROLLE"));
|
|
|
+ break;
|
|
|
+ case STURM:
|
|
|
+ setReturn(new String("STURM"));
|
|
|
+ break;
|
|
|
+ case DRACHENAUGE:
|
|
|
+ setReturn(new String("DRACHENAUGE"));
|
|
|
+ break;
|
|
|
+ case FEUERBALL:
|
|
|
+ setReturn(new String("FEUERBALL"));
|
|
|
+ break;
|
|
|
+ case ENTERHAKEN:
|
|
|
+ setReturn(new String("ENTERHAKEN"));
|
|
|
+ break;
|
|
|
+ case MINE:
|
|
|
+ setReturn(new String("MINE"));
|
|
|
+ break;
|
|
|
+ case RWEISHEIT:
|
|
|
+ setReturn(new String("RWEISHEIT"));
|
|
|
+ break;
|
|
|
+ case RSTRENGTH:
|
|
|
+ setReturn(new String("RSTRENGTH"));
|
|
|
+ break;
|
|
|
+ case RBOSHEIT:
|
|
|
+ setReturn(new String("RBOSHEIT"));
|
|
|
+ break;
|
|
|
+ case RLEBEN:
|
|
|
+ setReturn(new String("RLEBEN"));
|
|
|
+ break;
|
|
|
+ case RTEMPO:
|
|
|
+ setReturn(new String("RTEMPO"));
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ setReturn(new String("NICHTS"));
|
|
|
+ break;
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
|
|
|
-TextTriggerName::TextTriggerName( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEXT_TRIGGER_NAME, subActions )
|
|
|
+TextTriggerName::TextTriggerName(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEXT_TRIGGER_NAME, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TRIGGER );
|
|
|
+ erlaubteTypen.add(TRIGGER);
|
|
|
}
|
|
|
|
|
|
-void TextTriggerName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TextTriggerName::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( ( (Trigger *)zParam( 0 ) )->getName() ) );
|
|
|
+ setReturn(new String(((Trigger*)zParam(0))->getName()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-TextTeilVonText::TextTeilVonText( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEXT_TEIL_VON_TEXT, subActions )
|
|
|
+TextTeilVonText::TextTeilVonText(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEXT_TEIL_VON_TEXT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
}
|
|
|
|
|
|
-void TextTeilVonText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TextTeilVonText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- Text *txt = ( (String *)zParam( 2 ) )->getValue().getTeilText( ( (Integer *)zParam( 0 ) )->getValue(), ( (Integer *)zParam( 1 ) )->getValue() );
|
|
|
- setReturn( new String( txt->getText() ) );
|
|
|
- txt->release();
|
|
|
+ Text* txt = ((String*)zParam(2))->getValue().getTeilText(((Integer*)zParam(0))->getValue(), ((Integer*)zParam(1))->getValue());
|
|
|
+ setReturn(new String(txt->getText()));
|
|
|
+ txt->release();
|
|
|
}
|
|
|
|
|
|
|
|
|
TeamZufall::TeamZufall()
|
|
|
- : Aktion( TEAM_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(TEAM_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void TeamZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TeamZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomTeam() );
|
|
|
+ setReturn(zSpiel->getRandomTeam());
|
|
|
}
|
|
|
|
|
|
|
|
|
-TeamVonSpieler::TeamVonSpieler( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEAM_VON_SPIELER, subActions )
|
|
|
+TeamVonSpieler::TeamVonSpieler(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEAM_VON_SPIELER, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void TeamVonSpieler::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TeamVonSpieler::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( ( (Spieler *)zParam( 0 ) )->getTeam() );
|
|
|
+ setReturn(((Spieler*)zParam(0))->getTeam());
|
|
|
}
|
|
|
|
|
|
|
|
|
-TeamVonBariere::TeamVonBariere( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEAM_VON_BARIERE, subActions )
|
|
|
+TeamVonBariere::TeamVonBariere(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEAM_VON_BARIERE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BARIERE );
|
|
|
+ erlaubteTypen.add(BARIERE);
|
|
|
}
|
|
|
|
|
|
-void TeamVonBariere::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TeamVonBariere::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( ( (Bariere *)zParam( 0 ) )->getTeam() );
|
|
|
+ setReturn(((Bariere*)zParam(0))->getTeam());
|
|
|
}
|
|
|
|
|
|
|
|
|
TimerZufall::TimerZufall()
|
|
|
- : Aktion( TIMER_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(TIMER_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void TimerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TimerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomTimer() );
|
|
|
+ setReturn(zSpiel->getRandomTimer());
|
|
|
}
|
|
|
|
|
|
|
|
|
TimerZuletztAbgelaufen::TimerZuletztAbgelaufen()
|
|
|
- : Aktion( TIMER_ZULETZT_ABGELAUFEN, new RCArray< Aktion >() )
|
|
|
+ : Aktion(TIMER_ZULETZT_ABGELAUFEN, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void TimerZuletztAbgelaufen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TimerZuletztAbgelaufen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getTimerZuletztAbgelaufen() );
|
|
|
+ setReturn(zSpiel->getTimerZuletztAbgelaufen());
|
|
|
}
|
|
|
|
|
|
|
|
|
TimerZuletztGestartet::TimerZuletztGestartet()
|
|
|
- : Aktion( TIMER_ZULETZT_GESTARTET, new RCArray< Aktion >() )
|
|
|
+ : Aktion(TIMER_ZULETZT_GESTARTET, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void TimerZuletztGestartet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TimerZuletztGestartet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getTimerZuletztGestartet() );
|
|
|
+ setReturn(zSpiel->getTimerZuletztGestartet());
|
|
|
}
|
|
|
|
|
|
|
|
|
TimerZuletztPausiert::TimerZuletztPausiert()
|
|
|
- : Aktion( TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void TimerZuletztPausiert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TimerZuletztPausiert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getTimerZuletztPausiert() );
|
|
|
+ setReturn(zSpiel->getTimerZuletztPausiert());
|
|
|
}
|
|
|
|
|
|
|
|
|
TimerZuletztFortgesetzt::TimerZuletztFortgesetzt()
|
|
|
- : Aktion( TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void TimerZuletztFortgesetzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TimerZuletztFortgesetzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getTimerZuletztFortgesetzt() );
|
|
|
+ setReturn(zSpiel->getTimerZuletztFortgesetzt());
|
|
|
}
|
|
|
|
|
|
|
|
|
TunnelZufall::TunnelZufall()
|
|
|
- : Aktion( TUNNEL_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(TUNNEL_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void TunnelZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TunnelZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomTunnel() );
|
|
|
+ setReturn(zSpiel->getRandomTunnel());
|
|
|
}
|
|
|
|
|
|
|
|
|
TunnelZuletztBenutzt::TunnelZuletztBenutzt()
|
|
|
- : Aktion( TUNNEL_ZULETZT_BENUTZT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(TUNNEL_ZULETZT_BENUTZT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void TunnelZuletztBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TunnelZuletztBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getTunnelZuletztBenutzt() );
|
|
|
+ setReturn(zSpiel->getTunnelZuletztBenutzt());
|
|
|
}
|
|
|
|
|
|
|
|
|
UmlenkungZufall::UmlenkungZufall()
|
|
|
- : Aktion( UMLENKUNG_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(UMLENKUNG_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void UmlenkungZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void UmlenkungZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRandomUmlenkung() );
|
|
|
+ setReturn(zSpiel->getRandomUmlenkung());
|
|
|
}
|
|
|
|
|
|
|
|
|
UmlenkungZuletztBenutzt::UmlenkungZuletztBenutzt()
|
|
|
- : Aktion( UMLENKUNG_ZULETZT_BENUTZT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(UMLENKUNG_ZULETZT_BENUTZT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void UmlenkungZuletztBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void UmlenkungZuletztBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getUmlenkungZuletztBenutzt() );
|
|
|
+ setReturn(zSpiel->getUmlenkungZuletztBenutzt());
|
|
|
}
|
|
|
|
|
|
|
|
|
BooleanZufall::BooleanZufall()
|
|
|
- : Aktion( BOOLEAN_ZUFALL, new RCArray< Aktion >() )
|
|
|
+ : Aktion(BOOLEAN_ZUFALL, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void BooleanZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getRand() < 0.5 ? new Boolean( false ) : new Boolean( true ) );
|
|
|
+ setReturn(zSpiel->getRand() < 0.5 ? new Boolean(false) : new Boolean(true));
|
|
|
}
|
|
|
|
|
|
|
|
|
BooleanSpielPausiert::BooleanSpielPausiert()
|
|
|
- : Aktion( BOOLEAN_SPIEL_PAUSIERT, new RCArray< Aktion >() )
|
|
|
+ : Aktion(BOOLEAN_SPIEL_PAUSIERT, new RCArray< Aktion >())
|
|
|
{}
|
|
|
|
|
|
-void BooleanSpielPausiert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanSpielPausiert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( zSpiel->istPausiert() ) );
|
|
|
+ setReturn(new Boolean(zSpiel->istPausiert()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanSpielerAmLeben::BooleanSpielerAmLeben( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_SPIELER_AM_LEBEN, subActions )
|
|
|
+BooleanSpielerAmLeben::BooleanSpielerAmLeben(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_SPIELER_AM_LEBEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void BooleanSpielerAmLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanSpielerAmLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Spieler *)zParam( 0 ) )->istAmLeben() ) );
|
|
|
+ setReturn(new Boolean(((Spieler*)zParam(0))->istAmLeben()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanSpielerHatGegenstand::BooleanSpielerHatGegenstand( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_SPIELER_HAT_GEGENSTAND, subActions )
|
|
|
+BooleanSpielerHatGegenstand::BooleanSpielerHatGegenstand(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_SPIELER_HAT_GEGENSTAND, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GEGENSTAND_TYP );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(GEGENSTAND_TYP);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void BooleanSpielerHatGegenstand::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanSpielerHatGegenstand::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->getItemsInInventory( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) != 0 ) );
|
|
|
+ setReturn(new Boolean(((Spieler*)zParam(1))->getItemsInInventory(((GegenstandTypVar*)zParam(0))->getValue()) != 0));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanSpielerIstVerwundbar::BooleanSpielerIstVerwundbar( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_SPIELER_IST_VERWUNDBAR, subActions )
|
|
|
+BooleanSpielerIstVerwundbar::BooleanSpielerIstVerwundbar(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_SPIELER_IST_VERWUNDBAR, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( RICHTUNG );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(RICHTUNG);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void BooleanSpielerIstVerwundbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanSpielerIstVerwundbar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->isVerwundbar( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) ) ) );
|
|
|
+ setReturn(new Boolean(((Spieler*)zParam(1))->isVerwundbar(getRichtungFromString(((String*)zParam(0))->getValue()))));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanSpielerKannItemBenutzen::BooleanSpielerKannItemBenutzen( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN, subActions )
|
|
|
+BooleanSpielerKannItemBenutzen::BooleanSpielerKannItemBenutzen(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( GEGENSTAND_TYP );
|
|
|
- erlaubteTypen.add( SPIELER );
|
|
|
+ erlaubteTypen.add(GEGENSTAND_TYP);
|
|
|
+ erlaubteTypen.add(SPIELER);
|
|
|
}
|
|
|
|
|
|
-void BooleanSpielerKannItemBenutzen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanSpielerKannItemBenutzen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->istGegenstandErlaubt( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) ) );
|
|
|
+ setReturn(new Boolean(((Spieler*)zParam(1))->istGegenstandErlaubt(((GegenstandTypVar*)zParam(0))->getValue())));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanUmlenkungHatAbk::BooleanUmlenkungHatAbk( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_UMLENKUNG_HAT_ABK, subActions )
|
|
|
+BooleanUmlenkungHatAbk::BooleanUmlenkungHatAbk(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_UMLENKUNG_HAT_ABK, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( UMLENKUNG );
|
|
|
+ erlaubteTypen.add(UMLENKUNG);
|
|
|
}
|
|
|
|
|
|
-void BooleanUmlenkungHatAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanUmlenkungHatAbk::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Umlenkung *)zParam( 0 ) )->hatAbklingzeit() ) );
|
|
|
+ setReturn(new Boolean(((Umlenkung*)zParam(0))->hatAbklingzeit()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanUmlenkungIstDrehend::BooleanUmlenkungIstDrehend( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_UMLENKUNG_IST_DREHEND, subActions )
|
|
|
+BooleanUmlenkungIstDrehend::BooleanUmlenkungIstDrehend(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_UMLENKUNG_IST_DREHEND, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( UMLENKUNG );
|
|
|
+ erlaubteTypen.add(UMLENKUNG);
|
|
|
}
|
|
|
|
|
|
-void BooleanUmlenkungIstDrehend::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanUmlenkungIstDrehend::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Umlenkung *)zParam( 0 ) )->istDrehend() ) );
|
|
|
+ setReturn(new Boolean(((Umlenkung*)zParam(0))->istDrehend()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanBariereBewegtSich::BooleanBariereBewegtSich( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_BARIERE_BEWEGT_SICH, subActions )
|
|
|
+BooleanBariereBewegtSich::BooleanBariereBewegtSich(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_BARIERE_BEWEGT_SICH, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BARIERE );
|
|
|
+ erlaubteTypen.add(BARIERE);
|
|
|
}
|
|
|
|
|
|
-void BooleanBariereBewegtSich::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanBariereBewegtSich::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::InVerschiebung ) ) );
|
|
|
+ setReturn(new Boolean(((Bariere*)zParam(0))->hatStyle(Bariere::Style::InVerschiebung)));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanBariereIstSchaltend::BooleanBariereIstSchaltend( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_BARIERE_IST_SCHALTEND, subActions )
|
|
|
+BooleanBariereIstSchaltend::BooleanBariereIstSchaltend(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_BARIERE_IST_SCHALTEND, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BARIERE );
|
|
|
+ erlaubteTypen.add(BARIERE);
|
|
|
}
|
|
|
|
|
|
-void BooleanBariereIstSchaltend::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanBariereIstSchaltend::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::AutoSchaltung ) ) );
|
|
|
+ setReturn(new Boolean(((Bariere*)zParam(0))->hatStyle(Bariere::Style::AutoSchaltung)));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanBariereIstAktiv::BooleanBariereIstAktiv( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_BARIERE_IST_AKTIV, subActions )
|
|
|
+BooleanBariereIstAktiv::BooleanBariereIstAktiv(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_BARIERE_IST_AKTIV, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BARIERE );
|
|
|
+ erlaubteTypen.add(BARIERE);
|
|
|
}
|
|
|
|
|
|
-void BooleanBariereIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanBariereIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::Aktiv ) ) );
|
|
|
+ setReturn(new Boolean(((Bariere*)zParam(0))->hatStyle(Bariere::Style::Aktiv)));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanSchalterIstAktiv::BooleanSchalterIstAktiv( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_SCHALTER_IST_AKTIV, subActions )
|
|
|
+BooleanSchalterIstAktiv::BooleanSchalterIstAktiv(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_SCHALTER_IST_AKTIV, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( SCHALTER );
|
|
|
+ erlaubteTypen.add(SCHALTER);
|
|
|
}
|
|
|
|
|
|
-void BooleanSchalterIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanSchalterIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Schalter *)zParam( 0 ) )->isAktive() ) );
|
|
|
+ setReturn(new Boolean(((Schalter*)zParam(0))->isAktive()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanTunnelIstAktiv::BooleanTunnelIstAktiv( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_TUNNEL_IST_AKTIV, subActions )
|
|
|
+BooleanTunnelIstAktiv::BooleanTunnelIstAktiv(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_TUNNEL_IST_AKTIV, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TUNNEL );
|
|
|
+ erlaubteTypen.add(TUNNEL);
|
|
|
}
|
|
|
|
|
|
-void BooleanTunnelIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanTunnelIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Tunnel *)zParam( 0 ) )->istAktiv() ) );
|
|
|
+ setReturn(new Boolean(((Tunnel*)zParam(0))->istAktiv()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanBaseIstNeutral::BooleanBaseIstNeutral( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_BASE_IST_NEUTRAL, subActions )
|
|
|
+BooleanBaseIstNeutral::BooleanBaseIstNeutral(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_BASE_IST_NEUTRAL, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BASE );
|
|
|
+ erlaubteTypen.add(BASE);
|
|
|
}
|
|
|
|
|
|
-void BooleanBaseIstNeutral::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanBaseIstNeutral::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Base *)zParam( 0 ) )->zTeam() == 0 ) );
|
|
|
+ setReturn(new Boolean(((Base*)zParam(0))->zTeam() == 0));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanTimerIsRunning::BooleanTimerIsRunning( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_TIMER_IS_RUNNING, subActions )
|
|
|
+BooleanTimerIsRunning::BooleanTimerIsRunning(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_TIMER_IS_RUNNING, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TIMER );
|
|
|
+ erlaubteTypen.add(TIMER);
|
|
|
}
|
|
|
|
|
|
-void BooleanTimerIsRunning::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanTimerIsRunning::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Timer *)zParam( 0 ) )->isRunning() ) );
|
|
|
+ setReturn(new Boolean(((Timer*)zParam(0))->isRunning()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanTimerIstSichtbar::BooleanTimerIstSichtbar( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_TIMER_IST_SICHTBAR, subActions )
|
|
|
+BooleanTimerIstSichtbar::BooleanTimerIstSichtbar(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_TIMER_IST_SICHTBAR, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TIMER );
|
|
|
+ erlaubteTypen.add(TIMER);
|
|
|
}
|
|
|
|
|
|
-void BooleanTimerIstSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanTimerIstSichtbar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Timer *)zParam( 0 ) )->istSichtbar() ) );
|
|
|
+ setReturn(new Boolean(((Timer*)zParam(0))->istSichtbar()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanAusText::BooleanAusText( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_AUS_TEXT, subActions )
|
|
|
+BooleanAusText::BooleanAusText(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_AUS_TEXT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
}
|
|
|
|
|
|
-void BooleanAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanAusText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (String *)zParam( 0 ) )->getValue().istGleich( "true" ) ) );
|
|
|
+ setReturn(new Boolean(((String*)zParam(0))->getValue().istGleich("true")));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanTriggerIstAktiv::BooleanTriggerIstAktiv( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( BOOLEAN_TRIGGER_IST_AKTIV, subActions )
|
|
|
+BooleanTriggerIstAktiv::BooleanTriggerIstAktiv(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(BOOLEAN_TRIGGER_IST_AKTIV, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( TRIGGER );
|
|
|
+ erlaubteTypen.add(TRIGGER);
|
|
|
}
|
|
|
|
|
|
-void BooleanTriggerIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanTriggerIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Boolean( ( (Trigger *)zParam( 0 ) )->istAktiv() ) );
|
|
|
+ setReturn(new Boolean(((Trigger*)zParam(0))->istAktiv()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BooleanRechnung::BooleanRechnung( RCArray< Aktion > *subActions, Operator op )
|
|
|
- : Aktion( BOOLEAN_RECHNUNG, subActions )
|
|
|
+BooleanRechnung::BooleanRechnung(RCArray< Aktion >* subActions, Operator op)
|
|
|
+ : Aktion(BOOLEAN_RECHNUNG, subActions)
|
|
|
{
|
|
|
- this->op = op;
|
|
|
+ this->op = op;
|
|
|
}
|
|
|
|
|
|
-void BooleanRechnung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BooleanRechnung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- if( op == UND || op == ODER )
|
|
|
- {
|
|
|
- if( zParam( 0 )->getVariableTyp() != BOOLEAN || zParam( 1 )->getVariableTyp() != BOOLEAN )
|
|
|
- return;
|
|
|
- Boolean *b1 = (Boolean *)zParam( 0 );
|
|
|
- Boolean *b2 = (Boolean *)zParam( 1 );
|
|
|
- if( op == UND )
|
|
|
- setReturn( new Boolean( b1->getValue() && b2->getValue() ) );
|
|
|
- else
|
|
|
- setReturn( new Boolean( b1->getValue() || b2->getValue() ) );
|
|
|
- }
|
|
|
- if( op == GLEICH || op == UNGLEICH )
|
|
|
- {
|
|
|
- if( zParam( 1 )->getVariableTyp() != zParam( 0 )->getVariableTyp() )
|
|
|
- {
|
|
|
- setReturn( new Boolean( op == GLEICH ) );
|
|
|
- return;
|
|
|
- }
|
|
|
- switch( zParam( 0 )->getVariableTyp() )
|
|
|
- {
|
|
|
- case NICHTS:
|
|
|
- setReturn( new Boolean( op == GLEICH ) );
|
|
|
- break;
|
|
|
- case INTEGER:
|
|
|
- setReturn( new Boolean( ( op == GLEICH ) == ( ( (Integer *)zParam( 0 ) )->getValue() == ( (Integer *)zParam( 1 ) )->getValue() ) ) );
|
|
|
- break;
|
|
|
- case BOOLEAN:
|
|
|
- setReturn( new Boolean( ( op == GLEICH ) == ( ( (Boolean *)zParam( 0 ) )->getValue() == ( (Boolean *)zParam( 1 ) )->getValue() ) ) );
|
|
|
- break;
|
|
|
- case STRING:
|
|
|
- setReturn( new Boolean( ( op == GLEICH ) == ( ( (String *)zParam( 0 ) )->getValue().istGleich( ( (String *)zParam( 1 ) )->getValue() ) ) ) );
|
|
|
- break;
|
|
|
- case RICHTUNG:
|
|
|
- setReturn( new Boolean( ( op == GLEICH ) == ( ( (String *)zParam( 0 ) )->getValue().istGleich( ( (String *)zParam( 1 ) )->getValue() ) ) ) );
|
|
|
- break;
|
|
|
- case FLOAT:
|
|
|
- setReturn( new Boolean( ( op == GLEICH ) == ( ( (Float *)zParam( 0 ) )->getValue() == ( (Float *)zParam( 1 ) )->getValue() ) ) );
|
|
|
- break;
|
|
|
- case TASTE:
|
|
|
- setReturn( new Boolean( ( op == GLEICH ) == ( ( (Integer *)zParam( 0 ) )->getValue() == ( (Integer *)zParam( 1 ) )->getValue() ) ) );
|
|
|
- break;
|
|
|
- case GEGENSTAND_TYP:
|
|
|
- setReturn( new Boolean( ( op == GLEICH ) == ( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() == ( (GegenstandTypVar *)zParam( 1 ) )->getValue() ) ) );
|
|
|
- break;
|
|
|
- case GESCHOSS_TYP:
|
|
|
- setReturn( new Boolean( ( op == GLEICH ) == ( ( (String *)zParam( 0 ) )->getValue().istGleich( ( (String *)zParam( 1 ) )->getValue() ) ) ) );
|
|
|
- break;
|
|
|
- default:
|
|
|
- setReturn( new Boolean( ( op == GLEICH ) == ( zParam( 0 ) == zParam( 1 ) ) ) );
|
|
|
- }
|
|
|
- }
|
|
|
- if( op == GREATER || op == SMALLER || op == GREATER_OR_EQUAL || op == SMALLER_OR_EQUAL )
|
|
|
- {
|
|
|
- if( zParam( 1 )->getVariableTyp() != zParam( 0 )->getVariableTyp() )
|
|
|
- {
|
|
|
- setReturn( new Boolean( op == GLEICH ) );
|
|
|
- return;
|
|
|
- }
|
|
|
- if( zParam( 1 )->getVariableTyp() == INTEGER )
|
|
|
- {
|
|
|
- if( op == SMALLER || op == GREATER_OR_EQUAL )
|
|
|
- setReturn( new Boolean( ( op == SMALLER ) == ( ( (Integer *)zParam( 0 ) )->getValue() < ( (Integer *)zParam( 1 ) )->getValue() ) ) );
|
|
|
- else
|
|
|
- setReturn( new Boolean( ( op == GREATER ) == ( ( (Integer *)zParam( 0 ) )->getValue() > ( (Integer *)zParam( 1 ) )->getValue() ) ) );
|
|
|
- }
|
|
|
- if( zParam( 1 )->getVariableTyp() == FLOAT )
|
|
|
- {
|
|
|
- if( op == SMALLER || op == GREATER_OR_EQUAL )
|
|
|
- setReturn( new Boolean( ( op == SMALLER ) == ( ( (Float *)zParam( 0 ) )->getValue() < ( (Float *)zParam( 1 ) )->getValue() ) ) );
|
|
|
- else
|
|
|
- setReturn( new Boolean( ( op == GREATER ) == ( ( (Float *)zParam( 0 ) )->getValue() > ( (Float *)zParam( 1 ) )->getValue() ) ) );
|
|
|
- }
|
|
|
- }
|
|
|
- if( op == INVERT_BOOL )
|
|
|
- {
|
|
|
- setReturn( new Boolean( !( (Boolean *)zParam( 0 ) )->getValue() ) );
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void BooleanRechnung::writeOptions( Datei &dat )
|
|
|
-{
|
|
|
- dat.schreibe( (char *)&this->op, 1 );
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-Sequenz::Sequenz( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( SEQUENZ, subActions )
|
|
|
+ if (op == UND || op == ODER)
|
|
|
+ {
|
|
|
+ if (zParam(0)->getVariableTyp() != BOOLEAN || zParam(1)->getVariableTyp() != BOOLEAN)
|
|
|
+ return;
|
|
|
+ Boolean* b1 = (Boolean*)zParam(0);
|
|
|
+ Boolean* b2 = (Boolean*)zParam(1);
|
|
|
+ if (op == UND)
|
|
|
+ setReturn(new Boolean(b1->getValue() && b2->getValue()));
|
|
|
+ else
|
|
|
+ setReturn(new Boolean(b1->getValue() || b2->getValue()));
|
|
|
+ }
|
|
|
+ if (op == GLEICH || op == UNGLEICH)
|
|
|
+ {
|
|
|
+ if (zParam(1)->getVariableTyp() != zParam(0)->getVariableTyp())
|
|
|
+ {
|
|
|
+ setReturn(new Boolean(op == GLEICH));
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ switch (zParam(0)->getVariableTyp())
|
|
|
+ {
|
|
|
+ case NICHTS:
|
|
|
+ setReturn(new Boolean(op == GLEICH));
|
|
|
+ break;
|
|
|
+ case INTEGER:
|
|
|
+ setReturn(new Boolean((op == GLEICH) == (((Integer*)zParam(0))->getValue() == ((Integer*)zParam(1))->getValue())));
|
|
|
+ break;
|
|
|
+ case BOOLEAN:
|
|
|
+ setReturn(new Boolean((op == GLEICH) == (((Boolean*)zParam(0))->getValue() == ((Boolean*)zParam(1))->getValue())));
|
|
|
+ break;
|
|
|
+ case STRING:
|
|
|
+ setReturn(new Boolean((op == GLEICH) == (((String*)zParam(0))->getValue().istGleich(((String*)zParam(1))->getValue()))));
|
|
|
+ break;
|
|
|
+ case RICHTUNG:
|
|
|
+ setReturn(new Boolean((op == GLEICH) == (((String*)zParam(0))->getValue().istGleich(((String*)zParam(1))->getValue()))));
|
|
|
+ break;
|
|
|
+ case FLOAT:
|
|
|
+ setReturn(new Boolean((op == GLEICH) == (((Float*)zParam(0))->getValue() == ((Float*)zParam(1))->getValue())));
|
|
|
+ break;
|
|
|
+ case TASTE:
|
|
|
+ setReturn(new Boolean((op == GLEICH) == (((Integer*)zParam(0))->getValue() == ((Integer*)zParam(1))->getValue())));
|
|
|
+ break;
|
|
|
+ case GEGENSTAND_TYP:
|
|
|
+ setReturn(new Boolean((op == GLEICH) == (((GegenstandTypVar*)zParam(0))->getValue() == ((GegenstandTypVar*)zParam(1))->getValue())));
|
|
|
+ break;
|
|
|
+ case GESCHOSS_TYP:
|
|
|
+ setReturn(new Boolean((op == GLEICH) == (((String*)zParam(0))->getValue().istGleich(((String*)zParam(1))->getValue()))));
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ setReturn(new Boolean((op == GLEICH) == (zParam(0) == zParam(1))));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (op == GREATER || op == SMALLER || op == GREATER_OR_EQUAL || op == SMALLER_OR_EQUAL)
|
|
|
+ {
|
|
|
+ if (zParam(1)->getVariableTyp() != zParam(0)->getVariableTyp())
|
|
|
+ {
|
|
|
+ setReturn(new Boolean(op == GLEICH));
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (zParam(1)->getVariableTyp() == INTEGER)
|
|
|
+ {
|
|
|
+ if (op == SMALLER || op == GREATER_OR_EQUAL)
|
|
|
+ setReturn(new Boolean((op == SMALLER) == (((Integer*)zParam(0))->getValue() < ((Integer*)zParam(1))->getValue())));
|
|
|
+ else
|
|
|
+ setReturn(new Boolean((op == GREATER) == (((Integer*)zParam(0))->getValue() > ((Integer*)zParam(1))->getValue())));
|
|
|
+ }
|
|
|
+ if (zParam(1)->getVariableTyp() == FLOAT)
|
|
|
+ {
|
|
|
+ if (op == SMALLER || op == GREATER_OR_EQUAL)
|
|
|
+ setReturn(new Boolean((op == SMALLER) == (((Float*)zParam(0))->getValue() < ((Float*)zParam(1))->getValue())));
|
|
|
+ else
|
|
|
+ setReturn(new Boolean((op == GREATER) == (((Float*)zParam(0))->getValue() > ((Float*)zParam(1))->getValue())));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (op == INVERT_BOOL)
|
|
|
+ {
|
|
|
+ setReturn(new Boolean(!((Boolean*)zParam(0))->getValue()));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanRechnung::writeOptions(Datei& dat)
|
|
|
+{
|
|
|
+ dat.schreibe((char*)&this->op, 1);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+Sequenz::Sequenz(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(SEQUENZ, subActions)
|
|
|
{}
|
|
|
|
|
|
-void Sequenz::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void Sequenz::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{}
|
|
|
|
|
|
|
|
|
-FloatRechnung::FloatRechnung( RCArray< Aktion > *subActions, Operator op )
|
|
|
- : Aktion( FLOAT_RECHNUNG, subActions )
|
|
|
+FloatRechnung::FloatRechnung(RCArray< Aktion >* subActions, Operator op)
|
|
|
+ : Aktion(FLOAT_RECHNUNG, subActions)
|
|
|
{
|
|
|
- this->op = op;
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
+ this->op = op;
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
}
|
|
|
|
|
|
-void FloatRechnung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatRechnung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- Float *l = (Float *)zParam( 0 );
|
|
|
- Float *r = (Float *)zParam( 1 );
|
|
|
- switch( op )
|
|
|
- {
|
|
|
- case PLUS:
|
|
|
- setReturn( new Float( l->getValue() + r->getValue() ) );
|
|
|
- break;
|
|
|
- case MINUS:
|
|
|
- setReturn( new Float( l->getValue() - r->getValue() ) );
|
|
|
- break;
|
|
|
- case MAHL:
|
|
|
- setReturn( new Float( l->getValue() * r->getValue() ) );
|
|
|
- break;
|
|
|
- case GETEILT:
|
|
|
- setReturn( new Float( l->getValue() / r->getValue() ) );
|
|
|
- break;
|
|
|
- case HOCH:
|
|
|
- setReturn( new Float( (float)pow( l->getValue(), r->getValue() ) ) );
|
|
|
- break;
|
|
|
- case WURZEL:
|
|
|
- setReturn( new Float( (float)pow( l->getValue(), 1.0 / r->getValue() ) ) );
|
|
|
- break;
|
|
|
- case INVERT_SIGN:
|
|
|
- setReturn( new Float( -l->getValue() ) );
|
|
|
- break;
|
|
|
- case PLUS_PLUS_LEFT:
|
|
|
- l->setValue( l->getValue() + 1 );
|
|
|
- setReturn( new Float( l->getValue() ) );
|
|
|
- break;
|
|
|
- case PLUS_PLUS_RIGHT:
|
|
|
- {
|
|
|
- float tmp = l->getValue();
|
|
|
- l->setValue( l->getValue() + 1 );
|
|
|
- setReturn( new Float( tmp ) );
|
|
|
- break;
|
|
|
- }
|
|
|
- case MINUS_MINUS_LEFT:
|
|
|
- l->setValue( l->getValue() - 1 );
|
|
|
- setReturn( new Float( l->getValue() ) );
|
|
|
- break;
|
|
|
- case MINUS_MINUS_RIGHT:
|
|
|
- {
|
|
|
- float tmp = l->getValue();
|
|
|
- l->setValue( l->getValue() - 1 );
|
|
|
- setReturn( new Float( tmp ) );
|
|
|
- break;
|
|
|
- }
|
|
|
- case LOGARITHM:
|
|
|
- setReturn( new Float( (float)( log( l->getValue() ) / log( r->getValue() ) ) ) );
|
|
|
- break;
|
|
|
- case MODULO:
|
|
|
- setReturn( new Float( l->getValue() - (float)(int)( l->getValue() / r->getValue() ) * r->getValue() ) );
|
|
|
- break;
|
|
|
- default:
|
|
|
- break;
|
|
|
- }
|
|
|
+ Float* l = (Float*)zParam(0);
|
|
|
+ Float* r = (Float*)zParam(1);
|
|
|
+ switch (op)
|
|
|
+ {
|
|
|
+ case PLUS:
|
|
|
+ setReturn(new Float(l->getValue() + r->getValue()));
|
|
|
+ break;
|
|
|
+ case MINUS:
|
|
|
+ setReturn(new Float(l->getValue() - r->getValue()));
|
|
|
+ break;
|
|
|
+ case MAHL:
|
|
|
+ setReturn(new Float(l->getValue() * r->getValue()));
|
|
|
+ break;
|
|
|
+ case GETEILT:
|
|
|
+ setReturn(new Float(l->getValue() / r->getValue()));
|
|
|
+ break;
|
|
|
+ case HOCH:
|
|
|
+ setReturn(new Float((float)pow(l->getValue(), r->getValue())));
|
|
|
+ break;
|
|
|
+ case WURZEL:
|
|
|
+ setReturn(new Float((float)pow(l->getValue(), 1.0 / r->getValue())));
|
|
|
+ break;
|
|
|
+ case INVERT_SIGN:
|
|
|
+ setReturn(new Float(-l->getValue()));
|
|
|
+ break;
|
|
|
+ case PLUS_PLUS_LEFT:
|
|
|
+ l->setValue(l->getValue() + 1);
|
|
|
+ setReturn(new Float(l->getValue()));
|
|
|
+ break;
|
|
|
+ case PLUS_PLUS_RIGHT:
|
|
|
+ {
|
|
|
+ float tmp = l->getValue();
|
|
|
+ l->setValue(l->getValue() + 1);
|
|
|
+ setReturn(new Float(tmp));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case MINUS_MINUS_LEFT:
|
|
|
+ l->setValue(l->getValue() - 1);
|
|
|
+ setReturn(new Float(l->getValue()));
|
|
|
+ break;
|
|
|
+ case MINUS_MINUS_RIGHT:
|
|
|
+ {
|
|
|
+ float tmp = l->getValue();
|
|
|
+ l->setValue(l->getValue() - 1);
|
|
|
+ setReturn(new Float(tmp));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case LOGARITHM:
|
|
|
+ setReturn(new Float((float)(log(l->getValue()) / log(r->getValue()))));
|
|
|
+ break;
|
|
|
+ case MODULO:
|
|
|
+ setReturn(new Float(l->getValue() - (float)(int)(l->getValue() / r->getValue()) * r->getValue()));
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-void FloatRechnung::writeOptions( Datei &dat )
|
|
|
+void FloatRechnung::writeOptions(Datei& dat)
|
|
|
{
|
|
|
- dat.schreibe( (char *)&op, 1 );
|
|
|
+ dat.schreibe((char*)&op, 1);
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatAusInteger::FloatAusInteger( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( FLOAT_AUS_INTEGER, subActions )
|
|
|
+FloatAusInteger::FloatAusInteger(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(FLOAT_AUS_INTEGER, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
}
|
|
|
|
|
|
-void FloatAusInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatAusInteger::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( (float)( (Integer *)zParam( 0 ) )->getValue() ) );
|
|
|
+ setReturn(new Float((float)((Integer*)zParam(0))->getValue()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatAusText::FloatAusText( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( FLOAT_AUS_TEXT, subActions )
|
|
|
+FloatAusText::FloatAusText(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(FLOAT_AUS_TEXT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
}
|
|
|
|
|
|
-void FloatAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatAusText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Float( (float)( (String *)zParam( 0 ) )->getValue() ) );
|
|
|
+ setReturn(new Float((float)((String*)zParam(0))->getValue()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-TextAusFloat::TextAusFloat( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( TEXT_AUS_FLOAT, subActions )
|
|
|
+TextAusFloat::TextAusFloat(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(TEXT_AUS_FLOAT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
}
|
|
|
|
|
|
-void TextAusFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TextAusFloat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( Text( ( (Float *)zParam( 0 ) )->getValue() ) ) );
|
|
|
+ setReturn(new String(Text(((Float*)zParam(0))->getValue())));
|
|
|
}
|
|
|
|
|
|
|
|
|
-FloatZufall::FloatZufall( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( FLOAT_ZUFALL, subActions )
|
|
|
+FloatZufall::FloatZufall(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(FLOAT_ZUFALL, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
}
|
|
|
|
|
|
-void FloatZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void FloatZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- Float *min = ( (Float *)zParam( 0 ) );
|
|
|
- Float *max = ( (Float *)zParam( 0 ) );
|
|
|
- setReturn( new Float( (float)zSpiel->getRand() * ( max->getValue() - min->getValue() ) + min->getValue() ) );
|
|
|
+ Float* min = ((Float*)zParam(0));
|
|
|
+ Float* max = ((Float*)zParam(0));
|
|
|
+ setReturn(new Float((float)zSpiel->getRand() * (max->getValue() - min->getValue()) + min->getValue()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-IntegerAusFloat::IntegerAusFloat( RCArray< Aktion > *subActions )
|
|
|
- : Aktion( INTEGER_AUS_FLOAT, subActions )
|
|
|
+IntegerAusFloat::IntegerAusFloat(RCArray< Aktion >* subActions)
|
|
|
+ : Aktion(INTEGER_AUS_FLOAT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( FLOAT );
|
|
|
+ erlaubteTypen.add(FLOAT);
|
|
|
}
|
|
|
|
|
|
-void IntegerAusFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void IntegerAusFloat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Integer( (int)( (Float *)zParam( 0 ) )->getValue() ) );
|
|
|
+ setReturn(new Integer((int)((Float*)zParam(0))->getValue()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BestenlisteNeu::BestenlisteNeu( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( BESTENLISTE_NEU, subActions )
|
|
|
+BestenlisteNeu::BestenlisteNeu(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(BESTENLISTE_NEU, subActions)
|
|
|
{}
|
|
|
|
|
|
-void BestenlisteNeu::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BestenlisteNeu::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new Bestenliste( zSpiel->getNextId() ) );
|
|
|
+ setReturn(new Bestenliste(zSpiel->getNextId()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BestenlisteAddZeile::BestenlisteAddZeile( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( BESTENLISTE_ADD_ZEILE, subActions )
|
|
|
+BestenlisteAddZeile::BestenlisteAddZeile(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(BESTENLISTE_ADD_ZEILE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
- erlaubteTypen.add( BESTENLISTE );
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
+ erlaubteTypen.add(BESTENLISTE);
|
|
|
}
|
|
|
|
|
|
-void BestenlisteAddZeile::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BestenlisteAddZeile::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Bestenliste *)zParam( 1 ) )->addZeile( ( (String *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Bestenliste*)zParam(1))->addZeile(((String*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-BestenlisteAddSpalte::BestenlisteAddSpalte( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( BESTENLISTE_ADD_SPALTE, subActions )
|
|
|
+BestenlisteAddSpalte::BestenlisteAddSpalte(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(BESTENLISTE_ADD_SPALTE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
- erlaubteTypen.add( BESTENLISTE );
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
+ erlaubteTypen.add(BESTENLISTE);
|
|
|
}
|
|
|
|
|
|
-void BestenlisteAddSpalte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BestenlisteAddSpalte::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Bestenliste *)zParam( 1 ) )->addSpalte( ( (String *)zParam( 0 ) )->getValue() );
|
|
|
+ ((Bestenliste*)zParam(1))->addSpalte(((String*)zParam(0))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-BestenlisteSetWert::BestenlisteSetWert( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( BESTENLISTE_SET_WERT, subActions )
|
|
|
+BestenlisteSetWert::BestenlisteSetWert(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(BESTENLISTE_SET_WERT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
- erlaubteTypen.add( BESTENLISTE );
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
+ erlaubteTypen.add(BESTENLISTE);
|
|
|
}
|
|
|
|
|
|
-void BestenlisteSetWert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BestenlisteSetWert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- ( (Bestenliste *)zParam( 3 ) )->setWert( ( (String *)zParam( 0 ) )->getValue(), ( (String *)zParam( 1 ) )->getValue(), ( (String *)zParam( 2 ) )->getValue() );
|
|
|
+ ((Bestenliste*)zParam(3))->setWert(((String*)zParam(0))->getValue(), ((String*)zParam(1))->getValue(), ((String*)zParam(2))->getValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
-BestenlisteGetWert::BestenlisteGetWert( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( BESTENLISTE_GET_WERT, subActions )
|
|
|
+BestenlisteGetWert::BestenlisteGetWert(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(BESTENLISTE_GET_WERT, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
- erlaubteTypen.add( STRING );
|
|
|
- erlaubteTypen.add( BESTENLISTE );
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
+ erlaubteTypen.add(STRING);
|
|
|
+ erlaubteTypen.add(BESTENLISTE);
|
|
|
}
|
|
|
|
|
|
-void BestenlisteGetWert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BestenlisteGetWert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( new String( ( (Bestenliste *)zParam( 2 ) )->getWert( ( (String *)zParam( 0 ) )->getValue(), ( (String *)zParam( 1 ) )->getValue() ) ) );
|
|
|
+ setReturn(new String(((Bestenliste*)zParam(2))->getWert(((String*)zParam(0))->getValue(), ((String*)zParam(1))->getValue())));
|
|
|
}
|
|
|
|
|
|
|
|
|
-SchalterMitNummer::SchalterMitNummer( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( SCHALTER_MIT_NUMMER, subActions )
|
|
|
+SchalterMitNummer::SchalterMitNummer(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(SCHALTER_MIT_NUMMER, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
}
|
|
|
|
|
|
-void SchalterMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SchalterMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- Schalter *s = zSpiel->getSchalter( ( (Integer *)zParam( 0 ) )->getValue() );
|
|
|
- if( s )
|
|
|
- setReturn( s );
|
|
|
- else
|
|
|
- setReturn( new Variable( VariableTyp::NICHTS ) );
|
|
|
+ Schalter* s = zSpiel->getSchalter(((Integer*)zParam(0))->getValue());
|
|
|
+ if (s)
|
|
|
+ setReturn(s);
|
|
|
+ else
|
|
|
+ setReturn(new Variable(VariableTyp::NICHTS));
|
|
|
}
|
|
|
|
|
|
|
|
|
-BaseMitNummer::BaseMitNummer( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( BASE_MIT_NUMMER, subActions )
|
|
|
+BaseMitNummer::BaseMitNummer(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(BASE_MIT_NUMMER, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
}
|
|
|
|
|
|
-void BaseMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void BaseMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- Base *b = zSpiel->getBase( ( (Integer *)zParam( 0 ) )->getValue() );
|
|
|
- if( b )
|
|
|
- setReturn( b );
|
|
|
- else
|
|
|
- setReturn( new Variable( VariableTyp::NICHTS ) );
|
|
|
+ Base* b = zSpiel->getBase(((Integer*)zParam(0))->getValue());
|
|
|
+ if (b)
|
|
|
+ setReturn(b);
|
|
|
+ else
|
|
|
+ setReturn(new Variable(VariableTyp::NICHTS));
|
|
|
}
|
|
|
|
|
|
|
|
|
-TeamMitNummer::TeamMitNummer( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( TEAM_MIT_NUMMER, subActions )
|
|
|
+TeamMitNummer::TeamMitNummer(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(TEAM_MIT_NUMMER, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
}
|
|
|
|
|
|
-void TeamMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TeamMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- setReturn( zSpiel->getTeam( ( (Integer *)zParam( 0 ) )->getValue() ) );
|
|
|
+ setReturn(zSpiel->getTeam(((Integer*)zParam(0))->getValue()));
|
|
|
}
|
|
|
|
|
|
|
|
|
-TeamVonBase::TeamVonBase( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( TEAM_VON_BASE, subActions )
|
|
|
+TeamVonBase::TeamVonBase(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(TEAM_VON_BASE, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( BASE );
|
|
|
+ erlaubteTypen.add(BASE);
|
|
|
}
|
|
|
|
|
|
-void TeamVonBase::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void TeamVonBase::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- Team *t = ( (Base *)zParam( 0 ) )->getTeam();
|
|
|
- if( t )
|
|
|
- setReturn( t );
|
|
|
- else
|
|
|
- setReturn( new Variable( VariableTyp::NICHTS ) );
|
|
|
+ Team* t = ((Base*)zParam(0))->getTeam();
|
|
|
+ if (t)
|
|
|
+ setReturn(t);
|
|
|
+ else
|
|
|
+ setReturn(new Variable(VariableTyp::NICHTS));
|
|
|
}
|
|
|
|
|
|
|
|
|
-SpielerMitNummer::SpielerMitNummer( RCArray<Aktion> *subActions )
|
|
|
- : Aktion( SPIELER_MIT_NUMMER, subActions )
|
|
|
+SpielerMitNummer::SpielerMitNummer(RCArray<Aktion>* subActions)
|
|
|
+ : Aktion(SPIELER_MIT_NUMMER, subActions)
|
|
|
{
|
|
|
- erlaubteTypen.add( INTEGER );
|
|
|
+ erlaubteTypen.add(INTEGER);
|
|
|
}
|
|
|
|
|
|
-void SpielerMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+void SpielerMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
|
|
|
{
|
|
|
- Spieler *s = zSpiel->getSpieler( ( (Integer *)zParam( 0 ) )->getValue() );
|
|
|
- if( s )
|
|
|
- setReturn( s );
|
|
|
- else
|
|
|
- setReturn( new Variable( VariableTyp::NICHTS ) );
|
|
|
+ Spieler* s = zSpiel->getSpieler(((Integer*)zParam(0))->getValue());
|
|
|
+ if (s)
|
|
|
+ setReturn(s);
|
|
|
+ else
|
|
|
+ setReturn(new Variable(VariableTyp::NICHTS));
|
|
|
}
|