diff --git a/projects/mtg/include/ManaCost.h b/projects/mtg/include/ManaCost.h
index f714904ba..ddae4d038 100644
--- a/projects/mtg/include/ManaCost.h
+++ b/projects/mtg/include/ManaCost.h
@@ -27,6 +27,14 @@ protected:
     std::vector<ManaCostHybrid> hybrids;
 
     virtual void init();
+    ManaCost * suspend;
+    ManaCost * manaUsedToCast;
+    ManaCost * morph;
+    ManaCost * Retrace;
+    ManaCost * FlashBack;
+    ManaCost * BuyBack;
+    ManaCost * kicker;
+    ManaCost * alternative;
 
 public:
     enum
@@ -41,17 +49,31 @@ public:
         MANA_PAID_WITH_MORPH = 7,
         MANA_PAID_WITH_SUSPEND = 8
     };
-
     ExtraCosts * extraCosts;
-    ManaCost * kicker;
-    ManaCost * alternative;
-    ManaCost * BuyBack;
-    ManaCost * FlashBack;
-    ManaCost * Retrace;
-    ManaCost * morph;
-    ManaCost * suspend;
 
-    ManaCost * manaUsedToCast;
+	ManaCost * getAlternative(){ return alternative; };
+	void setAlternative(ManaCost * aMana){ SAFE_DELETE(alternative); alternative = aMana;};
+
+	ManaCost * getKicker(){ return kicker; };
+	void setKicker(ManaCost * aMana){ SAFE_DELETE(kicker); kicker = aMana;};
+
+	ManaCost * getBuyback(){ return BuyBack; };
+	void setBuyback(ManaCost * aMana){ SAFE_DELETE(BuyBack); BuyBack = aMana;};
+
+	ManaCost * getFlashback(){ return FlashBack; };
+	void setFlashback(ManaCost * aMana){ SAFE_DELETE(FlashBack); FlashBack = aMana;};
+
+	ManaCost * getRetrace(){ return Retrace; };
+	void setRetrace(ManaCost * aMana){ SAFE_DELETE(Retrace); Retrace = aMana;};
+
+	ManaCost * getMorph(){ return morph; };
+	void setMorph(ManaCost * aMana){ SAFE_DELETE(morph); morph = aMana;};
+
+	ManaCost * getSuspend(){ return suspend; };
+	void setSuspend(ManaCost * aMana){ SAFE_DELETE(suspend); suspend = aMana;};
+
+	ManaCost * getManaUsedToCast(){ return manaUsedToCast; };
+	void setManaUsedToCast(ManaCost * aMana){ SAFE_DELETE(manaUsedToCast); manaUsedToCast = aMana;};
 
     string alternativeName;
     bool isMulti;
diff --git a/projects/mtg/src/AIPlayerBaka.cpp b/projects/mtg/src/AIPlayerBaka.cpp
index 2940e8ad8..2c1039562 100644
--- a/projects/mtg/src/AIPlayerBaka.cpp
+++ b/projects/mtg/src/AIPlayerBaka.cpp
@@ -1042,10 +1042,10 @@ vector<MTGAbility*> AIPlayerBaka::canPayMana(MTGCardInstance * target,ManaCost *
                 return payments;//we didn't meet one of the color cost requirements.
             }
         }
-        if(cost->kicker && !searchingAgain)
+        if(cost->getKicker() && !searchingAgain)
         {
 
-            ManaCost * withKickerCost= NEW ManaCost(cost->kicker);
+            ManaCost * withKickerCost= NEW ManaCost(cost->getKicker());
             int canKick = 0;
             vector<MTGAbility*>kickerPayment;
             bool keepLooking = true;
@@ -1062,7 +1062,7 @@ vector<MTGAbility*> AIPlayerBaka::canPayMana(MTGCardInstance * target,ManaCost *
                         }
                     }
                     canKick += 1;
-                    keepLooking = cost->kicker->isMulti;
+                    keepLooking = cost->getKicker()->isMulti;
                 }
                 else
                     keepLooking = false;
