Stickman-World-Online-Client/StickmanWorldOnline/Spieler.cpp

#include "Spieler.h"
#include "Spiel.h"
#include "BosheitRune.h"
#include "Enterhaken.h"
#include "Geist.h"
#include "Leben.h"
#include "LebenRune.h"
#include "Rolle.h"
#include "Schild.h"
#include "Schuh.h"
#include "StrengthRune.h"
#include "Sturm.h"
#include "TempoRune.h"


Inventar::Inventar()
    : slots(),
    anzahl(),
    abklingzeit()
{
    for( int i = 0; i < INVENTORY_SLOTS; i++ )
    {
        slots[ i ] = KEIN_GEGENSTAND;
        anzahl[ i ] = 0;
        abklingzeit[ i ] = 0;
    }
    selected = 0;
}

void Inventar::addItem( GegenstandTyp typ, int anzahl )
{
    for( int i = 0; i < INVENTORY_SLOTS; i++ )
    {
        if( slots[ i ] == typ )
        {
            this->anzahl[ i ] += anzahl;
            return;
        }
    }
    for( int i = 0; i < INVENTORY_SLOTS; i++ )
    {
        if( slots[ i ] == KEIN_GEGENSTAND )
        {
            slots[ i ] = typ;
            this->anzahl[ i ] = consumable( typ ) ? anzahl : 1;
            return;
        }
    }
}

void Inventar::setSelected( int slot )
{
    selected = slot;
    if( selected >= INVENTORY_SLOTS )
        selected = INVENTORY_SLOTS - 1;
}

bool Inventar::hatAbklingzeit( GegenstandTyp typ ) const
{
    for( int i = 0; i < INVENTORY_SLOTS; i++ )
        if( slots[ i ] == typ && abklingzeit[ i ] > 0 )
            return 1;
    return 0;
}

GegenstandTyp Inventar::useItem()
{
    if( slots[ selected ] != KEIN_GEGENSTAND && abklingzeit[ selected ] <= 0 )
    {
        if( consumable( slots[ selected ] ) )
        {
            if( !--anzahl[ selected ] )
            {
                GegenstandTyp typ = slots[ selected ];
                slots[ selected ] = KEIN_GEGENSTAND;
                return typ;
            }
        }
        abklingzeit[ selected ] = ::abklingzeit( slots[ selected ] );
        return slots[ selected ];
    }
    return KEIN_GEGENSTAND;
}

void Inventar::tick( double zeit )
{
    for( int i = 0; i < INVENTORY_SLOTS; i++ )
    {
        if( slots[ i ] != KEIN_GEGENSTAND && abklingzeit[ i ] > 0 )
        {
            abklingzeit[ i ] -= (float)zeit;
            if( abklingzeit[ i ] < 0 )
                abklingzeit[ i ] = 0;
        }
    }
}

bool Inventar::canAddItem( GegenstandTyp typ ) const
{
    if( !consumable( typ ) )
    {
        for( int i = 0; i < INVENTORY_SLOTS; i++ )
        {
            if( slots[ i ] == typ )
                return 0;
        }
    }
    for( int i = 0; i < INVENTORY_SLOTS; i++ )
    {
        if( slots[ i ] == KEIN_GEGENSTAND || ( slots[ i ] == typ && consumable( typ ) ) )
            return 1;
    }
    return 0;
}

GegenstandTyp Inventar::selectedItem() const
{
    return slots[ selected ];
}

int Inventar::getItemAnzahl() const
{
    int sum = 0;
    for( int i = 0; i < INVENTORY_SLOTS; i++ )
        sum += anzahl[ i ];
    return sum;
}

int Inventar::getItemAnzahl( GegenstandTyp typ ) const
{
    for( int i = 0; i < INVENTORY_SLOTS; i++ )
    {
        if( slots[ i ] == typ )
            return anzahl[ i ];
    }
    return 0;
}

GegenstandTyp Inventar::getItemTyp( int index ) const
{
    if( index < 0 || index >= INVENTORY_SLOTS )
        return KEIN_GEGENSTAND;
    return slots[ index ];
}

void Inventar::removeItem( GegenstandTyp typ, int anzahl )
{
    for( int i = 0; i < INVENTORY_SLOTS; i++ )
    {
        if( slots[ i ] == typ )
        {
            this->anzahl[ i ] -= anzahl;
            if( this->anzahl[ i ] < 0 )
            {
                slots[ i ] = KEIN_GEGENSTAND;
                abklingzeit[ i ] = 0;
            }
        }
    }
}

