Spieler werden mit Effekten gezeichnen

StickmanWorldOnline/BosheitRune.cpp

@@ -2,15 +2,41 @@
 #include "Spieler.h"
 
 
-BosheitRuneEffect::BosheitRuneEffect( Spieler *zSpieler )
+BosheitRuneEffect::BosheitRuneEffect( ResourceRegistry *zResources, Spieler *zSpieler )
     : Effect( zSpieler, 75.f + ( 75.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
 {
     zSpieler->setSchadenBonus( zSpieler->getSchadenBonus() + 7 );
     zSpieler->setLebensRaub( zSpieler->getLebensRaub() + 3 );
+    annimation = zResources->getResource( R_RBOSHEIT_EFFECT, 0 );
+    currentImage = 0;
+    nextImage = 0.075;
 }
 
 BosheitRuneEffect::~BosheitRuneEffect()
 {
     zSpieler->setSchadenBonus( zSpieler->getSchadenBonus() - 7 );
     zSpieler->setLebensRaub( zSpieler->getLebensRaub() - 3 );
+    annimation->release();
+}
+
+bool BosheitRuneEffect::tick( double time, Spiel *zSpiel )
+{
+    nextImage -= time;
+    if( nextImage <= 0 )
+    {
+        nextImage += 0.075;
+        currentImage++;
+    }
+    return Effect::tick( time, zSpiel );
+}
+
+void BosheitRuneEffect::renderSpieler( Bild &rObj )
+{
+    if( currentImage >= annimation->getImageCount() )
+        return;
+    if( rObj.setDrawOptions( (int)zSpieler->getX(), (int)zSpieler->getY(), (int)zSpieler->getWidth(), (int)zSpieler->getHeight() ) )
+    {
+        rObj.alphaBildSkall( 0, 0, (int)zSpieler->getWidth(), (int)zSpieler->getHeight(), *annimation->zImage( currentImage ) );
+        rObj.releaseDrawOptions();
+    }
 }

StickmanWorldOnline/BosheitRune.h

@@ -5,8 +5,13 @@
 class BosheitRuneEffect : public Effect
 {
 private:
+    Resource *annimation;
+    int currentImage;
+    double nextImage;
 
 public:
-    BosheitRuneEffect( Spieler *zSpieler );
+    BosheitRuneEffect( ResourceRegistry *zResources, Spieler *zSpieler );
     ~BosheitRuneEffect();
+    bool tick( double time, Spiel *zSpiel ) override;
+    void renderSpieler( Bild &rObj ) override;
 };

StickmanWorldOnline/Brand.cpp

@@ -2,22 +2,43 @@
 #include "Spieler.h"
 
 
-BrandEffekt::BrandEffekt( Spieler *zVerursacher, Spieler *zOpfer )
+BrandEffekt::BrandEffekt( ResourceRegistry *zResources, Spieler *zVerursacher, Spieler *zOpfer )
     : Effect( zOpfer, B_DURATION )
 {
     this->zVerursacher = zVerursacher;
     laufTempoDecrease = B_MOVEMENT_DECREASE <= zSpieler->getLaufTempo() ? B_MOVEMENT_DECREASE : zSpieler->getLaufTempo();
     zSpieler->setLaufTempo( zSpieler->getLaufTempo() - laufTempoDecrease );
+    annimation = zResources->getResource( R_BRAND, 0 );
+    currentImage = 0;
+    nextImage = 0.075;
 }
 
 BrandEffekt::~BrandEffekt()
 {
     zSpieler->setLaufTempo( zSpieler->getLaufTempo() + laufTempoDecrease );
+    annimation->release();
 }
 
 bool BrandEffekt::tick( double time, Spiel *zSpiel )
 {
     float damage = B_MIN_DPS * (float)time;
     zSpieler->nimmSchaden( damage, zVerursacher, MITTE, zSpiel );
+    nextImage -= time;
+    if( nextImage <= 0 )
+    {
+        nextImage += 0.075;
+        currentImage++;
+        if( currentImage >= annimation->getImageCount() )
+            currentImage = 0;
+    }
     return Effect::tick( time, zSpiel );
+}
+
+void BrandEffekt::renderSpieler( Bild &rObj )
+{
+    if( rObj.setDrawOptions( (int)zSpieler->getX(), (int)zSpieler->getY(), (int)zSpieler->getWidth(), (int)zSpieler->getHeight() ) )
+    {
+        rObj.alphaBildSkall( 0, 0, (int)zSpieler->getWidth(), (int)zSpieler->getHeight(), *annimation->zImage( currentImage ) );
+        rObj.releaseDrawOptions();
+    }
 }

StickmanWorldOnline/Brand.h

@@ -11,9 +11,13 @@ class BrandEffekt : public Effect
 private:
     Spieler *zVerursacher;
     float laufTempoDecrease;
+    Resource *annimation;
+    int currentImage;
+    double nextImage;
 
 public:
-    BrandEffekt( Spieler *zVerursacher, Spieler *zOpfer );
+    BrandEffekt( ResourceRegistry *zResources, Spieler *zVerursacher, Spieler *zOpfer );
     ~BrandEffekt();
     bool tick( double time, Spiel *zSpiel ) override;
+    void renderSpieler( Bild &rObj ) override;
 };

StickmanWorldOnline/Effect.cpp

@@ -40,6 +40,14 @@ bool Effect::istGegenstandErlaubt( GegenstandTyp typ )
     return 1;
 }
 