@@ -1724,7 +1724,7 @@ MTGCardInstance * AIPlayerBaka::FindCardToPlay(ManaCost * pMana, const char * ty
     {
         nextCardToPlay = comboCards.back();
         gotPayments.clear();
-        if((!pMana->canAfford(nextCardToPlay->getManaCost()) || nextCardToPlay->getManaCost()->kicker))
+        if((!pMana->canAfford(nextCardToPlay->getManaCost()) || nextCardToPlay->getManaCost()->getKicker()))
             gotPayments = canPayMana(nextCardToPlay,nextCardToPlay->getManaCost());
         DebugTrace("ai is doing a combo:" << nextCardToPlay->getName());
         comboCards.pop_back();
@@ -1769,7 +1769,7 @@ MTGCardInstance * AIPlayerBaka::FindCardToPlay(ManaCost * pMana, const char * ty
                     continue;
                 nextCardToPlay = card;
                 gotPayments.clear();
-                if((!pMana->canAfford(nextCardToPlay->getManaCost()) || nextCardToPlay->getManaCost()->kicker))
+                if((!pMana->canAfford(nextCardToPlay->getManaCost()) || nextCardToPlay->getManaCost()->getKicker()))
                     gotPayments = canPayMana(nextCardToPlay,nextCardToPlay->getManaCost());
                 return activateCombo();
             }
@@ -1782,7 +1782,7 @@ MTGCardInstance * AIPlayerBaka::FindCardToPlay(ManaCost * pMana, const char * ty
         int currentCost = card->getManaCost()->getConvertedCost();
         int hasX = card->getManaCost()->hasX();
         gotPayments.clear();
-        if((!pMana->canAfford(card->getManaCost()) || card->getManaCost()->kicker))
+        if((!pMana->canAfford(card->getManaCost()) || card->getManaCost()->getKicker()))
             gotPayments = canPayMana(card,card->getManaCost());
             //for preformence reason we only look for specific mana if the payment couldn't be made with pmana.
         if ((currentCost > maxCost || hasX) && (gotPayments.size() || pMana->canAfford(card->getManaCost())))
@@ -1855,9 +1855,9 @@ MTGCardInstance * AIPlayerBaka::FindCardToPlay(ManaCost * pMana, const char * ty
                     xDiff = 0;
                 shouldPlayPercentage = shouldPlayPercentage - static_cast<int> ((shouldPlayPercentage * 1.9f) / (1 + xDiff));
             }
-            if(card->getManaCost() && card->getManaCost()->kicker && card->getManaCost()->kicker->isMulti)
+            if(card->getManaCost() && card->getManaCost()->getKicker() && card->getManaCost()->getKicker()->isMulti)
             {
-                shouldPlayPercentage = 10* size_t(gotPayments.size())/int(1+(card->getManaCost()->getConvertedCost()+card->getManaCost()->kicker->getConvertedCost()));
+                shouldPlayPercentage = 10* size_t(gotPayments.size())/int(1+(card->getManaCost()->getConvertedCost()+card->getManaCost()->getKicker()->getConvertedCost()));
                 if(shouldPlayPercentage <= 10)
                     shouldPlayPercentage = shouldPlayPercentage/3;
             }
@@ -1886,7 +1886,7 @@ MTGCardInstance * AIPlayerBaka::FindCardToPlay(ManaCost * pMana, const char * ty
     }
     if(nextCardToPlay)
     {
-        if(!pMana->canAfford(nextCardToPlay->getManaCost()) || nextCardToPlay->getManaCost()->kicker)
+        if(!pMana->canAfford(nextCardToPlay->getManaCost()) || nextCardToPlay->getManaCost()->getKicker())
             gotPayments = canPayMana(nextCardToPlay,nextCardToPlay->getManaCost());
         DebugTrace(" AI wants to play card." << endl
             << "- Next card to play: " << (nextCardToPlay ? nextCardToPlay->name : "None" ) << endl );
diff --git a/projects/mtg/src/ActionStack.cpp b/projects/mtg/src/ActionStack.cpp
index 2b4fef865..69a32202e 100644
--- a/projects/mtg/src/ActionStack.cpp
+++ b/projects/mtg/src/ActionStack.cpp
@@ -331,7 +331,9 @@ int Spell::resolve()
 			observer->getResourceManager()->PlaySample(source->getSample());
     }
     if(this->cost)
-        source->getManaCost()->manaUsedToCast = NEW ManaCost(this->cost);
+	{
+		source->getManaCost()->setManaUsedToCast(NEW ManaCost(this->cost));
+	}
     AbilityFactory af(observer);
     af.addAbilities(observer->mLayers->actionLayer()->getMaxId(), this);
     return 1;
diff --git a/projects/mtg/src/AllAbilities.cpp b/projects/mtg/src/AllAbilities.cpp
index f7685cfe2..bb25f7f6d 100644
--- a/projects/mtg/src/AllAbilities.cpp
+++ b/projects/mtg/src/AllAbilities.cpp
@@ -3875,13 +3875,13 @@ void AAlterCost::increaseTheCost(MTGCardInstance * card)
         for(int k = Constants::MTG_COLOR_ARTIFACT; k < Constants::NB_Colors;k++)
         {
             card->getManaCost()->add(k,card->getIncreasedManaCost()->getCost(k));
-            if (card->getManaCost()->alternative)
+            if (card->getManaCost()->getAlternative())
             {
-                card->getManaCost()->alternative->add(k,card->getIncreasedManaCost()->getCost(k));
+                card->getManaCost()->getAlternative()->add(k,card->getIncreasedManaCost()->getCost(k));
             }
-            if (card->getManaCost()->BuyBack)
+            if (card->getManaCost()->getBuyback())
             {
-                card->getManaCost()->BuyBack->add(k,card->getIncreasedManaCost()->getCost(k));
+                card->getManaCost()->getBuyback()->add(k,card->getIncreasedManaCost()->getCost(k));
             }
         }
     }
@@ -3895,13 +3895,13 @@ void AAlterCost::decreaseTheCost(MTGCardInstance * card)
         for(int k = Constants::MTG_COLOR_ARTIFACT; k < Constants::NB_Colors;k++)
         {
             card->getManaCost()->remove(k,card->getReducedManaCost()->getCost(k));
-            if (card->getManaCost()->alternative)
+            if (card->getManaCost()->getAlternative())
             {
-                card->getManaCost()->alternative->remove(k,card->getReducedManaCost()->getCost(k));
+                card->getManaCost()->getAlternative()->remove(k,card->getReducedManaCost()->getCost(k));
             }
-            if (card->getManaCost()->BuyBack)
+            if (card->getManaCost()->getBuyback())
             {
-                card->getManaCost()->BuyBack->remove(k,card->getReducedManaCost()->getCost(k));
+                card->getManaCost()->getBuyback()->remove(k,card->getReducedManaCost()->getCost(k));
             }
         }
     }
diff --git a/projects/mtg/src/CardPrimitive.cpp b/projects/mtg/src/CardPrimitive.cpp
index bce13789f..0af4460d5 100644
--- a/projects/mtg/src/CardPrimitive.cpp
+++ b/projects/mtg/src/CardPrimitive.cpp
@@ -47,8 +47,8 @@ CardPrimitive::CardPrimitive(CardPrimitive * source)
     manaCost.copy(source->getManaCost());
     //reducedCost.copy(source->getReducedManaCost());
     //increasedCost.copy(source->getIncreasedManaCost());
-    if(source->getManaCost()->alternative)
-        manaCost.alternative->alternativeName = source->getManaCost()->alternative->alternativeName;
+    if(source->getManaCost()->getAlternative())
+        manaCost.getAlternative()->alternativeName = source->getManaCost()->getAlternative()->alternativeName;
 
     text = source->text;
     formattedText = source->formattedText;
diff --git a/projects/mtg/src/MTGAbility.cpp b/projects/mtg/src/MTGAbility.cpp
index 08827ccab..74919cf8a 100644
--- a/projects/mtg/src/MTGAbility.cpp
+++ b/projects/mtg/src/MTGAbility.cpp
@@ -401,7 +401,7 @@ int AbilityFactory::parseCastRestrictions(MTGCardInstance * card, Player * playe
             if(spentMana.size())
             {
                 ManaCost * costToCheck = ManaCost::parseManaCost(restriction[i]);
-                ManaCost * spent = card->getManaCost()->manaUsedToCast;
+                ManaCost * spent = card->getManaCost()->getManaUsedToCast();
                 if(spent && costToCheck && !spent->canAfford(costToCheck))
                 {
                     SAFE_DELETE(costToCheck);
diff --git a/projects/mtg/src/MTGDeck.cpp b/projects/mtg/src/MTGDeck.cpp
index a8e6aa50d..b8debc0cd 100644
--- a/projects/mtg/src/MTGDeck.cpp
+++ b/projects/mtg/src/MTGDeck.cpp
@@ -101,7 +101,7 @@ int MTGAllCards::processConfLine(string &s, MTGCard *card, CardPrimitive * primi
         {
             string value = val;
             std::transform(value.begin(), value.end(), value.begin(), ::tolower);
-            cost->BuyBack = ManaCost::parseManaCost(value);
+            cost->setBuyback(ManaCost::parseManaCost(value));
         }
         break;
 
@@ -139,13 +139,13 @@ int MTGAllCards::processConfLine(string &s, MTGCard *card, CardPrimitive * primi
                 {
                     string value = val;
                     std::transform(value.begin(), value.end(), value.begin(), ::tolower);
-                    cost->morph = ManaCost::parseManaCost(value);
+                    cost->setMorph(ManaCost::parseManaCost(value));
                 }
                 else
                 {
                     string value = val;
                     std::transform(value.begin(), value.end(), value.begin(), ::tolower);
-                    cost->FlashBack = ManaCost::parseManaCost(value);
+                    cost->setFlashback(ManaCost::parseManaCost(value));
                 }
             }
             break;
@@ -174,8 +174,8 @@ int MTGAllCards::processConfLine(string &s, MTGCard *card, CardPrimitive * primi
                 value.erase(multikick, endK - multikick);
                 isMultikicker = true;
         }
-            cost->kicker = ManaCost::parseManaCost(value);  
-            cost->kicker->isMulti = isMultikicker;
+            cost->setKicker(ManaCost::parseManaCost(value));  
+            cost->getKicker()->isMulti = isMultikicker;
         }
         break;
 
@@ -214,9 +214,9 @@ int MTGAllCards::processConfLine(string &s, MTGCard *card, CardPrimitive * primi
                         theName = value.substr(name + 5,endName - name - 5);
                         value.erase(name, endName - name + 1);
                     }
-                    cost->alternative = ManaCost::parseManaCost(value);
+                    cost->setAlternative(ManaCost::parseManaCost(value));
                     if(theName.size())
-                        cost->alternative->alternativeName.append(theName);
+                        cost->getAlternative()->alternativeName.append(theName);
             }
         }
         break;
@@ -249,7 +249,7 @@ int MTGAllCards::processConfLine(string &s, MTGCard *card, CardPrimitive * primi
             {
                 string value = val;
                 std::transform(value.begin(), value.end(), value.begin(), ::tolower);
-                cost->Retrace = ManaCost::parseManaCost(value);
+                cost->setRetrace(ManaCost::parseManaCost(value));
             }
         }
         else if (s.find("rar") != string::npos)
@@ -271,7 +271,7 @@ int MTGAllCards::processConfLine(string &s, MTGCard *card, CardPrimitive * primi
                 {
                     string value = val;
                     std::transform(value.begin(), value.end(), value.begin(), ::tolower);
-                    cost->suspend = ManaCost::parseManaCost(value);
+					cost->setSuspend(ManaCost::parseManaCost(value));
                     primitive->suspendedTime = suspendTime;
                 }
                 
diff --git a/projects/mtg/src/MTGRules.cpp b/projects/mtg/src/MTGRules.cpp
index 13ebd3127..b8da4451c 100644
--- a/projects/mtg/src/MTGRules.cpp
+++ b/projects/mtg/src/MTGRules.cpp
@@ -388,24 +388,24 @@ int MTGPutInPlayRule::reactToClick(MTGCardInstance * card)
 
     ManaCost * previousManaPool = NEW ManaCost(player->getManaPool());
     int payResult = player->getManaPool()->pay(card->getManaCost());
-    if (card->getManaCost()->kicker && (OptionKicker::KICKER_ALWAYS == options[Options::KICKERPAYMENT].number || card->controller()->isAI()))
+    if (card->getManaCost()->getKicker() && (OptionKicker::KICKER_ALWAYS == options[Options::KICKERPAYMENT].number || card->controller()->isAI()))
     {
         ManaCost * withKickerCost= NEW ManaCost(card->getManaCost());
-        withKickerCost->add(withKickerCost->kicker);
-        if (card->getManaCost()->kicker->isMulti)
+        withKickerCost->add(withKickerCost->getKicker());
+        if (card->getManaCost()->getKicker()->isMulti)
         {
             while(previousManaPool->canAfford(withKickerCost))
             {
-                withKickerCost->add(withKickerCost->kicker);
+                withKickerCost->add(withKickerCost->getKicker());
                 card->kicked += 1;
             }
             for(int i = 0;i < card->kicked;i++)
-                player->getManaPool()->pay(card->getManaCost()->kicker);
+                player->getManaPool()->pay(card->getManaCost()->getKicker());
             payResult = ManaCost::MANA_PAID_WITH_KICKER;
         }
         else if (previousManaPool->canAfford(withKickerCost))
         {
-            player->getManaPool()->pay(card->getManaCost()->kicker);
+            player->getManaPool()->pay(card->getManaCost()->getKicker());
             payResult = ManaCost::MANA_PAID_WITH_KICKER;
         }
         delete withKickerCost;
@@ -481,7 +481,7 @@ int MTGKickerRule::isReactingToClick(MTGCardInstance * card, ManaCost *)
     Player * player = game->currentlyActing();
     if(!player->game->hand->hasCard(card))
 		return 0;
-    ManaCost * kicker = card->getManaCost()->kicker;
+    ManaCost * kicker = card->getManaCost()->getKicker();
     if(!kicker)
     {
 		SAFE_DELETE(kicker);
@@ -489,7 +489,7 @@ int MTGKickerRule::isReactingToClick(MTGCardInstance * card, ManaCost *)
     }
     ManaCost * playerMana = player->getManaPool();
     ManaCost * withKickerCost= NEW ManaCost(card->getManaCost());
-    withKickerCost->add(withKickerCost->kicker);
+    withKickerCost->add(withKickerCost->getKicker());
     if(!playerMana->canAfford(withKickerCost))
     {
         delete withKickerCost;
@@ -508,11 +508,11 @@ int MTGKickerRule::reactToClick(MTGCardInstance * card)
         
     Player * player = game->currentlyActing();
     ManaCost * withKickerCost= NEW ManaCost(card->getManaCost());//using pointers here alters the real cost of the card.
-    if (card->getManaCost()->kicker->isMulti)
+    if (card->getManaCost()->getKicker()->isMulti)
     {
         while(player->getManaPool()->canAfford(withKickerCost))
         {
-            withKickerCost->add(withKickerCost->kicker);
+            withKickerCost->add(withKickerCost->getKicker());
             card->kicked += 1;
         }
         card->kicked -= 1;
@@ -522,7 +522,7 @@ int MTGKickerRule::reactToClick(MTGCardInstance * card)
     }
     else
     {
-        withKickerCost->add(withKickerCost->kicker);
+        withKickerCost->add(withKickerCost->getKicker());
         card->paymenttype = MTGAbility::PUT_INTO_PLAY_WITH_KICKER;
     }
     if (withKickerCost->isExtraPaymentSet())
@@ -619,7 +619,7 @@ PermanentAbility(observer, _id)
 
 int MTGAlternativeCostRule::isReactingToClick(MTGCardInstance * card, ManaCost * mana)
 {
-	ManaCost * alternateCost = card->getManaCost()->alternative;
+	ManaCost * alternateCost = card->getManaCost()->getAlternative();
 	if (!game->currentlyActing()->game->hand->hasCard(card))
  		return 0;
     return isReactingToClick( card, mana, alternateCost );
@@ -635,8 +635,8 @@ int MTGAlternativeCostRule::isReactingToClick(MTGCardInstance * card, ManaCost *
     if(!allowedToAltCast(card,player))
         return 0;
 
-    if(card->model->data->getManaCost()->alternative && card->model->data->getManaCost()->alternative->alternativeName.size())
-        alternativeName = card->model->data->getManaCost()->alternative->alternativeName;
+    if(card->model->data->getManaCost()->getAlternative() && card->model->data->getManaCost()->getAlternative()->alternativeName.size())
+        alternativeName = card->model->data->getManaCost()->getAlternative()->alternativeName;
 
     if (card->isLand())
     {
@@ -676,7 +676,7 @@ int MTGAlternativeCostRule::reactToClick(MTGCardInstance * card)
 	if ( !isReactingToClick(card))
 		return 0;
 
-	ManaCost *alternateCost = card->getManaCost()->alternative;
+	ManaCost *alternateCost = card->getManaCost()->getAlternative();
 	card->paymenttype = MTGAbility::ALTERNATIVE_COST;
 
     return reactToClick(card, alternateCost, ManaCost::MANA_PAID_WITH_ALTERNATIVE);
@@ -776,7 +776,7 @@ int MTGBuyBackRule::isReactingToClick(MTGCardInstance * card, ManaCost * mana)
         return 0;
     if(!allowedToCast(card,player))
         return 0;
-    return MTGAlternativeCostRule::isReactingToClick( card, mana, card->getManaCost()->BuyBack );
+    return MTGAlternativeCostRule::isReactingToClick( card, mana, card->getManaCost()->getBuyback() );
 }
 
 int MTGBuyBackRule::reactToClick(MTGCardInstance * card) 
@@ -784,7 +784,7 @@ int MTGBuyBackRule::reactToClick(MTGCardInstance * card)
     if (!isReactingToClick(card))
         return 0;
 
-    ManaCost * alternateCost = card->getManaCost()->BuyBack;
+    ManaCost * alternateCost = card->getManaCost()->getBuyback();
     
     card->paymenttype = MTGAbility::BUYBACK_COST;
 
@@ -818,12 +818,12 @@ int MTGFlashBackRule::isReactingToClick(MTGCardInstance * card, ManaCost * mana)
     Player * player = game->currentlyActing();
     if (!player->game->graveyard->hasCard(card))
         return 0;
-    return MTGAlternativeCostRule::isReactingToClick(card, mana, card->getManaCost()->FlashBack );
+    return MTGAlternativeCostRule::isReactingToClick(card, mana, card->getManaCost()->getFlashback() );
 }
 
 int MTGFlashBackRule::reactToClick(MTGCardInstance * card) 
 {
-    ManaCost * alternateCost = card->getManaCost()->FlashBack;
+    ManaCost * alternateCost = card->getManaCost()->getFlashback();
     
     if (!isReactingToClick(card))
         return 0;
@@ -859,7 +859,7 @@ MTGAlternativeCostRule(observer, _id)
 int MTGRetraceRule::isReactingToClick(MTGCardInstance * card, ManaCost * mana)
 {
     Player * player = game->currentlyActing();
-    ManaCost * alternateManaCost = card->getManaCost()->Retrace;
+    ManaCost * alternateManaCost = card->getManaCost()->getRetrace();
 
     if (!player->game->graveyard->hasCard(card))
         return 0;
@@ -873,7 +873,7 @@ int MTGRetraceRule::reactToClick(MTGCardInstance * card)
     if (!isReactingToClick(card))
         return 0;
     
-    ManaCost * alternateCost = card->getManaCost()->Retrace;
+    ManaCost * alternateCost = card->getManaCost()->getRetrace();
     
     card->paymenttype = MTGAbility::RETRACE_COST;
 
@@ -906,7 +906,7 @@ MTGAlternativeCostRule(observer, _id)
 int MTGSuspendRule::isReactingToClick(MTGCardInstance * card, ManaCost * mana)
 {
     Player * player = game->currentlyActing();
-    ManaCost * alternateManaCost = card->getManaCost()->suspend;
+    ManaCost * alternateManaCost = card->getManaCost()->getSuspend();
 
     if (!player->game->hand->hasCard(card) || !alternateManaCost)
         return 0;
@@ -948,7 +948,7 @@ int MTGSuspendRule::reactToClick(MTGCardInstance * card)
         return 0;
     Player *player = game->currentlyActing();
     ManaCost * playerMana = player->getManaPool();
-    ManaCost * alternateCost = card->getManaCost()->suspend;
+    ManaCost * alternateCost = card->getManaCost()->getSuspend();
     //this handles extra cost payments at the moment a card is played.
     if (playerMana->canAfford(alternateCost))
     {
@@ -973,22 +973,22 @@ int MTGSuspendRule::reactToClick(MTGCardInstance * card)
         else
         {
             alternateCost->setExtraCostsAction(this, card);
-            game->mExtraPayment = getCost()->suspend->extraCosts;
+            game->mExtraPayment = getCost()->getSuspend()->extraCosts;
             return 0;
         }
             card->paymenttype = MTGAbility::SUSPEND_COST;
     }
     //------------------------------------------------------------------------
-    if(card->getManaCost()->suspend->hasX())
+    if(card->getManaCost()->getSuspend()->hasX())
     {
         ManaCost * pMana = NEW ManaCost(player->getManaPool());
-        ManaCost * suspendCheckMana = NEW ManaCost(card->getManaCost()->suspend);
+        ManaCost * suspendCheckMana = NEW ManaCost(card->getManaCost()->getSuspend());
         card->suspendedTime = pMana->getConvertedCost() - suspendCheckMana->getConvertedCost();
         SAFE_DELETE(pMana);
         SAFE_DELETE(suspendCheckMana);
     }
-    player->getManaPool()->pay(card->getManaCost()->suspend);
-    card->getManaCost()->suspend->doPayExtra();
+    player->getManaPool()->pay(card->getManaCost()->getSuspend());
+    card->getManaCost()->getSuspend()->doPayExtra();
     //---------------------------------------------------------------------------
     player->game->putInZone(card, card->currentZone, player->game->exile);
     card->next->suspended = true;
@@ -1031,7 +1031,7 @@ int MTGMorphCostRule::isReactingToClick(MTGCardInstance * card, ManaCost *)
     Player * currentPlayer = game->currentPlayer;
     if (!player->game->hand->hasCard(card))
         return 0;
-    if (!card->getManaCost()->morph)
+    if (!card->getManaCost()->getMorph())
         return 0;
     if(!allowedToAltCast(card,player))
         return 0;
@@ -1045,7 +1045,7 @@ int MTGMorphCostRule::isReactingToClick(MTGCardInstance * card, ManaCost *)
         if (game->currentActionPlayer->game->playRestrictions->canPutIntoZone(card, game->currentActionPlayer->game->stack) == PlayRestriction::CANT_PLAY)
             return 0;
         ManaCost * playerMana = player->getManaPool();
-        ManaCost * morph = card->getManaCost()->morph;
+        ManaCost * morph = card->getManaCost()->getMorph();
 
 #ifdef WIN32
         ManaCost * cost = card->getManaCost();
@@ -1068,12 +1068,12 @@ int MTGMorphCostRule::reactToClick(MTGCardInstance * card)
         return 0;
     Player * player = game->currentlyActing();
     ManaCost * cost = card->getManaCost();
-    ManaCost * morph = card->getManaCost()->morph;
+    ManaCost * morph = card->getManaCost()->getMorph();
     ManaCost * playerMana = player->getManaPool();
     //this handles extra cost payments at the moment a card is played.
     if (playerMana->canAfford(morph))
     {
-        if (cost->morph->isExtraPaymentSet())
+        if (cost->getMorph()->isExtraPaymentSet())
         {
             card->paymenttype = MTGAbility::MORPH_COST;
             if (!game->targetListIsSet(card))
@@ -1083,21 +1083,21 @@ int MTGMorphCostRule::reactToClick(MTGCardInstance * card)
         }
         else
         {
-            cost->morph->setExtraCostsAction(this, card);
-            game->mExtraPayment = cost->morph->extraCosts;
+            cost->getMorph()->setExtraCostsAction(this, card);
+            game->mExtraPayment = cost->getMorph()->extraCosts;
             card->paymenttype = MTGAbility::MORPH_COST;
             return 0;
         }
     }
     //------------------------------------------------------------------------
     ManaCost * previousManaPool = NEW ManaCost(player->getManaPool());
-    player->getManaPool()->pay(card->getManaCost()->morph);
-    card->getManaCost()->morph->doPayExtra();
+    player->getManaPool()->pay(card->getManaCost()->getMorph());
+    card->getManaCost()->getMorph()->doPayExtra();
     int payResult = ManaCost::MANA_PAID_WITH_MORPH;
     //if morph has a extra payment thats set, this code pays it.the if statement is 100% needed as it would cause a crash on cards that dont have the morph cost.
     if (morph)
     {
-        card->getManaCost()->morph->doPayExtra();
+        card->getManaCost()->getMorph()->doPayExtra();
     }
     //---------------------------------------------------------------------------
     ManaCost * spellCost = previousManaPool->Diff(player->getManaPool());
diff --git a/projects/mtg/src/ManaCost.cpp b/projects/mtg/src/ManaCost.cpp
index 609be332e..cee99c7cb 100644
--- a/projects/mtg/src/ManaCost.cpp
+++ b/projects/mtg/src/ManaCost.cpp
@@ -989,6 +989,15 @@ ostream& operator<<(ostream& out, ManaCost m)
 
 void ManaPool::Empty()
 {
+	SAFE_DELETE(extraCosts);
+    SAFE_DELETE(kicker);
+    SAFE_DELETE(alternative);
+    SAFE_DELETE(BuyBack);
+    SAFE_DELETE(FlashBack);
+    SAFE_DELETE(Retrace);
+    SAFE_DELETE(morph);
+    SAFE_DELETE(suspend);
+    SAFE_DELETE(manaUsedToCast);
     init();
     WEvent * e = NEW WEventEmptyManaPool(this);
     player->getObserver()->receiveEvent(e);