|
@@ -2072,7 +2072,10 @@ TextConcat::TextConcat( RCArray< Aktion > *subActions )
|
|
|
|
|
|
void TextConcat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
{
|
|
|
- setReturn( new String( ( (String *)zParam( 0 ) )->getValue() + ( (String *)zParam( 1 ) )->getValue().getText() ) );
|
|
|
+ String *p1 = (String *)zParam( 0 );
|
|
|
+ String *p2 = (String *)zParam( 1 );
|
|
|
+ String *res = new String( p1->getValue().operator+( p2->getValue().getText() ) );
|
|
|
+ setReturn( res );
|
|
|
}
|
|
|
|
|
|
|
|
@@ -2412,4 +2415,393 @@ BooleanSpielerKannItemBenutzen::BooleanSpielerKannItemBenutzen( RCArray< Aktion
|
|
|
void BooleanSpielerKannItemBenutzen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
{
|
|
|
setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->istGegenstandErlaubt( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanUmlenkungHatAbk::BooleanUmlenkungHatAbk( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_UMLENKUNG_HAT_ABK, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( UMLENKUNG );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanUmlenkungHatAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Umlenkung *)zParam( 0 ) )->hatAbklingzeit() ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanUmlenkungIstDrehend::BooleanUmlenkungIstDrehend( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_UMLENKUNG_IST_DREHEND, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( UMLENKUNG );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanUmlenkungIstDrehend::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Umlenkung *)zParam( 0 ) )->istDrehend() ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanBariereBewegtSich::BooleanBariereBewegtSich( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_BARIERE_BEWEGT_SICH, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( BARIERE );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanBariereBewegtSich::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::InVerschiebung ) ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanBariereIstSchaltend::BooleanBariereIstSchaltend( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_BARIERE_IST_SCHALTEND, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( BARIERE );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanBariereIstSchaltend::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::AutoSchaltung ) ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanBariereIstAktiv::BooleanBariereIstAktiv( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_BARIERE_IST_AKTIV, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( BARIERE );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanBariereIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::Aktiv ) ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanSchalterIstAktiv::BooleanSchalterIstAktiv( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_SCHALTER_IST_AKTIV, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( SCHALTER );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanSchalterIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Schalter *)zParam( 0 ) )->isAktive() ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanTunnelIstAktiv::BooleanTunnelIstAktiv( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_TUNNEL_IST_AKTIV, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( TUNNEL );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanTunnelIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Tunnel *)zParam( 0 ) )->istAktiv() ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanBaseIstNeutral::BooleanBaseIstNeutral( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_BASE_IST_NEUTRAL, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( BASE );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanBaseIstNeutral::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Base *)zParam( 0 ) )->zTeam() == 0 ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanTimerIsRunning::BooleanTimerIsRunning( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_TIMER_IS_RUNNING, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( TIMER );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanTimerIsRunning::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Timer *)zParam( 0 ) )->isRunning() ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanTimerIstSichtbar::BooleanTimerIstSichtbar( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_TIMER_IST_SICHTBAR, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( TIMER );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanTimerIstSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Timer *)zParam( 0 ) )->istSichtbar() ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanAusText::BooleanAusText( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_AUS_TEXT, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( STRING );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (String *)zParam( 0 ) )->getValue().istGleich( "true" ) ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanTriggerIstAktiv::BooleanTriggerIstAktiv( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( BOOLEAN_TRIGGER_IST_AKTIV, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( TRIGGER );
|
|
|
+}
|
|
|
+
|
|
|
+void BooleanTriggerIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Boolean( ( (Trigger *)zParam( 0 ) )->istAktiv() ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+BooleanRechnung::BooleanRechnung( RCArray< Aktion > *subActions, Operator op )
|
|
|
+ : Aktion( BOOLEAN_RECHNUNG, subActions )
|
|
|
+{
|
|
|
+ this->op = op;
|
|
|
+}
|
|
|
+
|
|
|
+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 TIMER:
|
|
|
+ case TEAM:
|
|
|
+ case BARIERE:
|
|
|
+ case SCHALTER:
|
|
|
+ case BASE:
|
|
|
+ case DROP:
|
|
|
+ case GEGENSTAND:
|
|
|
+ case GESCHOSS:
|
|
|
+ case SCHIENE:
|
|
|
+ case TUNNEL:
|
|
|
+ case UMLENKUNG:
|
|
|
+ case TRIGGER:
|
|
|
+ case FEUERBALL_TREFFER:
|
|
|
+ case AKTION:
|
|
|
+ case GAME_OBJEKT:
|
|
|
+ case ALLE:
|
|
|
+ case SPIELER:
|
|
|
+ setReturn( new Boolean( ( op == GLEICH ) == ( zParam( 0 ) == zParam( 1 ) ) ) );
|
|
|
+ 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;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 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() ) );
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+Sequenz::Sequenz( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( SEQUENZ, subActions )
|
|
|
+{}
|
|
|
+
|
|
|
+void Sequenz::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{}
|
|
|
+
|
|
|
+
|
|
|
+FloatRechnung::FloatRechnung( RCArray< Aktion > *subActions, Operator op )
|
|
|
+ : Aktion( FLOAT_RECHNUNG, subActions )
|
|
|
+{
|
|
|
+ this->op = op;
|
|
|
+ erlaubteTypen.add( FLOAT );
|
|
|
+ erlaubteTypen.add( FLOAT );
|
|
|
+}
|
|
|
+
|
|
|
+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;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+FloatAusInteger::FloatAusInteger( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( FLOAT_AUS_INTEGER, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( INTEGER );
|
|
|
+}
|
|
|
+
|
|
|
+void FloatAusInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Float( (float)( (Integer *)zParam( 0 ) )->getValue() ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+FloatAusText::FloatAusText( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( FLOAT_AUS_TEXT, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( STRING );
|
|
|
+}
|
|
|
+
|
|
|
+void FloatAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Float( (float)( (String *)zParam( 0 ) )->getValue() ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+TextAusFloat::TextAusFloat( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( TEXT_AUS_FLOAT, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( FLOAT );
|
|
|
+}
|
|
|
+
|
|
|
+void TextAusFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new String( Text( ( (Float *)zParam( 0 ) )->getValue() ) ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+FloatZufall::FloatZufall( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( FLOAT_ZUFALL, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( FLOAT );
|
|
|
+ erlaubteTypen.add( FLOAT );
|
|
|
+}
|
|
|
+
|
|
|
+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() ) );
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+IntegerAusFloat::IntegerAusFloat( RCArray< Aktion > *subActions )
|
|
|
+ : Aktion( INTEGER_AUS_FLOAT, subActions )
|
|
|
+{
|
|
|
+ erlaubteTypen.add( FLOAT );
|
|
|
+}
|
|
|
+
|
|
|
+void IntegerAusFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
|
|
|
+{
|
|
|
+ setReturn( new Integer( (int)( (Float *)zParam( 0 ) )->getValue() ) );
|
|
|
}
|