diff --git a/constructors.js b/constructors.js
index d0bf11a..b0dba99 100644
--- a/constructors.js
+++ b/constructors.js
@@ -10,7 +10,11 @@
  * @property {string} description
  * @method   printDetails
  */
-
+  function Spell (name, cost, description) {
+    this.name = name;
+    this.cost = cost;
+    this.description = description;
+  }
   /**
    * Returns a string of all of the spell's details.
    * The format doesn't matter, as long as it contains the spell name, cost, and description.
@@ -19,6 +23,9 @@
    * @return {string} details containing all of the spells information.
    */
 
+  Spell.prototype.getDetails = function () {
+    return this.name + ", " + this.cost + ", " + this.description;
+  };
 /**
  * A spell that deals damage.
  * We want to keep this code DRY (Don't Repeat Yourself).
@@ -43,6 +50,15 @@
  * @property {number} damage
  * @property {string} description
  */
+function DamageSpell (name, cost, damage, description) {
+  Spell.call(this, name, cost, description);
+  this.damage = damage;
+}
+DamageSpell.prototype = Object.create(Spell.prototype, {
+  constructor: {
+    value: DamageSpell
+  }
+});
 
 /**
  * Now that you've created some spells, let's create
@@ -60,6 +76,14 @@
  * @method  spendMana
  * @method  invoke
  */
+function Spellcaster (name, health, mana) {
+  this.name = name;
+  this.health = health;
+  this.mana = mana;
+  this.isAlive = true;
+}
+
+
 
   /**
    * @method inflictDamage
@@ -72,6 +96,14 @@
    * @param  {number} damage  Amount of damage to deal to the spellcaster
    */
 
+Spellcaster.prototype.inflictDamage = function (damage){
+
+  this.health -= damage; //x = x - y
+  if (this.health <= 0) {
+    this.health = 0;
+    this.isAlive = false;
+  }
+};
   /**
    * @method spendMana
    *
@@ -81,7 +113,14 @@
    * @param  {number} cost      The amount of mana to spend.
    * @return {boolean} success  Whether mana was successfully spent.
    */
-
+   Spellcaster.prototype.spendMana = function (cost) {
+    if (this.mana >= cost) {
+    this.mana -= cost;
+    return true;
+    }else{
+      return false;
+      }
+   };
   /**
    * @method invoke
    *
@@ -108,3 +147,26 @@
    * @param  {Spellcaster} target         The spell target to be inflicted.
    * @return {boolean}                    Whether the spell was successfully cast.
    */
+ Spellcaster.prototype.invoke = function (spell, target) {
+  //testng to see if first parameter is 'Spell'
+  //draw a tree 'flow chart', branches, and ask the right questions
+  //target = object, a person, the spellcaster
+  //instanceof for e.g. cars - porsche, toyota, cars the object and toyota and porsche are instances
+  if (!(spell instanceof Spell)) {
+    return false;
+  }
+  //this only checks if 'is' a DamageSpell, but not if it is a NON-DamageSpell, which is still acceptable
+  if (spell instanceof DamageSpell && (!(target instanceof Spellcaster))) {
+    return false;
+  }
+  //assumes either a DamageSpell or NON, also checking 'target'
+  if (this.spendMana(spell.cost)) {
+    if(target instanceof Spellcaster) {
+      target.inflictDamage(spell.damage);
+    }
+    return true;
+  }
+  return false;
+ };
+ //can also relook at wanting to return spendMana
+ //can also think of all questions that would return false