diff --git a/projects/mtg/include/AllAbilities.h b/projects/mtg/include/AllAbilities.h
index 1604386ac..ca7b73302 100644
--- a/projects/mtg/include/AllAbilities.h
+++ b/projects/mtg/include/AllAbilities.h
@@ -3540,11 +3540,11 @@ public:
         {
             if (source->controller()->opponent()->game->inPlay->hasType(land))
             {
-                source->basicAbilities[Constants::CANTATTACK] = 0;
+                source->basicAbilities[(int)Constants::CANTATTACK] = 0;
             }
             else
             {
-                source->basicAbilities[Constants::CANTATTACK] = 1;
+                source->basicAbilities[(int)Constants::CANTATTACK] = 1;
             }
         }
         Player * player = source->controller();
@@ -4772,7 +4772,7 @@ public:
         {
             initThisTurn = 0;
             for(unsigned int i = 0; i < effectedCards.size(); i++)
-            effectedCards.at(i)->basicAbilities[Constants::CANTATTACK] = 0;
+            effectedCards.at(i)->basicAbilities[(int)Constants::CANTATTACK] = 0;
             effectedCards.clear();
         }
         if (initThisTurn && currentPhase == Constants::MTG_PHASE_COMBATBEGIN && game->currentPlayer != source->controller())
@@ -4783,7 +4783,7 @@ public:
                 MTGCardInstance * card = zone->cards[i];
                 if (!card->has(Constants::FLYING) && !card->has(Constants::ISLANDWALK) && !card->has(Constants::CANTATTACK))
                 {
-                    card->basicAbilities[Constants::CANTATTACK] = 1;
+                    card->basicAbilities[(int)Constants::CANTATTACK] = 1;
                     effectedCards.push_back(card);
                 }
             }
