"X must implement the inherited pure virtual method Y"
===

I am attempting to implement an interface in C++ for a game that I am writing and I am running in an error.

Here is the interface and its subclass that I created: 

    //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;
    		}
    
    
    };

Here is the subclass :

    /*
     * 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;
    		}
    };







The error being returned from the compiler is :
The type 'Attack' must implement the inherited pure virtual method 'Attack::calculate_damage' 

Does anyone know the correct syntax for this? Do I have the inheritance setup correctly?
