BulletManager.cpp

#include "BulletManager.hpp"
#include "TilesheetManager.hpp"
#include <algorithm>
#include <box2d/b2_math.h>

namespace game
{

BulletManager::BulletManager(b2World *world, TilesheetManager &tilesheetManager, lvl::Level &level)
    : m_world(world), m_tilesheetManager(tilesheetManager), m_level(level)
{
}

BulletManager::~BulletManager()
{

    for (BulletObject *toBeDeleted : m_player_projectiles)
    {
        delete toBeDeleted;
    }

    for (BulletObject *toBeDeleted : m_enemy_projectiles)
    {
        delete toBeDeleted;
    }
}

void BulletManager::addPlayerProjectile(const b2Vec2 &player_position, const b2Vec2 &impulse)
{
    BulletObject *new_projectile =
        new BulletObject(m_world, player_position, b2Vec2(8.0f, 8.0f), 0.1f, m_tilesheetManager.getGameScale(), 0.0f,
                         std::vector<int>{361, 362, 363, 364, 365, 366, 367});
    new_projectile->ApplyLinearImpulse(impulse);
    new_projectile->getBody()->GetUserData().pointer = 1; // 1 = PlayerBullet (idenfier for contact listener)
    m_player_projectiles.emplace_back(new_projectile);
}

void BulletManager::addEnemyProjectile(const b2Vec2 &playerPosition, const b2Vec2 &enemy_position,
                                       const b2Vec2 &enemy_size, const float amplify_velocity)
{
    b2Vec2 impulse = playerPosition - enemy_position;
    impulse.Normalize();
    // offset the enemy position to avoid self collision
    b2Vec2 offset_position = enemy_position + enemy_size.x * impulse; // enemy_size.x is valid due to square hitbox
    impulse *= amplify_velocity;
    BulletObject *new_projectile =
        new BulletObject(m_world, offset_position, b2Vec2(8.0f, 8.0f), 0.1f, m_tilesheetManager.getGameScale(), 0.0f,
                         std::vector<int>{352, 353, 354, 355});
    new_projectile->ApplyLinearImpulse(impulse);
    new_projectile->getBody()->GetUserData().pointer = 3; // 3 = 'EnemyBullet (idenfier for contact listener)
    m_enemy_projectiles.emplace_back(new_projectile);
}

void BulletManager::removeObsoleteProjectiles(std::vector<b2Body *> playerBulletsToDestroy,
                                              std::vector<b2Body *> enemyBulletsToDestroy)
{
    // delete all player bullets
    for (b2Body *toBeDeleted : playerBulletsToDestroy)
    {
        for (BulletObject *bullet : m_player_projectiles)
        {
            if (bullet->getBody() == toBeDeleted)
            {
                delete bullet;
                m_player_projectiles.erase(
                    std::remove(m_player_projectiles.begin(), m_player_projectiles.end(), bullet),
                    m_player_projectiles.end());
                break;
            }
        }
    }

    // delete all enemy bullets
    for (b2Body *toBeDeleted : enemyBulletsToDestroy)
    {
        for (BulletObject *bullet : m_enemy_projectiles)
        {
            if (bullet->getBody() == toBeDeleted)
            {
                delete bullet;
                m_enemy_projectiles.erase(std::remove(m_enemy_projectiles.begin(), m_enemy_projectiles.end(), bullet),
                                          m_enemy_projectiles.end());
                break;
            }
        }
    }
}

void BulletManager::render(const Camera &camera) const
{

    for (BulletObject *bullet : m_player_projectiles)
    {
        bullet->render(m_tilesheetManager, camera);
    }

    for (BulletObject *bullet : m_enemy_projectiles)
    {
        bullet->render(m_tilesheetManager, camera);
    }
}

void BulletManager::cleanup()
{
    for (BulletObject *toBeDeleted : m_player_projectiles)
    {
        delete toBeDeleted;
    }

    for (BulletObject *toBeDeleted : m_enemy_projectiles)
    {
        delete toBeDeleted;
    }
    m_player_projectiles.clear();
    m_enemy_projectiles.clear();
}

}