|
|
@@ -18,6 +18,40 @@ Spiel::Spiel()
|
|
|
gameTicks = 0;
|
|
|
ende = 1;
|
|
|
stat = new Statistik();
|
|
|
+ zWinner = 0;
|
|
|
+ lastRunnedTrigger = 0;
|
|
|
+ zuletztEingeschalteteBariere = 0;
|
|
|
+ zuletztAusgeschalteteBariere = 0;
|
|
|
+ zuletztBewegteBariere = 0;
|
|
|
+ lastTeamChangedBase = 0;
|
|
|
+ lastDropedDrop = 0;
|
|
|
+ zuletztAufgehobenerGegenstand = KEIN_GEGENSTAND;
|
|
|
+ zuletztBenutzterGegenstand = KEIN_GEGENSTAND;
|
|
|
+ zuletztGedropterGegenstand = KEIN_GEGENSTAND;
|
|
|
+ zuletztAbgefeuertesGeschoss = 0;
|
|
|
+ zuletztUmgelenktesGeschoss = 0;
|
|
|
+ zuletztBariereGetroffenesGeschoss = 0;
|
|
|
+ zuletztTunnelBenutztesGeschoss = 0;
|
|
|
+ zuletztGeschossGetroffenesGeschoss = 0;
|
|
|
+ zuletztAktivierterSchalter = 0;
|
|
|
+ zuletztSchadenGemachterSpieler = 0;
|
|
|
+ zuletztSchadenGenommenerSpieler = 0;
|
|
|
+ zuletztGeheilterSpieler = 0;
|
|
|
+ zuletztLevelUpSpieler = 0;
|
|
|
+ zuletztErfahrungBekommenerSpieler = 0;
|
|
|
+ zuletztGegenstandAktivierterSpieler = 0;
|
|
|
+ zuletztGegenstandAufgehobenerSpieler = 0;
|
|
|
+ zuletztSchalterAktivierterSpieler = 0;
|
|
|
+ zuletztTunnelBenutzterSpieler = 0;
|
|
|
+ zuletztGestorbenerSpieler = 0;
|
|
|
+ zuletztWiederbelebterSpieler = 0;
|
|
|
+ zuletztGeschossenerSpieler = 0;
|
|
|
+ zuletztAbgelaufenerTimer = 0;
|
|
|
+ zuletztGestarteterTimer = 0;
|
|
|
+ zuletztPausierterTimer = 0;
|
|
|
+ zuletztFortgesetzterTimer = 0;
|
|
|
+ zuletztBenutzterTunnel = 0;
|
|
|
+ zuletztBenutzteUmlenkung = 0;
|
|
|
ref = 1;
|
|
|
}
|
|
|
|
|
|
@@ -27,6 +61,66 @@ Spiel::~Spiel()
|
|
|
stat->release();
|
|
|
if( psqldb )
|
|
|
psqldb->release();
|
|
|
+ if( lastRunnedTrigger )
|
|
|
+ lastRunnedTrigger->release();
|
|
|
+ if( zuletztEingeschalteteBariere )
|
|
|
+ zuletztEingeschalteteBariere->release();
|
|
|
+ if( zuletztAusgeschalteteBariere )
|
|
|
+ zuletztAusgeschalteteBariere->release();
|
|
|
+ if( zuletztBewegteBariere )
|
|
|
+ zuletztBewegteBariere->release();
|
|
|
+ if( lastTeamChangedBase )
|
|
|
+ lastTeamChangedBase->release();
|
|
|
+ if( lastDropedDrop )
|
|
|
+ lastDropedDrop->release();
|
|
|
+ if( zuletztAbgefeuertesGeschoss )
|
|
|
+ zuletztAbgefeuertesGeschoss->release();
|
|
|
+ if( zuletztUmgelenktesGeschoss )
|
|
|
+ zuletztUmgelenktesGeschoss->release();
|
|
|
+ if( zuletztBariereGetroffenesGeschoss )
|
|
|
+ zuletztBariereGetroffenesGeschoss->release();
|
|
|
+ if( zuletztTunnelBenutztesGeschoss )
|
|
|
+ zuletztTunnelBenutztesGeschoss->release();
|
|
|
+ if( zuletztGeschossGetroffenesGeschoss )
|
|
|
+ zuletztGeschossGetroffenesGeschoss->release();
|
|
|
+ if( zuletztAktivierterSchalter )
|
|
|
+ zuletztAktivierterSchalter->release();
|
|
|
+ if( zuletztSchadenGemachterSpieler )
|
|
|
+ zuletztSchadenGemachterSpieler->release();
|
|
|
+ if( zuletztSchadenGenommenerSpieler )
|
|
|
+ zuletztSchadenGenommenerSpieler->release();
|
|
|
+ if( zuletztGeheilterSpieler )
|
|
|
+ zuletztGeheilterSpieler->release();
|
|
|
+ if( zuletztLevelUpSpieler )
|
|
|
+ zuletztLevelUpSpieler->release();
|
|
|
+ if( zuletztErfahrungBekommenerSpieler )
|
|
|
+ zuletztErfahrungBekommenerSpieler->release();
|
|
|
+ if( zuletztGegenstandAktivierterSpieler )
|
|
|
+ zuletztGegenstandAktivierterSpieler->release();
|
|
|
+ if( zuletztGegenstandAufgehobenerSpieler )
|
|
|
+ zuletztGegenstandAufgehobenerSpieler->release();
|
|
|
+ if( zuletztSchalterAktivierterSpieler )
|
|
|
+ zuletztSchalterAktivierterSpieler->release();
|
|
|
+ if( zuletztTunnelBenutzterSpieler )
|
|
|
+ zuletztTunnelBenutzterSpieler->release();
|
|
|
+ if( zuletztGestorbenerSpieler )
|
|
|
+ zuletztGestorbenerSpieler->release();
|
|
|
+ if( zuletztWiederbelebterSpieler )
|
|
|
+ zuletztWiederbelebterSpieler->release();
|
|
|
+ if( zuletztGeschossenerSpieler )
|
|
|
+ zuletztGeschossenerSpieler->release();
|
|
|
+ if( zuletztAbgelaufenerTimer )
|
|
|
+ zuletztAbgelaufenerTimer->release();
|
|
|
+ if( zuletztGestarteterTimer )
|
|
|
+ zuletztGestarteterTimer->release();
|
|
|
+ if( zuletztPausierterTimer )
|
|
|
+ zuletztPausierterTimer->release();
|
|
|
+ if( zuletztFortgesetzterTimer )
|
|
|
+ zuletztFortgesetzterTimer->release();
|
|
|
+ if( zuletztBenutzterTunnel )
|
|
|
+ zuletztBenutzterTunnel->release();
|
|
|
+ if( zuletztBenutzteUmlenkung )
|
|
|
+ zuletztBenutzteUmlenkung->release();
|
|
|
}
|
|
|
|
|
|
// nicht constant
|
|
|
@@ -114,7 +208,7 @@ void Spiel::run()
|
|
|
int sNum = tmp->getSpielerNummer();
|
|
|
log->schreibe( (char *)& sNum, 4 );
|
|
|
tmp->zKlient()->sendeSpielerNummer( sNum, -1 );
|
|
|
- Text * name = psqldb->getAccountRufName( tmp->getAccountId() );
|
|
|
+ Text *name = psqldb->getAccountRufName( tmp->getAccountId() );
|
|
|
char len = (char)( name ? name->getLength() : 0 );
|
|
|
log->schreibe( &len, 1 );
|
|
|
if( len )
|
|
|
@@ -126,7 +220,7 @@ void Spiel::run()
|
|
|
__int64 randSeed = randG.getSeed();
|
|
|
log->schreibe( (char *)& randSeed, 8 );
|
|
|
Array< char > spielerStatus;
|
|
|
- ZeitMesser * zeit = new ZeitMesser();
|
|
|
+ ZeitMesser *zeit = new ZeitMesser();
|
|
|
zeit->messungStart();
|
|
|
isRunning = 1;
|
|
|
ende = 0;
|
|
|
@@ -167,7 +261,12 @@ void Spiel::run()
|
|
|
{
|
|
|
if( spieler.z( i ) && spieler.z( i )->zKlient() )
|
|
|
{
|
|
|
- if( !spieler.z( i )->zTeam()->getPunkte() )
|
|
|
+ if( !zWinner )
|
|
|
+ {
|
|
|
+ spielerStatus.set( 5, i ); // Datenbank Unentschieden
|
|
|
+ spieler.z( i )->zKlient()->sendeSpielEnde( 2, 0 );
|
|
|
+ }
|
|
|
+ else if( zWinner != spieler.z( i )->zTeam() )
|
|
|
{
|
|
|
spielerStatus.set( 1, i ); // Datenbank Verloren
|
|
|
spieler.z( i )->zKlient()->sendeSpielEnde( 0, 0 );
|
|
|
@@ -205,7 +304,7 @@ void Spiel::klientOffline( int accountId )
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void Spiel::klientOnline( int accountId, SSKlientV * zKlient )
|
|
|
+void Spiel::klientOnline( int accountId, SSKlientV *zKlient )
|
|
|
{
|
|
|
for( int i = 0; i < spielerAnzahl; i++ )
|
|
|
{
|
|
|
@@ -275,7 +374,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
|
|
|
Spieler *tmp = spieler.z( i );
|
|
|
if( tmp && tmp->getAccountId() == accountId )
|
|
|
{
|
|
|
- if( !tmp->setTastenStand( (unsigned char)*bytes, 0 ) )
|
|
|
+ if( !tmp->setTastenStand( (unsigned char)* bytes, 0 ) )
|
|
|
{
|
|
|
saveMSG = 0;
|
|
|
break;
|
|
|
@@ -393,6 +492,9 @@ void Spiel::tick( double zeit )
|
|
|
}
|
|
|
if( intersectsWithBariere || g->getX() < 0 || g->getY() < 0 || g->getX() + g->getWidth() >= mapSize.x || g->getY() + g->getHeight() >= mapSize.y )
|
|
|
{
|
|
|
+ if( zuletztBariereGetroffenesGeschoss )
|
|
|
+ zuletztBariereGetroffenesGeschoss->release();
|
|
|
+ zuletztBariereGetroffenesGeschoss = (Geschoss *)g->getThis();
|
|
|
g->tick( -zeit );
|
|
|
switch( g->getTyp() )
|
|
|
{
|
|
|
@@ -441,7 +543,7 @@ void Spiel::tick( double zeit )
|
|
|
{
|
|
|
g->setX( g->getX() + (float)t->getZielX() - t->getX() );
|
|
|
g->setY( g->getY() + (float)t->getZielY() - t->getY() );
|
|
|
- g->addTunnel();
|
|
|
+ g->addTunnel( this );
|
|
|
Ereignis *e = new Ereignis( TUNNEL_BENUTZT );
|
|
|
e->addParameter( "Betroffes Geschoss", g->getThis() );
|
|
|
e->addParameter( "Betroffer Tunnel", t->getThis() );
|
|
|
@@ -473,7 +575,7 @@ void Spiel::tick( double zeit )
|
|
|
if( u->isAktive() && !u->hatAbklingzeit() && g->getTyp() != GESCHOSS_PFEIL && u->intersectsWith( g ) )
|
|
|
{
|
|
|
g->setRichtung( u->getRichtung() );
|
|
|
- g->addUmlenkung();
|
|
|
+ g->addUmlenkung( this );
|
|
|
u->addBenutzt();
|
|
|
Ereignis *e = new Ereignis( UMLENKUNG_LENKT_UM );
|
|
|
e->addParameter( "Betroffes Geschoss", g->getThis() );
|
|
|
@@ -494,7 +596,7 @@ void Spiel::tick( double zeit )
|
|
|
{
|
|
|
if( g2->getTyp() == GESCHOSS_PFEIL )
|
|
|
removed = 1;
|
|
|
- g->addGeschossTreffer();
|
|
|
+ g->addGeschossTreffer( this );
|
|
|
if( j < i )
|
|
|
i--;
|
|
|
shots.remove( j );
|
|
|
@@ -600,7 +702,7 @@ void Spiel::tick( double zeit )
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-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++ )
|
|
|
@@ -617,7 +719,7 @@ 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++ )
|
|
|
@@ -632,78 +734,121 @@ 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 )
|
|
|
{
|
|
|
barieren.add( bariere );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addBase( Base * base )
|
|
|
+void Spiel::addBase( Base *base )
|
|
|
{
|
|
|
basen.add( base );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addDrop( Drop * drop )
|
|
|
+void Spiel::addDrop( Drop *drop )
|
|
|
{
|
|
|
drops.add( drop );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addGegenstand( Gegenstand * gegenstand )
|
|
|
+void Spiel::addGegenstand( Gegenstand *gegenstand )
|
|
|
{
|
|
|
items.add( gegenstand );
|
|
|
+ zuletztGedropterGegenstand = gegenstand->getTyp();
|
|
|
Ereignis *e = new Ereignis( GEGENSTAND_DROPED );
|
|
|
e->addParameter( "Betroffener Gegenstand", gegenstand->getThis() );
|
|
|
throwEvent( e );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addGeschoss( Geschoss * geschoss )
|
|
|
+void Spiel::addGeschoss( Geschoss *geschoss )
|
|
|
{
|
|
|
+ if( zuletztAbgefeuertesGeschoss )
|
|
|
+ zuletztAbgefeuertesGeschoss->release();
|
|
|
+ zuletztAbgefeuertesGeschoss = geschoss;
|
|
|
shots.add( geschoss );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addSchalter( Schalter * schalter )
|
|
|
+void Spiel::addSchalter( Schalter *schalter )
|
|
|
{
|
|
|
this->schalter.add( schalter );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addSchiene( Schiene * schiene )
|
|
|
+void Spiel::addSchiene( Schiene *schiene )
|
|
|
{
|
|
|
schienen.add( schiene );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addTimer( Timer * timer )
|
|
|
+void Spiel::addTimer( Timer *timer )
|
|
|
{
|
|
|
this->timer.add( timer );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addTunnel( Tunnel * tunnel )
|
|
|
+void Spiel::addTunnel( Tunnel *tunnel )
|
|
|
{
|
|
|
this->tunnel.add( tunnel );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addUmlenkung( Umlenkung * umlenkung )
|
|
|
+void Spiel::addUmlenkung( Umlenkung *umlenkung )
|
|
|
{
|
|
|
umlenkungen.add( umlenkung );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addTrigger( Trigger * trigger )
|
|
|
+void Spiel::addTrigger( Trigger *trigger )
|
|
|
{
|
|
|
this->trigger.add( trigger );
|
|
|
}
|
|
|
|
|
|
-void Spiel::addTriggerRun( TriggerRun * tRun )
|
|
|
+void Spiel::addTriggerRun( TriggerRun *tRun )
|
|
|
{
|
|
|
if( tRun )
|
|
|
+ {
|
|
|
+ if( lastRunnedTrigger )
|
|
|
+ lastRunnedTrigger->release();
|
|
|
+ lastRunnedTrigger = tRun->getTrigger();
|
|
|
triggerRuns.add( tRun );
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::spielerActivate( Spieler *zSpieler )
|
|
|
+{
|
|
|
+ // spieler - item intersection
|
|
|
+ for( int i = 0; i < items.getEintragAnzahl(); i++ )
|
|
|
+ {
|
|
|
+ if( items.z( i )->intersectsWith( zSpieler ) )
|
|
|
+ {
|
|
|
+ items.remove( i );
|
|
|
+ zSpieler->addItem( items.z( i )->getTyp(), 1, this );
|
|
|
+ i--;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // Spieler - schalter intersection
|
|
|
+ for( int i = 0; i < schalter.getEintragAnzahl(); i++ )
|
|
|
+ {
|
|
|
+ if( schalter.z( i )->intersectsWith( zSpieler ) )
|
|
|
+ {
|
|
|
+ zSpieler->addSchalterBenutzung( this );
|
|
|
+ schalter.z( i )->press( this );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // Spieler - tunnel intersection
|
|
|
+ for( int i = 0; i < tunnel.getEintragAnzahl(); i++ )
|
|
|
+ {
|
|
|
+ if( tunnel.z( i )->intersectsWith( zSpieler ) )
|
|
|
+ {
|
|
|
+ zSpieler->addTunnelBenutzung( this );
|
|
|
+ zSpieler->setX( (float)tunnel.z( i )->getZielX() - zSpieler->getWidth() / 2.f );
|
|
|
+ zSpieler->setY( (float)tunnel.z( i )->getZielY() - zSpieler->getHeight() / 2.f );
|
|
|
+ tunnel.z( i )->addBenutzung();
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
Team *Spiel::getTeam( int id ) const
|
|
|
@@ -721,7 +866,7 @@ Spieler *Spiel::getSpieler( int id ) const
|
|
|
for( auto s = spieler.getIterator(); s; s++ )
|
|
|
{
|
|
|
if( s->getId() == id )
|
|
|
- return (Spieler*)s->getThis();
|
|
|
+ return (Spieler *)s->getThis();
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
@@ -856,12 +1001,7 @@ void Spiel::activateShalter( int id )
|
|
|
for( auto s = schalter.getIterator(); s; s++ )
|
|
|
{
|
|
|
if( s->getId() == id )
|
|
|
- {
|
|
|
- s->press();
|
|
|
- Ereignis *e = new Ereignis( SCHALTER_AKTIVIERT );
|
|
|
- e->addParameter( "Betroffener Schalter", s->getThis() );
|
|
|
- throwEvent( e );
|
|
|
- }
|
|
|
+ s->press( this );
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -904,6 +1044,367 @@ int Spiel::getTickCount() const
|
|
|
return gameTicks;
|
|
|
}
|
|
|
|
|
|
+void Spiel::setEnde( Team *zGewinner )
|
|
|
+{
|
|
|
+ zWinner = zGewinner;
|
|
|
+ ende = true;
|
|
|
+}
|
|
|
+
|
|
|
+Trigger *Spiel::getRandomTrigger()
|
|
|
+{
|
|
|
+ if( !trigger.getEintragAnzahl() )
|
|
|
+ return 0;
|
|
|
+ return trigger.get( (int)( randG.rand() * trigger.getEintragAnzahl() ) );
|
|
|
+}
|
|
|
+
|
|
|
+Trigger *Spiel::getLastRunnedTrigger() const
|
|
|
+{
|
|
|
+ return lastRunnedTrigger ? (Trigger *)lastRunnedTrigger->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+Bariere *Spiel::getRandomBariere()
|
|
|
+{
|
|
|
+ return barieren.get( (int)( randG.rand() * barieren.getEintragAnzahl() ) );
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setZuletztEingeschalteteBariere( Bariere *b )
|
|
|
+{
|
|
|
+ if( zuletztEingeschalteteBariere )
|
|
|
+ zuletztEingeschalteteBariere->release();
|
|
|
+ zuletztEingeschalteteBariere = b;
|
|
|
+}
|
|
|
+
|
|
|
+Bariere *Spiel::getZuletztEingeschalteteBariere() const
|
|
|
+{
|
|
|
+ return zuletztEingeschalteteBariere ? (Bariere *)zuletztEingeschalteteBariere->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setZuletztAusgeschalteteBariere( Bariere *b )
|
|
|
+{
|
|
|
+ if( zuletztAusgeschalteteBariere )
|
|
|
+ zuletztAusgeschalteteBariere->release();
|
|
|
+ zuletztAusgeschalteteBariere = b;
|
|
|
+}
|
|
|
+
|
|
|
+Bariere *Spiel::getZuletztAusgeschalteteBariere() const
|
|
|
+{
|
|
|
+ return zuletztAusgeschalteteBariere ? (Bariere *)zuletztAusgeschalteteBariere->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setZuletztBewegteBariere( Bariere *b )
|
|
|
+{
|
|
|
+ if( zuletztBewegteBariere )
|
|
|
+ zuletztBewegteBariere->release();
|
|
|
+ zuletztBewegteBariere = b;
|
|
|
+}
|
|
|
+
|
|
|
+Bariere *Spiel::getZuletztBewegteBariere() const
|
|
|
+{
|
|
|
+ return zuletztBewegteBariere ? (Bariere *)zuletztBewegteBariere->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+Base *Spiel::getRandomBase()
|
|
|
+{
|
|
|
+ if( !basen.getEintragAnzahl() )
|
|
|
+ return 0;
|
|
|
+ return basen.get( (int)( randG.rand() * basen.getEintragAnzahl() ) );
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setLastTeamChangedBase( Base *b )
|
|
|
+{
|
|
|
+ if( lastTeamChangedBase )
|
|
|
+ lastTeamChangedBase->release();
|
|
|
+ lastTeamChangedBase = b;
|
|
|
+}
|
|
|
+
|
|
|
+Base *Spiel::getLastTeamChangedBase() const
|
|
|
+{
|
|
|
+ return lastTeamChangedBase ? (Base *)lastTeamChangedBase->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+Drop *Spiel::getRandomDrop()
|
|
|
+{
|
|
|
+ if( !drops.getEintragAnzahl() )
|
|
|
+ return 0;
|
|
|
+ return drops.get( (int)( randG.rand() * drops.getEintragAnzahl() ) );
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setLastDrop( Drop *d )
|
|
|
+{
|
|
|
+ if( lastDropedDrop )
|
|
|
+ lastDropedDrop->release();
|
|
|
+ lastDropedDrop = d;
|
|
|
+}
|
|
|
+
|
|
|
+Drop *Spiel::getLastDrop() const
|
|
|
+{
|
|
|
+ return lastDropedDrop ? (Drop *)lastDropedDrop->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setItemZuletztAufgehoben( GegenstandTyp g )
|
|
|
+{
|
|
|
+ zuletztAufgehobenerGegenstand = g;
|
|
|
+}
|
|
|
+
|
|
|
+GegenstandTyp Spiel::getItemZuletztAufgehoben() const
|
|
|
+{
|
|
|
+ return zuletztAufgehobenerGegenstand;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setItemZuletztAktiviert( GegenstandTyp g )
|
|
|
+{
|
|
|
+ zuletztBenutzterGegenstand = g;
|
|
|
+}
|
|
|
+
|
|
|
+GegenstandTyp Spiel::getItemZuletztAktiviert() const
|
|
|
+{
|
|
|
+ return zuletztBenutzterGegenstand;
|
|
|
+}
|
|
|
+
|
|
|
+GegenstandTyp Spiel::getItemZuletztGedropt() const
|
|
|
+{
|
|
|
+ return zuletztGedropterGegenstand;
|
|
|
+}
|
|
|
+
|
|
|
+Geschoss *Spiel::getRandomGeschoss()
|
|
|
+{
|
|
|
+ if( !shots.getEintragAnzahl() )
|
|
|
+ return 0;
|
|
|
+ return shots.get( (int)( randG.rand() * shots.getEintragAnzahl() ) );
|
|
|
+}
|
|
|
+
|
|
|
+Geschoss *Spiel::getGeschossZuletztAbgefeuert() const
|
|
|
+{
|
|
|
+ return zuletztAbgefeuertesGeschoss ? (Geschoss *)zuletztAbgefeuertesGeschoss->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setGeschossZuletztUmgelenkt( Geschoss *g )
|
|
|
+{
|
|
|
+ if( zuletztUmgelenktesGeschoss )
|
|
|
+ zuletztUmgelenktesGeschoss->release();
|
|
|
+ zuletztUmgelenktesGeschoss = g;
|
|
|
+}
|
|
|
+
|
|
|
+Geschoss *Spiel::getGeschossZuletztUmgelenkt() const
|
|
|
+{
|
|
|
+ return zuletztUmgelenktesGeschoss ? (Geschoss *)zuletztUmgelenktesGeschoss->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+Geschoss *Spiel::getGeschossZuletztBariereGetroffen() const
|
|
|
+{
|
|
|
+ return zuletztBariereGetroffenesGeschoss ? (Geschoss *)zuletztBariereGetroffenesGeschoss->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setGeschossZuletztTunnelBenutzt( Geschoss *g )
|
|
|
+{
|
|
|
+ if( zuletztTunnelBenutztesGeschoss )
|
|
|
+ zuletztTunnelBenutztesGeschoss->release();
|
|
|
+ zuletztTunnelBenutztesGeschoss = g;
|
|
|
+}
|
|
|
+
|
|
|
+Geschoss *Spiel::getGeschossZuletztTunnelBenutzt() const
|
|
|
+{
|
|
|
+ return zuletztTunnelBenutztesGeschoss ? (Geschoss *)zuletztTunnelBenutztesGeschoss->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setGeschossZuletztGeschossGetroffen( Geschoss *g )
|
|
|
+{
|
|
|
+ if( zuletztGeschossGetroffenesGeschoss )
|
|
|
+ zuletztGeschossGetroffenesGeschoss->release();
|
|
|
+ zuletztGeschossGetroffenesGeschoss = g;
|
|
|
+}
|
|
|
+
|
|
|
+Geschoss *Spiel::getGeschossZuletztGeschossGetroffen() const
|
|
|
+{
|
|
|
+ return zuletztGeschossGetroffenesGeschoss ? (Geschoss *)zuletztGeschossGetroffenesGeschoss->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+Schalter *Spiel::getRandomSchalter()
|
|
|
+{
|
|
|
+ if( !schalter.getEintragAnzahl() )
|
|
|
+ return 0;
|
|
|
+ return schalter.get( (int)( randG.rand() * schalter.getEintragAnzahl() ) );
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSchalterZuletztAktiviert( Schalter *s )
|
|
|
+{
|
|
|
+ if( zuletztAktivierterSchalter )
|
|
|
+ zuletztAktivierterSchalter->release();
|
|
|
+ zuletztAktivierterSchalter = s;
|
|
|
+}
|
|
|
+
|
|
|
+Schalter *Spiel::getSchalterZuletztAktiviert() const
|
|
|
+{
|
|
|
+ return zuletztAktivierterSchalter ? (Schalter *)zuletztAktivierterSchalter->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getRandomSpieler()
|
|
|
+{
|
|
|
+ if( !spieler.getEintragAnzahl() )
|
|
|
+ return 0;
|
|
|
+ return spieler.get( (int)( randG.rand() * spieler.getEintragAnzahl() ) );
|
|
|
+}
|
|
|
+
|
|
|
+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++ )
|
|
|
+ {
|
|
|
+ if( s->zTeam() == zTeam )
|
|
|
+ {
|
|
|
+ if( index-- <= 0 )
|
|
|
+ return (Spieler *)s->getThis();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztSchadenGemacht( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztSchadenGemachterSpieler )
|
|
|
+ zuletztSchadenGemachterSpieler->release();
|
|
|
+ zuletztSchadenGemachterSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztSchadenGemacht() const
|
|
|
+{
|
|
|
+ return zuletztSchadenGemachterSpieler ? (Spieler *)zuletztSchadenGemachterSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztSchadenGenommen( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztSchadenGenommenerSpieler )
|
|
|
+ zuletztSchadenGenommenerSpieler->release();
|
|
|
+ zuletztSchadenGenommenerSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztSchadenGenommen() const
|
|
|
+{
|
|
|
+ return zuletztSchadenGenommenerSpieler ? (Spieler *)zuletztSchadenGenommenerSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztGeheilt( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztGeheilterSpieler )
|
|
|
+ zuletztGeheilterSpieler->release();
|
|
|
+ zuletztGeheilterSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztGeheilt() const
|
|
|
+{
|
|
|
+ return zuletztGeheilterSpieler ? (Spieler *)zuletztGeheilterSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztLevelUp( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztLevelUpSpieler )
|
|
|
+ zuletztLevelUpSpieler->release();
|
|
|
+ zuletztLevelUpSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztLevelUp() const
|
|
|
+{
|
|
|
+ return zuletztLevelUpSpieler ? (Spieler *)zuletztLevelUpSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztErfahrungBekommen( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztErfahrungBekommenerSpieler )
|
|
|
+ zuletztErfahrungBekommenerSpieler->release();
|
|
|
+ zuletztErfahrungBekommenerSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztErfahrungBekommen() const
|
|
|
+{
|
|
|
+ return zuletztErfahrungBekommenerSpieler ? (Spieler *)zuletztErfahrungBekommenerSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztGegenstandAktiviert( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztGegenstandAktivierterSpieler )
|
|
|
+ zuletztGegenstandAktivierterSpieler->release();
|
|
|
+ zuletztGegenstandAktivierterSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztGegenstandAktiviert() const
|
|
|
+{
|
|
|
+ return zuletztGegenstandAktivierterSpieler ? (Spieler *)zuletztGegenstandAktivierterSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztGegenstandAufgehoben( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztGegenstandAufgehobenerSpieler )
|
|
|
+ zuletztGegenstandAufgehobenerSpieler->release();
|
|
|
+ zuletztGegenstandAufgehobenerSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztGegenstandAufgehoben() const
|
|
|
+{
|
|
|
+ return zuletztGegenstandAufgehobenerSpieler ? (Spieler *)zuletztGegenstandAufgehobenerSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztSchalterAktiviert( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztSchalterAktivierterSpieler )
|
|
|
+ zuletztSchalterAktivierterSpieler->release();
|
|
|
+ zuletztSchalterAktivierterSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztSchalterAktiviert() const
|
|
|
+{
|
|
|
+ return zuletztSchalterAktivierterSpieler ? (Spieler *)zuletztSchalterAktivierterSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztTunnelBenutzt( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztTunnelBenutzterSpieler )
|
|
|
+ zuletztTunnelBenutzterSpieler->release();
|
|
|
+ zuletztTunnelBenutzterSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztTunnelBenutzt() const
|
|
|
+{
|
|
|
+ return zuletztTunnelBenutzterSpieler ? (Spieler *)zuletztTunnelBenutzterSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztGestorben( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztGestorbenerSpieler )
|
|
|
+ zuletztGestorbenerSpieler->release();
|
|
|
+ zuletztGestorbenerSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztGestorben() const
|
|
|
+{
|
|
|
+ return zuletztGestorbenerSpieler ? (Spieler *)zuletztGestorbenerSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztWiederbelebt( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztWiederbelebterSpieler )
|
|
|
+ zuletztWiederbelebterSpieler->release();
|
|
|
+ zuletztWiederbelebterSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztWiederbelebt() const
|
|
|
+{
|
|
|
+ return zuletztWiederbelebterSpieler ? (Spieler*)zuletztWiederbelebterSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void Spiel::setSpielerZuletztGeschossen( Spieler *s )
|
|
|
+{
|
|
|
+ if( zuletztGeschossenerSpieler )
|
|
|
+ zuletztGeschossenerSpieler->release();
|
|
|
+ zuletztGeschossenerSpieler = s;
|
|
|
+}
|
|
|
+
|
|
|
+Spieler *Spiel::getSpielerZuletztGeschossen() const
|
|
|
+{
|
|
|
+ return zuletztGeschossenerSpieler ? (Spieler*)zuletztGeschossenerSpieler->getThis() : 0;
|
|
|
+}
|
|
|
+
|
|
|
StatistikV *Spiel::getStatistik() const
|
|
|
{
|
|
|
return stat->getThis();
|
Kolja Strohm