public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}

public class BulletEnhancedAttributeLogic {
    private float baseDamage = 10.0f;
    private float penetration = 0.0f;
    private float speed = 300.0f;
    private float range = 200.0f;
    private float criticalChance = 0.1f;
    
    private float damageBoost = 0.3f;
    private float penetrationBoost = 0.2f;
    private float speedBoost = 0.15f;
    private float rangeBoost = 0.25f;
    private float criticalChanceBoost = 0.08f;
    private float criticalDamageMultiplier = 2.0f;
    
    private boolean isArmorPiercing = false;
    private boolean isIncendiary = false;
    
    public void initializeEnhancements() {
        applyBaseEnhancements();
    }
    
    private void applyBaseEnhancements() {
        baseDamage *= (1 + damageBoost);
        penetration += penetrationBoost;
        speed *= (1 + speedBoost);
        range *= (1 + rangeBoost);
        criticalChance += criticalChanceBoost;
    }
    
    public float calculateDamage(boolean isCritical, boolean enemyHasArmor) {
        float damage = baseDamage;
        if (isCritical) {
            damage *= criticalDamageMultiplier;
        }
        if (isArmorPiercing && enemyHasArmor) {
            damage *= (1 + penetration);
        }
        if (isIncendiary) {
            damage += baseDamage * 0.2f;
        }
        return damage;
    }
    
    public float getEffectiveRange() {
        return range;
    }
    
    public float getBulletSpeed() {
        return speed;
    }
    
    public boolean checkCriticalHit() {
        return Math.random() < criticalChance;
    }
    
    public void setArmorPiercing(boolean state) {
        isArmorPiercing = state;
    }
    
    public void setIncendiary(boolean state) {
        isIncendiary = state;
    }
    
    public void setCriticalDamageMultiplier(float multiplier) {
        criticalDamageMultiplier = multiplier;
    }
}