diff --git a/projects/mtg/src/CardGui.cpp b/projects/mtg/src/CardGui.cpp
index 2d8dc221c..9aa0bbb85 100644
--- a/projects/mtg/src/CardGui.cpp
+++ b/projects/mtg/src/CardGui.cpp
@@ -453,7 +453,7 @@ void CardGui::AlternateRender(MTGCard * card, const Pos& pos)
         string s = "";
         for (int i = card->data->types.size() - 1; i > 0; --i)
         {
-            if (card->data->basicAbilities[Constants::CHANGELING])
+            if (card->data->basicAbilities[(int)Constants::CHANGELING])
             {// this avoids drawing the list of subtypes on changeling cards.
                 s += _("Shapeshifter - ");
                 break;
diff --git a/projects/mtg/src/Damage.cpp b/projects/mtg/src/Damage.cpp
index 220003abe..cb4e690fa 100644
--- a/projects/mtg/src/Damage.cpp
+++ b/projects/mtg/src/Damage.cpp
@@ -94,7 +94,7 @@ int Damage::resolve()
         }
         if ((_target)->has(Constants::ABSORB))
         {
-            damage -=  (_target)->basicAbilities[Constants::ABSORB];
+            damage -=  (_target)->basicAbilities[(int)Constants::ABSORB];
             if(damage < 0)
                 damage = 0;
         }
diff --git a/projects/mtg/src/MTGAbility.cpp b/projects/mtg/src/MTGAbility.cpp
index 8f7336383..9871ff2f2 100644
--- a/projects/mtg/src/MTGAbility.cpp
+++ b/projects/mtg/src/MTGAbility.cpp
@@ -2984,13 +2984,13 @@ int AbilityFactory::abilityEfficiency(MTGAbility * a, Player * p, int mode, Targ
         return BAKA_EFFECT_GOOD;
 
     map<int, bool> badAbilities;
-    badAbilities[Constants::CANTATTACK] = true;
-    badAbilities[Constants::CANTBLOCK] = true;
-    badAbilities[Constants::CLOUD] = true;
-    badAbilities[Constants::DEFENDER] = true;
-    badAbilities[Constants::DOESNOTUNTAP] = true;
-    badAbilities[Constants::MUSTATTACK] = true;
-    badAbilities[Constants::CANTREGEN] = true;
+    badAbilities[(int)Constants::CANTATTACK] = true;
+    badAbilities[(int)Constants::CANTBLOCK] = true;
+    badAbilities[(int)Constants::CLOUD] = true;
+    badAbilities[(int)Constants::DEFENDER] = true;
+    badAbilities[(int)Constants::DOESNOTUNTAP] = true;
+    badAbilities[(int)Constants::MUSTATTACK] = true;
+    badAbilities[(int)Constants::CANTREGEN] = true;
 
     if (AInstantBasicAbilityModifierUntilEOT * abi = dynamic_cast<AInstantBasicAbilityModifierUntilEOT *>(a))
     {
@@ -3771,40 +3771,40 @@ void AbilityFactory::addAbilities(int _id, Spell * spell)
      * It shouldn't be necessary to add an object. State based abilities could do the trick
      */
 
-    if (card->basicAbilities[Constants::EXALTED])
+    if (card->basicAbilities[(int)Constants::EXALTED])
     {
         game->addObserver(NEW AExalted(_id, card));
     }
 
-    if (card->basicAbilities[Constants::FLANKING])
+    if (card->basicAbilities[(int)Constants::FLANKING])
     {
         game->addObserver(NEW AFlankerAbility(_id, card));
     }
 
     // Tested works the first r10 did not function because of the mistake in the array of the definition
-    if (card->basicAbilities[Constants::FORESTHOME])
+    if (card->basicAbilities[(int)Constants::FORESTHOME])
     {
         game->addObserver(NEW AStrongLandLinkCreature(_id, card, "forest"));
     }
-    if (card->basicAbilities[Constants::ISLANDHOME])
+    if (card->basicAbilities[(int)Constants::ISLANDHOME])
     {
         game->addObserver(NEW AStrongLandLinkCreature(_id, card, "island"));
     }
-    if (card->basicAbilities[Constants::MOUNTAINHOME])
+    if (card->basicAbilities[(int)Constants::MOUNTAINHOME])
     {
         game->addObserver(NEW AStrongLandLinkCreature(_id, card, "moutain"));
     }
-    if (card->basicAbilities[Constants::SWAMPHOME])
+    if (card->basicAbilities[(int)Constants::SWAMPHOME])
     {
         game->addObserver(NEW AStrongLandLinkCreature(_id, card, "swamp"));
     }
-    if (card->basicAbilities[Constants::PLAINSHOME])
+    if (card->basicAbilities[(int)Constants::PLAINSHOME])
     {
         game->addObserver(NEW AStrongLandLinkCreature(_id, card, "plains"));
     }
 
     if(card->previous && card->previous->previous && card->previous->previous->suspended)
-        card->basicAbilities[Constants::HASTE] = 1;
+        card->basicAbilities[(int)Constants::HASTE] = 1;
 
     if (card->hasType(Subtypes::TYPE_INSTANT) || card->hasType(Subtypes::TYPE_SORCERY))
     {
diff --git a/projects/mtg/src/MTGCardInstance.cpp b/projects/mtg/src/MTGCardInstance.cpp
index 7769f8098..d26d96e83 100644
--- a/projects/mtg/src/MTGCardInstance.cpp
+++ b/projects/mtg/src/MTGCardInstance.cpp
@@ -173,7 +173,7 @@ void MTGCardInstance::initMTGCI()
     currentZone = NULL;
     data = this; //an MTGCardInstance point to itself for data, allows to update it without killing the underlying database item
 
-    if (basicAbilities[Constants::CHANGELING])
+    if (basicAbilities[(int)Constants::CHANGELING])
     {//if the card is a changeling.
         for (int i = Subtypes::LAST_TYPE + 1;; i++)
         {
@@ -304,12 +304,12 @@ int MTGCardInstance::afterDamage()
 int MTGCardInstance::bury()
 {
     Player * p = controller();
-    if (basicAbilities[Constants::EXILEDEATH])
+    if (basicAbilities[(int)Constants::EXILEDEATH])
     {
         p->game->putInZone(this, p->game->inPlay, owner->game->exile);
         return 1;
     }
-    if (!basicAbilities[Constants::INDESTRUCTIBLE])
+    if (!basicAbilities[(int)Constants::INDESTRUCTIBLE])
     {
         p->game->putInZone(this, p->game->inPlay, owner->game->graveyard);
         return 1;
@@ -512,7 +512,7 @@ int MTGCardInstance::hasSummoningSickness()
 {
     if (!summoningSickness)
         return 0;
-    if (basicAbilities[Constants::HASTE])
+    if (basicAbilities[(int)Constants::HASTE])
         return 0;
     if (!isCreature())
         return 0;
@@ -540,7 +540,7 @@ int MTGCardInstance::canAttack()
         return 0;
     if (hasSummoningSickness())
         return 0;
-    if ((basicAbilities[Constants::DEFENSER] || basicAbilities[Constants::CANTATTACK]) && !basicAbilities[Constants::CANATTACK])
+    if ((basicAbilities[(int)Constants::DEFENSER] || basicAbilities[(int)Constants::CANTATTACK]) && !basicAbilities[(int)Constants::CANATTACK])
         return 0;
     if (!isCreature())
         return 0;
@@ -569,7 +569,7 @@ int MTGCardInstance::canBlock()
 {
     if (tapped)
         return 0;
-    if (basicAbilities[Constants::CANTBLOCK])
+    if (basicAbilities[(int)Constants::CANTBLOCK])
         return 0;
     if (!isCreature())
         return 0;
@@ -591,19 +591,19 @@ int MTGCardInstance::canBlock(MTGCardInstance * opponent)
         return 0;
     if (opponent->cantBeBlockedBy(this))
         return 0;
-    if (opponent->basicAbilities[Constants::UNBLOCKABLE])
+    if (opponent->basicAbilities[(int)Constants::UNBLOCKABLE])
         return 0;
-    if (opponent->basicAbilities[Constants::ONEBLOCKER] && opponent->blocked)
+    if (opponent->basicAbilities[(int)Constants::ONEBLOCKER] && opponent->blocked)
         return 0;
-    if(opponent->basicAbilities[Constants::STRONG] && power < opponent->power)
+    if(opponent->basicAbilities[(int)Constants::STRONG] && power < opponent->power)
         return 0;
-    if(this->basicAbilities[Constants::WEAK] && power < opponent->power)
+    if(this->basicAbilities[(int)Constants::WEAK] && power < opponent->power)
         return 0;
-    if (opponent->basicAbilities[Constants::FEAR] && !(this->hasType(Subtypes::TYPE_ARTIFACT) || this->hasColor(Constants::MTG_COLOR_BLACK)))
+    if (opponent->basicAbilities[(int)Constants::FEAR] && !(this->hasType(Subtypes::TYPE_ARTIFACT) || this->hasColor(Constants::MTG_COLOR_BLACK)))
         return 0;
 
     //intimidate
-    if (opponent->basicAbilities[Constants::INTIMIDATE] && !(this->hasType(Subtypes::TYPE_ARTIFACT)))
+    if (opponent->basicAbilities[(int)Constants::INTIMIDATE] && !(this->hasType(Subtypes::TYPE_ARTIFACT)))
     {
         int canblock = 0;
         for (int i = Constants::MTG_COLOR_GREEN; i <= Constants::MTG_COLOR_WHITE; ++i)
@@ -618,47 +618,47 @@ int MTGCardInstance::canBlock(MTGCardInstance * opponent)
             return 0;
     }
 
-    if (opponent->basicAbilities[Constants::FLYING] && !(basicAbilities[Constants::FLYING] || basicAbilities[Constants::REACH]))
+    if (opponent->basicAbilities[(int)Constants::FLYING] && !(basicAbilities[(int)Constants::FLYING] || basicAbilities[(int)Constants::REACH]))
         return 0;
     //Can block only creatures with flying if has cloud
-    if (basicAbilities[Constants::CLOUD] && !(opponent->basicAbilities[Constants::FLYING]))
+    if (basicAbilities[(int)Constants::CLOUD] && !(opponent->basicAbilities[(int)Constants::FLYING]))
         return 0;
     // If opponent has shadow and a creature does not have either shadow or reachshadow it cannot be blocked
-    if (opponent->basicAbilities[Constants::SHADOW] && !(basicAbilities[Constants::SHADOW]
-                    || basicAbilities[Constants::REACHSHADOW]))
+    if (opponent->basicAbilities[(int)Constants::SHADOW] && !(basicAbilities[(int)Constants::SHADOW]
+                    || basicAbilities[(int)Constants::REACHSHADOW]))
         return 0;
     // If opponent does not have shadow and a creature has shadow it cannot be blocked
-    if (!opponent->basicAbilities[Constants::SHADOW] && basicAbilities[Constants::SHADOW])
+    if (!opponent->basicAbilities[(int)Constants::SHADOW] && basicAbilities[(int)Constants::SHADOW])
         return 0;
-    if (opponent->basicAbilities[Constants::HORSEMANSHIP] && !basicAbilities[Constants::HORSEMANSHIP])
+    if (opponent->basicAbilities[(int)Constants::HORSEMANSHIP] && !basicAbilities[(int)Constants::HORSEMANSHIP])
         return 0;
-    if (opponent->basicAbilities[Constants::SWAMPWALK] && controller()->game->inPlay->hasType("swamp"))
+    if (opponent->basicAbilities[(int)Constants::SWAMPWALK] && controller()->game->inPlay->hasType("swamp"))
         return 0;
-    if (opponent->basicAbilities[Constants::FORESTWALK] && controller()->game->inPlay->hasType("forest"))
+    if (opponent->basicAbilities[(int)Constants::FORESTWALK] && controller()->game->inPlay->hasType("forest"))
         return 0;
-    if (opponent->basicAbilities[Constants::ISLANDWALK] && controller()->game->inPlay->hasType("island"))
+    if (opponent->basicAbilities[(int)Constants::ISLANDWALK] && controller()->game->inPlay->hasType("island"))
         return 0;
-    if (opponent->basicAbilities[Constants::MOUNTAINWALK] && controller()->game->inPlay->hasType("mountain"))
+    if (opponent->basicAbilities[(int)Constants::MOUNTAINWALK] && controller()->game->inPlay->hasType("mountain"))
         return 0;
-    if (opponent->basicAbilities[Constants::PLAINSWALK] && controller()->game->inPlay->hasType("plains"))
+    if (opponent->basicAbilities[(int)Constants::PLAINSWALK] && controller()->game->inPlay->hasType("plains"))
         return 0;
-    if (opponent->basicAbilities[Constants::LEGENDARYWALK] && controller()->game->inPlay->hasPrimaryType("legendary","land"))
+    if (opponent->basicAbilities[(int)Constants::LEGENDARYWALK] && controller()->game->inPlay->hasPrimaryType("legendary","land"))
         return 0;
-    if (opponent->basicAbilities[Constants::DESERTWALK] && controller()->game->inPlay->hasSpecificType("land","desert"))
+    if (opponent->basicAbilities[(int)Constants::DESERTWALK] && controller()->game->inPlay->hasSpecificType("land","desert"))
         return 0;
-    if (opponent->basicAbilities[Constants::SNOWSWAMPWALK] && controller()->game->inPlay->hasSpecificType("snow","swamp"))
+    if (opponent->basicAbilities[(int)Constants::SNOWSWAMPWALK] && controller()->game->inPlay->hasSpecificType("snow","swamp"))
         return 0;
-    if (opponent->basicAbilities[Constants::SNOWFORESTWALK] && controller()->game->inPlay->hasSpecificType("snow","forest"))
+    if (opponent->basicAbilities[(int)Constants::SNOWFORESTWALK] && controller()->game->inPlay->hasSpecificType("snow","forest"))
         return 0;
-    if (opponent->basicAbilities[Constants::SNOWISLANDWALK] && controller()->game->inPlay->hasSpecificType("snow","island"))
+    if (opponent->basicAbilities[(int)Constants::SNOWISLANDWALK] && controller()->game->inPlay->hasSpecificType("snow","island"))
         return 0;
-    if (opponent->basicAbilities[Constants::SNOWMOUNTAINWALK] && controller()->game->inPlay->hasSpecificType("snow","mountain"))
+    if (opponent->basicAbilities[(int)Constants::SNOWMOUNTAINWALK] && controller()->game->inPlay->hasSpecificType("snow","mountain"))
         return 0;
-    if (opponent->basicAbilities[Constants::SNOWPLAINSWALK] && controller()->game->inPlay->hasSpecificType("snow","plains"))
+    if (opponent->basicAbilities[(int)Constants::SNOWPLAINSWALK] && controller()->game->inPlay->hasSpecificType("snow","plains"))
         return 0;
-    if (opponent->basicAbilities[Constants::SNOWWALK] && controller()->game->inPlay->hasPrimaryType("snow","land"))
+    if (opponent->basicAbilities[(int)Constants::SNOWWALK] && controller()->game->inPlay->hasPrimaryType("snow","land"))
         return 0;
-    if (opponent->basicAbilities[Constants::NONBASICWALK] && controller()->game->inPlay->hasTypeButNotType("land","basic"))
+    if (opponent->basicAbilities[(int)Constants::NONBASICWALK] && controller()->game->inPlay->hasTypeButNotType("land","basic"))
         return 0;
     return 1;
 }
@@ -674,7 +674,7 @@ MTGCardInstance * MTGCardInstance::getNextPartner()
     MTGCardInstance * bandingPartner = inplay->getNextAttacker(banding);
     while (bandingPartner)
     {
-        if (basicAbilities[Constants::BANDING] || bandingPartner->basicAbilities[Constants::BANDING])
+        if (basicAbilities[(int)Constants::BANDING] || bandingPartner->basicAbilities[(int)Constants::BANDING])
             return bandingPartner;
         bandingPartner = inplay->getNextAttacker(bandingPartner);
     }
diff --git a/projects/mtg/src/MTGGameZones.cpp b/projects/mtg/src/MTGGameZones.cpp
index 230eb4756..f2ab0f900 100644
--- a/projects/mtg/src/MTGGameZones.cpp
+++ b/projects/mtg/src/MTGGameZones.cpp
@@ -697,7 +697,7 @@ void MTGInPlay::untapAll()
     {
         MTGCardInstance * card = cards[i];
         card->setUntapping();
-        if (!card->basicAbilities[Constants::DOESNOTUNTAP])
+        if (!card->basicAbilities[(int)Constants::DOESNOTUNTAP])
         {
             if (card->frozen < 1)
             {
diff --git a/projects/mtg/src/MTGRules.cpp b/projects/mtg/src/MTGRules.cpp
index 770481a96..54ecfc893 100644
--- a/projects/mtg/src/MTGRules.cpp
+++ b/projects/mtg/src/MTGRules.cpp
@@ -295,14 +295,14 @@ int MTGPutInPlayRule::isReactingToClick(MTGCardInstance * card, ManaCost * mana)
     Player * currentPlayer = game->currentPlayer;
     if (!player->game->hand->hasCard(card))
         return 0;
-    if ((game->turn < 1) && (cardsinhand != 0) && (card->basicAbilities[Constants::LEYLINE])
+    if ((game->turn < 1) && (cardsinhand != 0) && (card->basicAbilities[(int)Constants::LEYLINE])
         && game->currentGamePhase == Constants::MTG_PHASE_FIRSTMAIN
         && game->players[0]->game->graveyard->nb_cards == 0
         && game->players[0]->game->exile->nb_cards == 0
         )
     {
 
-        if (card->basicAbilities[Constants::LEYLINE])
+        if (card->basicAbilities[(int)Constants::LEYLINE])
         {
             MTGCardInstance * copy = player->game->putInZone(card, player->game->hand, player->game->temp);
             Spell * spell = NEW Spell(copy);
@@ -1631,7 +1631,7 @@ int MTGPersistRule::receiveEvent(WEvent * event)
     {
         WEventZoneChange * e = (WEventZoneChange *) event;
         MTGCardInstance * card = e->card->previous;
-        if (card && card->basicAbilities[Constants::PERSIST] && !card->counters->hasCounter(-1, -1))
+        if (card && card->basicAbilities[(int)Constants::PERSIST] && !card->counters->hasCounter(-1, -1))
         {
             int ok = 0;
             for (int i = 0; i < 2; i++)
@@ -1704,7 +1704,7 @@ int MTGUnearthRule::receiveEvent(WEvent * event)
             e->card->fresh = 1;
         }
 
-        if (card && card->basicAbilities[Constants::UNEARTH])
+        if (card && card->basicAbilities[(int)Constants::UNEARTH])
         {
             int ok = 0;
             for (int i = 0; i < 2; i++)
@@ -1911,7 +1911,7 @@ int MTGLifelinkRule::receiveEvent(WEvent * event)
         WEventDamage * e = (WEventDamage *) event;
         Damage * d = e->damage;
         MTGCardInstance * card = d->source;
-        if (d->damage > 0 && card && card->basicAbilities[Constants::LIFELINK])
+        if (d->damage > 0 && card && card->basicAbilities[(int)Constants::LIFELINK])
         {
             card->controller()->gainLife(d->damage);
             return 1;
@@ -1962,7 +1962,7 @@ int MTGDeathtouchRule::receiveEvent(WEvent * event)
             return 0;
         MTGCardInstance * _target = (MTGCardInstance *) (d->target);
 
-        if (card->basicAbilities[Constants::DEATHTOUCH])
+        if (card->basicAbilities[(int)Constants::DEATHTOUCH])
         {
             _target->destroy();
             return 1;