Mahtan/wagic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Android cross-compiling fixes regarding constants

Browse Source
This commit is contained in:
Xawotihs
2011-04-20 20:14:25 +00:00
parent 2fdc80aee1
commit 78e34386ee
7 changed files with 61 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
projects/mtg/include/AllAbilities.h
View File

@@ -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);
}
}

2
projects/mtg/src/CardGui.cpp
View File

@@ -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;

2
projects/mtg/src/Damage.cpp
View File

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

30
projects/mtg/src/MTGAbility.cpp
View File

@@ -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))
{

66
projects/mtg/src/MTGCardInstance.cpp
View File

@@ -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);
}

2
projects/mtg/src/MTGGameZones.cpp
View File

@@ -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)
{

12
projects/mtg/src/MTGRules.cpp
View File

@@ -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;