int Inventar::getSelectedIndex() const
{
    return selected;
}

float Inventar::getAbklingzeit( int index ) const
{
    return abklingzeit[ index ];
}


Spieler::Spieler( ResourceRegistry *zResources, int id, Team *team, int spawnX, int spawnY, int farbe )
    : GameObject( SPIELER, spawnX, spawnY, 40, 50 ),
    tastenStand()
{
    accountId = 0;
    spielerNummer = id;
    this->team = team;
    amLeben = 1;
    maxWiederbelebungsZeit = 2;
    wiederbelebungsZeit = 0;
    zuletztAufgehoben = KEIN_GEGENSTAND;
    zuletztAktiviert = KEIN_GEGENSTAND;
    this->leben = 300;
    this->maxLeben = 300;
    level = 1;
    erfahrung = 0;
    maxErfahrung = 5;
    this->spawnX = spawnX;
    this->spawnY = spawnY;
    laufTempo = 30;
    geschossTempo = 100;
    armor = 0;
    schadensBonus = 0;
    lebensraub = 0;
    lebensRegeneration = 1;
    abklingZeitVerringerung = 0;
    color = farbe;
    kills = 0;
    tode = 0;
    treffer = 0;
    getroffen = 0;
    schadenGenommen = 0;
    schadenGemacht = 0;
    lebenGeheilt = 0;
    erhalteneErfahrung = 0;
    itemsAufgehoben = 0;
    itemsVerwendet = 0;
    tunnelBenutzt = 0;
    schalterAktiviert = 0;
    geschosseGeschossen = 0;
    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 )
{
    bool ret = tastenStand[ (int)taste ] != pressed;
    tastenStand[ (int)taste ] = pressed;
    if( pressed )
    {
        if( taste == 'w' )
        {
            if( ausrichtung == MITTE )
            {
                current->release();
                current = resources->getResource( R_SPIELER_RECHTS, color );
                if( !current )
                    throw "error";
            }
            ausrichtung = OBEN;
        }
        if( taste == 'a' )
        {
            current->release();
            current = resources->getResource( R_SPIELER_LINKS, color );
            if( !current )
                throw "error";
            ausrichtung = LINKS;
        }
        if( taste == 's' )
        {
            if( ausrichtung == MITTE )
            {
                current->release();
                current = resources->getResource( R_SPIELER_LINKS, color );
                if( !current )
                    throw "error";
            }
            ausrichtung = UNTEN;
        }
        if( taste == 'd' )
        {
            current->release();
            current = resources->getResource( R_SPIELER_RECHTS, color );
            if( !current )
                throw "error";
            ausrichtung = RECHTS;
        }
        if( taste >= '1' && taste <= '8' )
            inv.setSelected( taste - '1' );
    }
    else
    {
        if( !tastenStand[ 'w' ] && !tastenStand[ 'a' ] && !tastenStand[ 's' ] && !tastenStand[ 'd' ] )
        {
            current->release();
            current = resources->getResource( R_SPIELER, color );
            if( !current )
                throw "error";
            ausrichtung = MITTE;
        }
        else
        {
            if( ( ausrichtung == OBEN && taste == 'w' ) ||
                ( ausrichtung == LINKS && taste == 'a' ) ||
                ( ausrichtung == UNTEN && taste == 's' ) ||
                ( ausrichtung == RECHTS && taste == 'd' ) )
            {
                if( tastenStand[ 'w' ] )
                    ausrichtung = OBEN;
                if( tastenStand[ 'a' ] )
                {
                    current->release();
                    current = resources->getResource( R_SPIELER_LINKS, color );
                    if( !current )
                        throw "error";
                    ausrichtung = LINKS;
                }
                if( tastenStand[ 's' ] )
                    ausrichtung = UNTEN;
                if( tastenStand[ 'd' ] )
                {
                    current->release();
                    current = resources->getResource( R_SPIELER_RECHTS, color );
                    if( !current )
                        throw "error";
                    ausrichtung = RECHTS;
                }
            }
        }
    }
    return ret;
}

void Spieler::setTeam( Team *team )
{
    if( this->team )
        this->team->removeSpieler();
    this->team->release();
    this->team = team;
    this->team->addSpieler();
}

void Spieler::setAccount( int id )
{
    this->accountId = id;
}

