Bullet.cpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2024
** rtype (Workspace)
** File description:
** Bullet.cpp
*/
 
#include "GUI/ECS/Online/Bullet.hpp"
 
GUI::ECS::Online::Bullet::Bullet(const std::uint32_t EntityId)
    : EntityNode(EntityId)
{
};
 
GUI::ECS::Online::Bullet::Bullet(const GUI::ECS::Components::SpriteComponent &sprite, const bool fromEnemy, const std::pair<int, int> &positionInitial, const unsigned int speed, const std::pair<int, int> &direction, const int damage)
    : EntityNode(0), _sprite(sprite), _fromEnemy(fromEnemy), _speed(speed), _direction(direction), _positionInitial(positionInitial), _damage(damage)
{
    _createBullet(positionInitial);
};
 
GUI::ECS::Online::Bullet::Bullet(const std::uint32_t EntityId, const GUI::ECS::Components::SpriteComponent &sprite, const bool fromEnemy, const std::pair<int, int> &positionInitial, const unsigned int speed, const std::pair<int, int> &direction, const int damage)
    : EntityNode(EntityId), _sprite(sprite), _fromEnemy(fromEnemy), _speed(speed), _direction(direction), _positionInitial(positionInitial), _damage(damage)
{
    _createBullet(positionInitial);
};
 
GUI::ECS::Online::Bullet::Bullet(const GUI::ECS::Online::Bullet &bullet)
    : EntityNode(0)
{
    update(bullet);
};
 
GUI::ECS::Online::Bullet::Bullet(const std::uint32_t EntityId, const GUI::ECS::Online::Bullet &bullet)
    : EntityNode(EntityId)
{
    update(bullet);
};
 
 
void GUI::ECS::Online::Bullet::setVisible(const bool visible)
{
    _visible = visible;
    _sprite.setVisible(visible);
}
 
void GUI::ECS::Online::Bullet::setPosition(const std::pair<float, float> &pos)
{
    _collision.setPosition(pos);
    _sprite.setPosition(pos);
};
 
void GUI::ECS::Online::Bullet::setSprite(const GUI::ECS::Components::SpriteComponent &sprite)
{
    _sprite.update(sprite);
}
 
void GUI::ECS::Online::Bullet::setEnemy(const bool enemy)
{
    _fromEnemy = enemy;
}
 
void GUI::ECS::Online::Bullet::setSpeed(const unsigned int speed)
{
    _speed = speed;
}
 
void GUI::ECS::Online::Bullet::setDirection(const std::pair<int, int> &direction)
{
    _direction = direction;
}
 
void GUI::ECS::Online::Bullet::setSize(const std::pair<float, float> &dimension)
{
    _collision.setDimension(dimension);
    _sprite.setDimension(dimension);
}
 
void GUI::ECS::Online::Bullet::setDamage(const int damage)
{
    _damage = damage;
}
 
void GUI::ECS::Online::Bullet::tick()
{
    PRETTY_DEBUG << "In the bullet tick function" << std::endl;
    if (!_visible) {
        PRETTY_DEBUG << "The bullet isn't visible" << std::endl;
        return;
    }
    PRETTY_DEBUG << "Checking sprite tick" << std::endl;
    _sprite.checkTick();
    _sprite.forceTick();
    PRETTY_DEBUG << "Sprite has ticked: " << Recoded::myToString(_sprite.hasTicked()) << std::endl;
    PRETTY_DEBUG << "Calculating the new position" << std::endl;
    PRETTY_DEBUG << "Current collision: " << _collision.getPosition() << ", direction: " << _direction << ", speed :" << Recoded::myToString(_speed) << std::endl;
    const float offsetX = (_direction.first * static_cast<int>(_speed));
    const float offsetY = (_direction.second * static_cast<int>(_speed));
    PRETTY_DEBUG << "OffsetX = " << Recoded::myToString(offsetX) << ", offsetY = " << Recoded::myToString(offsetY) << std::endl;
    const float finalPositionX = _collision.getPositionX() + offsetX;
    const float finalPositionY = _collision.getPositionY() + offsetY;
    PRETTY_DEBUG << "finalPositionX = " << finalPositionX << ", finalPositionY = " << finalPositionY << std::endl;
    std::pair<float, float> opt = { finalPositionX,finalPositionY };
    PRETTY_DEBUG << "Bullet tick: initial position: " << getPosition() << ", updated position: " << opt << std::endl;
    setPosition(opt);
    PRETTY_DEBUG << "Position updated" << std::endl;
}
 
const GUI::ECS::Components::SpriteComponent GUI::ECS::Online::Bullet::render()
{
    return _sprite;
};
 
const bool GUI::ECS::Online::Bullet::isVisible() const
{
    return _visible;
}
 
const bool GUI::ECS::Online::Bullet::isEnemy() const
{
    return _fromEnemy;
}
 
