Space Defender: Enemy Ship

//---------------------------
// Includes
//---------------------------
#include "EnemyShip.h"

//---------------------------
// Defines
//---------------------------
#define GAME_ENGINE (GameEngine::GetSingleton())
Bitmap* EnemyShip::m_BmpShipPtr=nullptr;
//---------------------------
// Constructor & Destructor
//---------------------------
EnemyShip::EnemyShip(DOUBLE2 middlePoint, int radius, double angleCircle):m_MiddlePoint(middlePoint),m_Radius(radius),m_AngleCircle(angleCircle),m_PlayerIsSeen(false),m_BackToRightAngle(true),m_BulletTimer(0)
{
    if(m_BmpShipPtr==nullptr)
    {
        m_BmpShipPtr= new Bitmap("./Resources/EnemyShip.png");
        if(m_BmpShipPtr->Exists())
        {
            m_BmpShipPtr->SetTransparencyColor(255,0,255);
        }
    }
    for (int i = 0; i < AMOUNTOFBULLETS; i++)
    {
        m_BulletPtrArr[i]=new Bullet();
    }

    // nothing to create
}

EnemyShip::~EnemyShip()
{
    for (int i = 0; i < AMOUNTOFBULLETS; i++)
    {
        delete m_BulletPtrArr[i];
    }
    // nothing to destroy
}

//---------------------------
// Own methods
//---------------------------

void EnemyShip::Tick(double deltaTime,DOUBLE2 playerCoordinates)
{
    //Explosion animation
    if(m_IsExploding)
    {
        m_Angle+=0.03*deltaTime;
        m_DoesBoem-=deltaTime;
        if(m_DoesBoem<=0)
        {
            m_IsExploding=false;
            m_Activated=false;
        }
    }
    else if(m_Activated)
    {
        //Shoot if player is seen
        if(m_PlayerIsSeen)
        {
            if(m_BulletTimer<=0&&rand()%RANDOMSHOOTCHANCE==0)
            {
                FireBullet();
            }
            m_BulletTimer-=deltaTime;
        }

        //Check if player is in range to shoot
        PlayerInRadius(playerCoordinates);


        //Rotating back
        if(!m_BackToRightAngle&&!m_PlayerIsSeen)
        {
            double expectedAngle,givenAngle;
            int expectedAngleInt,givenAngleInt;
            expectedAngle=(m_AngleCircle+(1.000*(M_PI/2)));
            givenAngle=m_Angle;

            expectedAngleInt=(int)(expectedAngle*180/(M_PI));
            givenAngleInt=(int)(givenAngle*180/(M_PI));
            expectedAngleInt=expectedAngleInt%360;
            givenAngleInt=givenAngleInt%360;

            int deltaAngle=(expectedAngleInt-givenAngleInt);
            if(abs(deltaAngle)<LOWANGLE||abs(deltaAngle)>HIGHANGLE)
            {
                m_Angle=m_AngleCircle+(1.000*(M_PI/2));
                m_BackToRightAngle=true;
            }
            else
            {
                m_Angle-=(2*M_PI*deltaTime);
            }
        }

        //Fly around
        if(!m_PlayerIsSeen&&m_BackToRightAngle)
        {
            m_AngleCircle+=deltaTime*(1.000*DELTADISTANCE/m_Radius);
            m_Coordinates.x=m_MiddlePoint.x+m_Radius*cos(m_AngleCircle);
            m_Coordinates.y=m_MiddlePoint.y+m_Radius*sin(m_AngleCircle);

            m_Angle=m_AngleCircle+(1.000*(M_PI/2));
        }
    }

    //Tick for active bullets
    for (int i = 0; i < AMOUNTOFBULLETS; i++)
    {
        m_BulletPtrArr[i]->Tick(deltaTime);
    }
}

void EnemyShip::Paint()
{
    RECT ANIMATION;
    ANIMATION.left=0;
    ANIMATION.top=0;
    ANIMATION.right=ANIMATION.left+SIZE;
    ANIMATION.bottom=ANIMATION.top+SIZE;
    if(m_IsExploding)
    {
        double opacity=1;
        opacity=1.000*m_DoesBoem/(EXPLOSIONDURATION*0.1);
        if (opacity<0.1)opacity=0.1;

        ANIMATION.left=SIZE;
        ANIMATION.top=0;
        ANIMATION.right=ANIMATION.left+SIZE;
        ANIMATION.bottom=ANIMATION.top+SIZE;

        m_BmpShipPtr->SetOpacity(opacity/4);
        GAME_ENGINE->DrawBitmap(m_BmpShipPtr,-SIZE/2,-SIZE/2,ANIMATION);

        m_BmpShipPtr->SetOpacity(1);

        if(m_ShowExplosion)
        {
            ExplosionPaint(opacity);
        }
    }
    else GAME_ENGINE->DrawBitmap(m_BmpShipPtr,-SIZE/2,-SIZE/2,ANIMATION);
}

//Check if player is in range
void EnemyShip::PlayerInRadius(DOUBLE2 playerCoordinates)
{
    DOUBLE2 distance=(playerCoordinates-m_Coordinates);
    if(((distance).Length())<WATCHRADIUS)
    {
        DOUBLE2 basic(1,0);
        m_PlayerIsSeen=true;

        m_Angle=basic.AngleWith(distance);

        m_BackToRightAngle=false;
    }
    else if(m_PlayerIsSeen)
    {
        if(((distance).Length())>WATCHRADIUS+EXTRAWATCH)
        {
            m_PlayerIsSeen=false;

        }
    }
    else m_PlayerIsSeen=false;
}

void EnemyShip::Move(DOUBLE2 middleCoordinates,int radius)
{
    m_MiddlePoint=middleCoordinates;
    m_Radius=radius;
}