void Spieler::addEffekt( Effect *e )
{
    Resource *r = e->getCurrentResource();
    if( r )
    {
        currentImage = 0;
        r->release();
    }
    effekte.add( e );
}

void Spieler::setLaufTempo( float pps )
{
    laufTempo = pps;
}

void Spieler::addErfahrung( float anz, Spiel *zSpiel )
{
    erfahrung += anz;
    zSpiel->setSpielerZuletztErfahrungBekommen( (Spieler *)getThis() );
    Ereignis *e = new Ereignis( SPIELER_BEKOMMT_ERFAHRUNG );
    e->addParameter( "Betroffener Spieler", getThis() );
    e->addParameter( "Wert", new Float( anz ) );
    zSpiel->throwEvent( e );
    while( erfahrung > maxErfahrung )
        levelUp( zSpiel );
    while( erfahrung < 0 )
        levelDown( zSpiel );
}

void Spieler::levelUp( Spiel *zSpiel )
{
    level++;
    erfahrung -= (float)maxErfahrung;
    maxErfahrung += ( maxErfahrung / level ) + 2;
    maxLeben += 20;
    heilung( 20, zSpiel );
    if( level <= 10 )
    {
        laufTempo += 2;
        geschossTempo += 2;
    }
    if( level <= 50 )
    {
        armor += 1;
        abklingZeitVerringerung += 1;
    }
    if( level <= 75 )
    {
        schadensBonus += 1;
        lebensraub += 1;
    }
    if( level <= 100 )
        lebensRegeneration += 0.25f;
    zSpiel->setSpielerZuletztLevelUp( (Spieler *)getThis() );
    Ereignis *e = new Ereignis( SPIELER_LEVEL_UP );
    e->addParameter( "Betroffener Spieler", getThis() );
    zSpiel->throwEvent( e );
}

void Spieler::levelDown( Spiel *zSpiel )
{
    if( level <= 100 )
        lebensRegeneration -= 0.25f;
    if( level <= 75 )
    {
        schadensBonus -= 1;
        lebensraub -= 1;
    }
    if( level <= 50 )
    {
        armor -= 1;
        abklingZeitVerringerung -= 1;
    }
    if( level <= 10 )
    {
        laufTempo -= 2;
        geschossTempo -= 2;
    }
    maxLeben -= 20;
    maxErfahrung -= ( maxErfahrung / level ) + 2;
    erfahrung += (float)maxErfahrung;
    level--;
}

void Spieler::addTunnelBenutzung( Spiel *zSpiel )
{
    tunnelBenutzt++;
    zSpiel->setSpielerZuletztTunnelBenutzt( (Spieler *)getThis() );
}

void Spieler::addSchalterBenutzung( Spiel *zSpiel )
{
    schalterAktiviert++;
    zSpiel->setSpielerZuletztSchalterAktiviert( (Spieler *)getThis() );
}

// aktualisiert auch die team statistik
void Spieler::addKill()
{
    team->addKill();
    kills++;
}

void Spieler::addTreffer( Spiel *zSpiel )
{
    addErfahrung( 2, zSpiel );
    treffer++;
}

void Spieler::addGetroffen()
{
    getroffen++;
}

void Spieler::move( double zeit )
{
    if( istAmLeben() )
    {
        if( tastenStand[ 'w' ] && istBeweglich( OBEN ) )
            y -= laufTempo * (float)zeit;
        if( tastenStand[ 'a' ] && istBeweglich( LINKS ) )
            x -= laufTempo * (float)zeit;
        if( tastenStand[ 's' ] && istBeweglich( UNTEN ) )
            y += laufTempo * (float)zeit;
        if( tastenStand[ 'd' ] && istBeweglich( RECHTS ) )
            x += laufTempo * (float)zeit;
        for( auto e = effekte.getIterator(); e; e++ )
            e->move( zeit );
    }
}

void Spieler::wiederbelebung( Spiel *zSpiel )
{
    amLeben = 1;
    leben = (float)maxLeben;
    zSpiel->setSpielerZuletztWiederbelebt( (Spieler *)getThis() );
    Ereignis *e = new Ereignis( SPIELER_WIEDERBELEBT );
    e->addParameter( "Betroffener Spieler", getThis() );
    zSpiel->throwEvent( e );
}