const std::pair<float, float> GUI::ECS::Online::Bullet::getPosition() const
{
    return _collision.getPosition();
}
 
 
/*
If needed, check the opposite condition, as if<object> was the target and target the object
( = check isColliding as target with bullet as parameter)
*/
const bool GUI::ECS::Online::Bullet::isColliding(const GUI::ECS::Systems::Collision &second) const
{
    PRETTY_DEBUG << "Enemy Position: X = " << _collision.getPositionX()
        << ", Y = " << _collision.getPositionY()
        << ", Width = " << _collision.getWidth()
        << ", Height = " << _collision.getHeight() << std::endl;
 
    PRETTY_DEBUG << "External entity Position: X = " << second.getPositionX()
        << ", Y = " << second.getPositionY()
        << ", Width = " << second.getWidth()
        << ", Height = " << second.getHeight() << std::endl;
 
 
    PRETTY_DEBUG << "Setting the tolerance for the collision" << std::endl;
    const float tolerance = 30.0f;
    PRETTY_DEBUG << "The tolerance is set to: " << Recoded::myToString(tolerance) << std::endl;
 
    PRETTY_DEBUG << "Calculating the overlap of X" << std::endl;
    const bool xOverlap = (std::abs(_collision.getPositionX() - second.getPositionX()) <= (tolerance + (_collision.getWidth() + second.getWidth())));
    PRETTY_DEBUG << "The X overlap was calculated at: " << Recoded::myToString(xOverlap) << std::endl;
 
    PRETTY_DEBUG << "Calculating the overlap of Y" << std::endl;
    const bool yOverlap = (std::abs(_collision.getPositionY() - second.getPositionY()) <= (tolerance + (_collision.getHeight() + second.getHeight())));
    PRETTY_DEBUG << "The Y overlap was calculated at: " << Recoded::myToString(yOverlap) << std::endl;
 
    PRETTY_DEBUG << "X Overlap: " << Recoded::myToString(xOverlap) << ", Y Overlap: " << Recoded::myToString(yOverlap) << std::endl;
    PRETTY_DEBUG << "Checking if x and y are overlapping" << std::endl;
    const bool overlapping = xOverlap && yOverlap;
    PRETTY_DEBUG << "The result of if x and y are overlapping is: " << Recoded::myToString(overlapping) << std::endl;
    return overlapping;
}
 
void GUI::ECS::Online::Bullet::update(const GUI::ECS::Online::Bullet &copy)
{
    _entityID = copy._entityID;
    _speed = copy.getSpeed();
    _sprite = copy.getSprite();
    _damage = copy.getDamage();
    _visible = copy.isVisible();
    _fromEnemy = copy.isEnemy();
    _direction = copy.getDirection();
    _collision = copy.getCollision();
    _positionInitial = copy.getPositionInitial();
}
 
GUI::ECS::Online::Bullet &GUI::ECS::Online::Bullet::operator =(const GUI::ECS::Online::Bullet &copy)
{
    update(copy);
    return *this;
}
 
const unsigned int GUI::ECS::Online::Bullet::getSpeed() const
{
    return _speed;
}
 
const GUI::ECS::Systems::Collision GUI::ECS::Online::Bullet::getCollision() const
{
    return _collision;
}
 
const GUI::ECS::Components::SpriteComponent GUI::ECS::Online::Bullet::getSprite() const
{
    return _sprite;
}
 
const std::pair<int, int> GUI::ECS::Online::Bullet::getPositionInitial() const
{
    return _positionInitial;
}
 
const int GUI::ECS::Online::Bullet::getDamage() const
{
    return _damage;
}
 
const std::pair<int, int> GUI::ECS::Online::Bullet::getDirection() const
{
    return _direction;
}
 
const std::string GUI::ECS::Online::Bullet::getInfo(const unsigned int indent) const
{
 
    std::string indentation = "";
    for (unsigned int i = 0; i < indent; ++i) {
        indentation += "\t";
    }
    std::string result = indentation + "Bullet:\n";
    result += indentation + "- Entity Id: " + Recoded::myToString(getEntityNodeId()) + "\n";
    result += indentation + "- Damage: '" + Recoded::myToString(_damage) + "'\n";
    result += indentation + "- Visible: '" + Recoded::myToString(_visible) + "'\n";
    result += indentation + "- From Enemy: '" + Recoded::myToString(_fromEnemy) + "'\n";
    result += indentation + "- Speed: '" + Recoded::myToString(_speed) + "'\n";
    result += indentation + "- Direction: '" + Recoded::myToString(_direction) + "'\n";
    result += indentation + "- Position Initial: '" + Recoded::myToString(_positionInitial) + "'\n";
    result += indentation + "- Collision: {\n" + _collision.getInfo(indent + 1) + indentation + "}\n";
    result += indentation + "- Sprite: {\n" + _sprite.getInfo(indent + 1) + indentation + "}\n";
 
    return result;
}
 
void GUI::ECS::Online::Bullet::_createBullet(const std::pair<int, int> &positionInitial)
{
    _sprite.setPosition(positionInitial);
    _collision.setPosition(positionInitial);
    _collision.setDimension(_sprite.getSpritesheet().getCollisionInfo().getDimension());
}
 
std::ostream &GUI::ECS::Online::operator<<(std::ostream &os, const GUI::ECS::Online::Bullet &item)
{
    os << item.getInfo();
    return os;
}