+void Effect::renderSpieler( Bild &rObj )
+{}
+
+Resource *Effect::getCurrentResource()
+{
+    return 0;
+}
+
 Effect *Effect::getThis()
 {
     ref++;

StickmanWorldOnline/Effect.h

@@ -22,6 +22,8 @@ public:
     virtual bool istSpielerSichtbar( Team *zTeam );
     virtual void move( double time );
     virtual bool istGegenstandErlaubt( GegenstandTyp typ );
+    virtual void renderSpieler( Bild &rObj );
+    virtual Resource *getCurrentResource();
     Effect *getThis();
     Effect *release();
 };

StickmanWorldOnline/Enterhaken.cpp

@@ -2,17 +2,24 @@
 #include "Spieler.h"
 #include "Spiel.h"
 
-EnterhakenEffect::EnterhakenEffect( Spieler *zSpieler, Richtung r )
+EnterhakenEffect::EnterhakenEffect( ResourceRegistry *zResources, Spieler *zSpieler, Richtung r )
     : Effect( zSpieler, 1.5f + ( 1.5f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
 {
     maxTime = timeLeft;
     state = 0;
     ehpx = zSpieler->getX() + zSpieler->getWidth() / 2;
     ehpy = zSpieler->getY() + zSpieler->getHeight() / 2;
+    ehSchnur = zResources->zResource( R_ENTERHAKEN_SEIL, 0 )->getImage( 0 );
+    ehSpitze = zResources->zResource( R_ENTERHAKEN_SPITZE, 0 )->getImage( 0 );
+    spieler = zResources->zResource( R_SPIELER, zSpieler->getFarbe() );
 }
 
 EnterhakenEffect::~EnterhakenEffect()
-{}
+{
+    ehSchnur->release();
+    ehSpitze->release();
+    spieler->release();
+}
 
 bool EnterhakenEffect::istSpielerBeweglich( Richtung r )
 {
@@ -29,22 +36,22 @@ void EnterhakenEffect::move( double time )
         {
         case OBEN:
             zSpieler->setY( zSpieler->getY() - 200 * (float)time );
-            if( zSpieler->getY() <= ehpy - 10 )
+            if( zSpieler->getY() <= ehpy - 7 )
                 state = 4;
             break;
         case LINKS:
             zSpieler->setX( zSpieler->getX() - 200 * (float)time );
-            if( zSpieler->getX() <= ehpx - 10 )
+            if( zSpieler->getX() <= ehpx - 7 )
                 state = 4;
             break;
         case UNTEN:
             zSpieler->setY( zSpieler->getY() + 200 * (float)time );
-            if( zSpieler->getY() >= ehpy - 10 )
+            if( zSpieler->getY() >= ehpy - 7 )
                 state = 4;
             break;
         case RECHTS:
             zSpieler->setX( zSpieler->getX() + 200 * (float)time );
-            if( zSpieler->getX() >= ehpx - 10 )
+            if( zSpieler->getX() >= ehpx - 7 )
                 state = 4;
             break;
         default:
@@ -88,14 +95,14 @@ bool EnterhakenEffect::tick( double time, Spiel *zSpiel )
         }
         for( auto s = zSpiel->getSpieler(); s; s++ )
         {
-            if( s->zTeam() != zSpieler->zTeam() && s->getX() <= ehpx - 10 && s->getX() + s->getWidth() > ehpx + 10 && s->getY() <= ehpy - 10 && s->getY() + s->getWidth() > ehpy + 10 )
+            if( s->zTeam() != zSpieler->zTeam() && s->getX() <= ehpx - 7 && s->getX() + s->getWidth() > ehpx + 7 && s->getY() <= ehpy - 7 && s->getY() + s->getWidth() > ehpy + 7 )
                 s->nimmSchaden( 150 * (float)time, zSpieler, r, zSpiel );
         }
         for( auto b = zSpiel->getBarieren(); b; b++ )
         {
             if( b->hatStyle( Bariere::Style::Aktiv ) && ( !b->zTeam() || b->zTeam() == zSpieler->zTeam() ) )
             {
-                if( b->getX() <= ehpx - 10 && b->getX() + b->getWidth() > ehpx + 10 && b->getY() <= ehpy - 10 && b->getY() + b->getWidth() > ehpy + 10 )
+                if( b->getX() <= ehpx - 7 && b->getX() + b->getWidth() > ehpx + 7 && b->getY() <= ehpy - 7 && b->getY() + b->getWidth() > ehpy + 7 )
                 {
                     target = b;
                     state = 2;
@@ -123,7 +130,7 @@ bool EnterhakenEffect::tick( double time, Spiel *zSpiel )
         }
         for( auto s = zSpiel->getSpieler(); s; s++ )
         {
-            if( s->zTeam() != zSpieler->zTeam() && s->getX() <= ehpx - 10 && s->getX() + s->getWidth() > ehpx + 10 && s->getY() <= ehpy - 10 && s->getY() + s->getWidth() > ehpy + 10 )
+            if( s->zTeam() != zSpieler->zTeam() && s->getX() <= ehpx - 7 && s->getX() + s->getWidth() > ehpx + 7 && s->getY() <= ehpy - 7 && s->getY() + s->getWidth() > ehpy + 7 )
                 s->nimmSchaden( 150 * (float)time, zSpieler, invert( r ), zSpiel );
         }
         timeLeft -= (float)time;
@@ -148,7 +155,7 @@ bool EnterhakenEffect::tick( double time, Spiel *zSpiel )
         default:
             break;
         }
-        if( !target->hatStyle( Bariere::Style::Aktiv ) || target->getX() > ehpx - 10 || target->getX() + target->getWidth() <= ehpx + 10 || target->getY() > ehpy - 10 || target->getY() + target->getWidth() <= ehpy + 10 )
+        if( !target->hatStyle( Bariere::Style::Aktiv ) || target->getX() > ehpx - 7 || target->getX() + target->getWidth() <= ehpx + 7 || target->getY() > ehpy - 7 || target->getY() + target->getWidth() <= ehpy + 7 )
             state = 3;
     }
     return state != 5;
@@ -163,3 +170,37 @@ bool EnterhakenEffect::istSpielerVerwundbar( Richtung r )
 {
     return r != MITTE;
 }
+
+void EnterhakenEffect::renderSpieler( Bild &rObj )
+{
+    switch( r )
+    {
+    case RECHTS:
+        for( int x = (int)ehpx - 7 - 4; x > zSpieler->getX() + zSpieler->getWidth() / 2; x -= 4 )
+            rObj.alphaBild( x, (int)zSpieler->getY() + (int)zSpieler->getHeight() / 2 - 2, 4, 4, *ehSchnur );
+        rObj.alphaBild( (int)ehpx - 7, (int)ehpy - 7, 14, 14, *ehSpitze );
+        break;
+    case LINKS:
+        for( int x = (int)ehpx + 7; x < zSpieler->getX() + zSpieler->getWidth() / 2; x += 4 )
+            rObj.alphaBild180( x, (int)zSpieler->getY() + (int)zSpieler->getHeight() / 2 - 2, 4, 4, *ehSchnur );
+        rObj.alphaBild180( (int)ehpx - 7, (int)ehpy - 7, 14, 14, *ehSpitze );
+        break;
+    case OBEN:
+        for( int y = (int)ehpy + 7; y < zSpieler->getY() + zSpieler->getHeight() / 2; y += 4 )
+            rObj.alphaBild270( (int)zSpieler->getX() + (int)zSpieler->getWidth() / 2 - 2, y, 4, 4, *ehSchnur );
+        rObj.alphaBild270( (int)ehpx - 7, (int)ehpy - 7, 14, 14, *ehSpitze );
+        break;
+    case UNTEN:
+        for( int y = (int)ehpy - 7 - 4; y > zSpieler->getY() + zSpieler->getHeight() / 2; y -= 4 )
+            rObj.alphaBild90( (int)zSpieler->getX() + (int)zSpieler->getWidth() / 2 - 2, y, 4, 4, *ehSchnur );
+        rObj.alphaBild90( (int)ehpx - 7, (int)ehpy - 7, 14, 14, *ehSpitze );
+        break;
+    default:
+        break;
+    }
+}
+
+Resource *EnterhakenEffect::getCurrentResource()
+{
+    return spieler->getThis();
+}

StickmanWorldOnline/Enterhaken.h

@@ -12,14 +12,19 @@ private:
     int state;
     float maxTime;
     Richtung r;
+    Resource *spieler;
     Bariere *target;
+    Bild *ehSchnur;
+    Bild *ehSpitze;
 
 public:
-    EnterhakenEffect( Spieler *zSpieler, Richtung r );
+    EnterhakenEffect( ResourceRegistry *zResources, Spieler *zSpieler, Richtung r );
     ~EnterhakenEffect();
     bool istSpielerBeweglich( Richtung r ) override;
     void move( double time ) override;
     bool tick( double time, Spiel *zSpiel ) override;
     bool istGegenstandErlaubt( GegenstandTyp typ ) override;
     bool istSpielerVerwundbar( Richtung r ) override;
+    void renderSpieler( Bild &rObj ) override;
+    Resource *getCurrentResource() override;
 };

StickmanWorldOnline/GameObjekt.cpp

@@ -51,12 +51,12 @@ void GameObject::render( Bild &rObj )
         if( rObj.setDrawOptions( (int)x, (int)y, (int)w, (int)h ) )
         {
             if( texturScale )
-                rObj.alphaBildSkall( (int)x, (int)y, (int)w, (int)h, *textur );
+                rObj.alphaBildSkall( 0, 0, (int)w, (int)h, *textur );
             else
             {
-                for( int xx = (int)x; xx < x + w; x += textur->getBreite() )
+                for( int xx = 0; xx < w; x += textur->getBreite() )
                 {
-                    for( int yy = (int)y; yy < y + h; y += textur->getHeight() )
+                    for( int yy = 0; yy < h; y += textur->getHeight() )
                         rObj.alphaBild( xx, yy, textur->getBreite(), textur->getHeight(), *textur );
                 }
             }

StickmanWorldOnline/Geist.cpp

@@ -1,14 +1,27 @@
 #include "Geist.h"
 #include "Spieler.h"
 
-GeistEffect::GeistEffect( Spieler *zSpieler )
+GeistEffect::GeistEffect( ResourceRegistry *zResources, Spieler *zSpieler )
     : Effect( zSpieler, 5.f + ( 5.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
-{}
+{
+    bild = zResources->zResource( R_GEIST, 0 )->getImage( 0 );
+}
 
 GeistEffect::~GeistEffect()
-{}
+{
+    bild->release();
+}
 
 bool GeistEffect::istSpielerSichtbar( Team *zTeam )
 {
     return zTeam == zSpieler->zTeam();
 }
+
+void GeistEffect::renderSpieler( Bild &rObj )
+{
+    if( rObj.setDrawOptions( (int)zSpieler->getX(), (int)zSpieler->getY(), (int)zSpieler->getWidth(), (int)zSpieler->getHeight() ) )
+    {
+        rObj.alphaBildSkall( 0, 0, (int)zSpieler->getWidth(), (int)zSpieler->getHeight(), *bild );
+        rObj.releaseDrawOptions();
+    }
+}

StickmanWorldOnline/Geist.h

@@ -5,9 +5,11 @@
 class GeistEffect : public Effect
 {
 private:
+    Bild *bild;
 
 public:
-    GeistEffect( Spieler *zSpieler );
+    GeistEffect( ResourceRegistry *zResources, Spieler *zSpieler );
     ~GeistEffect();
     bool istSpielerSichtbar( Team *zTeam ) override;
+    void renderSpieler( Bild &rObj ) override;
 };

StickmanWorldOnline/LebenRune.cpp

@@ -2,13 +2,39 @@
 #include "Spieler.h"
 
 
-LebenRuneEffect::LebenRuneEffect( Spieler *zSpieler )
+LebenRuneEffect::LebenRuneEffect( ResourceRegistry *zResources, Spieler *zSpieler )
     : Effect( zSpieler, 75.f + ( 75.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
 {
     zSpieler->setLebensRegeneration( zSpieler->getLebensRegenneration() + 10 );
+    annimation = zResources->getResource( R_RLEBEN_EFFECT, 0 );
+    currentImage = 0;
+    nextImage = 0.075;
 }
 
 LebenRuneEffect::~LebenRuneEffect()
 {
     zSpieler->setLebensRegeneration( zSpieler->getLebensRegenneration() - 10 );
+    annimation->release();
+}
+
+bool LebenRuneEffect::tick( double time, Spiel *zSpiel )
+{
+    nextImage -= time;
+    if( nextImage <= 0 )
+    {
+        nextImage += 0.075;
+        currentImage++;
+    }
+    return Effect::tick( time, zSpiel );
+}
+
+void LebenRuneEffect::renderSpieler( Bild &rObj )
+{
+    if( currentImage >= annimation->getImageCount() )
+        return;
+    if( rObj.setDrawOptions( (int)zSpieler->getX(), (int)zSpieler->getY(), (int)zSpieler->getWidth(), (int)zSpieler->getHeight() ) )
+    {
+        rObj.alphaBildSkall( 0, 0, (int)zSpieler->getWidth(), (int)zSpieler->getHeight(), *annimation->zImage( currentImage ) );
+        rObj.releaseDrawOptions();
+    }
 }

StickmanWorldOnline/LebenRune.h

@@ -5,8 +5,13 @@
 class LebenRuneEffect : public Effect
 {
 private:
+    Resource *annimation;
+    int currentImage;
+    double nextImage;
 
 public:
-    LebenRuneEffect( Spieler *zSpieler );
+    LebenRuneEffect( ResourceRegistry *zResources, Spieler *zSpieler );
     ~LebenRuneEffect();
+    bool tick( double time, Spiel *zSpiel ) override;
+    void renderSpieler( Bild &rObj ) override;
 };

StickmanWorldOnline/Reader.cpp

@@ -629,7 +629,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
                 team++;
             if( sts.teamSize.hat( team ) )
                 maxT += sts.teamSize.get( team );
-            zSpiel->addSpieler( new Spieler( i, zSpiel->getTeam( team ), spawnX, spawnY, sts.spielerFarbe.get( i ) ) );
+            zSpiel->addSpieler( new Spieler( zSpiel->zResources(), i, zSpiel->getTeam( team ), spawnX, spawnY, sts.spielerFarbe.get( i ) ) );
         }
     }
     // Barieren

StickmanWorldOnline/Rolle.cpp

@@ -1,14 +1,26 @@
 #include "Rolle.h"
 #include "Spieler.h"
 
-RolleEffect::RolleEffect( Spieler *zSpieler, Richtung r )
+RolleEffect::RolleEffect( ResourceRegistry *zResources, Spieler *zSpieler, Richtung r )
     : Effect( zSpieler, 2.f + ( 2.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
 {
     this->r = r;
+    annimation = 0;
+    if( r == LINKS )
+        annimation = zResources->getResource( R_ROLLE_LINKS, zSpieler->getFarbe() );
+    if( r == RECHTS )
+        annimation = zResources->getResource( R_ROLLE_LINKS, zSpieler->getFarbe() );
+    if( r == OBEN )
+        annimation = zResources->getResource( R_ROLLE_LINKS, zSpieler->getFarbe() );
+    if( r == UNTEN )
+        annimation = zResources->getResource( R_ROLLE_LINKS, zSpieler->getFarbe() );
 }
 
 RolleEffect::~RolleEffect()
-{}
+{
+    if( annimation )
+        annimation->release();
+}
 
 bool RolleEffect::istSpielerBeweglich( Richtung r )
 {
@@ -45,3 +57,8 @@ bool RolleEffect::istGegenstandErlaubt( GegenstandTyp typ )
 {
     return typ != STURM && typ != ENTERHAKEN;
 }
+
+Resource *RolleEffect::getCurrentResource()
+{
+    return annimation ? annimation->getThis() : 0;
+}

StickmanWorldOnline/Rolle.h

@@ -6,12 +6,14 @@ class RolleEffect : public Effect
 {
 private:
     Richtung r;
+    Resource *annimation;
 
 public:
-    RolleEffect( Spieler *zSpieler, Richtung r );
+    RolleEffect( ResourceRegistry *zResources, Spieler *zSpieler, Richtung r );
     ~RolleEffect();
     bool istSpielerBeweglich( Richtung r ) override;
     bool istSpielerVerwundbar( Richtung r ) override;
     void move( double time ) override;
     bool istGegenstandErlaubt( GegenstandTyp typ ) override;
+    Resource *getCurrentResource() override;
 };

StickmanWorldOnline/Schild.cpp

@@ -2,14 +2,27 @@
 #include "Spieler.h"
 
 
-SchildEffect::SchildEffect( Spieler *zSpieler )
+SchildEffect::SchildEffect( ResourceRegistry *zResources, Spieler *zSpieler )
     : Effect( zSpieler, 5.f + ( 5.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
-{}
+{
+    bild = zResources->zResource( R_SCHILD, 0 )->getImage( 0 );
+}
 
 SchildEffect::~SchildEffect()
-{}
+{
+    bild->release();
+}
 
 bool SchildEffect::istSpielerVerwundbar( Richtung r )
 {
     return 0;
 }
+
+void SchildEffect::renderSpieler( Bild &rObj )
+{
+    if( rObj.setDrawOptions( (int)zSpieler->getX(), (int)zSpieler->getY(), (int)zSpieler->getWidth(), (int)zSpieler->getHeight() ) )
+    {
+        rObj.alphaBildSkall( 0, (int)zSpieler->getHeight() / 2, (int)zSpieler->getWidth(), (int)zSpieler->getHeight() / 2, *bild );
+        rObj.releaseDrawOptions();
+    }
+}

StickmanWorldOnline/Schild.h

@@ -5,9 +5,11 @@
 class SchildEffect : public Effect
 {
 private:
+    Bild *bild;
 
 public:
-    SchildEffect( Spieler *zSpieler );
+    SchildEffect( ResourceRegistry *zResources, Spieler *zSpieler );
     ~SchildEffect();
     bool istSpielerVerwundbar( Richtung r ) override;
+    void renderSpieler( Bild &rObj ) override;
 };

StickmanWorldOnline/Schuh.cpp

@@ -1,16 +1,18 @@
 #include "Schuh.h"
 #include "Spieler.h"
 
-SchuhEffect::SchuhEffect( Spieler *zSpieler )
+SchuhEffect::SchuhEffect( ResourceRegistry *zResources, Spieler *zSpieler )
     : Effect( zSpieler, 20.f + ( 20.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
 {
     speedup = 15;
     zSpieler->setLaufTempo( zSpieler->getLaufTempo() + speedup );
+    bild = zResources->zResource( R_GEIST, 0 )->getImage( 0 );
 }
 
 SchuhEffect::~SchuhEffect()
 {
     zSpieler->setLaufTempo( zSpieler->getLaufTempo() - speedup );
+    bild->release();
 }
 
 bool SchuhEffect::tick( double time, Spiel *zSpiel )
@@ -19,3 +21,12 @@ bool SchuhEffect::tick( double time, Spiel *zSpiel )
     speedup -= ( (float)time / timeLeft ) * speedup;
     return Effect::tick( time, zSpiel );
 }
+
+void SchuhEffect::renderSpieler( Bild &rObj )
+{
+    if( rObj.setDrawOptions( (int)zSpieler->getX(), (int)zSpieler->getY(), (int)zSpieler->getWidth(), (int)zSpieler->getHeight() ) )
+    {
+        rObj.alphaBildSkall( 0, (int)zSpieler->getHeight() / 2, (int)zSpieler->getWidth(), (int)zSpieler->getHeight() / 2, *bild );
+        rObj.releaseDrawOptions();
+    }
+}

StickmanWorldOnline/Schuh.h

@@ -6,9 +6,11 @@ class SchuhEffect : public Effect
 {
 private:
     float speedup;
+    Bild *bild;
 
 public:
-    SchuhEffect( Spieler *zSpieler );
+    SchuhEffect( ResourceRegistry *zResources, Spieler *zSpieler );
     ~SchuhEffect();
     bool tick( double time, Spiel *zSpiel ) override;
+    void renderSpieler( Bild &rObj ) override;
 };

StickmanWorldOnline/Spiel.cpp

@@ -375,7 +375,7 @@ void Spiel::tick()
             for( auto s = spieler.getIterator(); s; s++ )
             {
                 if( s->abstandZu( f ) < f->getWidth() / 2 )
-                    s->addEffekt( new BrandEffekt( f->zVerursacher(), s ) );
+                    s->addEffekt( new BrandEffekt( resources, f->zVerursacher(), s ) );
             }
         }
     }

StickmanWorldOnline/Spieler.cpp

@@ -157,7 +157,7 @@ void Inventar::removeItem( GegenstandTyp typ, int anzahl )
 }
 
 
-Spieler::Spieler( int id, Team *team, int spawnX, int spawnY, int farbe )
+Spieler::Spieler( ResourceRegistry *zResources, int id, Team *team, int spawnX, int spawnY, int farbe )
     : GameObject( SPIELER, spawnX, spawnY, 40, 50 )
 {
     accountId = 0;
@@ -199,12 +199,30 @@ Spieler::Spieler( int id, Team *team, int spawnX, int spawnY, int farbe )
     for( int i = 0; i < 256; i++ )
         tastenStand[ i ] = 0;
     ausrichtung = MITTE;
+    currentImage = 0;
+    currentNext = 0.075;
+    heilungImage = 0;
+    heilungNext = 0.075;
+    showHeilung = 0;
+    schadenImage = 0;
+    schadenNext = 0.075;
+    showSchaden = 0;
+    texturScale = 1;
+    resources = zResources->getThis();
+    current = zResources->getResource( R_SPIELER, farbe );
+    textur = current->getImages()->getThis();
+    heilungR = zResources->getResource( R_HEILUNG, 0 );
+    schadenR = zResources->getResource( R_SCHADEN, 0 );
 }
 
 Spieler::~Spieler()
 {
     if( team )
         team->release();
+    resources->release();
+    current->release();
+    heilungR->release();
+    schadenR->release();
 }
 
 bool Spieler::setTastenStand( unsigned char taste, bool pressed )
@@ -214,18 +232,44 @@ bool Spieler::setTastenStand( unsigned char taste, bool pressed )
     if( pressed )
     {
         if( taste == 'w' )
+        {
+            if( ausrichtung == MITTE )
+            {
+                current->release();
+                current = resources->getResource( R_SPIELER_RECHTS, color );
+            }
             ausrichtung = OBEN;
+        }
         if( taste == 'a' )
+        {
+            current->release();
+            current = resources->getResource( R_SPIELER_LINKS, color );
             ausrichtung = LINKS;
+        }
         if( taste == 's' )
+        {
+            if( ausrichtung == MITTE )
+            {
+                current->release();
+                current = resources->getResource( R_SPIELER_LINKS, color );
+            }
             ausrichtung = UNTEN;
+        }
         if( taste == 'd' )
+        {
+            current->release();
+            current = resources->getResource( R_SPIELER_RECHTS, color );
             ausrichtung = RECHTS;
+        }
     }
     else
     {
         if( !tastenStand[ 'w' ] && !tastenStand[ 'a' ] && !tastenStand[ 's' ] && !tastenStand[ 'd' ] )
+        {
+            current->release();
+            current = resources->getResource( R_SPIELER, color );
             ausrichtung = MITTE;
+        }
         else
         {
             if( ( ausrichtung == OBEN && taste == 'w' ) ||
@@ -236,11 +280,19 @@ bool Spieler::setTastenStand( unsigned char taste, bool pressed )
                 if( tastenStand[ 'w' ] )
                     ausrichtung = OBEN;
                 if( tastenStand[ 'a' ] )
+                {
+                    current->release();
+                    current = resources->getResource( R_SPIELER_LINKS, color );
                     ausrichtung = LINKS;
+                }
                 if( tastenStand[ 's' ] )
                     ausrichtung = UNTEN;
                 if( tastenStand[ 'd' ] )
+                {
+                    current->release();
+                    current = resources->getResource( R_SPIELER_RECHTS, color );
                     ausrichtung = RECHTS;
+                }
             }
         }
     }
@@ -263,6 +315,12 @@ void Spieler::setAccount( int id )
 
 void Spieler::addEffekt( Effect *e )
 {
+    Resource *r = e->getCurrentResource();
+    if( r )
+    {
+        currentImage = 0;
+        r->release();
+    }
     effekte.add( e );
 }
 
@@ -415,7 +473,54 @@ void Spieler::tick( double zeit, Spiel *zSpiel )
             useItem( zSpiel );
         if( tastenStand[ 'e' ] )
             zSpiel->spielerActivate( this );
-        heilung( lebensRegeneration * (float)zeit, zSpiel );
+        heilung( lebensRegeneration * (float)zeit, zSpiel, 0 );
+        Resource *r = current->getThis();
+        for( auto e = effekte.getIterator(); e; e++ )
+        {
+            Resource *t = e->getCurrentResource();
+            if( t )
+                r->release();
+            r = t;
+        }
+        currentNext -= zeit;
+        if( currentNext <= 0 )
+        {
+            currentNext += 0.075;
+            currentImage++;
+        }
+        if( currentImage >= r->getImageCount() )
+            currentImage = 0;
+        textur->release();
+        textur = r->getImage( currentImage );
+        r->release();
+        if( showHeilung )
+        {
+            heilungNext -= zeit;
+            if( heilungNext <= 0 )
+            {
+                heilungNext += 0.075;
+                heilungImage++;
+                if( heilungR->getImageCount() <= heilungImage )
+                {
+                    heilungImage = 0;
+                    showHeilung = 0;
+                }
+            }
+        }
+        if( showSchaden )
+        {
+            schadenNext -= zeit;
+            if( schadenNext <= 0 )
+            {
+                schadenNext += 0.075;
+                schadenImage++;
+                if( schadenR->getImageCount() <= schadenImage )
+                {
+                    schadenImage = 0;
+                    showSchaden = 0;
+                }
+            }
+        }
     }
     else
     {
@@ -428,6 +533,21 @@ void Spieler::tick( double zeit, Spiel *zSpiel )
     }
 }
 
+void Spieler::render( Bild &rObj )
+{
+    GameObject::render( rObj );
+    if( rObj.setDrawOptions( (int)x, (int)y, (int)w, (int)h ) )
+    {
+        if( showHeilung )
+            rObj.alphaBildSkall( (int)x, (int)y, (int)w, (int)h, *heilungR->zImage( heilungImage ) );
+        if( showSchaden )
+            rObj.alphaBildSkall( (int)x, (int)y, (int)w, (int)h, *schadenR->zImage( schadenImage ) );
+        rObj.releaseDrawOptions();
+    }
+    for( auto e = effekte.getIterator(); e; e++ )
+        e->renderSpieler( rObj );
+}
+
 void Spieler::useItem( Spiel *zSpiel )
 {
     if( istAmLeben() && inv.selectedItem() != KEIN_GEGENSTAND && istGegenstandErlaubt( inv.selectedItem() ) )
@@ -447,13 +567,13 @@ void Spieler::useItem( Spiel *zSpiel )
             addEffekt( new LebenEffect( this ) );
             break;
         case SCHILD:
-            addEffekt( new SchildEffect( this ) );
+            addEffekt( new SchildEffect( zSpiel->zResources(), this ) );
             break;
         case SCHUH:
-            addEffekt( new SchuhEffect( this ) );
+            addEffekt( new SchuhEffect( zSpiel->zResources(), this ) );
             break;
         case GEIST:
-            addEffekt( new GeistEffect( this ) );
+            addEffekt( new GeistEffect( zSpiel->zResources(), this ) );
             break;
         case KUGEL:
             geschosseGeschossen++;
@@ -461,10 +581,10 @@ void Spieler::useItem( Spiel *zSpiel )
             zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_KUGEL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
             break;
         case ROLLE:
-            addEffekt( new RolleEffect( this, getAusrichtung() ) );
+            addEffekt( new RolleEffect( zSpiel->zResources(), this, getAusrichtung() ) );
             break;
         case STURM:
-            addEffekt( new SturmEffect( this, getAusrichtung() ) );
+            addEffekt( new SturmEffect( zSpiel->zResources(), this, getAusrichtung() ) );
             break;
         case DRACHENAUGE:
             geschosseGeschossen++;
@@ -477,7 +597,7 @@ void Spieler::useItem( Spiel *zSpiel )
             zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_FEUERBALL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
             break;
         case ENTERHAKEN:
-            addEffekt( new EnterhakenEffect( this, getAusrichtung() ) );
+            addEffekt( new EnterhakenEffect( zSpiel->zResources(), this, getAusrichtung() ) );
             break;
         case MINE:
             geschosseGeschossen++;
@@ -535,16 +655,16 @@ bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
                 addErfahrung( 2, zSpiel );
                 break;
             case RSTRENGTH:
-                addEffekt( new StrengthRuneEffect( this ) );
+                addEffekt( new StrengthRuneEffect( zSpiel->zResources(), this ) );
                 break;
             case RBOSHEIT:
-                addEffekt( new BosheitRuneEffect( this ) );
+                addEffekt( new BosheitRuneEffect( zSpiel->zResources(), this ) );
                 break;
             case RLEBEN:
-                addEffekt( new LebenRuneEffect( this ) );
+                addEffekt( new LebenRuneEffect( zSpiel->zResources(), this ) );
                 break;
             case RTEMPO:
-                addEffekt( new TempoRuneEffect( this ) );
+                addEffekt( new TempoRuneEffect( zSpiel->zResources(), this ) );
                 break;
             default:
                 break;
@@ -584,8 +704,15 @@ void Spieler::nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spi
     e->addParameter( "Betroffener Spieler", getThis() );
     e->addParameter( "Wert", new Float( schaden ) );
     zSpiel->throwEvent( e );
+    showSchaden = 1;
     if( leben == 0 )
     {
+        current->release();
+        current = resources->getResource( R_SPIELER, color );
+        heilungImage = 0;
+        schadenImage = 0;
+        showSchaden = 0;
+        showHeilung = 0;
         wiederbelebungsZeit = (float)( (float)maxWiederbelebungsZeit + team->getMaxWiederbelebungsZeit() );
         wiederbelebungsZeit -= wiederbelebungsZeit / 100 * abklingZeitVerringerung;
         team->addTod();
@@ -600,7 +727,7 @@ void Spieler::nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spi
     }
 }
 
-void Spieler::heilung( float heal, Spiel *zSpiel )
+void Spieler::heilung( float heal, Spiel *zSpiel, bool show )
 {
     if( amLeben )
     {
@@ -611,6 +738,8 @@ void Spieler::heilung( float heal, Spiel *zSpiel )
         e->addParameter( "Betroffener Spieler", getThis() );
         e->addParameter( "Wert", new Float( heal ) );
         zSpiel->throwEvent( e );
+        if( show )
+            showHeilung = 1;
     }
 }
 

StickmanWorldOnline/Spieler.h

@@ -76,9 +76,21 @@ private:
     Text name;
     Richtung ausrichtung;
     Inventar inv;
+    int currentImage;
+    double currentNext;
+    Resource *current;
+    int heilungImage;
+    double heilungNext;
+    bool showHeilung;
+    Resource *heilungR;
+    int schadenImage;
+    double schadenNext;
+    bool showSchaden;
+    Resource *schadenR;
+    ResourceRegistry *resources;
 
 public:
-    Spieler( int id, Team *team, int spawnX, int spawnY, int farbe );
+    Spieler( ResourceRegistry *zResources, int id, Team *team, int spawnX, int spawnY, int farbe );
     ~Spieler();
     bool setTastenStand( unsigned char taste, bool pressed );
     void setTeam( Team *team );
@@ -97,13 +109,14 @@ public:
     void move( double zeit );
     void wiederbelebung( Spiel *zSpiel );
     void tick( double zeit, Spiel *zSpiel );
+    void render( Bild &rObj ) override;
     void useItem( Spiel *zSpiel );
     bool addItem( GegenstandTyp typ, int anz, Spiel *zSpiel );
     // heilt auch um den lebensraub prozentsatz
     void addGemachterSchaden( float schaden, Spiel *zSpiel );
     // zieht die rüstung ab
     void nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spiel *zSpiel );
-    void heilung( float heal, Spiel *zSpiel );
+    void heilung( float heal, Spiel *zSpiel, bool show = 1 );
     void setSchadenBonus( float bonus );
     void setLebensRaub( float raub );
     void setGeschossTempo( float tempo );

StickmanWorldOnline/StrengthRune.cpp

@@ -2,15 +2,41 @@
 #include "Spieler.h"
 
 
-StrengthRuneEffect::StrengthRuneEffect( Spieler *zSpieler )
+StrengthRuneEffect::StrengthRuneEffect( ResourceRegistry *zResources, Spieler *zSpieler )
     : Effect( zSpieler, 75.f + ( 75.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
 {
     zSpieler->setArmor( zSpieler->getArmor() + 7 );
     zSpieler->setSchadenBonus( zSpieler->getSchadenBonus() + 3 );
+    annimation = zResources->getResource( R_RSTRENGTH_EFFECT, 0 );
+    currentImage = 0;
+    nextImage = 0.075;
 }
 
 StrengthRuneEffect::~StrengthRuneEffect()
 {
     zSpieler->setArmor( zSpieler->getArmor() - 7 );
     zSpieler->setSchadenBonus( zSpieler->getSchadenBonus() - 3 );
+    annimation->release();
+}
+
+bool StrengthRuneEffect::tick( double time, Spiel *zSpiel )
+{
+    nextImage -= time;
+    if( nextImage <= 0 )
+    {
+        nextImage += 0.075;
+        currentImage++;
+    }
+    return Effect::tick( time, zSpiel );
+}
+
+void StrengthRuneEffect::renderSpieler( Bild &rObj )
+{
+    if( currentImage >= annimation->getImageCount() )
+        return;
+    if( rObj.setDrawOptions( (int)zSpieler->getX(), (int)zSpieler->getY(), (int)zSpieler->getWidth(), (int)zSpieler->getHeight() ) )
+    {
+        rObj.alphaBildSkall( 0, 0, (int)zSpieler->getWidth(), (int)zSpieler->getHeight(), *annimation->zImage( currentImage ) );
+        rObj.releaseDrawOptions();
+    }
 }

StickmanWorldOnline/StrengthRune.h

@@ -5,8 +5,13 @@
 class StrengthRuneEffect : public Effect
 {
 private:
+    Resource *annimation;
+    int currentImage;
+    double nextImage;
 
 public:
-    StrengthRuneEffect( Spieler *zSpieler );
+    StrengthRuneEffect( ResourceRegistry *zResources, Spieler *zSpieler );
     ~StrengthRuneEffect();
+    bool tick( double time, Spiel *zSpiel ) override;
+    void renderSpieler( Bild &rObj ) override;
 };

StickmanWorldOnline/Sturm.cpp

@@ -2,14 +2,26 @@
 #include "Spieler.h"
 #include "Spiel.h"
 
-SturmEffect::SturmEffect( Spieler *zSpieler, Richtung r )
+SturmEffect::SturmEffect( ResourceRegistry *zResources, Spieler *zSpieler, Richtung r )
     : Effect( zSpieler, 2.f + ( 2.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
 {
     this->r = r;
+    annimation = 0;
+    if( r == LINKS )
+        annimation = zResources->getResource( R_ROLLE_LINKS, zSpieler->getFarbe() );
+    if( r == RECHTS )
+        annimation = zResources->getResource( R_ROLLE_LINKS, zSpieler->getFarbe() );
+    if( r == OBEN )
+        annimation = zResources->getResource( R_ROLLE_LINKS, zSpieler->getFarbe() );
+    if( r == UNTEN )
+        annimation = zResources->getResource( R_ROLLE_LINKS, zSpieler->getFarbe() );
 }
 
 SturmEffect::~SturmEffect()
-{}
+{
+    if( annimation )
+        annimation->release();
+}
 
 bool SturmEffect::istSpielerBeweglich( Richtung r )
 {
@@ -59,3 +71,8 @@ bool SturmEffect::istGegenstandErlaubt( GegenstandTyp typ )
 {
     return typ != ROLLE && typ != ENTERHAKEN;
 }
+
+Resource *SturmEffect::getCurrentResource()
+{
+    return annimation ? annimation->getThis() : 0;
+}

StickmanWorldOnline/Sturm.h

@@ -6,13 +6,15 @@ class SturmEffect : public Effect
 {
 private:
     Richtung r;
+    Resource *annimation;
 
 public:
-    SturmEffect( Spieler *zSpieler, Richtung r );
+    SturmEffect( ResourceRegistry *zResources, Spieler *zSpieler, Richtung r );
     ~SturmEffect();
     bool istSpielerBeweglich( Richtung r ) override;
     bool istSpielerVerwundbar( Richtung r ) override;
     void move( double time ) override;
     bool tick( double time, Spiel *zSpiel ) override;
     bool istGegenstandErlaubt( GegenstandTyp typ ) override;
+    Resource *getCurrentResource() override;
 };

StickmanWorldOnline/TempoRune.cpp

@@ -2,15 +2,41 @@
 #include "Spieler.h"
 
 
-TempoRuneEffect::TempoRuneEffect( Spieler *zSpieler )
+TempoRuneEffect::TempoRuneEffect( ResourceRegistry *zResources, Spieler *zSpieler )
     : Effect( zSpieler, 75.f + ( 75.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
 {
     zSpieler->setLaufTempo( zSpieler->getLaufTempo() + 7 );
     zSpieler->setGeschossTempo( zSpieler->getGeschossTempo() + 3 );
+    annimation = zResources->getResource( R_RTEMPO_EFFECT, 0 );
+    currentImage = 0;
+    nextImage = 0.075;
 }
 
 TempoRuneEffect::~TempoRuneEffect()
 {
     zSpieler->setLaufTempo( zSpieler->getLaufTempo() - 7 );
     zSpieler->setGeschossTempo( zSpieler->getGeschossTempo() - 3 );
+    annimation->release();
+}
+
+bool TempoRuneEffect::tick( double time, Spiel *zSpiel )
+{
+    nextImage -= time;
+    if( nextImage <= 0 )
+    {
+        nextImage += 0.075;
+        currentImage++;
+    }
+    return Effect::tick( time, zSpiel );
+}
+
+void TempoRuneEffect::renderSpieler( Bild &rObj )
+{
+    if( currentImage >= annimation->getImageCount() )
+        return;
+    if( rObj.setDrawOptions( (int)zSpieler->getX(), (int)zSpieler->getY(), (int)zSpieler->getWidth(), (int)zSpieler->getHeight() ) )
+    {
+        rObj.alphaBildSkall( 0, 0, (int)zSpieler->getWidth(), (int)zSpieler->getHeight(), *annimation->zImage( currentImage ) );
+        rObj.releaseDrawOptions();
+    }
 }

StickmanWorldOnline/TempoRune.h

@@ -5,8 +5,13 @@
 class TempoRuneEffect : public Effect
 {
 private:
+    Resource *annimation;
+    int currentImage;
+    double nextImage;
 
 public:
-    TempoRuneEffect( Spieler *zSpieler );
+    TempoRuneEffect( ResourceRegistry *zResources, Spieler *zSpieler );
     ~TempoRuneEffect();
+    bool tick( double time, Spiel *zSpiel ) override;
+    void renderSpieler( Bild &rObj ) override;
 };