void Spieler::tick( double zeit, Spiel *zSpiel )
{
    if( istAmLeben() )
    {
        for( int i = 0; i < effekte.getEintragAnzahl(); i++ )
        {
            if( effekte.z( i )->tick( zeit, zSpiel ) && istAmLeben() )
            {
                effekte.remove( i );
                i--;
            }
            if( !istAmLeben() )
                break;
        }
        if( tastenStand[ ' ' ] )
            useItem( zSpiel );
        if( tastenStand[ 'e' ] )
            zSpiel->spielerActivate( this );
        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
    {
        effekte.leeren();
        wiederbelebungsZeit -= (float)zeit;
        if( wiederbelebungsZeit <= 0 )
        {
            wiederbelebung( zSpiel );
        }
    }
    inv.tick( zeit );
}

void Spieler::render( Bild &rObj )
{
    if( istAmLeben() )
    {
        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() ) )
    {
        zSpiel->setSpielerZuletztGegenstandAktiviert( (Spieler *)getThis() );
        itemsVerwendet++;
        GegenstandTyp typ = inv.useItem();
        zSpiel->setItemZuletztAktiviert( typ );
        switch( typ )
        {
        case PFEIL:
            geschosseGeschossen++;
            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_PFEIL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
            break;
        case LEBEN:
            addEffekt( new LebenEffect( this ) );
            break;
        case SCHILD:
            addEffekt( new SchildEffect( zSpiel->zResources(), this ) );
            break;
        case SCHUH:
            addEffekt( new SchuhEffect( zSpiel->zResources(), this ) );
            break;
        case GEIST:
            addEffekt( new GeistEffect( zSpiel->zResources(), this ) );
            break;
        case KUGEL:
            geschosseGeschossen++;
            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_KUGEL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
            break;
        case ROLLE:
            addEffekt( new RolleEffect( zSpiel->zResources(), this, getAusrichtung() ) );
            break;
        case STURM:
            addEffekt( new SturmEffect( zSpiel->zResources(), this, getAusrichtung() ) );
            break;
        case DRACHENAUGE:
            geschosseGeschossen++;
            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_DRACHENAUGE, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
            break;
        case FEUERBALL:
            geschosseGeschossen++;
            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_FEUERBALL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
            break;
        case ENTERHAKEN:
            addEffekt( new EnterhakenEffect( zSpiel->zResources(), this, getAusrichtung() ) );
            break;
        case MINE:
            geschosseGeschossen++;
            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), 0, GESCHOSS_MINE, MITTE, (int)x, (int)y, (Spieler *)getThis() ) );
            break;
        default:
            break;
        }
        Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
        e->addParameter( "Betroffener Spieler", getThis() );
        e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
        zSpiel->throwEvent( e );
    }
}

bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
{
    if( storable( typ ) )
    {
        if( inv.canAddItem( typ ) )
        {
            zSpiel->setItemZuletztAufgehoben( typ );
            zSpiel->setSpielerZuletztGegenstandAufgehoben( (Spieler *)getThis() );
            itemsAufgehoben += anz;
            inv.addItem( typ, anz );
            Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
            e->addParameter( "Betroffener Spieler", getThis() );
            e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
            e->addParameter( "Anzahl", new Integer( anz ) );
            zSpiel->throwEvent( e );
            return 1;
        }
    }
    else
    {
        zSpiel->setItemZuletztAufgehoben( typ );
        zSpiel->setSpielerZuletztGegenstandAufgehoben( (Spieler *)getThis() );
        itemsAufgehoben += anz;
        Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
        e->addParameter( "Betroffener Spieler", getThis() );
        e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
        e->addParameter( "Anzahl", new Integer( anz ) );
        zSpiel->throwEvent( e );
        for( int i = 0; i < anz; i++ )
        {
            Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
            e->addParameter( "Betroffener Spieler", getThis() );
            e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
            zSpiel->throwEvent( e );
            itemsVerwendet++;
            switch( typ )
            {
            case RWEISHEIT:
                addErfahrung( 2, zSpiel );
                break;
            case RSTRENGTH:
                addEffekt( new StrengthRuneEffect( zSpiel->zResources(), this ) );
                break;
            case RBOSHEIT:
                addEffekt( new BosheitRuneEffect( zSpiel->zResources(), this ) );
                break;
            case RLEBEN:
                addEffekt( new LebenRuneEffect( zSpiel->zResources(), this ) );
                break;
            case RTEMPO:
                addEffekt( new TempoRuneEffect( zSpiel->zResources(), this ) );
                break;
            default:
                break;
            }
        }
    }
    return 0;
}