void EnemyShip::BulletPaint()
{
        m_BulletPtrArr[0]->Paint();
}

bool EnemyShip::FireBullet()
{
    for (int i = 0; i < AMOUNTOFBULLETS; i++)
    {
        if(!m_BulletPtrArr[i]->IsActivated())
        {
            DOUBLE2 coordinates(m_Coordinates);
            coordinates.x+=HITRADIUS*cos(m_Angle);
            coordinates.y+=HITRADIUS*sin(m_Angle);
            m_BulletPtrArr[i]->Fire(m_Angle,coordinates);
            m_BulletTimer=1;
            return true;
        }
    }
    return false;
}

void EnemyShip::HitDetectionBullet(HitRegion * level)
{
    for (int i = 0; i < AMOUNTOFBULLETS; i++)
    {
        if(m_BulletPtrArr[i]->IsActivated())
        {
            DOUBLE2 bulletCoordinate=m_BulletPtrArr[i]->GetCoordinates();
            if(level->HitTest(bulletCoordinate))
            {
                m_BulletPtrArr[i]->Hits();
            }
        }
    }
}

DOUBLE2 EnemyShip::GetHitMiddlePoints(int i)
{
    DOUBLE2 coordinates=m_Coordinates;
    switch (i)
    {
        case 0:
            coordinates.x+=HITXONE;
            break;
        case 1:
            coordinates.x+=-HITXTWO;

            coordinates.y+=-HITYONE;
            break;
        case 2:
            coordinates.x+=-HITXTWO;

            coordinates.y+=HITYONE;
            break;
    default:
        break;

    }
    return coordinates;
}

int EnemyShip::GetHitRadius(bool sub)
{
    if(sub)
    {
        return HITRADIUS;
    }
    else return HITRADIUSSUB;
}

void EnemyShip::BulletHits(int i)
{
    m_BulletPtrArr[i]->Hits();
}

void EnemyShip::Reset()
{
    m_Activated=true;
    m_IsExploding=false;
    m_DoesBoem=0;

    for (int i = 0; i < AMOUNTOFBULLETS; i++)
    {
        m_BulletPtrArr[i]->Hits();
    }
}

bool EnemyShip::CheckHitAttackRocket(DOUBLE2 *pointArr, int AmountPoints)
{
    if(!CanHit())return false;


    for (int i = 0; i < AmountPoints; i++)
    {
        if((HITRADIUS)>=(m_Coordinates-pointArr[i]).Length())
        {
            DOUBLE2 subPointsArr[AMOUNTSUBPOINTS];
            for (int m = 0; m < AMOUNTSUBPOINTS; m++)
            {
                subPointsArr[m].x=0;
                subPointsArr[m].y=0;
            }
            subPointsArr[0].x+=HITXONE;
            subPointsArr[1].x+=-HITXTWO;
            subPointsArr[1].y+=-HITYONE;
            subPointsArr[2].x+=-HITXTWO;
            subPointsArr[2].y+=HITYONE;
            PointRelocator(subPointsArr,AMOUNTSUBPOINTS);

            for (int m = 0; m < AMOUNTSUBPOINTS; m++)
            {
                if((HITRADIUSSUB)>=(subPointsArr[m]-pointArr[i]).Length())
                {
                    return true;
                }
            }
        }
    }
    return false;
}

//Transform points
void EnemyShip::PointRelocator(DOUBLE2 *pointArr, int AmountPoints)
{
    MATRIX3X2 matTranslate, matRotate, matWorldTransform;
    matTranslate.SetAsTranslate(m_Coordinates);
    matRotate.SetAsRotate(m_Angle);
    matWorldTransform=matRotate*matTranslate;
    for (int i = 0; i < AmountPoints; i++)
    {
        pointArr[i]=matWorldTransform.TransformPoint(pointArr[i]);
    }
}

void EnemyShip::CheckHitExplosion(DOUBLE2 explosionCoordinate, double explosionRadius)
{
    if(CanHit())
    {
        if((HITRADIUS+explosionRadius)>=(m_Coordinates-explosionCoordinate).Length())
        {
            SetDestroyed();
        }
    }
    for (int i = 0; i < AMOUNTOFBULLETS; i++)
    {
        if(m_BulletPtrArr[i]->IsActivated())
        {
            DOUBLE2 bulletCoordinate=m_BulletPtrArr[i]->GetCoordinates();
            if((explosionRadius)>=(bulletCoordinate-explosionCoordinate).Length())
            {
                m_BulletPtrArr[i]->Hits();
            }
        }
    }
}

void EnemyShip::BulletsHit(bool* booleanArr, int lengthArr)
{
    if(lengthArr<=AMOUNTOFBULLETS)
    {
        for (int i = 0; i < AMOUNTOFBULLETS; i++)
        {
            if(booleanArr[i])m_BulletPtrArr[i]->Hits();
        }
    }
}

int EnemyShip::SendOutBullets(DOUBLE2* emptyArr,bool* booleanArr, int lengthArr,bool andAngle, double *angleArr)
{
    if(lengthArr<AMOUNTOFBULLETS)
    {
        return 0;
    }
    for (int i = 0; i < lengthArr; i++)
    {
        booleanArr[i]=false;
    }
    for (int i = 0; i < AMOUNTOFBULLETS; i++)
    {
        if(m_BulletPtrArr[i]->IsActivated())
        {
            emptyArr[i]=m_BulletPtrArr[i]->GetCoordinates();
            booleanArr[i]=true;
        }
        if(andAngle)
        {
            angleArr[i]=m_BulletPtrArr[i]->GetAngle();
        }
    }
    return AMOUNTOFBULLETS;
}