Fangen-Minigame/Fangen/Spieler.cpp

#include "Spieler.h"
#include <math.h>
#include <TastaturEreignis.h>
#include <Globals.h>

// Inhalt der Spieler Klasse aus Spieler.h
// Konstruktor
Spieler::Spieler( SpielerTyp typ, int mapBr, int mapHö, RandomGenerator *zRand )
{
    if( typ == GEGNER )
    {
        xSpeed = ( ( zRand->rand() * 8001 ) / 1000.0 - 4.0 ) * 60;
        ySpeed = ( ( zRand->rand() * 8001 ) / 1000.0 - 4.0 ) * 60;
        durchlässig = 3;
        farbe = 0xFFFF0000;
    }
    if( typ == ZIEL )
    {
        xSpeed = ( ( zRand->rand() * 7001 ) / 1000.0 - 4.0 ) * 60;
        ySpeed = ( ( zRand->rand() * 7001 ) / 1000.0 - 4.0 ) * 60;
        durchlässig = 3;
        farbe = 0xFF00FFFF;
    }
    if( typ == SPIELER )
    {
        xSpeed = 0;
        ySpeed = 0;
        farbe = 0xFF00FF00;
        durchlässig = 0;
    }
    xPos = ( zRand->rand() * ( mapBr - 100 ) ) + 50;
    yPos = ( zRand->rand() * ( mapHö - 100 ) ) + 50;
    ref = 1;
}

Spieler::Spieler( SpielerTyp typ, Datei *zD )
{
    if( typ == GEGNER )
        farbe = 0xFFFF0000;
    if( typ == ZIEL )
        farbe = 0xFF00FFFF;
    if( typ == SPIELER )
        farbe = 0xFF00FF00;
    zD->lese( (char*)&xPos, 8 );
    zD->lese( (char*)&yPos, 8 );
    zD->lese( (char*)&xSpeed, 8 );
    zD->lese( (char*)&ySpeed, 8 );
    zD->lese( (char*)&durchlässig, 8 );
    ref = 1;
}

Spieler::Spieler()
{
    ref = 1;
}

// Destruktor
Spieler::~Spieler()
{}

// nicht constant
void Spieler::tick( double z, int mapBr, int mapHö, char tastenStände )
{
    if( farbe == 0xFF00FF00 )
    {
        if( ( tastenStände | 4 ) == tastenStände )
            xPos -= 150 * z;
        if( ( tastenStände | 2 ) == tastenStände )
            xPos += 150 * z;
        if( ( tastenStände | 1 ) == tastenStände )
            yPos -= 150 * z;
        if( ( tastenStände | 8 ) == tastenStände )
            yPos += 150 * z;
    }
    if( durchlässig )
    {
        durchlässig -= z;
        if( durchlässig < 0 )
            durchlässig = 0;
    }
    xPos += xSpeed * z;
    yPos += ySpeed * z;
    if( xPos < 10 )
    {
        xPos = 10;
        xSpeed = -xSpeed;
    }
    else if( xPos > mapBr - 10 )
    {
        xPos = mapBr - 10;
        xSpeed = -xSpeed;
    }
    if( yPos < 10 )
    {
        yPos = 10;
        ySpeed = -ySpeed;
    }
    else if( yPos > mapHö - 10 )
    {
        yPos = mapHö - 10;
        ySpeed = -ySpeed;
    }
}

void Spieler::render( Bild &zRObj )
{
    if( !durchlässig || (int)( durchlässig * 8 ) % 2 )
    {
        zRObj.drawKreis( (int)xPos, (int)yPos, 10, farbe );
        zRObj.drawKreis( (int)xPos - 3, (int)yPos - 3, 2, farbe );
        zRObj.drawKreis( (int)xPos + 3, (int)yPos - 3, 2, farbe );
        zRObj.drawLinieV( (int)xPos, (int)yPos - 1, 4, farbe );
        zRObj.drawLinieH( (int)xPos - 3, (int)yPos + 5, 6, farbe );
    }
}

// constant
bool Spieler::berührt( double px, double py ) const
{
    return !durchlässig && sqrt( (double)( px - xPos ) * ( px - xPos ) + ( py - yPos ) * ( py - yPos ) ) <= 20;
}

int Spieler::getX() const
{
    return (int)xPos;
}

int Spieler::getY() const
{
    return (int)yPos;
}

float Spieler::getXSpeed() const
{
    return xSpeed;
}

float Spieler::getYSpeed() const
{
    return ySpeed;
}

void Spieler::save( Datei *zD ) const
{
    zD->schreibe( (char*)&xPos, 8 );
    zD->schreibe( (char*)&yPos, 8 );
    zD->schreibe( (char*)&xSpeed, 8 );
    zD->schreibe( (char*)&ySpeed, 8 );
    zD->schreibe( (char*)&durchlässig, 8 );
}

Spieler *Spieler::copy() const
{
    Spieler *ret = new Spieler();
    ret->xPos = xPos;
    ret->yPos = yPos;
    ret->xSpeed = xSpeed;
    ret->ySpeed = ySpeed;
    ret->durchlässig = durchlässig;
    ret->farbe = farbe;
    return ret;
}

// Reference Counting
Spieler *Spieler::getThis()
{
    ref++;
    return this;
}

Spieler *Spieler::release()
{
    ref--;
    if( !ref )
        delete this;
    return 0;
}