|
|
@@ -167,15 +167,15 @@ void Spiel::tick()
|
|
|
{
|
|
|
nextAutoVerschiebung += 30 + randG.rand() * 30;
|
|
|
int anz = 0;
|
|
|
- for( auto b = barieren.getIterator(); b; b++ )
|
|
|
+ for( auto b : barieren )
|
|
|
{
|
|
|
if( b->hatStyle( Bariere::Style::AutoVerschiebung ) )
|
|
|
anz++;
|
|
|
}
|
|
|
if( anz )
|
|
|
{
|
|
|
- int rand = (int)( randG.rand() * anz );
|
|
|
- for( auto b = barieren.getIterator(); b; b++ )
|
|
|
+ int rand = (int)(randG.rand() * anz);
|
|
|
+ for( auto b : barieren )
|
|
|
{
|
|
|
if( b->hatStyle( Bariere::Style::AutoVerschiebung ) )
|
|
|
{
|
|
|
@@ -193,15 +193,15 @@ void Spiel::tick()
|
|
|
{
|
|
|
nextAutoSchaltung += 30 + randG.rand() * 30;
|
|
|
int anz = 0;
|
|
|
- for( auto b = barieren.getIterator(); b; b++ )
|
|
|
+ for( auto b : barieren )
|
|
|
{
|
|
|
if( b->hatStyle( Bariere::Style::AutoSchaltung ) )
|
|
|
anz++;
|
|
|
}
|
|
|
if( anz )
|
|
|
{
|
|
|
- int rand = (int)( randG.rand() * anz );
|
|
|
- for( auto b = barieren.getIterator(); b; b++ )
|
|
|
+ int rand = (int)(randG.rand() * anz);
|
|
|
+ for( auto b : barieren )
|
|
|
{
|
|
|
if( b->hatStyle( Bariere::Style::AutoSchaltung ) )
|
|
|
{
|
|
|
@@ -230,7 +230,7 @@ void Spiel::tick()
|
|
|
}
|
|
|
}
|
|
|
Richtung rs[] = { OBEN, RECHTS, UNTEN, LINKS };
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
for( Richtung r : rs )
|
|
|
{
|
|
|
@@ -239,28 +239,28 @@ void Spiel::tick()
|
|
|
s->move( r, -zeit );
|
|
|
else
|
|
|
{
|
|
|
- for( auto b = barieren.getIterator(); b; b++ )
|
|
|
+ for( auto b : barieren )
|
|
|
{ // spieler - bariere intersection
|
|
|
- if( b->hatStyle( Bariere::Style::Aktiv ) && ( b->zTeam() != s->zTeam() ) && b->intersectsWith( s ) )
|
|
|
+ if( b->hatStyle( Bariere::Style::Aktiv ) && (b->zTeam() != s->zTeam()) && b->intersectsWith( s ) )
|
|
|
s->move( r, -zeit );
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ for( auto s : spieler )
|
|
|
s->tick( zeit, this );
|
|
|
// barieren bewegung
|
|
|
- for( auto b = barieren.getIterator(); b; b++ )
|
|
|
+ for( auto b : barieren )
|
|
|
b->tick( zeit, this );
|
|
|
// geschoss bewegung
|
|
|
for( int i = 0; i < shots.getEintragAnzahl(); i++ )
|
|
|
{
|
|
|
- Geschoss *g = shots.z( i );
|
|
|
+ Geschoss* g = shots.z( i );
|
|
|
g->tick( zeit );
|
|
|
bool removed = 0;
|
|
|
// geschoss - bariere intersection
|
|
|
bool intersectsWithBariere = 0;
|
|
|
- for( auto b = barieren.getIterator(); b; b++ )
|
|
|
+ for( auto b : barieren )
|
|
|
{
|
|
|
if( b->hatStyle( Bariere::Style::Aktiv ) && b->intersectsWith( g ) )
|
|
|
{
|
|
|
@@ -272,7 +272,7 @@ void Spiel::tick()
|
|
|
{
|
|
|
if( zuletztBariereGetroffenesGeschoss )
|
|
|
zuletztBariereGetroffenesGeschoss->release();
|
|
|
- zuletztBariereGetroffenesGeschoss = dynamic_cast<Geschoss *>( g->getThis() );
|
|
|
+ zuletztBariereGetroffenesGeschoss = dynamic_cast<Geschoss*>(g->getThis());
|
|
|
g->tick( -zeit );
|
|
|
switch( g->getTyp() )
|
|
|
{
|
|
|
@@ -297,7 +297,7 @@ void Spiel::tick()
|
|
|
g->invertDirection();
|
|
|
break;
|
|
|
case GESCHOSS_MINE:
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->abstandZu( g ) < 50 )
|
|
|
{
|
|
|
@@ -316,23 +316,23 @@ void Spiel::tick()
|
|
|
}
|
|
|
if( !removed )
|
|
|
{ // geschoss - tunnel intersection
|
|
|
- for( auto t = tunnel.getIterator(); t; t++ )
|
|
|
+ for( auto t : tunnel )
|
|
|
{
|
|
|
if( t->istAktiv() && t->intersectsWith( g ) )
|
|
|
{
|
|
|
g->setX( g->getX() + (float)t->getZielX() - t->getX() );
|
|
|
g->setY( g->getY() + (float)t->getZielY() - t->getY() );
|
|
|
g->addTunnel( this );
|
|
|
- Ereignis *e = new Ereignis( TUNNEL_BENUTZT );
|
|
|
- e->addParameter( "Betroffes Geschoss", dynamic_cast<Geschoss *>( g->getThis() ) );
|
|
|
- e->addParameter( "Betroffer Tunnel", dynamic_cast<Tunnel *>( t->getThis() ) );
|
|
|
+ Ereignis* e = new Ereignis( TUNNEL_BENUTZT );
|
|
|
+ e->addParameter( "Betroffes Geschoss", dynamic_cast<Geschoss*>(g->getThis()) );
|
|
|
+ e->addParameter( "Betroffer Tunnel", dynamic_cast<Tunnel*>(t->getThis()) );
|
|
|
throwEvent( e );
|
|
|
}
|
|
|
}
|
|
|
// geschoss - schalter intersection
|
|
|
if( g->getTyp() == GESCHOSS_PFEIL )
|
|
|
{
|
|
|
- for( auto s = schalter.getIterator(); s; s++ )
|
|
|
+ for( auto s : schalter )
|
|
|
{
|
|
|
if( s->isAktive() && s->intersectsWith( g ) )
|
|
|
{
|
|
|
@@ -350,16 +350,16 @@ void Spiel::tick()
|
|
|
// geschoss - umlenkung intersection
|
|
|
if( g->getTyp() != GESCHOSS_PFEIL )
|
|
|
{
|
|
|
- for( auto u = umlenkungen.getIterator(); u; u++ )
|
|
|
+ for( auto u : umlenkungen )
|
|
|
{
|
|
|
if( u->isAktive() && !u->hatAbklingzeit() && g->getTyp() != GESCHOSS_PFEIL && u->intersectsWith( g ) )
|
|
|
{
|
|
|
g->setRichtung( u->getRichtung() );
|
|
|
g->addUmlenkung( this );
|
|
|
u->addBenutzt( this );
|
|
|
- Ereignis *e = new Ereignis( UMLENKUNG_LENKT_UM );
|
|
|
- e->addParameter( "Betroffes Geschoss", dynamic_cast<Geschoss *>( g->getThis() ) );
|
|
|
- e->addParameter( "Betroffe Umlenkung", dynamic_cast<Umlenkung *>( u->getThis() ) );
|
|
|
+ Ereignis* e = new Ereignis( UMLENKUNG_LENKT_UM );
|
|
|
+ e->addParameter( "Betroffes Geschoss", dynamic_cast<Geschoss*>(g->getThis()) );
|
|
|
+ e->addParameter( "Betroffe Umlenkung", dynamic_cast<Umlenkung*>(u->getThis()) );
|
|
|
throwEvent( e );
|
|
|
}
|
|
|
}
|
|
|
@@ -371,7 +371,7 @@ void Spiel::tick()
|
|
|
{
|
|
|
if( i == j )
|
|
|
continue;
|
|
|
- Geschoss *g2 = shots.z( j );
|
|
|
+ Geschoss* g2 = shots.z( j );
|
|
|
if( g2->intersectsWith( g ) )
|
|
|
{
|
|
|
addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 20, g->getY() + g->getHeight() / 2 - 20, 40, 40, resources->getResource( R_EXPLOSION, 0 ) ) );
|
|
|
@@ -393,7 +393,7 @@ void Spiel::tick()
|
|
|
if( !removed )
|
|
|
{
|
|
|
// geschoss - spieler intersection
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->istAmLeben() && g->intersectsWith( s ) )
|
|
|
{
|
|
|
@@ -412,14 +412,14 @@ void Spiel::tick()
|
|
|
}
|
|
|
case GESCHOSS_DRACHENAUGE:
|
|
|
addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 25, g->getY() + g->getHeight() / 2 - 25, 50, 50, resources->getResource( R_EXPLOSION, 0 ) ) );
|
|
|
- s->addEffekt( new DrachenAugeEffect( resources, g->zBesitzer(), s._ ) );
|
|
|
+ s->addEffekt( new DrachenAugeEffect( resources, g->zBesitzer(), s ) );
|
|
|
break;
|
|
|
case GESCHOSS_FEUERBALL:
|
|
|
feuer.add( new FeuerballTreffer( resources, ++nextId, (int)g->getX() - (int)g->getWidth() / 2, (int)g->getY() - (int)g->getHeight() / 2, g->getBesitzer(), 10 ) );
|
|
|
break;
|
|
|
case GESCHOSS_MINE:
|
|
|
addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 50, g->getY() + g->getHeight() / 2 - 50, 100, 100, resources->getResource( R_EXPLOSION, 0 ) ) );
|
|
|
- for( auto s2 = spieler.getIterator(); s2; s2++ )
|
|
|
+ for( auto s2 : spieler )
|
|
|
{
|
|
|
if( s2->abstandZu( g ) < 50 )
|
|
|
{
|
|
|
@@ -450,7 +450,7 @@ void Spiel::tick()
|
|
|
// Feuer Ticks
|
|
|
for( int i = 0; i < feuer.getEintragAnzahl(); i++ )
|
|
|
{
|
|
|
- FeuerballTreffer *f = feuer.z( i );
|
|
|
+ FeuerballTreffer* f = feuer.z( i );
|
|
|
f->tick( zeit );
|
|
|
if( f->isOver() )
|
|
|
{
|
|
|
@@ -460,7 +460,7 @@ void Spiel::tick()
|
|
|
}
|
|
|
if( f->makeDamage() )
|
|
|
{
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->abstandZu( f ) < f->getWidth() / 2 )
|
|
|
s->addEffekt( new BrandEffekt( resources, f->zVerursacher(), s ) );
|
|
|
@@ -468,23 +468,23 @@ void Spiel::tick()
|
|
|
}
|
|
|
}
|
|
|
// Drop Ticks
|
|
|
- for( auto d = drops.getIterator(); d; d++ )
|
|
|
+ for( auto d : drops )
|
|
|
d->tick( zeit, this );
|
|
|
// Timer Ticks
|
|
|
- for( auto t = timer.getIterator(); t; t++ )
|
|
|
+ for( auto t : timer )
|
|
|
t->tick( zeit, this );
|
|
|
// Umlenkung Ticks
|
|
|
- for( auto u = umlenkungen.getIterator(); u; u++ )
|
|
|
+ for( auto u : umlenkungen )
|
|
|
u->tick( zeit );
|
|
|
// Base Ticks
|
|
|
- for( auto b = basen.getIterator(); b; b++ )
|
|
|
+ for( auto b : basen )
|
|
|
b->tick( zeit, this );
|
|
|
// aktive trigger Ticks
|
|
|
for( int i = 0; i < triggerRuns.getEintragAnzahl(); i++ )
|
|
|
{
|
|
|
if( !triggerRuns.z( i )->runNext( zeit ) )
|
|
|
{
|
|
|
- Ereignis *e = new Ereignis( AUSLOESER_RUNNED );
|
|
|
+ Ereignis* e = new Ereignis( AUSLOESER_RUNNED );
|
|
|
e->addParameter( "Betroffener Auslöser", triggerRuns.z( i )->getTrigger() );
|
|
|
throwEvent( e );
|
|
|
triggerRuns.remove( i );
|
|
|
@@ -493,9 +493,9 @@ void Spiel::tick()
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::zEigenerSpieler() const
|
|
|
+Spieler* Spiel::zEigenerSpieler() const
|
|
|
{
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->getId() == spielerNummer )
|
|
|
return s;
|
|
|
@@ -503,9 +503,9 @@ Spieler *Spiel::zEigenerSpieler() const
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Team *Spiel::zEigenesTeam() const
|
|
|
+Team* Spiel::zEigenesTeam() const
|
|
|
{
|
|
|
- Spieler *s = zEigenerSpieler();
|
|
|
+ Spieler* s = zEigenerSpieler();
|
|
|
return s ? s->zTeam() : 0;
|
|
|
}
|
|
|
|
|
|
@@ -521,13 +521,13 @@ void Spiel::unlock()
|
|
|
}
|
|
|
|
|
|
// call 3
|
|
|
-void Spiel::setUIFactory( UIInit &uiFactory )
|
|
|
+void Spiel::setUIFactory( UIInit& uiFactory )
|
|
|
{
|
|
|
this->uiFactory = uiFactory;
|
|
|
chat = new SpielChat( uiFactory );
|
|
|
}
|
|
|
|
|
|
-void Spiel::nachricht( int län, char *bytes )
|
|
|
+void Spiel::nachricht( int län, char* bytes )
|
|
|
{
|
|
|
lock();
|
|
|
stkn->add( new STKNachricht( län, bytes ) );
|
|
|
@@ -535,7 +535,7 @@ void Spiel::nachricht( int l
|
|
|
}
|
|
|
|
|
|
// call 2
|
|
|
-void Spiel::setKlients( KSGClient::InformationServerClient *infoKlient, KSGClient::SpielServerClient *spielKlient )
|
|
|
+void Spiel::setKlients( KSGClient::InformationServerClient* infoKlient, KSGClient::SpielServerClient* spielKlient )
|
|
|
{
|
|
|
if( this->infoKlient )
|
|
|
this->infoKlient->release();
|
|
|
@@ -555,7 +555,7 @@ void Spiel::setKarteId( int karteId )
|
|
|
void Spiel::ladeDaten()
|
|
|
{
|
|
|
Sleep( 1000 );
|
|
|
- Text *gamePath = infoKlient->getDateiGruppePfad( infoKlient->getDateiGruppeIdVonSpiel( infoKlient->getSpielId( karteId ) ) );
|
|
|
+ Text* gamePath = infoKlient->getDateiGruppePfad( infoKlient->getDateiGruppeIdVonSpiel( infoKlient->getSpielId( karteId ) ) );
|
|
|
Text mapPf = Text( "data/tmp/Karten/" ) + karteId + "/spiel/files";
|
|
|
// loading resources
|
|
|
if( resources )
|
|
|
@@ -624,35 +624,35 @@ void Spiel::ladeDaten()
|
|
|
resources->zResource( R_GUI_SPIELER, 0, new ColorMode(), "spiel:/bilder/gui.ltdb/spieler.png" );
|
|
|
spielKlient->setLadenProzent( 20 );
|
|
|
|
|
|
- MapReader *reader = new MapReader( karteId, Text( "data/tmp/Karten/" ) + karteId + "/spiel/data/" );
|
|
|
+ MapReader* reader = new MapReader( karteId, Text( "data/tmp/Karten/" ) + karteId + "/spiel/data/" );
|
|
|
// apply team color filters
|
|
|
- Array<int> *colors = reader->getTeamFarben();
|
|
|
- AlphaColorMode *alphaMode = new AlphaColorMode( 0x77 );
|
|
|
- for( auto c = colors->getIterator(); c; c++ )
|
|
|
+ Array<int>* colors = reader->getTeamFarben();
|
|
|
+ AlphaColorMode* alphaMode = new AlphaColorMode( 0x77 );
|
|
|
+ for( auto c : *colors )
|
|
|
{
|
|
|
- resources->zResource( R_BARIERE, c._, dynamic_cast<AlphaColorMode *>( alphaMode->getThis() ) );
|
|
|
- resources->zResource( R_BASE, c._, dynamic_cast<AlphaColorMode *>( alphaMode->getThis() ) );
|
|
|
+ resources->zResource( R_BARIERE, c, dynamic_cast<AlphaColorMode*>(alphaMode->getThis()) );
|
|
|
+ resources->zResource( R_BASE, c, dynamic_cast<AlphaColorMode*>(alphaMode->getThis()) );
|
|
|
}
|
|
|
colors->release();
|
|
|
alphaMode->release();
|
|
|
spielKlient->setLadenProzent( 35 );
|
|
|
// apply player color filters
|
|
|
colors = reader->getSpielerFarben();
|
|
|
- MaskColorMode *maskMode = new MaskColorMode( 0xFFFFFF );
|
|
|
- for( auto c = colors->getIterator(); c; c++ )
|
|
|
+ MaskColorMode* maskMode = new MaskColorMode( 0xFFFFFF );
|
|
|
+ for( auto c : *colors )
|
|
|
{
|
|
|
- resources->zResource( R_ROLLE_OBEN, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_ROLLE_LINKS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_ROLLE_RECHTS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_ROLLE_UNTEN, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_STURM_OBEN, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_STURM_LINKS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_STURM_RECHTS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_STURM_UNTEN, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_SPIELER_STIRBT, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_SPIELER, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_SPIELER_RECHTS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
- resources->zResource( R_SPIELER_LINKS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
|
|
|
+ resources->zResource( R_ROLLE_OBEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_ROLLE_LINKS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_ROLLE_RECHTS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_ROLLE_UNTEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_STURM_OBEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_STURM_LINKS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_STURM_RECHTS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_STURM_UNTEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_SPIELER_STIRBT, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_SPIELER, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_SPIELER_RECHTS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
+ resources->zResource( R_SPIELER_LINKS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
|
|
|
}
|
|
|
colors->release();
|
|
|
spielKlient->setLadenProzent( 50 );
|
|
|
@@ -667,7 +667,7 @@ void Spiel::ladeDaten()
|
|
|
gamePath->release();
|
|
|
}
|
|
|
|
|
|
-void Spiel::doPublicMausEreignis( MausEreignis &me )
|
|
|
+void Spiel::doPublicMausEreignis( MausEreignis& me )
|
|
|
{
|
|
|
if( me.verarbeitet || !begonnen )
|
|
|
return;
|
|
|
@@ -680,7 +680,7 @@ void Spiel::doPublicMausEreignis( MausEreignis &me )
|
|
|
chat->doPublicMausEreignis( me );
|
|
|
}
|
|
|
|
|
|
-void Spiel::doTastaturEreignis( TastaturEreignis &te )
|
|
|
+void Spiel::doTastaturEreignis( TastaturEreignis& te )
|
|
|
{
|
|
|
if( te.verarbeitet || !begonnen )
|
|
|
return;
|
|
|
@@ -715,25 +715,25 @@ void Spiel::stknVerarbeitung()
|
|
|
lock();
|
|
|
while( stkn->getEintragAnzahl() )
|
|
|
{
|
|
|
- STKNachricht *n = stkn->z( 0 );
|
|
|
- char *msg = n->getNachricht();
|
|
|
+ STKNachricht* n = stkn->z( 0 );
|
|
|
+ char* msg = n->getNachricht();
|
|
|
switch( *msg )
|
|
|
{
|
|
|
case 1: // initialisation
|
|
|
{
|
|
|
- spielerAnzahl = (int)*( msg + 1 );
|
|
|
+ spielerAnzahl = (int)*(msg + 1);
|
|
|
for( int i = 0; i < spielerAnzahl; i++ )
|
|
|
{
|
|
|
- int sId = *(int *)( msg + 2 + (__int64)i * 8 );
|
|
|
- int aId = *(int *)( msg + 6 + (__int64)i * 8 );
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ int sId = *(int*)(msg + 2 + (__int64)i * 8);
|
|
|
+ int aId = *(int*)(msg + 6 + (__int64)i * 8);
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->getId() == sId )
|
|
|
{
|
|
|
s->setAccount( aId );
|
|
|
if( aId != 0 )
|
|
|
{
|
|
|
- Text *t = infoKlient->getSpielerName( aId );
|
|
|
+ Text* t = infoKlient->getSpielerName( aId );
|
|
|
s->setName( t->getText() );
|
|
|
t->release();
|
|
|
}
|
|
|
@@ -741,17 +741,17 @@ void Spiel::stknVerarbeitung()
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
- __int64 seed = *(__int64 *)( msg + 2 + (__int64)spielerAnzahl * 8 );
|
|
|
+ __int64 seed = *(__int64*)(msg + 2 + (__int64)spielerAnzahl * 8);
|
|
|
randG.setSeed( seed );
|
|
|
n->setVerarbeitet();
|
|
|
break;
|
|
|
}
|
|
|
case 2: // spielernummer
|
|
|
- spielerNummer = *(int *)( msg + 1 );
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ spielerNummer = *(int*)(msg + 1);
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->getId() == spielerNummer )
|
|
|
- spielerGUI->setSpieler( dynamic_cast<Spieler *>( s->getThis() ) );
|
|
|
+ spielerGUI->setSpieler( dynamic_cast<Spieler*>(s->getThis()) );
|
|
|
}
|
|
|
n->setVerarbeitet();
|
|
|
break;
|
|
|
@@ -763,18 +763,18 @@ void Spiel::stknVerarbeitung()
|
|
|
break;
|
|
|
case 4: // tasten stand
|
|
|
{
|
|
|
- char taste = *(char *)( msg + 1 );
|
|
|
- char aktiv = *(char *)( msg + 2 );
|
|
|
- int sId = *(int *)( msg + 3 );
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ char taste = *(char*)(msg + 1);
|
|
|
+ char aktiv = *(char*)(msg + 2);
|
|
|
+ int sId = *(int*)(msg + 3);
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->getId() == sId )
|
|
|
{
|
|
|
if( s->setTastenStand( taste, aktiv ) )
|
|
|
{
|
|
|
- Ereignis *e = new Ereignis( aktiv ? SPIELER_KEY_PRESSED : SPIELER_KEY_RELEASED );
|
|
|
+ Ereignis* e = new Ereignis( aktiv ? SPIELER_KEY_PRESSED : SPIELER_KEY_RELEASED );
|
|
|
e->addParameter( "Betroffene Taste", new Integer( taste, 1 ) );
|
|
|
- e->addParameter( "Ausführender Spieler", dynamic_cast<Spieler *>( s->getThis() ) );
|
|
|
+ e->addParameter( "Ausführender Spieler", dynamic_cast<Spieler*>(s->getThis()) );
|
|
|
throwEvent( e );
|
|
|
}
|
|
|
break;
|
|
|
@@ -795,7 +795,7 @@ void Spiel::stknVerarbeitung()
|
|
|
break;
|
|
|
case 7: // chat nachricht
|
|
|
{
|
|
|
- char *buf = new char[ (__int64)n->getLength() ];
|
|
|
+ char* buf = new char[ (__int64)n->getLength() ];
|
|
|
memcpy( buf, msg + 1, n->getLength() - 1 );
|
|
|
buf[ n->getLength() - 1 ] = 0;
|
|
|
if( chat )
|
|
|
@@ -832,12 +832,12 @@ bool Spiel::tick( double zeit )
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
-void Spiel::render( Bild &zRObj )
|
|
|
+void Spiel::render( Bild& zRObj )
|
|
|
{
|
|
|
if( spielerGUI )
|
|
|
spielerGUI->render( zRObj );
|
|
|
- Spieler *i = 0;
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ Spieler* i = 0;
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->getId() == spielerNummer )
|
|
|
i = s;
|
|
|
@@ -845,40 +845,40 @@ void Spiel::render( Bild &zRObj )
|
|
|
if( zRObj.setDrawOptions( 300, 0, zRObj.getBreite() - 300, zRObj.getHeight() ) )
|
|
|
{
|
|
|
if( !begonnen )
|
|
|
- zRObj.addScrollOffset( mapSize.x - ( zRObj.getBreite() - 300 ) / 2, mapSize.y - zRObj.getHeight() / 2 );
|
|
|
+ zRObj.addScrollOffset( mapSize.x - (zRObj.getBreite() - 300) / 2, mapSize.y - zRObj.getHeight() / 2 );
|
|
|
else if( i )
|
|
|
- zRObj.addScrollOffset( (int)i->getX() - ( zRObj.getBreite() - 300 ) / 2, (int)i->getY() - zRObj.getHeight() / 2 );
|
|
|
- for( auto f = feuer.getIterator(); f; f++ )
|
|
|
+ zRObj.addScrollOffset( (int)i->getX() - (zRObj.getBreite() - 300) / 2, (int)i->getY() - zRObj.getHeight() / 2 );
|
|
|
+ for( auto f : feuer )
|
|
|
f->render( zRObj );
|
|
|
- for( auto s = schalter.getIterator(); s; s++ )
|
|
|
+ for( auto s : schalter )
|
|
|
s->render( zRObj );
|
|
|
- for( auto t = tunnel.getIterator(); t; t++ )
|
|
|
+ for( auto t : tunnel )
|
|
|
t->render( zRObj );
|
|
|
- for( auto b = basen.getIterator(); b; b++ )
|
|
|
+ for( auto b : basen )
|
|
|
b->render( zRObj );
|
|
|
- for( auto u = umlenkungen.getIterator(); u; u++ )
|
|
|
+ for( auto u : umlenkungen )
|
|
|
u->render( zRObj );
|
|
|
- for( auto s = schienen.getIterator(); s; s++ )
|
|
|
+ for( auto s : schienen )
|
|
|
s->render( zRObj );
|
|
|
- for( auto i = items.getIterator(); i; i++ )
|
|
|
+ for( auto i : items )
|
|
|
i->render( zRObj );
|
|
|
- for( auto b = barieren.getIterator(); b; b++ )
|
|
|
+ for( auto b : barieren )
|
|
|
b->render( zRObj );
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->istSichtbar( zEigenesTeam() ) )
|
|
|
s->render( zRObj );
|
|
|
}
|
|
|
- for( auto s = shots.getIterator(); s; s++ )
|
|
|
+ for( auto s : shots )
|
|
|
s->render( zRObj );
|
|
|
- for( auto a = animations.getIterator(); a; a++ )
|
|
|
+ for( auto a : animations )
|
|
|
a->render( zRObj );
|
|
|
- for( auto t = timer.getIterator(); t; t++ )
|
|
|
+ for( auto t : timer )
|
|
|
t->render( zRObj );
|
|
|
zRObj.releaseDrawOptions();
|
|
|
}
|
|
|
int y = 5;
|
|
|
- for( auto b = bestenlisten.getIterator(); b; b++ )
|
|
|
+ for( auto b : bestenlisten )
|
|
|
{
|
|
|
int x = zRObj.getBreite() - b->getBreite() - 5;
|
|
|
b->render( x, y, zRObj );
|
|
|
@@ -903,10 +903,10 @@ void Spiel::setPausiert( bool pausiert )
|
|
|
this->pause = pausiert;
|
|
|
}
|
|
|
|
|
|
-void Spiel::addVariable( const char *name, Variable *var )
|
|
|
+void Spiel::addVariable( const char* name, Variable* var )
|
|
|
{
|
|
|
bool found = 0;
|
|
|
- for( auto v = variablen.getIterator(); v; v++ )
|
|
|
+ for( auto v : variablen )
|
|
|
{
|
|
|
if( v->getName().istGleich( name ) )
|
|
|
{
|
|
|
@@ -920,10 +920,10 @@ void Spiel::addVariable( const char *name, Variable *var )
|
|
|
var->release();
|
|
|
}
|
|
|
|
|
|
-void Spiel::setVariable( const char *name, Variable *var )
|
|
|
+void Spiel::setVariable( const char* name, Variable* var )
|
|
|
{
|
|
|
bool found = 0;
|
|
|
- for( auto v = variablen.getIterator(); v; v++ )
|
|
|
+ for( auto v : variablen )
|
|
|
{
|
|
|
if( v->getName().istGleich( name ) )
|
|
|
{
|
|
|
@@ -936,90 +936,90 @@ void Spiel::setVariable( const char *name, Variable *var )
|
|
|
var->release();
|
|
|
}
|
|
|
|
|
|
-void Spiel::addTeam( Team *team )
|
|
|
+void Spiel::addTeam( Team* team )
|
|
|
{
|
|
|
teams.add( team );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addSpieler( Spieler *spieler )
|
|
|
+void Spiel::addSpieler( Spieler* spieler )
|
|
|
{
|
|
|
this->spieler.add( spieler );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addBariere( Bariere *bariere )
|
|
|
+void Spiel::addBariere( Bariere* bariere )
|
|
|
{
|
|
|
nextId = nextId > bariere->getId() ? nextId : bariere->getId() + 1;
|
|
|
barieren.add( bariere );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addBase( Base *base )
|
|
|
+void Spiel::addBase( Base* base )
|
|
|
{
|
|
|
nextId = nextId > base->getId() ? nextId : base->getId() + 1;
|
|
|
basen.add( base );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addDrop( Drop *drop )
|
|
|
+void Spiel::addDrop( Drop* drop )
|
|
|
{
|
|
|
nextId = nextId > drop->getId() ? nextId : drop->getId() + 1;
|
|
|
drops.add( drop );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addGegenstand( Gegenstand *gegenstand )
|
|
|
+void Spiel::addGegenstand( Gegenstand* gegenstand )
|
|
|
{
|
|
|
nextId = nextId > gegenstand->getId() ? nextId : gegenstand->getId() + 1;
|
|
|
items.add( gegenstand );
|
|
|
zuletztGedropterGegenstand = gegenstand->getTyp();
|
|
|
- Ereignis *e = new Ereignis( GEGENSTAND_DROPED );
|
|
|
- e->addParameter( "Betroffener Gegenstand", dynamic_cast<Gegenstand *>( gegenstand->getThis() ) );
|
|
|
+ Ereignis* e = new Ereignis( GEGENSTAND_DROPED );
|
|
|
+ e->addParameter( "Betroffener Gegenstand", dynamic_cast<Gegenstand*>(gegenstand->getThis()) );
|
|
|
throwEvent( e );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addGeschoss( Geschoss *geschoss )
|
|
|
+void Spiel::addGeschoss( Geschoss* geschoss )
|
|
|
{
|
|
|
nextId = nextId > geschoss->getId() ? nextId : geschoss->getId() + 1;
|
|
|
if( zuletztAbgefeuertesGeschoss )
|
|
|
zuletztAbgefeuertesGeschoss->release();
|
|
|
- zuletztAbgefeuertesGeschoss = dynamic_cast<Geschoss *>( geschoss->getThis() );
|
|
|
+ zuletztAbgefeuertesGeschoss = dynamic_cast<Geschoss*>(geschoss->getThis());
|
|
|
shots.add( geschoss );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addSchalter( Schalter *schalter )
|
|
|
+void Spiel::addSchalter( Schalter* schalter )
|
|
|
{
|
|
|
nextId = nextId > schalter->getId() ? nextId : schalter->getId() + 1;
|
|
|
this->schalter.add( schalter );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addSchiene( Schiene *schiene )
|
|
|
+void Spiel::addSchiene( Schiene* schiene )
|
|
|
{
|
|
|
nextId = nextId > schiene->getId() ? nextId : schiene->getId() + 1;
|
|
|
schienen.add( schiene );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addTimer( Timer *timer )
|
|
|
+void Spiel::addTimer( Timer* timer )
|
|
|
{
|
|
|
nextId = nextId > timer->getId() ? nextId : timer->getId() + 1;
|
|
|
this->timer.add( timer );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addTunnel( Tunnel *tunnel )
|
|
|
+void Spiel::addTunnel( Tunnel* tunnel )
|
|
|
{
|
|
|
nextId = nextId > tunnel->getId() ? nextId : tunnel->getId() + 1;
|
|
|
this->tunnel.add( tunnel );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addUmlenkung( Umlenkung *umlenkung )
|
|
|
+void Spiel::addUmlenkung( Umlenkung* umlenkung )
|
|
|
{
|
|
|
nextId = nextId > umlenkung->getId() ? nextId : umlenkung->getId() + 1;
|
|
|
umlenkungen.add( umlenkung );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addTrigger( Trigger *trigger )
|
|
|
+void Spiel::addTrigger( Trigger* trigger )
|
|
|
{
|
|
|
nextId = nextId > trigger->getId() ? nextId : trigger->getId() + 1;
|
|
|
this->trigger.add( trigger );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addTriggerRun( TriggerRun *tRun )
|
|
|
+void Spiel::addTriggerRun( TriggerRun* tRun )
|
|
|
{
|
|
|
if( tRun )
|
|
|
{
|
|
|
@@ -1030,7 +1030,7 @@ void Spiel::addTriggerRun( TriggerRun *tRun )
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void Spiel::spielerActivate( Spieler *zSpieler )
|
|
|
+void Spiel::spielerActivate( Spieler* zSpieler )
|
|
|
{
|
|
|
// spieler - item intersection
|
|
|
for( int i = 0; i < items.getEintragAnzahl(); i++ )
|
|
|
@@ -1066,129 +1066,129 @@ void Spiel::spielerActivate( Spieler *zSpieler )
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-Team *Spiel::getTeam( int id ) const
|
|
|
+Team* Spiel::getTeam( int id ) const
|
|
|
{
|
|
|
- for( auto t = teams.getIterator(); t; t++ )
|
|
|
+ for( auto t : teams )
|
|
|
{
|
|
|
if( t->getTeamNummer() == id )
|
|
|
- return dynamic_cast<Team *>( t->getThis() );
|
|
|
+ return dynamic_cast<Team*>(t->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpieler( int id ) const
|
|
|
+Spieler* Spiel::getSpieler( int id ) const
|
|
|
{
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->getId() == id )
|
|
|
- return dynamic_cast<Spieler *>( s->getThis() );
|
|
|
+ return dynamic_cast<Spieler*>(s->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Iterator<Spieler *> Spiel::getSpieler() const
|
|
|
+Iterator<Spieler*> Spiel::getSpieler() const
|
|
|
{
|
|
|
- return spieler.getIterator();
|
|
|
+ return spieler.begin();
|
|
|
}
|
|
|
|
|
|
-Iterator<Bariere *> Spiel::getBarieren() const
|
|
|
+Iterator<Bariere*> Spiel::getBarieren() const
|
|
|
{
|
|
|
- return barieren.getIterator();
|
|
|
+ return barieren.begin();
|
|
|
}
|
|
|
|
|
|
-Bariere *Spiel::getBariere( int id ) const
|
|
|
+Bariere* Spiel::getBariere( int id ) const
|
|
|
{
|
|
|
- for( auto b = barieren.getIterator(); b; b++ )
|
|
|
+ for( auto b : barieren )
|
|
|
{
|
|
|
if( b->getId() == id )
|
|
|
- return dynamic_cast<Bariere *>( b->getThis() );
|
|
|
+ return dynamic_cast<Bariere*>(b->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Base *Spiel::getBase( int id ) const
|
|
|
+Base* Spiel::getBase( int id ) const
|
|
|
{
|
|
|
- for( auto b = basen.getIterator(); b; b++ )
|
|
|
+ for( auto b : basen )
|
|
|
{
|
|
|
if( b->getId() == id )
|
|
|
- return dynamic_cast<Base *>( b->getThis() );
|
|
|
+ return dynamic_cast<Base*>(b->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Drop *Spiel::getDrop( int id ) const
|
|
|
+Drop* Spiel::getDrop( int id ) const
|
|
|
{
|
|
|
- for( auto d = drops.getIterator(); d; d++ )
|
|
|
+ for( auto d : drops )
|
|
|
{
|
|
|
if( d->getId() == id )
|
|
|
- return dynamic_cast<Drop *>( d->getThis() );
|
|
|
+ return dynamic_cast<Drop*>(d->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Schalter *Spiel::getSchalter( int id ) const
|
|
|
+Schalter* Spiel::getSchalter( int id ) const
|
|
|
{
|
|
|
- for( auto s = schalter.getIterator(); s; s++ )
|
|
|
+ for( auto s : schalter )
|
|
|
{
|
|
|
if( s->getId() == id )
|
|
|
- return dynamic_cast<Schalter *>( s->getThis() );
|
|
|
+ return dynamic_cast<Schalter*>(s->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Schiene *Spiel::getSchiene( int id ) const
|
|
|
+Schiene* Spiel::getSchiene( int id ) const
|
|
|
{
|
|
|
- for( auto s = schienen.getIterator(); s; s++ )
|
|
|
+ for( auto s : schienen )
|
|
|
{
|
|
|
if( s->getId() == id )
|
|
|
- return dynamic_cast<Schiene *>( s->getThis() );
|
|
|
+ return dynamic_cast<Schiene*>(s->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Timer *Spiel::getTimer( int id ) const
|
|
|
+Timer* Spiel::getTimer( int id ) const
|
|
|
{
|
|
|
- for( auto t = timer.getIterator(); t; t++ )
|
|
|
+ for( auto t : timer )
|
|
|
{
|
|
|
if( t->getId() == id )
|
|
|
- return dynamic_cast<Timer *>( t->getThis() );
|
|
|
+ return dynamic_cast<Timer*>(t->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Tunnel *Spiel::getTunnel( int id ) const
|
|
|
+Tunnel* Spiel::getTunnel( int id ) const
|
|
|
{
|
|
|
- for( auto t = tunnel.getIterator(); t; t++ )
|
|
|
+ for( auto t : tunnel )
|
|
|
{
|
|
|
if( t->getId() == id )
|
|
|
- return dynamic_cast<Tunnel *>( t->getThis() );
|
|
|
+ return dynamic_cast<Tunnel*>(t->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Umlenkung *Spiel::getUmlenkung( int id ) const
|
|
|
+Umlenkung* Spiel::getUmlenkung( int id ) const
|
|
|
{
|
|
|
- for( auto u = umlenkungen.getIterator(); u; u++ )
|
|
|
+ for( auto u : umlenkungen )
|
|
|
{
|
|
|
if( u->getId() == id )
|
|
|
- return dynamic_cast<Umlenkung *>( u->getThis() );
|
|
|
+ return dynamic_cast<Umlenkung*>(u->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Trigger *Spiel::getTrigger( int id ) const
|
|
|
+Trigger* Spiel::getTrigger( int id ) const
|
|
|
{
|
|
|
- for( auto t = trigger.getIterator(); t; t++ )
|
|
|
+ for( auto t : trigger )
|
|
|
{
|
|
|
if( t->getId() == id )
|
|
|
- return dynamic_cast<Trigger *>( t->getThis() );
|
|
|
+ return dynamic_cast<Trigger*>(t->getThis());
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Variable *Spiel::getVariable( const char *name ) const
|
|
|
+Variable* Spiel::getVariable( const char* name ) const
|
|
|
{
|
|
|
- for( auto v = variablen.getIterator(); v; v++ )
|
|
|
+ for( auto v : variablen )
|
|
|
{
|
|
|
if( v->getName().istGleich( name ) )
|
|
|
return v->getVariable();
|
|
|
@@ -1196,9 +1196,9 @@ Variable *Spiel::getVariable( const char *name ) const
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-Variable *Spiel::zVariable( const char *name ) const
|
|
|
+Variable* Spiel::zVariable( const char* name ) const
|
|
|
{
|
|
|
- for( auto v = variablen.getIterator(); v; v++ )
|
|
|
+ for( auto v : variablen )
|
|
|
{
|
|
|
if( v->getName().istGleich( name ) )
|
|
|
return v->zVariable();
|
|
|
@@ -1213,20 +1213,20 @@ bool Spiel::istPausiert() const
|
|
|
|
|
|
void Spiel::activateShalter( int id )
|
|
|
{
|
|
|
- for( auto s = schalter.getIterator(); s; s++ )
|
|
|
+ for( auto s : schalter )
|
|
|
{
|
|
|
if( s->getId() == id )
|
|
|
s->press( this );
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void Spiel::throwEvent( Ereignis *e )
|
|
|
+void Spiel::throwEvent( Ereignis* e )
|
|
|
{
|
|
|
- for( auto t = trigger.getIterator(); t; t++ )
|
|
|
+ for( auto t : trigger )
|
|
|
{
|
|
|
if( t->hatEreignis( e->getTyp() ) )
|
|
|
{
|
|
|
- TriggerRun *tr = t->runTrigger( dynamic_cast<Ereignis *>( e->getThis() ), this );
|
|
|
+ TriggerRun* tr = t->runTrigger( dynamic_cast<Ereignis*>(e->getThis()), this );
|
|
|
if( tr )
|
|
|
triggerRuns.add( tr );
|
|
|
}
|
|
|
@@ -1236,7 +1236,7 @@ void Spiel::throwEvent( Ereignis *e )
|
|
|
|
|
|
bool Spiel::needEvent( EreignisTyp typ ) const
|
|
|
{
|
|
|
- for( auto t = trigger.getIterator(); t; t++ )
|
|
|
+ for( auto t : trigger )
|
|
|
{
|
|
|
if( t->hatEreignis( typ ) )
|
|
|
return 1;
|
|
|
@@ -1259,108 +1259,108 @@ int Spiel::getTickCount() const
|
|
|
return gameTicks;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setEnde( Team *zGewinner )
|
|
|
+void Spiel::setEnde( Team* zGewinner )
|
|
|
{
|
|
|
zWinner = zGewinner;
|
|
|
- Spieler *i = 0;
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ Spieler* i = 0;
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->getId() == spielerNummer )
|
|
|
i = s;
|
|
|
}
|
|
|
end = new Ende( uiFactory );
|
|
|
- end->setGewonnen( ( zGewinner && i ) ? ( i->zTeam() == zGewinner ) : -1 );
|
|
|
+ end->setGewonnen( (zGewinner && i) ? (i->zTeam() == zGewinner) : -1 );
|
|
|
}
|
|
|
|
|
|
-Trigger *Spiel::getRandomTrigger()
|
|
|
+Trigger* Spiel::getRandomTrigger()
|
|
|
{
|
|
|
if( !trigger.getEintragAnzahl() )
|
|
|
return 0;
|
|
|
- return trigger.get( (int)( randG.rand() * trigger.getEintragAnzahl() ) );
|
|
|
+ return trigger.get( (int)(randG.rand() * trigger.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-Trigger *Spiel::getLastRunnedTrigger() const
|
|
|
+Trigger* Spiel::getLastRunnedTrigger() const
|
|
|
{
|
|
|
- return lastRunnedTrigger ? dynamic_cast<Trigger *>( lastRunnedTrigger->getThis() ) : 0;
|
|
|
+ return lastRunnedTrigger ? dynamic_cast<Trigger*>(lastRunnedTrigger->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-Bariere *Spiel::getRandomBariere()
|
|
|
+Bariere* Spiel::getRandomBariere()
|
|
|
{
|
|
|
- return barieren.get( (int)( randG.rand() * barieren.getEintragAnzahl() ) );
|
|
|
+ return barieren.get( (int)(randG.rand() * barieren.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-void Spiel::setZuletztEingeschalteteBariere( Bariere *b )
|
|
|
+void Spiel::setZuletztEingeschalteteBariere( Bariere* b )
|
|
|
{
|
|
|
if( zuletztEingeschalteteBariere )
|
|
|
zuletztEingeschalteteBariere->release();
|
|
|
zuletztEingeschalteteBariere = b;
|
|
|
}
|
|
|
|
|
|
-Bariere *Spiel::getZuletztEingeschalteteBariere() const
|
|
|
+Bariere* Spiel::getZuletztEingeschalteteBariere() const
|
|
|
{
|
|
|
- return zuletztEingeschalteteBariere ? dynamic_cast<Bariere *>( zuletztEingeschalteteBariere->getThis() ) : 0;
|
|
|
+ return zuletztEingeschalteteBariere ? dynamic_cast<Bariere*>(zuletztEingeschalteteBariere->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setZuletztAusgeschalteteBariere( Bariere *b )
|
|
|
+void Spiel::setZuletztAusgeschalteteBariere( Bariere* b )
|
|
|
{
|
|
|
if( zuletztAusgeschalteteBariere )
|
|
|
zuletztAusgeschalteteBariere->release();
|
|
|
zuletztAusgeschalteteBariere = b;
|
|
|
}
|
|
|
|
|
|
-Bariere *Spiel::getZuletztAusgeschalteteBariere() const
|
|
|
+Bariere* Spiel::getZuletztAusgeschalteteBariere() const
|
|
|
{
|
|
|
- return zuletztAusgeschalteteBariere ? dynamic_cast<Bariere *>( zuletztAusgeschalteteBariere->getThis() ) : 0;
|
|
|
+ return zuletztAusgeschalteteBariere ? dynamic_cast<Bariere*>(zuletztAusgeschalteteBariere->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setZuletztBewegteBariere( Bariere *b )
|
|
|
+void Spiel::setZuletztBewegteBariere( Bariere* b )
|
|
|
{
|
|
|
if( zuletztBewegteBariere )
|
|
|
zuletztBewegteBariere->release();
|
|
|
zuletztBewegteBariere = b;
|
|
|
}
|
|
|
|
|
|
-Bariere *Spiel::getZuletztBewegteBariere() const
|
|
|
+Bariere* Spiel::getZuletztBewegteBariere() const
|
|
|
{
|
|
|
- return zuletztBewegteBariere ? dynamic_cast<Bariere *>( zuletztBewegteBariere->getThis() ) : 0;
|
|
|
+ return zuletztBewegteBariere ? dynamic_cast<Bariere*>(zuletztBewegteBariere->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-Base *Spiel::getRandomBase()
|
|
|
+Base* Spiel::getRandomBase()
|
|
|
{
|
|
|
if( !basen.getEintragAnzahl() )
|
|
|
return 0;
|
|
|
- return basen.get( (int)( randG.rand() * basen.getEintragAnzahl() ) );
|
|
|
+ return basen.get( (int)(randG.rand() * basen.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-void Spiel::setLastTeamChangedBase( Base *b )
|
|
|
+void Spiel::setLastTeamChangedBase( Base* b )
|
|
|
{
|
|
|
if( lastTeamChangedBase )
|
|
|
lastTeamChangedBase->release();
|
|
|
lastTeamChangedBase = b;
|
|
|
}
|
|
|
|
|
|
-Base *Spiel::getLastTeamChangedBase() const
|
|
|
+Base* Spiel::getLastTeamChangedBase() const
|
|
|
{
|
|
|
- return lastTeamChangedBase ? dynamic_cast<Base *>( lastTeamChangedBase->getThis() ) : 0;
|
|
|
+ return lastTeamChangedBase ? dynamic_cast<Base*>(lastTeamChangedBase->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-Drop *Spiel::getRandomDrop()
|
|
|
+Drop* Spiel::getRandomDrop()
|
|
|
{
|
|
|
if( !drops.getEintragAnzahl() )
|
|
|
return 0;
|
|
|
- return drops.get( (int)( randG.rand() * drops.getEintragAnzahl() ) );
|
|
|
+ return drops.get( (int)(randG.rand() * drops.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-void Spiel::setLastDrop( Drop *d )
|
|
|
+void Spiel::setLastDrop( Drop* d )
|
|
|
{
|
|
|
if( lastDropedDrop )
|
|
|
lastDropedDrop->release();
|
|
|
lastDropedDrop = d;
|
|
|
}
|
|
|
|
|
|
-Drop *Spiel::getLastDrop() const
|
|
|
+Drop* Spiel::getLastDrop() const
|
|
|
{
|
|
|
- return lastDropedDrop ? dynamic_cast<Drop *>( lastDropedDrop->getThis() ) : 0;
|
|
|
+ return lastDropedDrop ? dynamic_cast<Drop*>(lastDropedDrop->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
void Spiel::setItemZuletztAufgehoben( GegenstandTyp g )
|
|
|
@@ -1388,356 +1388,356 @@ GegenstandTyp Spiel::getItemZuletztGedropt() const
|
|
|
return zuletztGedropterGegenstand;
|
|
|
}
|
|
|
|
|
|
-Geschoss *Spiel::getRandomGeschoss()
|
|
|
+Geschoss* Spiel::getRandomGeschoss()
|
|
|
{
|
|
|
if( !shots.getEintragAnzahl() )
|
|
|
return 0;
|
|
|
- return shots.get( (int)( randG.rand() * shots.getEintragAnzahl() ) );
|
|
|
+ return shots.get( (int)(randG.rand() * shots.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-Geschoss *Spiel::getGeschossZuletztAbgefeuert() const
|
|
|
+Geschoss* Spiel::getGeschossZuletztAbgefeuert() const
|
|
|
{
|
|
|
- return zuletztAbgefeuertesGeschoss ? dynamic_cast<Geschoss *>( zuletztAbgefeuertesGeschoss->getThis() ) : 0;
|
|
|
+ return zuletztAbgefeuertesGeschoss ? dynamic_cast<Geschoss*>(zuletztAbgefeuertesGeschoss->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setGeschossZuletztUmgelenkt( Geschoss *g )
|
|
|
+void Spiel::setGeschossZuletztUmgelenkt( Geschoss* g )
|
|
|
{
|
|
|
if( zuletztUmgelenktesGeschoss )
|
|
|
zuletztUmgelenktesGeschoss->release();
|
|
|
zuletztUmgelenktesGeschoss = g;
|
|
|
}
|
|
|
|
|
|
-Geschoss *Spiel::getGeschossZuletztUmgelenkt() const
|
|
|
+Geschoss* Spiel::getGeschossZuletztUmgelenkt() const
|
|
|
{
|
|
|
- return zuletztUmgelenktesGeschoss ? dynamic_cast<Geschoss *>( zuletztUmgelenktesGeschoss->getThis() ) : 0;
|
|
|
+ return zuletztUmgelenktesGeschoss ? dynamic_cast<Geschoss*>(zuletztUmgelenktesGeschoss->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-Geschoss *Spiel::getGeschossZuletztBariereGetroffen() const
|
|
|
+Geschoss* Spiel::getGeschossZuletztBariereGetroffen() const
|
|
|
{
|
|
|
- return zuletztBariereGetroffenesGeschoss ? dynamic_cast<Geschoss *>( zuletztBariereGetroffenesGeschoss->getThis() ) : 0;
|
|
|
+ return zuletztBariereGetroffenesGeschoss ? dynamic_cast<Geschoss*>(zuletztBariereGetroffenesGeschoss->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setGeschossZuletztTunnelBenutzt( Geschoss *g )
|
|
|
+void Spiel::setGeschossZuletztTunnelBenutzt( Geschoss* g )
|
|
|
{
|
|
|
if( zuletztTunnelBenutztesGeschoss )
|
|
|
zuletztTunnelBenutztesGeschoss->release();
|
|
|
zuletztTunnelBenutztesGeschoss = g;
|
|
|
}
|
|
|
|
|
|
-Geschoss *Spiel::getGeschossZuletztTunnelBenutzt() const
|
|
|
+Geschoss* Spiel::getGeschossZuletztTunnelBenutzt() const
|
|
|
{
|
|
|
- return zuletztTunnelBenutztesGeschoss ? dynamic_cast<Geschoss *>( zuletztTunnelBenutztesGeschoss->getThis() ) : 0;
|
|
|
+ return zuletztTunnelBenutztesGeschoss ? dynamic_cast<Geschoss*>(zuletztTunnelBenutztesGeschoss->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setGeschossZuletztGeschossGetroffen( Geschoss *g )
|
|
|
+void Spiel::setGeschossZuletztGeschossGetroffen( Geschoss* g )
|
|
|
{
|
|
|
if( zuletztGeschossGetroffenesGeschoss )
|
|
|
zuletztGeschossGetroffenesGeschoss->release();
|
|
|
zuletztGeschossGetroffenesGeschoss = g;
|
|
|
}
|
|
|
|
|
|
-Geschoss *Spiel::getGeschossZuletztGeschossGetroffen() const
|
|
|
+Geschoss* Spiel::getGeschossZuletztGeschossGetroffen() const
|
|
|
{
|
|
|
- return zuletztGeschossGetroffenesGeschoss ? dynamic_cast<Geschoss *>( zuletztGeschossGetroffenesGeschoss->getThis() ) : 0;
|
|
|
+ return zuletztGeschossGetroffenesGeschoss ? dynamic_cast<Geschoss*>(zuletztGeschossGetroffenesGeschoss->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-Schalter *Spiel::getRandomSchalter()
|
|
|
+Schalter* Spiel::getRandomSchalter()
|
|
|
{
|
|
|
if( !schalter.getEintragAnzahl() )
|
|
|
return 0;
|
|
|
- return schalter.get( (int)( randG.rand() * schalter.getEintragAnzahl() ) );
|
|
|
+ return schalter.get( (int)(randG.rand() * schalter.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSchalterZuletztAktiviert( Schalter *s )
|
|
|
+void Spiel::setSchalterZuletztAktiviert( Schalter* s )
|
|
|
{
|
|
|
if( zuletztAktivierterSchalter )
|
|
|
zuletztAktivierterSchalter->release();
|
|
|
zuletztAktivierterSchalter = s;
|
|
|
}
|
|
|
|
|
|
-Schalter *Spiel::getSchalterZuletztAktiviert() const
|
|
|
+Schalter* Spiel::getSchalterZuletztAktiviert() const
|
|
|
{
|
|
|
- return zuletztAktivierterSchalter ? dynamic_cast<Schalter *>( zuletztAktivierterSchalter->getThis() ) : 0;
|
|
|
+ return zuletztAktivierterSchalter ? dynamic_cast<Schalter*>(zuletztAktivierterSchalter->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getRandomSpieler()
|
|
|
+Spieler* Spiel::getRandomSpieler()
|
|
|
{
|
|
|
if( !spieler.getEintragAnzahl() )
|
|
|
return 0;
|
|
|
- return spieler.get( (int)( randG.rand() * spieler.getEintragAnzahl() ) );
|
|
|
+ return spieler.get( (int)(randG.rand() * spieler.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getRandomSpieler( Team *zTeam )
|
|
|
+Spieler* Spiel::getRandomSpieler( Team* zTeam )
|
|
|
{
|
|
|
if( !zTeam || !zTeam->getSpielerAnzahl() )
|
|
|
return 0;
|
|
|
- int index = (int)( randG.rand() * zTeam->getSpielerAnzahl() );
|
|
|
- for( auto s = spieler.getIterator(); s; s++ )
|
|
|
+ int index = (int)(randG.rand() * zTeam->getSpielerAnzahl());
|
|
|
+ for( auto s : spieler )
|
|
|
{
|
|
|
if( s->zTeam() == zTeam )
|
|
|
{
|
|
|
if( index-- <= 0 )
|
|
|
- return dynamic_cast<Spieler *>( s->getThis() );
|
|
|
+ return dynamic_cast<Spieler*>(s->getThis());
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztSchadenGemacht( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztSchadenGemacht( Spieler* s )
|
|
|
{
|
|
|
if( zuletztSchadenGemachterSpieler )
|
|
|
zuletztSchadenGemachterSpieler->release();
|
|
|
zuletztSchadenGemachterSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztSchadenGemacht() const
|
|
|
+Spieler* Spiel::getSpielerZuletztSchadenGemacht() const
|
|
|
{
|
|
|
- return zuletztSchadenGemachterSpieler ? dynamic_cast<Spieler *>( zuletztSchadenGemachterSpieler->getThis() ) : 0;
|
|
|
+ return zuletztSchadenGemachterSpieler ? dynamic_cast<Spieler*>(zuletztSchadenGemachterSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztSchadenGenommen( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztSchadenGenommen( Spieler* s )
|
|
|
{
|
|
|
if( zuletztSchadenGenommenerSpieler )
|
|
|
zuletztSchadenGenommenerSpieler->release();
|
|
|
zuletztSchadenGenommenerSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztSchadenGenommen() const
|
|
|
+Spieler* Spiel::getSpielerZuletztSchadenGenommen() const
|
|
|
{
|
|
|
- return zuletztSchadenGenommenerSpieler ? dynamic_cast<Spieler *>( zuletztSchadenGenommenerSpieler->getThis() ) : 0;
|
|
|
+ return zuletztSchadenGenommenerSpieler ? dynamic_cast<Spieler*>(zuletztSchadenGenommenerSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztGeheilt( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztGeheilt( Spieler* s )
|
|
|
{
|
|
|
if( zuletztGeheilterSpieler )
|
|
|
zuletztGeheilterSpieler->release();
|
|
|
zuletztGeheilterSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztGeheilt() const
|
|
|
+Spieler* Spiel::getSpielerZuletztGeheilt() const
|
|
|
{
|
|
|
- return zuletztGeheilterSpieler ? dynamic_cast<Spieler *>( zuletztGeheilterSpieler->getThis() ) : 0;
|
|
|
+ return zuletztGeheilterSpieler ? dynamic_cast<Spieler*>(zuletztGeheilterSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztLevelUp( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztLevelUp( Spieler* s )
|
|
|
{
|
|
|
if( zuletztLevelUpSpieler )
|
|
|
zuletztLevelUpSpieler->release();
|
|
|
zuletztLevelUpSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztLevelUp() const
|
|
|
+Spieler* Spiel::getSpielerZuletztLevelUp() const
|
|
|
{
|
|
|
- return zuletztLevelUpSpieler ? dynamic_cast<Spieler *>( zuletztLevelUpSpieler->getThis() ) : 0;
|
|
|
+ return zuletztLevelUpSpieler ? dynamic_cast<Spieler*>(zuletztLevelUpSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztErfahrungBekommen( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztErfahrungBekommen( Spieler* s )
|
|
|
{
|
|
|
if( zuletztErfahrungBekommenerSpieler )
|
|
|
zuletztErfahrungBekommenerSpieler->release();
|
|
|
zuletztErfahrungBekommenerSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztErfahrungBekommen() const
|
|
|
+Spieler* Spiel::getSpielerZuletztErfahrungBekommen() const
|
|
|
{
|
|
|
- return zuletztErfahrungBekommenerSpieler ? dynamic_cast<Spieler *>( zuletztErfahrungBekommenerSpieler->getThis() ) : 0;
|
|
|
+ return zuletztErfahrungBekommenerSpieler ? dynamic_cast<Spieler*>(zuletztErfahrungBekommenerSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztGegenstandAktiviert( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztGegenstandAktiviert( Spieler* s )
|
|
|
{
|
|
|
if( zuletztGegenstandAktivierterSpieler )
|
|
|
zuletztGegenstandAktivierterSpieler->release();
|
|
|
zuletztGegenstandAktivierterSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztGegenstandAktiviert() const
|
|
|
+Spieler* Spiel::getSpielerZuletztGegenstandAktiviert() const
|
|
|
{
|
|
|
- return zuletztGegenstandAktivierterSpieler ? dynamic_cast<Spieler *>( zuletztGegenstandAktivierterSpieler->getThis() ) : 0;
|
|
|
+ return zuletztGegenstandAktivierterSpieler ? dynamic_cast<Spieler*>(zuletztGegenstandAktivierterSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztGegenstandAufgehoben( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztGegenstandAufgehoben( Spieler* s )
|
|
|
{
|
|
|
if( zuletztGegenstandAufgehobenerSpieler )
|
|
|
zuletztGegenstandAufgehobenerSpieler->release();
|
|
|
zuletztGegenstandAufgehobenerSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztGegenstandAufgehoben() const
|
|
|
+Spieler* Spiel::getSpielerZuletztGegenstandAufgehoben() const
|
|
|
{
|
|
|
- return zuletztGegenstandAufgehobenerSpieler ? dynamic_cast<Spieler *>( zuletztGegenstandAufgehobenerSpieler->getThis() ) : 0;
|
|
|
+ return zuletztGegenstandAufgehobenerSpieler ? dynamic_cast<Spieler*>(zuletztGegenstandAufgehobenerSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztSchalterAktiviert( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztSchalterAktiviert( Spieler* s )
|
|
|
{
|
|
|
if( zuletztSchalterAktivierterSpieler )
|
|
|
zuletztSchalterAktivierterSpieler->release();
|
|
|
zuletztSchalterAktivierterSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztSchalterAktiviert() const
|
|
|
+Spieler* Spiel::getSpielerZuletztSchalterAktiviert() const
|
|
|
{
|
|
|
- return zuletztSchalterAktivierterSpieler ? dynamic_cast<Spieler *>( zuletztSchalterAktivierterSpieler->getThis() ) : 0;
|
|
|
+ return zuletztSchalterAktivierterSpieler ? dynamic_cast<Spieler*>(zuletztSchalterAktivierterSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztTunnelBenutzt( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztTunnelBenutzt( Spieler* s )
|
|
|
{
|
|
|
if( zuletztTunnelBenutzterSpieler )
|
|
|
zuletztTunnelBenutzterSpieler->release();
|
|
|
zuletztTunnelBenutzterSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztTunnelBenutzt() const
|
|
|
+Spieler* Spiel::getSpielerZuletztTunnelBenutzt() const
|
|
|
{
|
|
|
- return zuletztTunnelBenutzterSpieler ? dynamic_cast<Spieler *>( zuletztTunnelBenutzterSpieler->getThis() ) : 0;
|
|
|
+ return zuletztTunnelBenutzterSpieler ? dynamic_cast<Spieler*>(zuletztTunnelBenutzterSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztGestorben( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztGestorben( Spieler* s )
|
|
|
{
|
|
|
if( zuletztGestorbenerSpieler )
|
|
|
zuletztGestorbenerSpieler->release();
|
|
|
zuletztGestorbenerSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztGestorben() const
|
|
|
+Spieler* Spiel::getSpielerZuletztGestorben() const
|
|
|
{
|
|
|
- return zuletztGestorbenerSpieler ? dynamic_cast<Spieler *>( zuletztGestorbenerSpieler->getThis() ) : 0;
|
|
|
+ return zuletztGestorbenerSpieler ? dynamic_cast<Spieler*>(zuletztGestorbenerSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztWiederbelebt( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztWiederbelebt( Spieler* s )
|
|
|
{
|
|
|
if( zuletztWiederbelebterSpieler )
|
|
|
zuletztWiederbelebterSpieler->release();
|
|
|
zuletztWiederbelebterSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztWiederbelebt() const
|
|
|
+Spieler* Spiel::getSpielerZuletztWiederbelebt() const
|
|
|
{
|
|
|
- return zuletztWiederbelebterSpieler ? dynamic_cast<Spieler *>( zuletztWiederbelebterSpieler->getThis() ) : 0;
|
|
|
+ return zuletztWiederbelebterSpieler ? dynamic_cast<Spieler*>(zuletztWiederbelebterSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setSpielerZuletztGeschossen( Spieler *s )
|
|
|
+void Spiel::setSpielerZuletztGeschossen( Spieler* s )
|
|
|
{
|
|
|
if( zuletztGeschossenerSpieler )
|
|
|
zuletztGeschossenerSpieler->release();
|
|
|
zuletztGeschossenerSpieler = s;
|
|
|
}
|
|
|
|
|
|
-Spieler *Spiel::getSpielerZuletztGeschossen() const
|
|
|
+Spieler* Spiel::getSpielerZuletztGeschossen() const
|
|
|
{
|
|
|
- return zuletztGeschossenerSpieler ? dynamic_cast<Spieler *>( zuletztGeschossenerSpieler->getThis() ) : 0;
|
|
|
+ return zuletztGeschossenerSpieler ? dynamic_cast<Spieler*>(zuletztGeschossenerSpieler->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-Team *Spiel::getRandomTeam()
|
|
|
+Team* Spiel::getRandomTeam()
|
|
|
{
|
|
|
if( !teams.getEintragAnzahl() )
|
|
|
return 0;
|
|
|
- return teams.get( (int)( randG.rand() * teams.getEintragAnzahl() ) );
|
|
|
+ return teams.get( (int)(randG.rand() * teams.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-Timer *Spiel::getRandomTimer()
|
|
|
+Timer* Spiel::getRandomTimer()
|
|
|
{
|
|
|
if( !timer.getEintragAnzahl() )
|
|
|
return 0;
|
|
|
- return timer.get( (int)( randG.rand() * timer.getEintragAnzahl() ) );
|
|
|
+ return timer.get( (int)(randG.rand() * timer.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-void Spiel::setTimerZuletztAbgelaufen( Timer *t )
|
|
|
+void Spiel::setTimerZuletztAbgelaufen( Timer* t )
|
|
|
{
|
|
|
if( zuletztAbgelaufenerTimer )
|
|
|
zuletztAbgelaufenerTimer->release();
|
|
|
zuletztAbgelaufenerTimer = t;
|
|
|
}
|
|
|
|
|
|
-Timer *Spiel::getTimerZuletztAbgelaufen() const
|
|
|
+Timer* Spiel::getTimerZuletztAbgelaufen() const
|
|
|
{
|
|
|
- return zuletztAbgelaufenerTimer ? dynamic_cast<Timer *>( zuletztAbgelaufenerTimer->getThis() ) : 0;
|
|
|
+ return zuletztAbgelaufenerTimer ? dynamic_cast<Timer*>(zuletztAbgelaufenerTimer->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setTimerZuletztGestartet( Timer *t )
|
|
|
+void Spiel::setTimerZuletztGestartet( Timer* t )
|
|
|
{
|
|
|
if( zuletztGestarteterTimer )
|
|
|
zuletztGestarteterTimer->release();
|
|
|
zuletztGestarteterTimer = t;
|
|
|
}
|
|
|
|
|
|
-Timer *Spiel::getTimerZuletztGestartet() const
|
|
|
+Timer* Spiel::getTimerZuletztGestartet() const
|
|
|
{
|
|
|
- return zuletztGestarteterTimer ? dynamic_cast<Timer *>( zuletztGestarteterTimer->getThis() ) : 0;
|
|
|
+ return zuletztGestarteterTimer ? dynamic_cast<Timer*>(zuletztGestarteterTimer->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setTimerZuletztPausiert( Timer *t )
|
|
|
+void Spiel::setTimerZuletztPausiert( Timer* t )
|
|
|
{
|
|
|
if( zuletztPausierterTimer )
|
|
|
zuletztPausierterTimer->release();
|
|
|
zuletztPausierterTimer = t;
|
|
|
}
|
|
|
|
|
|
-Timer *Spiel::getTimerZuletztPausiert() const
|
|
|
+Timer* Spiel::getTimerZuletztPausiert() const
|
|
|
{
|
|
|
- return zuletztPausierterTimer ? dynamic_cast<Timer *>( zuletztPausierterTimer->getThis() ) : 0;
|
|
|
+ return zuletztPausierterTimer ? dynamic_cast<Timer*>(zuletztPausierterTimer->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-void Spiel::setTimerZuletztFortgesetzt( Timer *t )
|
|
|
+void Spiel::setTimerZuletztFortgesetzt( Timer* t )
|
|
|
{
|
|
|
if( zuletztFortgesetzterTimer )
|
|
|
zuletztFortgesetzterTimer->release();
|
|
|
zuletztFortgesetzterTimer = t;
|
|
|
}
|
|
|
|
|
|
-Timer *Spiel::getTimerZuletztFortgesetzt() const
|
|
|
+Timer* Spiel::getTimerZuletztFortgesetzt() const
|
|
|
{
|
|
|
- return zuletztFortgesetzterTimer ? dynamic_cast<Timer *>( zuletztFortgesetzterTimer->getThis() ) : 0;
|
|
|
+ return zuletztFortgesetzterTimer ? dynamic_cast<Timer*>(zuletztFortgesetzterTimer->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-Tunnel *Spiel::getRandomTunnel()
|
|
|
+Tunnel* Spiel::getRandomTunnel()
|
|
|
{
|
|
|
if( !tunnel.getEintragAnzahl() )
|
|
|
return 0;
|
|
|
- return tunnel.get( (int)( randG.rand() * tunnel.getEintragAnzahl() ) );
|
|
|
+ return tunnel.get( (int)(randG.rand() * tunnel.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-void Spiel::setTunnelZuletztBenutzt( Tunnel *t )
|
|
|
+void Spiel::setTunnelZuletztBenutzt( Tunnel* t )
|
|
|
{
|
|
|
if( zuletztBenutzterTunnel )
|
|
|
zuletztBenutzterTunnel->release();
|
|
|
zuletztBenutzterTunnel = t;
|
|
|
}
|
|
|
|
|
|
-Tunnel *Spiel::getTunnelZuletztBenutzt() const
|
|
|
+Tunnel* Spiel::getTunnelZuletztBenutzt() const
|
|
|
{
|
|
|
- return zuletztBenutzterTunnel ? dynamic_cast<Tunnel *>( zuletztBenutzterTunnel->getThis() ) : 0;
|
|
|
+ return zuletztBenutzterTunnel ? dynamic_cast<Tunnel*>(zuletztBenutzterTunnel->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-Umlenkung *Spiel::getRandomUmlenkung()
|
|
|
+Umlenkung* Spiel::getRandomUmlenkung()
|
|
|
{
|
|
|
if( !umlenkungen.getEintragAnzahl() )
|
|
|
return 0;
|
|
|
- return umlenkungen.get( (int)( randG.rand() * umlenkungen.getEintragAnzahl() ) );
|
|
|
+ return umlenkungen.get( (int)(randG.rand() * umlenkungen.getEintragAnzahl()) );
|
|
|
}
|
|
|
|
|
|
-void Spiel::setUmlenkungZuletztBenutzt( Umlenkung *t )
|
|
|
+void Spiel::setUmlenkungZuletztBenutzt( Umlenkung* t )
|
|
|
{
|
|
|
if( zuletztBenutzteUmlenkung )
|
|
|
zuletztBenutzteUmlenkung->release();
|
|
|
zuletztBenutzteUmlenkung = t;
|
|
|
}
|
|
|
|
|
|
-Umlenkung *Spiel::getUmlenkungZuletztBenutzt() const
|
|
|
+Umlenkung* Spiel::getUmlenkungZuletztBenutzt() const
|
|
|
{
|
|
|
- return zuletztBenutzteUmlenkung ? dynamic_cast<Umlenkung *>( zuletztBenutzteUmlenkung->getThis() ) : 0;
|
|
|
+ return zuletztBenutzteUmlenkung ? dynamic_cast<Umlenkung*>(zuletztBenutzteUmlenkung->getThis()) : 0;
|
|
|
}
|
|
|
|
|
|
-ResourceRegistry *Spiel::zResources() const
|
|
|
+ResourceRegistry* Spiel::zResources() const
|
|
|
{
|
|
|
return resources;
|
|
|
}
|
|
|
|
|
|
-void Spiel::addAnimation( SingleAnimation *animation )
|
|
|
+void Spiel::addAnimation( SingleAnimation* animation )
|
|
|
{
|
|
|
animations.add( animation );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addBestenliste( Bestenliste *b )
|
|
|
+void Spiel::addBestenliste( Bestenliste* b )
|
|
|
{
|
|
|
bestenlisten.add( b );
|
|
|
}
|
Kolja Strohm