Кажется, я переопределил виртуальный метод, но все равно получаю :«X должен реализовать унаследованный чисто виртуальный метод Y»

Я пытаюсь реализовать интерфейс на С++ для игры, которую я пишу, и я запускаю ошибку.

Вот интерфейс и его подкласс, который я создал:

//Attack.h
//defines a set of values associated with all attacks
//and an interface for all attacks
typedef unsigned const int attack_type;
typedef unsigned const int p_attack_type;
//defines the attack types
static const attack_type NORMAL = 0;
static const attack_type ADDER = 1;
static const attack_type MULTIPLIER = 2;
static const attack_type AREA_OF_EFFECT = 3;
static const attack_type DAMAGE_OVER_TIME = 4;
static const attack_type STATUS = 5;

//String representation of the names of attack types
static std::string attack_types [] = {"Normal","Adder","Multiplier","Area-Of-Effect","Damage-Over-Time","Status"};

class Attack
{
    protected:
        std::string attack_name;//the name of this attack
        attack_type type;//the type of attack this represents
        int cool_down_turns;//represents the number of turns this ability cannot be used after being used
        bool causesGlobalCooldown;//does this attack cause ALL abilities to cooldown -- during combat should force cooldown on everything
        bool on_cool_down;

    public:
        Attack(std::string name, attack_type, int cooldown_t, bool causesGlobalCooldown = false)
        {
            this->attack_name = name;
            this->type = attack_type;
            this->causesGlobalCooldown = causesGlobalCooldown;//whether or not ALL abilities need to cooldown
            this->cool_down_turns = cooldown_t;//amount of turns that cooldown occurs
            this->on_cool_down = false;//whether or not this attack is on cooldown
        }

        //the main method called to perform this attack
        //calculate damage, calculate cooldown -- for spells calculate cost
        //return the amount of damage this attack does
        virtual int do_attack(int modifier, int roll)
        {
            //calculate damage
            int damage = calculate_damage(modifier,roll);
            //check cooldown
            if(this->cool_down_turns>0)
            {
                this->cooldown(true);
            }
            return damage;
        }

        //defined by sub classes -- useful to tell you how much damage the attack is going to do
        virtual int calculate_damage(int modifier, int roll) = 0;

        //**standard method definitions**//

        //get the attack name
        std::string get_attack_name() const
        {
            return this->attack_name;
        }

        //get the attack type
        attack_type get_attack_type() const
        {
            return this->type;
        }

        //get the attack type name of this attack
        std::string get_attack_type_name() const
        {
            return attack_types[this->type];
        }

        //check the cooldown status of this attack
        bool cooldown() const
        {
            return on_cool_down;
        }

        //set the cooldown status of this attack
        void cooldown(bool set)
        {
            this->on_cool_down = set;
        }


};

Вот подкласс:

/*
 * Normal.cpp
 *
 *  Created on: Jul 15, 2012
 *      Author: christian
 *      Standard Definition of a Normal attack
 */
#include "Attack.h"

class Normal : public Attack
{
    public:

        Normal(std::string name)
        {
            Attack(name,NORMAL);
        }

        int calculate_damage(int modifier, int roll) const
        {
            return roll + modifier;
        }
};

Компилятор возвращает ошибку :. Тип «Атака» должен реализовывать унаследованный чисто виртуальный метод «Атака ::вычислить _урон»

. Кто-нибудь знает правильный синтаксис для этого? Правильно ли я настроил наследование?