// heilt auch um den lebensraub prozentsatz
void Spieler::addGemachterSchaden( float schaden, Spiel *zSpiel )
{
    zSpiel->setSpielerZuletztSchadenGemacht( (Spieler *)getThis() );
    schadenGemacht += schaden;
    heilung( schaden / 100 * lebensraub, zSpiel );
    Ereignis *e = new Ereignis( SPIELER_MACHT_SCHADEN );
    e->addParameter( "Betroffener Spieler", getThis() );
    e->addParameter( "Wert", new Float( schaden ) );
    zSpiel->throwEvent( e );
}

// zieht die rüstung ab
void Spieler::nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spiel *zSpiel )
{
    if( !isVerwundbar( r ) || !istAmLeben() )
        return;
    if( zVerursacher )
        schaden += schaden / 100 * zVerursacher->getSchadenBonus();
    schaden -= schaden / 100 * armor;
    schaden = leben < schaden ? leben : schaden;
    schadenGenommen += schaden;
    leben -= schaden;
    zSpiel->setSpielerZuletztSchadenGenommen( (Spieler *)getThis() );
    if( zVerursacher )
        zVerursacher->addGemachterSchaden( schaden, zSpiel );
    Ereignis *e = new Ereignis( SPIELER_NIMMT_SCHADEN );
    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 );
        if( !current )
            throw "error";
        heilungImage = 0;
        schadenImage = 0;
        showSchaden = 0;
        showHeilung = 0;
        wiederbelebungsZeit = (float)( (float)maxWiederbelebungsZeit + team->getMaxWiederbelebungsZeit() );
        wiederbelebungsZeit -= wiederbelebungsZeit / 100 * abklingZeitVerringerung;
        team->addTod();
        amLeben = 0;
        tode++;
        zSpiel->setSpielerZuletztGestorben( (Spieler *)getThis() );
        if( zVerursacher )
            zVerursacher->addKill();
        Ereignis *e = new Ereignis( SPIELER_STIRBT );
        e->addParameter( "Betroffener Spieler", getThis() );
        zSpiel->throwEvent( e );
    }
}

void Spieler::heilung( float heal, Spiel *zSpiel, bool show )
{
    if( istAmLeben() )
    {
        lebenGeheilt += heal;
        leben += heal;
        zSpiel->setSpielerZuletztGeheilt( (Spieler *)getThis() );
        Ereignis *e = new Ereignis( SPIELER_WIRD_GEHEILT );
        e->addParameter( "Betroffener Spieler", getThis() );
        e->addParameter( "Wert", new Float( heal ) );
        zSpiel->throwEvent( e );
        if( show )
            showHeilung = 1;
    }
}

void Spieler::setSchadenBonus( float bonus )
{
    schadensBonus = bonus;
}

void Spieler::setLebensRaub( float raub )
{
    lebensraub = raub;
}

void Spieler::setGeschossTempo( float tempo )
{
    geschossTempo = tempo;
}

void Spieler::setArmor( float armor )
{
    this->armor = armor;
}

void Spieler::setLebensRegeneration( float reg )
{
    lebensRegeneration = reg;
}

void Spieler::setName( const char *name )
{
    this->name = name;
}

void Spieler::setLevel( int level, Spiel *zSpiel )
{
    if( level < 0 || level > 100 )
        return;
    while( level > this->level )
        levelUp( zSpiel );
    while( level < this->level )
        levelDown( zSpiel );
    erfahrung = 0;
}

void Spieler::removeItem( GegenstandTyp typ, int anzahl )
{
    inv.removeItem( typ, anzahl );
}

void Spieler::setLeben( float leben )
{
    this->leben = leben;
    if( this->leben < 0 )
    {
        this->leben = 0;
        // the player is now undead :D
    }
    if( this->leben > maxLeben )
        this->leben = (float)maxLeben;
}

void Spieler::setMaxLeben( int leben )
{
    maxLeben = leben;
    if( maxLeben < 1 )
        maxLeben = 1;
    if( this->leben > maxLeben )
        this->leben = (float)maxLeben;
}

void Spieler::setErfahrung( float erf, Spiel *zSpiel )
{
    erfahrung = erf;
    while( erfahrung < 0 )
        levelDown( zSpiel );
    while( erfahrung >= maxErfahrung )
        levelUp( zSpiel );
}

void Spieler::setMaxErfahrung( int erf )
{
    this->maxErfahrung = erf;
}

