Przekazywanie efektu naboju do przeciwnika

#pragma once

#include "Item.hpp"

class Weapon
    : public Item
{
public:
    Weapon( std::string data, TextureManager & textureManager );
    void update( sf::Time dt );
    void useItem( Statistic & statistic );
   
private:
    int speed;
    int damage, currentDamage;
    bool collision;
    float criticalAttack;
   
    sf::Vector2i bRect, bTileSize;
   
    sf::Clock game_clock;
    sf::Time shot_delay;
    sf::Time last_fire_timestamp;
};

statistic.bullet.emplace_back( new NormalBullet( statistic.playerPosition, statistic.mousePosition, speed, currentDamage, collision,
bRect, bTileSize, effectData, textureManager ) );

#pragma once

#include <SFML\Graphics.hpp>
#include "TextureManager.hpp"

#define _USE_MATH_DEFINES
#include <math.h>

class Bullet
    : public sf::Drawable
{
public:
    Bullet();
   
    virtual void update( sf::Time dt );
    void draw( sf::RenderTarget & target, sf::RenderStates states ) const;
   
    void setIsActive( bool isActive );
    bool getIsActive();
    bool getCollision();
   
    sf::FloatRect getGlobalBounds();
    int getDamage();
protected:
    int setItems( std::string & item );
   
    sf::Sprite sprite;
   
    int damage;
    int speed;
    bool collision;
    sf::Vector2f direction;
    float angle;
   
    bool isActive;
};

#pragma once

#include "Entity.hpp"
#include "Bullet.hpp"

#include "Animation.hpp"
#include "SpriteSheetAnimation.hpp"

class Player
    : public Entity
{
public:
    void draw( sf::RenderTarget & target, sf::RenderStates states ) const;
    Player( std::string data, TextureManager & textureManager );
    void update( sf::Time dt, Cursor & cursor );
    void handleEvent( sf::Event & event );
    void checkCollision( Entity & entity );
   
    void takeItem( std::vector < std::unique_ptr < Item > > & item );
    void dropItem( std::vector < std::unique_ptr < Item > > & item );
private:
    bool inventoryIsOpen;
};

void Player::checkCollision( Entity & entity )
{
    for( int i = 0; i < entity.statistic.bullet.size(); i++ )
    if( entity.statistic.bullet[ i ]->getGlobalBounds().intersects( sprite.getGlobalBounds() ) )
    {
        statistic.currentHitPoints -= entity.statistic.bullet[ i ]->getDamage();
       
        entity.statistic.bullet[ i ]->setIsActive( false );
       
        showHitPointsBar = true;
        isDamaged = true;
    }
}

#pragma once

#include <SFML\Graphics.hpp>
#include <memory>
#include "Bullet.hpp"

class Statistic
{
public:
    sf::Vector2f velocity, mousePosition, playerPosition;
    float moveSpeed;
    int jumpAmount, currentJumpAmount;
    float jumpSpeed, currentJumpSpeed, jumpAcceleration;
    float currentFallSpeed, maxFallSpeed, fallSpeed, fallAcceleration;
   
    bool falling, ableToJump, jumping, onGround;
    bool collision;
   
    int collisionDamage;
    float currentHitPoints, maxHitPoints;
    bool isDead;
   
    float fireProtection, poisonProtection;
   
    std::vector < std::shared_ptr < Bullet > > bullet;
};

void Effect::update( sf::Time dt, Statistic & statistic )

void ElementalEffect::update( sf::Time dt, Statistic & statistic )
{
    float currentDamage = damage;
    sf::Time now = clock.getElapsedTime();
   
    if( duration <= now ) isActive = false;
   
    if( isActive )
    if(( now - last_timestamp ) >= delay )
    switch( elementalEffectType )
    {
    case Fire:
        {
            if( statistic.fireProtection >= 0 )
            {
                currentDamage =( 100 /( 100 + statistic.fireProtection ) ) * damage;
                statistic.currentHitPoints -= currentDamage;
            }
            else
                 statistic.currentHitPoints -= currentDamage;
           
            damageEffect.emplace_back( new DamageEffect( currentDamage, sf::Color::Red, statistic.playerPosition ) );
            last_timestamp = now;
            break;
        }
    case Poison:
        {
            if( statistic.poisonProtection >= 0 )
            {
                currentDamage =( 100 /( 100 + statistic.poisonProtection ) ) * damage;
                statistic.currentHitPoints -= currentDamage;
            }
            else
                 statistic.currentHitPoints -= currentDamage;
           
            damageEffect.emplace_back( new DamageEffect( currentDamage, sf::Color::Green, statistic.playerPosition ) );
            last_timestamp = now;
            break;
        }
    }
   
    for( int i = 0; i < damageEffect.size(); i++ )
         damageEffect[ i ]->update( dt );
   
    for( int i = 0; i < damageEffect.size(); i++ )
    if( !damageEffect[ i ]->getIsActive() )
         damageEffect.erase( damageEffect.begin() + i );
   
}

statistic.bullet.emplace_back( new NormalBullet( /*...*/ ) );