Enemy.cpp

#include "Enemy.hpp"
#include "Level.hpp"
#include "Enemyprojectile.hpp"
//WeberMa73121: implementation enum direction dir replaces int direcion---------------------------------------
//Hauerch71498 ----------------------------------------------------------------------------------------------
Enemy::Enemy(int health,float x, float y, enum direction dir, int animationstep)
{
    this->hitpoints = health;
    this->topleft = { x, y };
    this->dir = dir;
    this->animationstep = animationstep;
}

void Enemy::shoot(Level &level)
{
    const auto &sprite = this->getSprite();
    if(timetillreload<0)
    {
        switch ( this->dir ) {
        case direction::FRONT: //Up
        {
            level.addEnemyProjectile({this->topleft.X+sprite.w()/2-1,this->topleft.Y+sprite.h()/2,dir});
            break;
        }
        case direction::LEFT: //left
            level.addEnemyProjectile({this->topleft.X,this->topleft.Y+sprite.h()/2,dir});
            break;
        case direction::RIGHT: //right
            level.addEnemyProjectile({this->topleft.X+sprite.w(),this->topleft.Y+sprite.h()/2,dir});
            break;
        default: //Down
            level.addEnemyProjectile({this->topleft.X+sprite.w()/2-1,this->topleft.Y,dir});
            break;
        }
        timetillreload = 5;
    }
};

void Enemy::move(
    [[maybe_unused]] FloatSeconds const & Frametime,
    [[maybe_unused]] Level &level
)
{

};

bool Enemy::lookup(float PlayerY, Level &level)
{
    if(this->topleft.Y > PlayerY)
    {
        int i = static_cast<int>(this->topleft.Y-(this->getSprite().h()/2));
        i = i-static_cast<int>(PlayerY);
        if(level.checkCollision(this->topleft.X, this->topleft.Y+(this->getSprite().h()/2)+i, i, 1))
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    else
    {
        return false;
    }
};
bool Enemy::lookdown(float PlayerY, Level &level)
{
    if(this->topleft.Y < PlayerY)
    {
        int i = static_cast<int>(this->topleft.Y+(this->getSprite().h()/2));
        i = static_cast<int>(PlayerY)-i;
        if(level.checkCollision(this->topleft.X, this->topleft.Y+(this->getSprite().h()/2), i, 1))
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    else
    {
        return false;
    }
};
bool Enemy::lookleft(float PlayerX, Level &level)
{
    if(this->topleft.X > PlayerX)
    {
        int i = static_cast<int>(this->topleft.X-(this->getSprite().w()/2));
        i = i-static_cast<int>(PlayerX);
        if(level.checkCollision(this->topleft.X-(this->getSprite().w()/2)-i, this->topleft.Y, i, 1))
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    else
    {
        return false;
    }
};
bool Enemy::lookright(float PlayerX, Level &level)
{
    if(this->topleft.X < PlayerX)
    {
        int i = static_cast<int>(this->topleft.X+(this->getSprite().w()/2));
        i = static_cast<int>(PlayerX)-i;
        if(level.checkCollision(this->topleft.X-(this->getSprite().w()/2), this->topleft.Y, i, 1))
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    else
    {
        return false;
    }
};

bool Enemy::lookAtPlayer(float PlayerX, float PlayerY, Level &level)
{
    switch (dir) {
    case direction::BACK: //back
        return lookup(PlayerY, level);
        break;
    case direction::LEFT: //left
        return lookleft(PlayerX, level);

        break;
    case direction::RIGHT: //right
        return lookright(PlayerX, level);
        break;
    default:
        return lookdown(PlayerY, level);
        break;
    }
}

bool Enemy::playerdetected(float PlayerX, float PlayerY, Level &level)
{
        if(abs(this->topleft.X - PlayerX) < 20) //buffer of 5
        {
            if(lookdown(PlayerY, level))
            {
                dir = direction::FRONT;
                return true;
            }
            else if(lookup(PlayerY, level))
            {
                dir = direction::BACK;
                return true;
            }
            else
            {
                return false;
            }
        }
        else if(abs(this->topleft.Y - PlayerY) < 20) //buffer of 5
        {
            if(lookleft(PlayerX, level))
            {
                dir = direction::LEFT;
                return true;
            }
            else if(lookright(PlayerX, level))
            {
                dir = direction::RIGHT;
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
};