#include "Aktionen.h" #include "Trigger.h" #include "Spiel.h" 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; } 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 = zMemory->zVariable( "__return__" ); if( ( !result && erlaubteTypen.get( i ) != NICHTS ) || result->getVariableTyp() != erlaubteTypen.get( i ) ) { zPC->stepOut(); return 1; } if( result ) zMemory->setVar( zPC->getUniqueString() + "R" + i + "__", 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 ) {} KonstantNichts::KonstantNichts() : Aktion( KONSTANT_NICHTS, new RCArray< Aktion >() ) {} void KonstantNichts::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Variable( NICHTS ) ); } KonstantInteger::KonstantInteger( int val ) : Aktion( KONSTANT_INTEGER, new RCArray< Aktion >() ) { this->value = val; } void KonstantInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Integer( value ) ); } KonstantBoolean::KonstantBoolean( bool val ) : Aktion( KONSTANT_BOOLEAN, new RCArray< Aktion >() ) { value = val; } void KonstantBoolean::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Boolean( value ) ); } KonstantString::KonstantString( Text val ) : Aktion( KONSTANT_STRING, new RCArray< Aktion >() ) { value = val; } void KonstantString::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new String( value ) ); } KonstantFloat::KonstantFloat( float val ) : Aktion( KONSTANT_FLOAT, new RCArray< Aktion >() ) { value = val; } void KonstantFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Float( value ) ); } KonstantVariable::KonstantVariable( Text name ) : Aktion( KONSTANT_VARIABLE, new RCArray< Aktion >() ) { this->name = name; } void KonstantVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { if( zMemory->zVariable( name ) ) zMemory->setVar( "__return__", zMemory->getVariable( name ) ); else if( zEreignis->zParameter( name ) ) zMemory->setVar( "__return__", zEreignis->zParameter( name ) ); else if( zSpiel->zVariable( name ) ) zMemory->setVar( "__return__", zSpiel->getVariable( name ) ); else zMemory->setVar( "__return__", new Variable( NICHTS ) ); } Warten::Warten( RCArray< Aktion > *subActions ) : Aktion( WARTEN, subActions ) { this->erlaubteTypen.add( FLOAT ); } Warten::~Warten() {} void Warten::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { waitCount += ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue(); } WennDannSonst::WennDannSonst( RCArray< Aktion > *subActions ) : Aktion( WENN_DANN_SONST, subActions ) {} WennDannSonst::~WennDannSonst() {} 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 = zMemory->zVariable( "__return__" ); 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; } SetVariable::~SetVariable() {} 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, getEvaluatedParam( 0, zMemory, zPC ) ); else zSpiel->setVariable( name, getEvaluatedParam( 0, zMemory, zPC ) ); } TriggerAktion::TriggerAktion( RCArray< Aktion > *subActions ) : Aktion( TRIGGER_AKTION, subActions ) {} TriggerAktion::~TriggerAktion() {} 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 = zMemory->zVariable( "__return__" ); if( !t || t->getVariableTyp() != INTEGER ) { zPC->stepOut(); return 1; } zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() ); zPC->count(); } } if( zPC->currentPosition() == 1 && waitCount <= 0 ) { if( subActions->z( 1 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) ) { Variable *t = zMemory->zVariable( "__return__" ); if( !t || t->getVariableTyp() != TRIGGER ) { zPC->stepOut(); return 1; } int id = ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->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 *)zEvaluatedParam( 0, zMemory, zPC ) )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) ) { zPC->stepOut(); return 1; } } zPC->stepOut(); return 0; } SpielerNachricht::SpielerNachricht( RCArray< Aktion > *subActions ) : Aktion( SPIELER_NACHRICHT, subActions ) { erlaubteTypen.add( SPIELER ); erlaubteTypen.add( STRING ); } SpielerNachricht::~SpielerNachricht() {} 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) } DisplayText::DisplayText( RCArray< Aktion > *subActions ) : Aktion( DISPLAY_TEXT, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( FLOAT ); erlaubteTypen.add( INTEGER ); erlaubteTypen.add( FLOAT ); erlaubteTypen.add( STRING ); } DisplayText::~DisplayText() {} void DisplayText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { // do nothing because the server does not need to show text } SpielPause::SpielPause( RCArray< Aktion > *subActions ) : Aktion( SPIEL_PAUSE, subActions ) { erlaubteTypen.add( BOOLEAN ); } SpielPause::~SpielPause() {} void SpielPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zSpiel->setPausiert( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielEnde::SpielEnde( RCArray< Aktion > *subActions ) : Aktion( SPIEL_ENDE, subActions ) {} SpielEnde::~SpielEnde() {} void SpielEnde::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { Variable *t = zEvaluatedParam( 0, zMemory, zPC ); if( t->getVariableTyp() != NICHTS && t->getVariableTyp() != TEAM ) t = 0; zSpiel->setEnde( t->getVariableTyp() == NICHTS ? 0 : (Team *)t ); } SpielerSetLevel::SpielerSetLevel( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_LEVEL, subActions ) { erlaubteTypen.add( INTEGER ); erlaubteTypen.add( SPIELER ); } SpielerSetLevel::~SpielerSetLevel() {} void SpielerSetLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLevel( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerGiveItem::SpielerGiveItem( RCArray< Aktion > *subActions ) : Aktion( SPIELER_GIVE_ITEM, subActions ) { erlaubteTypen.add( GEGENSTAND_TYP ); erlaubteTypen.add( INTEGER ); erlaubteTypen.add( SPIELER ); } SpielerGiveItem::~SpielerGiveItem() {} void SpielerGiveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 2, zMemory, zPC ) )->addItem( ( (GegenstandTypVar *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue(), ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue(), zSpiel ); } SpielerRemoveItem::SpielerRemoveItem( RCArray< Aktion > *subActions ) : Aktion( SPIELER_REMOVE_ITEM, subActions ) { erlaubteTypen.add( GEGENSTAND_TYP ); erlaubteTypen.add( INTEGER ); erlaubteTypen.add( SPIELER ); } SpielerRemoveItem::~SpielerRemoveItem() {} void SpielerRemoveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 2, zMemory, zPC ) )->removeItem( ( (GegenstandTypVar *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue(), ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() ); } SpielerSetLeben::SpielerSetLeben( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_LEBEN, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( SPIELER ); } SpielerSetLeben::~SpielerSetLeben() {} void SpielerSetLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLeben( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerSetMaxLeben::SpielerSetMaxLeben( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_LEBEN, subActions ) { erlaubteTypen.add( INTEGER ); erlaubteTypen.add( SPIELER ); } SpielerSetMaxLeben::~SpielerSetMaxLeben() {} void SpielerSetMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxLeben( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerSetErfahrung::SpielerSetErfahrung( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_ERFAHRUNG, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( SPIELER ); } SpielerSetErfahrung::~SpielerSetErfahrung() {} void SpielerSetErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setErfahrung( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerSetMaxErfahrung::SpielerSetMaxErfahrung( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_MAX_ERFAHRUNG, subActions ) { erlaubteTypen.add( INTEGER ); erlaubteTypen.add( SPIELER ); } SpielerSetMaxErfahrung::~SpielerSetMaxErfahrung() {} void SpielerSetMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxErfahrung( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerSetTempo::SpielerSetTempo( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_TEMPO, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( SPIELER ); } SpielerSetTempo::~SpielerSetTempo() {} void SpielerSetTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLaufTempo( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerSetWaffenTempo::SpielerSetWaffenTempo( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_GESCHOSS_TEMPO, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( SPIELER ); } SpielerSetWaffenTempo::~SpielerSetWaffenTempo() {} void SpielerSetWaffenTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setGeschossTempo( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerSetArmor::SpielerSetArmor( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_ARMOR, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( SPIELER ); } SpielerSetArmor::~SpielerSetArmor() {} void SpielerSetArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setArmor( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerSetSchadenBonus::SpielerSetSchadenBonus( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_SCHADEN_BONUS, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( SPIELER ); } SpielerSetSchadenBonus::~SpielerSetSchadenBonus() {} void SpielerSetSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setSchadenBonus( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerSetLebensraub::SpielerSetLebensraub( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_LEBENSRAUB, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( SPIELER ); } SpielerSetLebensraub::~SpielerSetLebensraub() {} void SpielerSetLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLebensRaub( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerSetLebensregeneration::SpielerSetLebensregeneration( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_LEBENSRAUB, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( SPIELER ); } SpielerSetLebensregeneration::~SpielerSetLebensregeneration() {} void SpielerSetLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLebensRegeneration( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung( RCArray< Aktion > *subActions ) : Aktion( SPIELER_SET_ABKLINGZEITVERRINGERUNG, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( SPIELER ); } SpielerSetAbklingzeitverringerung::~SpielerSetAbklingzeitverringerung() {} void SpielerSetAbklingzeitverringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setAbklingZeitVerringerung( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } DropSetTime::DropSetTime( RCArray< Aktion > *subActions ) : Aktion( DROP_SET_TIME, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( DROP ); } DropSetTime::~DropSetTime() {} void DropSetTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Drop *)zEvaluatedParam( 1, zMemory, zPC ) )->setTime( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } DropSetMaxTime::DropSetMaxTime( RCArray< Aktion > *subActions ) : Aktion( DROP_SET_MAX_TIME, subActions ) { erlaubteTypen.add( INTEGER ); erlaubteTypen.add( DROP ); } DropSetMaxTime::~DropSetMaxTime() {} void DropSetMaxTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Drop *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxTime( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } 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 ); } DropSetArea::~DropSetArea() {} void DropSetArea::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Drop *)zEvaluatedParam( 4, zMemory, zPC ) )->setMinX( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); ( (Drop *)zEvaluatedParam( 4, zMemory, zPC ) )->setMaxX( ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() ); ( (Drop *)zEvaluatedParam( 4, zMemory, zPC ) )->setMinY( ( (Integer *)zEvaluatedParam( 2, zMemory, zPC ) )->getValue() ); ( (Drop *)zEvaluatedParam( 4, zMemory, zPC ) )->setMaxY( ( (Integer *)zEvaluatedParam( 3, zMemory, zPC ) )->getValue() ); } DropDoDrop::DropDoDrop( RCArray< Aktion > *subActions ) : Aktion( DROP_DO_DROP, subActions ) { erlaubteTypen.add( DROP ); } DropDoDrop::~DropDoDrop() {} void DropDoDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->doDrop( zSpiel ); } BariereBewegung::BariereBewegung( RCArray< Aktion > *subActions ) : Aktion( BARIERE_BEWEGUNG, subActions ) { erlaubteTypen.add( BARIERE ); } BariereBewegung::~BariereBewegung() {} void BariereBewegung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Bariere *)zEvaluatedParam( 0, zMemory, zPC ) )->startAutoVerschiebung( zSpiel ); } BariereSetEingeschaltet::BariereSetEingeschaltet( RCArray< Aktion > *subActions ) : Aktion( BARIERE_SET_EINGESCHALTET, subActions ) { erlaubteTypen.add( BOOLEAN ); erlaubteTypen.add( DROP ); } BariereSetEingeschaltet::~BariereSetEingeschaltet() {} void BariereSetEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Bariere *)zEvaluatedParam( 1, zMemory, zPC ) )->setEingeschaltet( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } GameObjektSetPosition::GameObjektSetPosition( RCArray< Aktion > *subActions ) : Aktion( GAME_OBJEKT_SET_POSITION, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( FLOAT ); erlaubteTypen.add( GAME_OBJEKT ); } GameObjektSetPosition::~GameObjektSetPosition() {} void GameObjektSetPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setX( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setY( ( (Float *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() ); } GameObjektSetSize::GameObjektSetSize( RCArray< Aktion > *subActions ) : Aktion( GAME_OBJEKT_SET_SIZE, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( FLOAT ); erlaubteTypen.add( GAME_OBJEKT ); } GameObjektSetSize::~GameObjektSetSize() {} void GameObjektSetSize::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setWidth( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setHeight( ( (Float *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() ); } BariereSetTeam::BariereSetTeam( RCArray< Aktion > *subActions ) : Aktion( BARIERE_SET_TEAM, subActions ) { erlaubteTypen.add( TEAM ); erlaubteTypen.add( BARIERE ); } BariereSetTeam::~BariereSetTeam() {} void BariereSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Bariere *)zEvaluatedParam( 1, zMemory, zPC ) )->setTeam( ( (Team *)zEvaluatedParam( 0, zMemory, zPC ) ) ); } SchalterSetErlaubt::SchalterSetErlaubt( RCArray< Aktion > *subActions ) : Aktion( SCHALTER_SET_ERLAUBT, subActions ) { erlaubteTypen.add( BOOLEAN ); erlaubteTypen.add( SCHALTER ); } SchalterSetErlaubt::~SchalterSetErlaubt() {} void SchalterSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Schalter *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktive( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } SchalterAktivieren::SchalterAktivieren( RCArray< Aktion > *subActions ) : Aktion( SCHALTER_AKTIVIEREN, subActions ) { erlaubteTypen.add( SCHALTER ); } SchalterAktivieren::~SchalterAktivieren() {} void SchalterAktivieren::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zSpiel->activateShalter( ( (Schalter *)zEvaluatedParam( 0, zMemory, zPC ) )->getId() ); } TunnelSetZielPosition::TunnelSetZielPosition( RCArray< Aktion > *subActions ) : Aktion( TUNNEL_SET_ZIEL_POSITION, subActions ) { erlaubteTypen.add( INTEGER ); erlaubteTypen.add( INTEGER ); erlaubteTypen.add( TUNNEL ); } TunnelSetZielPosition::~TunnelSetZielPosition() {} void TunnelSetZielPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Tunnel *)zEvaluatedParam( 2, zMemory, zPC ) )->setZielX( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); ( (Tunnel *)zEvaluatedParam( 2, zMemory, zPC ) )->setZielY( ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() ); } TunnelSetErlaubt::TunnelSetErlaubt( RCArray< Aktion > *subActions ) : Aktion( TUNNEL_SET_ERLAUBT, subActions ) { erlaubteTypen.add( BOOLEAN ); erlaubteTypen.add( TUNNEL ); } TunnelSetErlaubt::~TunnelSetErlaubt() {} void TunnelSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Tunnel *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktiv( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } UmlenkungSetRichtung::UmlenkungSetRichtung( RCArray< Aktion > *subActions ) : Aktion( UMLENKUNG_SET_RICHTUNG, subActions ) { erlaubteTypen.add( RICHTUNG ); erlaubteTypen.add( UMLENKUNG ); } UmlenkungSetRichtung::~UmlenkungSetRichtung() {} void UmlenkungSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Umlenkung *)zEvaluatedParam( 1, zMemory, zPC ) )->setRichtung( getRichtungFromString( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) ); } UmlenkungSetMaxAbk::UmlenkungSetMaxAbk( RCArray< Aktion > *subActions ) : Aktion( UMLENKUNG_SET_MAX_ABK, subActions ) { erlaubteTypen.add( INTEGER ); erlaubteTypen.add( UMLENKUNG ); } UmlenkungSetMaxAbk::~UmlenkungSetMaxAbk() {} void UmlenkungSetMaxAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Umlenkung *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxAbklingzeit( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } UmlenkungSetEnabled::UmlenkungSetEnabled( RCArray< Aktion > *subActions ) : Aktion( UMLENKUNG_SET_ERLAUBT, subActions ) { erlaubteTypen.add( BOOLEAN ); erlaubteTypen.add( UMLENKUNG ); } UmlenkungSetEnabled::~UmlenkungSetEnabled() {} void UmlenkungSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Umlenkung *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktiv( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } BaseSetTeam::BaseSetTeam( RCArray< Aktion > *subActions ) : Aktion( BASE_SET_TEAM, subActions ) { erlaubteTypen.add( TEAM ); erlaubteTypen.add( BASE ); } BaseSetTeam::~BaseSetTeam() {} void BaseSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Base *)zEvaluatedParam( 1, zMemory, zPC ) )->setTeam( ( (Team *)zEvaluatedParam( 0, zMemory, zPC ) ) ); } TriggerRunStart::TriggerRunStart( RCArray< Aktion > *subActions ) : Aktion( TRIGGER_RUN_START, subActions ) { erlaubteTypen.add( TRIGGER ); } TriggerRunStart::~TriggerRunStart() {} void TriggerRunStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zSpiel->addTriggerRun( ( (Trigger *)zEvaluatedParam( 0, zMemory, zPC ) )->runTrigger( zEreignis->getThis(), zSpiel ) ); } TriggerSetEnabled::TriggerSetEnabled( RCArray< Aktion > *subActions ) : Aktion( TRIGGER_SET_ENABLED, subActions ) { erlaubteTypen.add( BOOLEAN ); erlaubteTypen.add( TRIGGER ); } TriggerSetEnabled::~TriggerSetEnabled() {} void TriggerSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Trigger *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktiv( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } TeamSetPunkte::TeamSetPunkte( RCArray< Aktion > *subActions ) : Aktion( TEAM_SET_PUNKTE, subActions ) { erlaubteTypen.add( INTEGER ); erlaubteTypen.add( TEAM ); } TeamSetPunkte::~TeamSetPunkte() {} void TeamSetPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Team *)zEvaluatedParam( 1, zMemory, zPC ) )->setPunkte( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } TimerSetPause::TimerSetPause( RCArray< Aktion > *subActions ) : Aktion( TIMER_SET_PAUSE, subActions ) { erlaubteTypen.add( BOOLEAN ); erlaubteTypen.add( TIMER ); } TimerSetPause::~TimerSetPause() {} void TimerSetPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Timer *)zEvaluatedParam( 1, zMemory, zPC ) )->setPause( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } TimerStart::TimerStart( RCArray< Aktion > *subActions ) : Aktion( TIMER_START, subActions ) { erlaubteTypen.add( TIMER ); } TimerStart::~TimerStart() {} void TimerStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Timer *)zEvaluatedParam( 0, zMemory, zPC ) )->start( zSpiel ); } TimerSetZeit::TimerSetZeit( RCArray< Aktion > *subActions ) : Aktion( TIMER_SET_ZEIT, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( TIMER ); } TimerSetZeit::~TimerSetZeit() {} void TimerSetZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Timer *)zEvaluatedParam( 1, zMemory, zPC ) )->setZeit( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } TimerSetSichtbar::TimerSetSichtbar( RCArray< Aktion > *subActions ) : Aktion( TIMER_SET_SICHTBAR, subActions ) { erlaubteTypen.add( BOOLEAN ); erlaubteTypen.add( TIMER ); } TimerSetSichtbar::~TimerSetSichtbar() {} void TimerSetSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Timer *)zEvaluatedParam( 1, zMemory, zPC ) )->setSichtbar( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } GeschossNeu::GeschossNeu( RCArray< Aktion > *subActions ) : Aktion( GESCHOSS_NEU, subActions ) { erlaubteTypen.add( INTEGER ); erlaubteTypen.add( INTEGER ); erlaubteTypen.add( GESCHOSS_TYP ); erlaubteTypen.add( RICHTUNG ); } GeschossNeu::~GeschossNeu() {} void GeschossNeu::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { Geschoss *g = new Geschoss( zSpiel->getNextId(), 0, getGeschossTypFromString( ( (String *)zEvaluatedParam( 2, zMemory, zPC ) )->getValue() ), getRichtungFromString( ( (String *)zEvaluatedParam( 3, zMemory, zPC ) )->getValue() ), ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue(), ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue(), 0 ); zSpiel->addGeschoss( (Geschoss *)g->getThis() ); zMemory->setVar( "__return__", g ); } GeschossSetSpeed::GeschossSetSpeed( RCArray< Aktion > *subActions ) : Aktion( GESCHOSS_SET_SPEED, subActions ) { erlaubteTypen.add( FLOAT ); erlaubteTypen.add( GESCHOSS ); } GeschossSetSpeed::~GeschossSetSpeed() {} void GeschossSetSpeed::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Geschoss *)zEvaluatedParam( 1, zMemory, zPC ) )->setSpeed( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ); } GeschossSetPlayer::GeschossSetPlayer( RCArray< Aktion > *subActions ) : Aktion( GESCHOSS_SET_PLAYER, subActions ) { erlaubteTypen.add( SPIELER ); erlaubteTypen.add( GESCHOSS ); } GeschossSetPlayer::~GeschossSetPlayer() {} void GeschossSetPlayer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Geschoss *)zEvaluatedParam( 1, zMemory, zPC ) )->setBesitzer( ( (Spieler *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) ); } GeschossSetRichtung::GeschossSetRichtung( RCArray< Aktion > *subActions ) : Aktion( GESCHOSS_SET_RICHTUNG, subActions ) { erlaubteTypen.add( RICHTUNG ); erlaubteTypen.add( GESCHOSS ); } GeschossSetRichtung::~GeschossSetRichtung() {} void GeschossSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Geschoss *)zEvaluatedParam( 1, zMemory, zPC ) )->setRichtung( getRichtungFromString( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) ); } GeschossSetType::GeschossSetType( RCArray< Aktion > *subActions ) : Aktion( GESCHOSS_SET_TYPE, subActions ) { erlaubteTypen.add( GESCHOSS_TYP ); erlaubteTypen.add( GESCHOSS ); } GeschossSetType::~GeschossSetType() {} void GeschossSetType::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { ( (Geschoss *)zEvaluatedParam( 1, zMemory, zPC ) )->setTyp( getGeschossTypFromString( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) ); } TriggerZufall::TriggerZufall() : Aktion( TRIGGER_ZUFALL, new RCArray< Aktion >() ) {} void TriggerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", zSpiel->getRandomTrigger() ); } TriggerLastRunned::TriggerLastRunned() : Aktion( TRIGGER_LAST_RUNNED, new RCArray< Aktion >() ) {} void TriggerLastRunned::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", zSpiel->getLastRunnedTrigger() ); } BariereZufall::BariereZufall() : Aktion( BARIERE_ZUFALL, new RCArray< Aktion >() ) {} void BariereZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", zSpiel->getRandomBariere() ); } BariereZuletztEingeschaltet::BariereZuletztEingeschaltet() : Aktion( BARIERE_ZULETZT_EINGESCHALTET, new RCArray< Aktion >() ) {} void BariereZuletztEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", zSpiel->getZuletztEingeschalteteBariere() ); } BariereZuletztAusgeschaltet::BariereZuletztAusgeschaltet() : Aktion( BARIERE_ZULETZT_AUSGESCHALTET, new RCArray< Aktion >() ) {} void BariereZuletztAusgeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", zSpiel->getZuletztAusgeschalteteBariere() ); } BariereZuletztBewegt::BariereZuletztBewegt() : Aktion( BARIERE_ZULETZT_BEWEGT, new RCArray< Aktion >() ) {} void BariereZuletztBewegt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", zSpiel->getZuletztBewegteBariere() ); } BaseZufall::BaseZufall() : Aktion( BASE_ZUFALL, new RCArray< Aktion >() ) {} void BaseZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", zSpiel->getRandomBase() ); } BaseZuletztBesitzerGewechselt::BaseZuletztBesitzerGewechselt() : Aktion( BASE_ZULETZT_BESITZER_GEWECHSELT, new RCArray< Aktion >() ) {} void BaseZuletztBesitzerGewechselt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", zSpiel->getLastTeamChangedBase() ); } DropZufall::DropZufall() : Aktion( DROP_ZUFALL, new RCArray< Aktion >() ) {} void DropZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", zSpiel->getRandomDrop() ); } DropZuletztGedropt::DropZuletztGedropt() : Aktion( DROP_ZULETZT_GEDROPT, new RCArray< Aktion >() ) {} void DropZuletztGedropt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", zSpiel->getLastDrop() ); } IntegerRechnen::IntegerRechnen( RCArray< Aktion > *subActions, Operator op ) : Aktion( INTEGER_RECHNEN, subActions ) { erlaubteTypen.add( INTEGER ); erlaubteTypen.add( INTEGER ); } IntegerRechnen::~IntegerRechnen() {} void IntegerRechnen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { Integer *l = (Integer *)zEvaluatedParam( 0, zMemory, zPC ); Integer *r = (Integer *)zEvaluatedParam( 1, zMemory, zPC ); switch( op ) { case PLUS: zMemory->setVar( "__return__", new Integer( l->getValue() + r->getValue() ) ); break; case MINUS: zMemory->setVar( "__return__", new Integer( l->getValue() - r->getValue() ) ); break; case MAHL: zMemory->setVar( "__return__", new Integer( l->getValue() * r->getValue() ) ); break; case GETEILT: zMemory->setVar( "__return__", new Integer( l->getValue() / r->getValue() ) ); break; case HOCH: zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), r->getValue() ) ) ); break; case WURZEL: zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), 1.0 / r->getValue() ) ) ); break; case BIT_ODER: zMemory->setVar( "__return__", new Integer( l->getValue() | r->getValue() ) ); break; case BIT_UND: zMemory->setVar( "__return__", new Integer( l->getValue() & r->getValue() ) ); break; case BIT_XOR: zMemory->setVar( "__return__", new Integer( l->getValue() ^ r->getValue() ) ); break; case BIT_FLIP: zMemory->setVar( "__return__", new Integer( ~l->getValue() ) ); break; case BIT_SHIFT_LEFT: zMemory->setVar( "__return__", new Integer( l->getValue() << r->getValue() ) ); break; case BIT_SHIFT_RIGHT: zMemory->setVar( "__return__", new Integer( l->getValue() >> r->getValue() ) ); break; case INVERT_SIGN: zMemory->setVar( "__return__", new Integer( -l->getValue() ) ); break; case PLUS_PLUS_LEFT: l->setValue( l->getValue() + 1 ); zMemory->setVar( "__return__", new Integer( l->getValue() ) ); break; case PLUS_PLUS_RIGHT: { int tmp = l->getValue(); l->setValue( l->getValue() + 1 ); zMemory->setVar( "__return__", new Integer( tmp ) ); break; } case MINUS_MINUS_LEFT: l->setValue( l->getValue() - 1 ); zMemory->setVar( "__return__", new Integer( l->getValue() ) ); break; case MINUS_MINUS_RIGHT: { int tmp = l->getValue(); l->setValue( l->getValue() - 1 ); zMemory->setVar( "__return__", new Integer( tmp ) ); break; } case LOGARITHM: zMemory->setVar( "__return__", new Integer( (int)( log( l->getValue() ) / log( r->getValue() ) ) ) ); break; case MODULO: zMemory->setVar( "__return__", new Integer( l->getValue() % r->getValue() ) ); break; default: break; } } IntegerZufall::IntegerZufall( RCArray< Aktion > *subActions ) : Aktion( INTEGER_ZUFALL, subActions ) { erlaubteTypen.add( INTEGER ); erlaubteTypen.add( INTEGER ); } IntegerZufall::~IntegerZufall() {} void IntegerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { int mi = ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue(); int ma = ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue(); zMemory->setVar( "__return__", new Integer( (int)( zSpiel->getRand() * ( ma - mi ) + mi ) ) ); } IntegerAusText::IntegerAusText( RCArray< Aktion > *subActions ) : Aktion( INTEGER_AUS_TEXT, subActions ) { erlaubteTypen.add( STRING ); } IntegerAusText::~IntegerAusText() {} void IntegerAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Integer( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) ); } FloatXVonGameObjekt::FloatXVonGameObjekt( RCArray< Aktion > *subActions ) : Aktion( FLOAT_X_VON_GAME_OBJEKT, subActions ) { erlaubteTypen.add( GAME_OBJEKT ); } FloatXVonGameObjekt::~FloatXVonGameObjekt() {} void FloatXVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Float( ( (GameObject *)zEvaluatedParam( 0, zMemory, zPC ) )->getX() ) ); } FloatYVonGameObjekt::FloatYVonGameObjekt( RCArray< Aktion > *subActions ) : Aktion( FLOAT_Y_VON_GAME_OBJEKT, subActions ) { erlaubteTypen.add( GAME_OBJEKT ); } FloatYVonGameObjekt::~FloatYVonGameObjekt() {} void FloatYVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Float( ( (GameObject *)zEvaluatedParam( 0, zMemory, zPC ) )->getY() ) ); } IntegerXVonTunnelZiel::IntegerXVonTunnelZiel( RCArray< Aktion > *subActions ) : Aktion( INTEGER_X_VON_TUNNEL_ZIEL, subActions ) { erlaubteTypen.add( TUNNEL ); } IntegerXVonTunnelZiel::~IntegerXVonTunnelZiel() {} void IntegerXVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Integer( ( (Tunnel *)zEvaluatedParam( 0, zMemory, zPC ) )->getZielX() ) ); } IntegerYVonTunnelZiel::IntegerYVonTunnelZiel( RCArray< Aktion > *subActions ) : Aktion( INTEGER_Y_VON_TUNNEL_ZIEL, subActions ) { erlaubteTypen.add( TUNNEL ); } IntegerYVonTunnelZiel::~IntegerYVonTunnelZiel() {} void IntegerYVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Integer( ( (Tunnel *)zEvaluatedParam( 0, zMemory, zPC ) )->getZielY() ) ); } IntegerMinXVonDrop::IntegerMinXVonDrop( RCArray< Aktion > *subActions ) : Aktion( INTEGER_MIN_X_VON_DROP, subActions ) { erlaubteTypen.add( DROP ); } IntegerMinXVonDrop::~IntegerMinXVonDrop() {} void IntegerMinXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMinX() ) ); } IntegerMinYVonDrop::IntegerMinYVonDrop( RCArray< Aktion > *subActions ) : Aktion( INTEGER_MIN_Y_VON_DROP, subActions ) { erlaubteTypen.add( DROP ); } IntegerMinYVonDrop::~IntegerMinYVonDrop() {} void IntegerMinYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMinY() ) ); } IntegerMaxXVonDrop::IntegerMaxXVonDrop( RCArray< Aktion > *subActions ) : Aktion( INTEGER_MAX_X_VON_DROP, subActions ) { erlaubteTypen.add( DROP ); } IntegerMaxXVonDrop::~IntegerMaxXVonDrop() {} void IntegerMaxXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMaxX() ) ); } IntegerMaxYVonDrop::IntegerMaxYVonDrop( RCArray< Aktion > *subActions ) : Aktion( INTEGER_MAX_Y_VON_DROP, subActions ) { erlaubteTypen.add( DROP ); } IntegerMaxYVonDrop::~IntegerMaxYVonDrop() {} void IntegerMaxYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMaxY() ) ); } IntegerSpielerLevel::IntegerSpielerLevel( RCArray< Aktion > *subActions ) : Aktion( INTEGER_SPIELER_LEVEL, subActions ) { erlaubteTypen.add( SPIELER ); } IntegerSpielerLevel::~IntegerSpielerLevel() {} void IntegerSpielerLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Integer( ( (Spieler *)zEvaluatedParam( 0, zMemory, zPC ) )->getLevel() ) ); } FloatSpielerLeben::FloatSpielerLeben( RCArray< Aktion > *subActions ) : Aktion( FLOAT_SPIELER_LEBEN, subActions ) { erlaubteTypen.add( SPIELER ); } FloatSpielerLeben::~FloatSpielerLeben() {} void FloatSpielerLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) { zMemory->setVar( "__return__", new Float( ( (Spieler *)zEvaluatedParam( 0, zMemory, zPC ) )->getLeben() ) ); }