void Spieler::setAbklingZeitVerringerung( float verringerung )
{
    abklingZeitVerringerung = verringerung;
}

float Spieler::getLebensRegenneration() const
{
    return lebensRegeneration;
}

float Spieler::getArmor() const
{
    return armor;
}

float Spieler::getGeschossTempo() const
{
    return geschossTempo;
}

float Spieler::getLebensRaub() const
{
    return lebensraub;
}

float Spieler::getSchadenBonus() const
{
    return schadensBonus;
}

Team *Spieler::zTeam() const
{
    return team;
}

Team *Spieler::getTeam() const
{
    return team ? (Team *)team->getThis() : 0;
}

int Spieler::getFarbe() const
{
    return color;
}

int Spieler::getAccountId() const
{
    return accountId;
}

int Spieler::getPunkte() const
{
    return kills - tode + ( treffer - getroffen ) / 2;
}

bool Spieler::istAmLeben() const
{
    return amLeben && accountId;
}

float Spieler::getLaufTempo() const
{
    return laufTempo;
}

bool Spieler::isVerwundbar( Richtung r ) const
{
    bool verwundbar = 1;
    for( auto e = effekte.getIterator(); e; e++ )
    {
        verwundbar &= e->istSpielerVerwundbar( r );
        if( !verwundbar )
            return 0;
    }
    return 1;
}

bool Spieler::istBeweglich( Richtung r ) const
{
    bool beweglich = 1;
    for( auto e = effekte.getIterator(); e; e++ )
    {
        beweglich &= e->istSpielerBeweglich( r );
        if( !beweglich )
            return 0;
    }
    return 1;
}

bool Spieler::istSichtbar( Team *zTeam ) const
{
    bool sichtbar = 1;
    for( auto e = effekte.getIterator(); e; e++ )
    {
        sichtbar &= e->istSpielerSichtbar( zTeam );
        if( !sichtbar )
            return 0;
    }
    return 1;
}

bool Spieler::istGegenstandErlaubt( GegenstandTyp typ ) const
{
    bool erlaubt = !brauchtRichtung( typ ) || ausrichtung != MITTE;
    for( auto e = effekte.getIterator(); e; e++ )
    {
        erlaubt &= e->istGegenstandErlaubt( typ );
        if( !erlaubt )
            return 0;
    }
    return !inv.hatAbklingzeit( typ );
}

Richtung Spieler::getAusrichtung() const
{
    return ausrichtung;
}

float Spieler::getAbklingZeitVerringerung() const
{
    return abklingZeitVerringerung;
}

int Spieler::getId() const
{
    return spielerNummer;
}

int Spieler::getLevel() const
{
    return level;
}

float Spieler::getLeben() const
{
    return leben;
}

int Spieler::getMaxLeben() const
{
    return maxLeben;
}

float Spieler::getErfahrung() const
{
    return erfahrung;
}

int Spieler::getMaxErfahrung() const
{
    return maxErfahrung;
}

int Spieler::getTode() const
{
    return tode;
}

int Spieler::getKills() const
{
    return kills;
}

int Spieler::getTreffer() const
{
    return treffer;
}

int Spieler::getGetroffen() const
{
    return getroffen;
}

float Spieler::getErlittenerSchaden() const
{
    return schadenGenommen;
}

float Spieler::getGemachterSchaden() const
{
    return schadenGemacht;
}

float Spieler::getGeheiltesLeben() const
{
    return lebenGeheilt;
}

int Spieler::getItemsAufgehoben() const
{
    return itemsAufgehoben;
}

int Spieler::getItemsVerwendet() const
{
    return itemsVerwendet;
}

int Spieler::getItemsInInventory() const
{
    return inv.getItemAnzahl();
}

int Spieler::getItemsInInventory( GegenstandTyp typ ) const
{
    return inv.getItemAnzahl( typ );
}

int Spieler::getTunnelBenutzt() const
{
    return tunnelBenutzt;
}

int Spieler::getSchalterAktiviert() const
{
    return schalterAktiviert;
}

int Spieler::getGeschossen() const
{
    return geschosseGeschossen;
}

GegenstandTyp Spieler::getInventorySlot( int index ) const
{
    return inv.getItemTyp( index );
}

const char *Spieler::getName() const
{
    return name;
}

const Inventar &Spieler::getInventory() const
{
    return inv;
}


bool DeadPlayer::isFinished() const
{
    return 1;
}