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

Cleanup tabs

Browse Source
This commit is contained in:
Anthony Calosa
2016-07-07 13:25:36 +08:00
parent c544206437
commit 4da7f77089
27 changed files with 1875 additions and 1875 deletions
Download Patch File Download Diff File Expand all files Collapse all files
projects/mtg/src/ActionLayer.cpp
+14 -14
View File
@@ -105,11 +105,11 @@ bool ActionLayer::CheckUserInput(JButton key)
//being cancelled. currently only menuability and paidability will care.
}
}
if (observer->mExtraPayment->costs.size() && observer->mExtraPayment->costs[0]->tc)
{
//if we cancel, clear the targets list so that when you try again you dont already have targets from before.
observer->mExtraPayment->costs[0]->tc->initTargets();
}
if (observer->mExtraPayment->costs.size() && observer->mExtraPayment->costs[0]->tc)
{
//if we cancel, clear the targets list so that when you try again you dont already have targets from before.
observer->mExtraPayment->costs[0]->tc->initTargets();
}
observer->mExtraPayment = NULL;
return 1;
}
@@ -191,11 +191,11 @@ void ActionLayer::Update(float dt)
without this, the game locks into a freeze state while you try to select the targets and dont have enough to
fill the maxtargets list.
*/
if (int(ae->getActionTc()->getNbTargets()) == countTargets)//if the amount of targets is equal the all we can target
{
ae->getActionTc()->done = true;//were done
ae->getActionTc()->source->getObserver()->cardClick(ae->getActionTc()->source, 0, false);//click source.
}
if (int(ae->getActionTc()->getNbTargets()) == countTargets)//if the amount of targets is equal the all we can target
{
ae->getActionTc()->done = true;//were done
ae->getActionTc()->source->getObserver()->cardClick(ae->getActionTc()->source, 0, false);//click source.
}
}
}
}
@@ -467,10 +467,10 @@ void ActionLayer::doReactTo(int menuIndex)
{
int controlid = abilitiesMenu->mObjects[menuIndex]->GetId();
DebugTrace("ActionLayer::doReactTo " << controlid);
if (abilitiesMenu && abilitiesMenu->isMultipleChoice)
{
return ButtonPressedOnMultipleChoice(menuIndex);
}
if (abilitiesMenu && abilitiesMenu->isMultipleChoice)
{
return ButtonPressedOnMultipleChoice(menuIndex);
}
ButtonPressed(0, controlid);
}
}
projects/mtg/src/ActionStack.cpp
+4 -4
View File
@@ -578,10 +578,10 @@ int ActionStack::addAbility(MTGAbility * ability)
if (!observer->players[0]->isAI() && ability->source->controller() == observer->players[0] && 0
== options[Options::INTERRUPTMYABILITIES].number)
interruptDecision[0] = DONT_INTERRUPT;
if (observer->OpenedDisplay && observer->players[0]->game->reveal->cards.size())
{
interruptDecision[0] = DONT_INTERRUPT;
}
if (observer->OpenedDisplay && observer->players[0]->game->reveal->cards.size())
{
interruptDecision[0] = DONT_INTERRUPT;
}
return result;
}
projects/mtg/src/AllAbilities.cpp
+744 -744
View File
File diff suppressed because it is too large Load Diff
projects/mtg/src/ExtraCost.cpp
+191 -191
View File
@@ -72,10 +72,10 @@ int ExtraCost::setPayment(MTGCardInstance * card)
if (tc)
{
result = tc->addTarget(card);
//this is flawed logic, we need to fix. if there is a target in list
//we return targetready instead, the card is not pushed back into list
//how ever, it is made the target becuase the result is 1 even if we couldnt
//target it with the targetchooser.
//this is flawed logic, we need to fix. if there is a target in list
//we return targetready instead, the card is not pushed back into list
//how ever, it is made the target becuase the result is 1 even if we couldnt
//target it with the targetchooser.
if (result)
{
target = card;
@@ -166,7 +166,7 @@ int SnowCost::isPaymentSet()
return 1;
else
return 0;
}
}
}
return 0;
}
@@ -763,7 +763,7 @@ int TapTargetCost::doPay()
if (target)
{
source->storedCard = target->createSnapShot();
source->storedCard = target->createSnapShot();
_target->tap();
target = NULL;
if (tc)
@@ -807,7 +807,7 @@ int UnTapTargetCost::doPay()
if (target)
{
source->storedCard = target->createSnapShot();
source->storedCard = target->createSnapShot();
_target->untap();
target = NULL;
if (tc)
@@ -929,189 +929,189 @@ int Ninja::doPay()
//Convoke
Convoke * Convoke::clone() const
{
Convoke * ec = NEW Convoke(*this);
if (tc)
ec->tc = tc->clone();
return ec;
Convoke * ec = NEW Convoke(*this);
if (tc)
ec->tc = tc->clone();
return ec;
}
Convoke::Convoke(TargetChooser *_tc) :
ExtraCost("Select Cards To Tap", _tc)
ExtraCost("Select Cards To Tap", _tc)
{
}
int Convoke::canPay()
{
return isPaymentSet();
return isPaymentSet();
}
int Convoke::isPaymentSet()
{
if (target && target->isTapped())
{
tc->removeTarget(target);
target->isExtraCostTarget = false;
target = NULL;
return 0;
}
ManaCost * toReduce = getReduction();
if (target && (!source->controller()->getManaPool()->canAfford(toReduce)))
{
target = NULL;
SAFE_DELETE(toReduce);
return 0;
}
if (target && (source->controller()->getManaPool()->canAfford(toReduce)))
{
SAFE_DELETE(toReduce);
return 1;
}
SAFE_DELETE(toReduce);
return 0;
if (target && target->isTapped())
{
tc->removeTarget(target);
target->isExtraCostTarget = false;
target = NULL;
return 0;
}
ManaCost * toReduce = getReduction();
if (target && (!source->controller()->getManaPool()->canAfford(toReduce)))
{
target = NULL;
SAFE_DELETE(toReduce);
return 0;
}
if (target && (source->controller()->getManaPool()->canAfford(toReduce)))
{
SAFE_DELETE(toReduce);
return 1;
}
SAFE_DELETE(toReduce);
return 0;
}
ManaCost * Convoke::getReduction()
{
ManaCost * toReduce = NEW ManaCost(source->getManaCost());
tc->maxtargets = source->getManaCost()->getConvertedCost();
if (tc->getNbTargets())
{
vector<Targetable*>targetlist = tc->getTargetsFrom();
for (vector<Targetable*>::iterator it = targetlist.begin(); it != targetlist.end(); it++)
{
bool next = false;
for (int i = Constants::MTG_COLOR_GREEN; i <= Constants::MTG_COLOR_WHITE; ++i)
{
if (next == true)
break;
MTGCardInstance * targetCard = dynamic_cast<MTGCardInstance*>(*it);
if ((targetCard->getManaCost()->hasColor(i) || targetCard->hasColor(i)) && toReduce->hasColor(i))
{
toReduce->remove(i, 1);
next = true;
}
else
{
toReduce->remove(Constants::MTG_COLOR_ARTIFACT, 1);
next = true;
}
}
}
//if we didnt find it payable one way, lets try again backwards.
if (!source->controller()->getManaPool()->canAfford(toReduce))
{
SAFE_DELETE(toReduce);
toReduce = NEW ManaCost(source->getManaCost());
for (vector<Targetable*>::reverse_iterator it = targetlist.rbegin(); it != targetlist.rend(); it++)
{
bool next = false;
for (int i = Constants::MTG_COLOR_GREEN; i <= Constants::MTG_COLOR_WHITE; ++i)
{
if (next == true)
break;
MTGCardInstance * targetCard = dynamic_cast<MTGCardInstance*>(*it);
if ((targetCard->getManaCost()->hasColor(i) || targetCard->hasColor(i)) && toReduce->hasColor(i))
{
toReduce->remove(i, 1);
next = true;
}
else
{
toReduce->remove(Constants::MTG_COLOR_ARTIFACT, 1);
next = true;
}
}
}
}
}
return toReduce;
ManaCost * toReduce = NEW ManaCost(source->getManaCost());
tc->maxtargets = source->getManaCost()->getConvertedCost();
if (tc->getNbTargets())
{
vector<Targetable*>targetlist = tc->getTargetsFrom();
for (vector<Targetable*>::iterator it = targetlist.begin(); it != targetlist.end(); it++)
{
bool next = false;
for (int i = Constants::MTG_COLOR_GREEN; i <= Constants::MTG_COLOR_WHITE; ++i)
{
if (next == true)
break;
MTGCardInstance * targetCard = dynamic_cast<MTGCardInstance*>(*it);
if ((targetCard->getManaCost()->hasColor(i) || targetCard->hasColor(i)) && toReduce->hasColor(i))
{
toReduce->remove(i, 1);
next = true;
}
else
{
toReduce->remove(Constants::MTG_COLOR_ARTIFACT, 1);
next = true;
}
}
}
//if we didnt find it payable one way, lets try again backwards.
if (!source->controller()->getManaPool()->canAfford(toReduce))
{
SAFE_DELETE(toReduce);
toReduce = NEW ManaCost(source->getManaCost());
for (vector<Targetable*>::reverse_iterator it = targetlist.rbegin(); it != targetlist.rend(); it++)
{
bool next = false;
for (int i = Constants::MTG_COLOR_GREEN; i <= Constants::MTG_COLOR_WHITE; ++i)
{
if (next == true)
break;
MTGCardInstance * targetCard = dynamic_cast<MTGCardInstance*>(*it);
if ((targetCard->getManaCost()->hasColor(i) || targetCard->hasColor(i)) && toReduce->hasColor(i))
{
toReduce->remove(i, 1);
next = true;
}
else
{
toReduce->remove(Constants::MTG_COLOR_ARTIFACT, 1);
next = true;
}
}
}
}
}
return toReduce;
}
int Convoke::doPay()
{
if (target && tc->getNbTargets())
{
ManaCost * toReduce = getReduction();
target->controller()->getManaPool()->pay(toReduce);
SAFE_DELETE(toReduce);
vector<Targetable*>targetlist = tc->getTargetsFrom();
for (vector<Targetable*>::iterator it = targetlist.begin(); it != targetlist.end(); it++)
{
MTGCardInstance * targetCard = dynamic_cast<MTGCardInstance*>(*it);
source->storedCard = targetCard->createSnapShot();
targetCard->tap();
}
if (tc)
tc->initTargets();
return 1;
}
return 0;
if (target && tc->getNbTargets())
{
ManaCost * toReduce = getReduction();
target->controller()->getManaPool()->pay(toReduce);
SAFE_DELETE(toReduce);
vector<Targetable*>targetlist = tc->getTargetsFrom();
for (vector<Targetable*>::iterator it = targetlist.begin(); it != targetlist.end(); it++)
{
MTGCardInstance * targetCard = dynamic_cast<MTGCardInstance*>(*it);
source->storedCard = targetCard->createSnapShot();
targetCard->tap();
}
if (tc)
tc->initTargets();
return 1;
}
return 0;
}
//DELVE
Delve * Delve::clone() const
{
Delve * ec = NEW Delve(*this);
if (tc)
ec->tc = tc->clone();
return ec;
Delve * ec = NEW Delve(*this);
if (tc)
ec->tc = tc->clone();
return ec;
}
Delve::Delve(TargetChooser *_tc) :
ExtraCost("Select Cards To Exile", _tc)
ExtraCost("Select Cards To Exile", _tc)
{
}
int Delve::canPay()
{
return isPaymentSet();
return isPaymentSet();
}
int Delve::isPaymentSet()
{
ManaCost * toReduce = NEW ManaCost(source->getManaCost());
tc->maxtargets = source->getManaCost()->getCost(Constants::MTG_COLOR_ARTIFACT);
if (tc->getNbTargets())
{
toReduce->remove(Constants::MTG_COLOR_ARTIFACT, tc->getNbTargets());
}
if (target && (!source->controller()->getManaPool()->canAfford(toReduce)))
{
target = NULL;
SAFE_DELETE(toReduce);
return 0;
}
if (target && (source->controller()->getManaPool()->canAfford(toReduce)))
{
SAFE_DELETE(toReduce);
return 1;
}
SAFE_DELETE(toReduce);
return 0;
ManaCost * toReduce = NEW ManaCost(source->getManaCost());
tc->maxtargets = source->getManaCost()->getCost(Constants::MTG_COLOR_ARTIFACT);
if (tc->getNbTargets())
{
toReduce->remove(Constants::MTG_COLOR_ARTIFACT, tc->getNbTargets());
}
if (target && (!source->controller()->getManaPool()->canAfford(toReduce)))
{
target = NULL;
SAFE_DELETE(toReduce);
return 0;
}
if (target && (source->controller()->getManaPool()->canAfford(toReduce)))
{
SAFE_DELETE(toReduce);
return 1;
}
SAFE_DELETE(toReduce);
return 0;
}
int Delve::doPay()
{
if (target && tc->getNbTargets())
{
ManaCost * toReduce = NEW ManaCost(source->getManaCost());
if (target && tc->getNbTargets())
{
ManaCost * toReduce = NEW ManaCost(source->getManaCost());
toReduce->remove(Constants::MTG_COLOR_ARTIFACT, tc->getNbTargets());
toReduce->remove(Constants::MTG_COLOR_ARTIFACT, tc->getNbTargets());
target->controller()->getManaPool()->pay(toReduce);
SAFE_DELETE(toReduce);
vector<Targetable*>targetlist = tc->getTargetsFrom();
for (vector<Targetable*>::iterator it = targetlist.begin(); it != targetlist.end(); it++)
{
MTGCardInstance * targetCard = dynamic_cast<MTGCardInstance*>(*it);
source->storedCard = targetCard->createSnapShot();
targetCard->controller()->game->putInExile(targetCard);
}
if (tc)
tc->initTargets();
return 1;
}
return 0;
target->controller()->getManaPool()->pay(toReduce);
SAFE_DELETE(toReduce);
vector<Targetable*>targetlist = tc->getTargetsFrom();
for (vector<Targetable*>::iterator it = targetlist.begin(); it != targetlist.end(); it++)
{
MTGCardInstance * targetCard = dynamic_cast<MTGCardInstance*>(*it);
source->storedCard = targetCard->createSnapShot();
targetCard->controller()->game->putInExile(targetCard);
}
if (tc)
tc->initTargets();
return 1;
}
return 0;
}
///////////////
@@ -1402,41 +1402,41 @@ int ExtraCosts::tryToSetPayment(MTGCardInstance * card)
{
for(size_t k = 0; k < costs.size(); k++)
{
if (card == costs[k]->target)
{
//tapping or sacrificing a target to pay for its own cost
//is allowed, unless the source is already being tapped and contains a tap target
//or sacced and contains a sactarget
//cost like {t}{s(creature)} the source is allowed to be targeted for this
//if it is a creature. these cases below should be added whenever we a need
//for extra cost that have both a source and target version used on cards.
if (dynamic_cast<TapCost*>(costs[k]))
{
for (size_t tapCheck = 0; tapCheck < costs.size(); tapCheck++)
{
if (dynamic_cast<TapTargetCost*>(costs[tapCheck]))
{
return 0;//{t}{t(creature)}
}
}
if (card == costs[k]->target)
{
//tapping or sacrificing a target to pay for its own cost
//is allowed, unless the source is already being tapped and contains a tap target
//or sacced and contains a sactarget
//cost like {t}{s(creature)} the source is allowed to be targeted for this
//if it is a creature. these cases below should be added whenever we a need
//for extra cost that have both a source and target version used on cards.
if (dynamic_cast<TapCost*>(costs[k]))
{
for (size_t tapCheck = 0; tapCheck < costs.size(); tapCheck++)
{
if (dynamic_cast<TapTargetCost*>(costs[tapCheck]))
{
return 0;//{t}{t(creature)}
}
}
}
else if (SacrificeCost * checking = dynamic_cast<SacrificeCost*>(costs[k]))
{
for (size_t sacCheck = 0; sacCheck < costs.size(); sacCheck++)
{
SacrificeCost * checking2 = dynamic_cast<SacrificeCost*>(costs[sacCheck]);
if (checking2)
if ((checking->tc != NULL && checking2->tc == NULL)
|| (checking->tc == NULL && checking2->tc != NULL))
{
return 0; //{s}{s(creature)}
}
}
}
else
return 0;
}
}
else if (SacrificeCost * checking = dynamic_cast<SacrificeCost*>(costs[k]))
{
for (size_t sacCheck = 0; sacCheck < costs.size(); sacCheck++)
{
SacrificeCost * checking2 = dynamic_cast<SacrificeCost*>(costs[sacCheck]);
if (checking2)
if ((checking->tc != NULL && checking2->tc == NULL)
|| (checking->tc == NULL && checking2->tc != NULL))
{
return 0; //{s}{s(creature)}
}
}
}
else
return 0;
}
}
if (int result = costs[i]->setPayment(card))
{
@@ -1481,16 +1481,16 @@ int ExtraCosts::doPay()
{
costs[i]->target->isExtraCostTarget = false;
}
if (costs[i]->tc)
{
vector<Targetable*>targetlist = costs[i]->tc->getTargetsFrom();
for (vector<Targetable*>::iterator it = targetlist.begin(); it != targetlist.end(); it++)
{
costs[i]->target = dynamic_cast<MTGCardInstance*>(*it);
costs[i]->doPay();
}
}
else
if (costs[i]->tc)
{
vector<Targetable*>targetlist = costs[i]->tc->getTargetsFrom();
for (vector<Targetable*>::iterator it = targetlist.begin(); it != targetlist.end(); it++)
{
costs[i]->target = dynamic_cast<MTGCardInstance*>(*it);
costs[i]->doPay();
}
}
else
result += costs[i]->doPay();
}
return result;
projects/mtg/src/GameObserver.cpp
+33 -33
View File
@@ -52,7 +52,7 @@ void GameObserver::cleanup()
connectRule = false;
actionsList.clear();
gameTurn.clear();
OpenedDisplay = NULL;
OpenedDisplay = NULL;
}
GameObserver::~GameObserver()
@@ -97,7 +97,7 @@ GameObserver::GameObserver(WResourceManager *output, JGE* input)
targetChooser = NULL;
cardWaitingForTargets = NULL;
mExtraPayment = NULL;
OpenedDisplay = NULL;
OpenedDisplay = NULL;
guiOpenDisplay = NULL;
gameOver = NULL;
phaseRing = NULL;
@@ -328,11 +328,11 @@ void GameObserver::userRequestNextGamePhase(bool allowInterrupt, bool log)
// Here's what I find weird - if the extra cost is something like a sacrifice, doesn't that imply a TargetChooser?
if (WaitForExtraPayment(NULL))
return;
/*if (OpenedDisplay)//dont let us fly through all the phases with grave and library box still open.
{
return;//I want this here, but it locks up on opponents turn, we need to come up with a clever way to close opened
//displays, it makes no sense that you travel through 4 or 5 phases with library or grave still open.
}*/
/*if (OpenedDisplay)//dont let us fly through all the phases with grave and library box still open.
{
return;//I want this here, but it locks up on opponents turn, we need to come up with a clever way to close opened
//displays, it makes no sense that you travel through 4 or 5 phases with library or grave still open.
}*/
Phase * cPhaseOld = phaseRing->getCurrentPhase();
if (allowInterrupt && ((cPhaseOld->id == MTG_PHASE_COMBATBLOCKERS && combatStep == ORDER)
|| (cPhaseOld->id == MTG_PHASE_COMBATBLOCKERS && combatStep == TRIGGERS)
@@ -716,27 +716,27 @@ void GameObserver::gameStateBasedEffects()
}
}
card->bypassTC = false; //turn off bypass
///////////////////////////
//reset extracost shadows//
///////////////////////////
card->isExtraCostTarget = false;
if (mExtraPayment != NULL)
{
for (unsigned int ec = 0; ec < mExtraPayment->costs.size(); ec++)
{
///////////////////////////
//reset extracost shadows//
///////////////////////////
card->isExtraCostTarget = false;
if (mExtraPayment != NULL)
{
for (unsigned int ec = 0; ec < mExtraPayment->costs.size(); ec++)
{
if (mExtraPayment->costs[ec]->tc)
{
vector<Targetable*>targetlist = mExtraPayment->costs[ec]->tc->getTargetsFrom();
for (vector<Targetable*>::iterator it = targetlist.begin(); it != targetlist.end(); it++)
{
Targetable * cardMasked = *it;
dynamic_cast<MTGCardInstance*>(cardMasked)->isExtraCostTarget = true;
}
if (mExtraPayment->costs[ec]->tc)
{
vector<Targetable*>targetlist = mExtraPayment->costs[ec]->tc->getTargetsFrom();
for (vector<Targetable*>::iterator it = targetlist.begin(); it != targetlist.end(); it++)
{
Targetable * cardMasked = *it;
dynamic_cast<MTGCardInstance*>(cardMasked)->isExtraCostTarget = true;
}
}
}
}
}
}
}
////////////////////////////////////////////////////
//Unattach Equipments that dont have valid targets//
////////////////////////////////////////////////////
@@ -759,13 +759,13 @@ void GameObserver::gameStateBasedEffects()
///////////////////////////////////////////////////////
//Remove auras that don't have a valid target anymore//
///////////////////////////////////////////////////////
if (card->target && !isInPlay(card->target) && card->isBestowed && card->hasType("aura"))
{
card->removeType("aura");
card->addType("creature");
card->target = NULL;
card->isBestowed = false;
}
if (card->target && !isInPlay(card->target) && card->isBestowed && card->hasType("aura"))
{
card->removeType("aura");
card->addType("creature");
card->target = NULL;
card->isBestowed = false;
}
if ((card->target||card->playerTarget) && !card->hasType(Subtypes::TYPE_EQUIPMENT))
{
projects/mtg/src/GameStateOptions.cpp
+1 -1
View File
@@ -49,7 +49,7 @@ void GameStateOptions::Start()
optionsList->Add(NEW OptionInteger(Options::INTERRUPT_SECONDS, "Seconds to pause for an Interrupt", 20, 1));
optionsList->Add(NEW OptionInteger(Options::INTERRUPTMYSPELLS, "Interrupt my spells"));
// optionsList->Add(NEW OptionInteger(Options::INTERRUPTMYABILITIES, "Interrupt my abilities"));
//this is a dev option, not meant for standard play. uncomment if you need to see abilities you own hitting the stack.
//this is a dev option, not meant for standard play. uncomment if you need to see abilities you own hitting the stack.
optionsList->Add(NEW OptionInteger(Options::INTERRUPT_SECONDMAIN, "Interrupt opponent's end of turn"));
optionsTabs = NEW WGuiTabMenu();
optionsTabs->Add(optionsList);
projects/mtg/src/GuiStatic.cpp
+6 -6
View File
@@ -149,18 +149,18 @@ ostream& GuiAvatar::toString(ostream& out) const
void GuiGameZone::toggleDisplay()
{
if (showCards)
{
if (showCards)
{
cd->zone->owner->getObserver()->guiOpenDisplay = NULL;
showCards = 0;
cd->zone->owner->getObserver()->OpenedDisplay = NULL;
}
showCards = 0;
cd->zone->owner->getObserver()->OpenedDisplay = NULL;
}
else if(!cd->zone->owner->getObserver()->OpenedDisplay)//one display at a time please.
{
cd->zone->owner->getObserver()->guiOpenDisplay = this;
showCards = 1;
cd->init(zone);
cd->zone->owner->getObserver()->OpenedDisplay = cd;
cd->zone->owner->getObserver()->OpenedDisplay = cd;
}
}
projects/mtg/src/MTGAbility.cpp
+167 -167
View File
@@ -353,23 +353,23 @@ int AbilityFactory::parseCastRestrictions(MTGCardInstance * card, Player * playe
return 0;
}
check = restriction[i].find("delirium");
if (check != string::npos)
{
Player * checkCurrent = card->controller();
MTGGameZone * grave = checkCurrent->game->graveyard;
check = restriction[i].find("delirium");
if (check != string::npos)
{
Player * checkCurrent = card->controller();
MTGGameZone * grave = checkCurrent->game->graveyard;
int checkTypesAmount = 0;
if(grave->hasType("creature")) checkTypesAmount++;
if (grave->hasType("enchantment")) checkTypesAmount++;
if (grave->hasType("sorcery")) checkTypesAmount++;
if (grave->hasType("instant")) checkTypesAmount++;
if (grave->hasType("land")) checkTypesAmount++;
if (grave->hasType("artifact")) checkTypesAmount++;
if (grave->hasType("planeswalker")) checkTypesAmount++;
if (checkTypesAmount < 4)
return 0;
}
int checkTypesAmount = 0;
if(grave->hasType("creature")) checkTypesAmount++;
if (grave->hasType("enchantment")) checkTypesAmount++;
if (grave->hasType("sorcery")) checkTypesAmount++;
if (grave->hasType("instant")) checkTypesAmount++;
if (grave->hasType("land")) checkTypesAmount++;
if (grave->hasType("artifact")) checkTypesAmount++;
if (grave->hasType("planeswalker")) checkTypesAmount++;
if (checkTypesAmount < 4)
return 0;
}
check = restriction[i].find("miracle");
if(check != string::npos)
@@ -380,12 +380,12 @@ int AbilityFactory::parseCastRestrictions(MTGCardInstance * card, Player * playe
return 0;
}
check = restriction[i].find("madnessplayed");
if (check != string::npos)
{
if (card->previous && !card->previous->MadnessPlay)
return 0;
}
check = restriction[i].find("madnessplayed");
if (check != string::npos)
{
if (card->previous && !card->previous->MadnessPlay)
return 0;
}
check = restriction[i].find("prowl");
if(check != string::npos)
@@ -462,12 +462,12 @@ int AbilityFactory::parseCastRestrictions(MTGCardInstance * card, Player * playe
return 0;
}
check = restriction[i].find("geared");
if (check != string::npos)
{
if (card->equipment < 1)
return 0;
}
check = restriction[i].find("geared");
if (check != string::npos)
{
if (card->equipment < 1)
return 0;
}
check = restriction[i].find("canuntap");
if(check != string::npos)
@@ -1178,13 +1178,13 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
observer->addObserver(NEW MTGFlashBackRule(observer, -1));
return NULL;
}
//alternative cost type flashback
found = s.find("bestowrule");
if (found != string::npos)
{
observer->addObserver(NEW MTGBestowRule(observer, -1));
return NULL;
}
//alternative cost type flashback
found = s.find("bestowrule");
if (found != string::npos)
{
observer->addObserver(NEW MTGBestowRule(observer, -1));
return NULL;
}
//alternative cost type retrace
found = s.find("retracerule");
if(found != string::npos)
@@ -1353,53 +1353,53 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
string unchangedS = "";
unchangedS.append(s);
//Reveal:x remove the core so we dont build them prematurely
vector<string>transPayfound = parseBetween(s, "newability[pay(", " ");
vector<string>transfound = parseBetween(s,"newability[reveal:"," ");//if we are using reveal inside a newability, let transforms remove the string instead.
vector<string>abilfound = parseBetween(s, "ability$!name(reveal) reveal:", " ");
if(!abilfound.size())
abilfound = parseBetween(s, "ability$!reveal:", " ");//see above. this allows us to nest reveals inside these 2 other master classes. while also allowing us to nest them inside reveals.
found = s.find("pay(");
if (found != string::npos && storedPayString.empty() && !transPayfound.size())
{
vector<string> splitMayPaystr = parseBetween(s, "pay(", ")", true);
if (splitMayPaystr.size())
{
storedPayString.append(splitMayPaystr[2]);
s = splitMayPaystr[0];
s.append("pay(");
s.append(splitMayPaystr[1]);
s.append(")");
}
}
//Reveal:x remove the core so we dont build them prematurely
vector<string>transPayfound = parseBetween(s, "newability[pay(", " ");
vector<string>transfound = parseBetween(s,"newability[reveal:"," ");//if we are using reveal inside a newability, let transforms remove the string instead.
vector<string>abilfound = parseBetween(s, "ability$!name(reveal) reveal:", " ");
if(!abilfound.size())
abilfound = parseBetween(s, "ability$!reveal:", " ");//see above. this allows us to nest reveals inside these 2 other master classes. while also allowing us to nest them inside reveals.
found = s.find("pay(");
if (found != string::npos && storedPayString.empty() && !transPayfound.size())
{
vector<string> splitMayPaystr = parseBetween(s, "pay(", ")", true);
if (splitMayPaystr.size())
{
storedPayString.append(splitMayPaystr[2]);
s = splitMayPaystr[0];
s.append("pay(");
s.append(splitMayPaystr[1]);
s.append(")");
}
}
vector<string> splitGrant = parseBetween(s, "grant ", " grantend", false);
if (splitGrant.size() && storedAbilityString.empty())
{
storedAbilityString = splitGrant[1];
s = splitGrant[0];
s.append("grant ");
s.append(splitGrant[2]);
}
vector<string> splitGrant = parseBetween(s, "grant ", " grantend", false);
if (splitGrant.size() && storedAbilityString.empty())
{
storedAbilityString = splitGrant[1];
s = splitGrant[0];
s.append("grant ");
s.append(splitGrant[2]);
}
vector<string> splitRevealx = parseBetween(s, "reveal:", " revealend", false);
if (!abilfound.size() && !transfound.size() && splitRevealx.size() && storedAbilityString.empty())
{
storedAbilityString = splitRevealx[1];
s = splitRevealx[0];
s.append("reveal: ");
s.append(splitRevealx[2]);
}
vector<string> splitRevealx = parseBetween(s, "reveal:", " revealend", false);
if (!abilfound.size() && !transfound.size() && splitRevealx.size() && storedAbilityString.empty())
{
storedAbilityString = splitRevealx[1];
s = splitRevealx[0];
s.append("reveal: ");
s.append(splitRevealx[2]);
}
vector<string> splitScryx = parseBetween(s, "scry:", " scryend", false);
if (splitScryx.size() && storedAbilityString.empty())
{
storedAbilityString = splitScryx[1];
s = splitScryx[0];
s.append("scry: ");
s.append(splitScryx[2]);
}
vector<string> splitScryx = parseBetween(s, "scry:", " scryend", false);
if (splitScryx.size() && storedAbilityString.empty())
{
storedAbilityString = splitScryx[1];
s = splitScryx[0];
s.append("scry: ");
s.append(splitScryx[2]);
}
found = s.find("transforms((");
if (found != string::npos && storedString.empty())
@@ -1832,25 +1832,25 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
}
if (end != string::npos)
{
ThisDescriptor * td = NULL;
ThisDescriptor * td = NULL;
string thisDescriptorString = s.substr(found + header, end - found - header);
vector<string> splitRest = parseBetween(s, "restriction{", "}");
if (splitRest.size())
{
vector<string> splitRest = parseBetween(s, "restriction{", "}");
if (splitRest.size())
{
}
else
{
ThisDescriptorFactory tdf;
td = tdf.createThisDescriptor(observer, thisDescriptorString);
}
else
{
ThisDescriptorFactory tdf;
td = tdf.createThisDescriptor(observer, thisDescriptorString);
if (!td)
{
DebugTrace("MTGABILITY: Parsing Error:" << s);
return NULL;
}
}
if (!td)
{
DebugTrace("MTGABILITY: Parsing Error:" << s);
return NULL;
}
}
MTGAbility * a = parseMagicLine(s1, id, spell, card, 0, activated);
if (!a)
@@ -1887,9 +1887,9 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
case 1:
result = NEW AThisForEach(observer, id, card, _target, td, a);
break;
case 2:
result = NEW AThis(observer, id, card, _target, NULL, a, thisDescriptorString);
break;
case 2:
result = NEW AThis(observer, id, card, _target, NULL, a, thisDescriptorString);
break;
default:
result = NULL;
}
@@ -2251,15 +2251,15 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
return a;
}
//grant ability until source is untapped or leaves battlefield
found = s.find("grant ");
if (found != string::npos)
{
MTGAbility * toGrant = parseMagicLine(storedAbilityString, id, spell, card);
MTGAbility * a = NEW AGrantWrapper(observer, id, card, target,toGrant);
a->oneShot = 1;
return a;
}
//grant ability until source is untapped or leaves battlefield
found = s.find("grant ");
if (found != string::npos)
{
MTGAbility * toGrant = parseMagicLine(storedAbilityString, id, spell, card);
MTGAbility * a = NEW AGrantWrapper(observer, id, card, target,toGrant);
a->oneShot = 1;
return a;
}
//momentary blink
found = s.find("(blink)");
@@ -2382,21 +2382,21 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
tok->oneShot = 1;
return tok;
}
string tokenDesc = splitToken[1];
vector<string> tokenParameters = split(tokenDesc, ',');
//lets try finding a token by card name.
if (splitToken[1].size() && tokenParameters.size() ==1)
{
string cardName = splitToken[1];
MTGCard * safetycard = MTGCollection()->getCardByName(cardName);
if (safetycard) //lets try constructing it then,we didnt find it by name
{
ATokenCreator * tok = NEW ATokenCreator(observer, id, card, target, NULL, cardName, starfound, multiplier, who);
tok->oneShot = 1;
return tok;
}
}
//lets try finding a token by card name.
if (splitToken[1].size() && tokenParameters.size() ==1)
{
string cardName = splitToken[1];
MTGCard * safetycard = MTGCollection()->getCardByName(cardName);
if (safetycard) //lets try constructing it then,we didnt find it by name
{
ATokenCreator * tok = NEW ATokenCreator(observer, id, card, target, NULL, cardName, starfound, multiplier, who);
tok->oneShot = 1;
return tok;
}
}
if (tokenParameters.size() < 3)
{
DebugTrace("incorrect Parameters for Token" << tokenDesc);
@@ -2599,7 +2599,7 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
bool withRestrictions = splitCastCard[1].find("restricted") != string::npos;
bool asCopy = splitCastCard[1].find("copied") != string::npos;
bool asNormal = splitCastCard[1].find("normal") != string::npos;
bool asNormalMadness = splitCastCard[1].find("madness") != string::npos;
bool asNormalMadness = splitCastCard[1].find("madness") != string::npos;
bool sendNoEvent = splitCastCard[1].find("noevent") != string::npos;
bool putinplay = splitCastCard[1].find("putinplay") != string::npos;
string nameCard = "";
@@ -3058,15 +3058,15 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
return a;
}
//bestow
found = s.find("bstw");
if (found != string::npos)
{
MTGAbility * a = NEW ABestow(observer, id, card, target);
a->oneShot = 1;
return a;
//bestow
found = s.find("bstw");
if (found != string::npos)
{
MTGAbility * a = NEW ABestow(observer, id, card, target);
a->oneShot = 1;
return a;
}
}
//no counters on target of optional type
vector<string> splitCounterShroud = parseBetween(s, "countershroud(", ")");
@@ -3257,29 +3257,29 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
}
//Reveal:x (activate aility)
vector<string> splitReveal = parseBetween(s, "reveal:", "revealend", false);
if (splitReveal.size())
{
string backup = storedAbilityString;
storedAbilityString = "";//we clear the string here for cards that contain more than 1 reveal.
GenericRevealAbility * a = NEW GenericRevealAbility(observer, id, card, target, backup);
a->oneShot = 1;
a->canBeInterrupted = false;
return a;
}
//Reveal:x (activate aility)
vector<string> splitReveal = parseBetween(s, "reveal:", "revealend", false);
if (splitReveal.size())
{
string backup = storedAbilityString;
storedAbilityString = "";//we clear the string here for cards that contain more than 1 reveal.
GenericRevealAbility * a = NEW GenericRevealAbility(observer, id, card, target, backup);
a->oneShot = 1;
a->canBeInterrupted = false;
return a;
}
//scry:x (activate aility)
vector<string> splitScry = parseBetween(s, "scry:", "scryend", false);
if (splitScry.size())
{
string backup = storedAbilityString;
storedAbilityString = "";//we clear the string here for cards that contain more than 1 reveal.
GenericScryAbility * a = NEW GenericScryAbility(observer, id, card, target, backup);
a->oneShot = 1;
a->canBeInterrupted = false;
return a;
}
//scry:x (activate aility)
vector<string> splitScry = parseBetween(s, "scry:", "scryend", false);
if (splitScry.size())
{
string backup = storedAbilityString;
storedAbilityString = "";//we clear the string here for cards that contain more than 1 reveal.
GenericScryAbility * a = NEW GenericScryAbility(observer, id, card, target, backup);
a->oneShot = 1;
a->canBeInterrupted = false;
return a;
}
//flip
vector<string> splitFlipStat = parseBetween(s, "flip(", ")", true);
@@ -3455,14 +3455,14 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
return a;
}
//frozen, next untap this does not untap.
found = s.find("freeze");
if (found != string::npos)
{
MTGAbility * a = NEW AAFrozen(observer, id, card, target,true);
a->oneShot = 1;
return a;
}
//frozen, next untap this does not untap.
found = s.find("freeze");
if (found != string::npos)
{
MTGAbility * a = NEW AAFrozen(observer, id, card, target,true);
a->oneShot = 1;
return a;
}
//get a new target - retarget and newtarget makes the card refreshed - from exile to play...
if ((s.find("retarget") != string::npos) || s.find("newtarget") != string::npos)
@@ -3498,13 +3498,13 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
return a;
}
vector<string> splitCountObject = parseBetween(s, "count(", ")", false);
if (splitCountObject.size())
{
MTGAbility * a = NEW AACountObject(observer, id, card, card, NULL, splitCountObject[1]);
a->oneShot = 1;
return a;
}
vector<string> splitCountObject = parseBetween(s, "count(", ")", false);
if (splitCountObject.size())
{
MTGAbility * a = NEW AACountObject(observer, id, card, card, NULL, splitCountObject[1]);
a->oneShot = 1;
return a;
}
//switch targest power with toughness
found = s.find("swap");
@@ -4801,7 +4801,7 @@ MTGAbility::MTGAbility(const MTGAbility& a): ActionElement(a)
BuyBack = a.BuyBack; //? NEW ManaCost(a.BuyBack) : NULL;
FlashBack = a.FlashBack; // ? NEW ManaCost(a.FlashBack) : NULL;
Retrace = a.Retrace;// ? NEW ManaCost(a.Retrace) : NULL;
Bestow = a.Bestow;
Bestow = a.Bestow;
morph = a.morph; //? NEW ManaCost(a.morph) : NULL;
suspend = a.suspend;// ? NEW ManaCost(a.suspend) : NULL;
@@ -5949,7 +5949,7 @@ int AManaProducer::resolve()
Player * player = getPlayerFromTarget(_target);
if (!player)
return 0;
player->getManaPool()->add(output, source);
if(DoesntEmpty)
player->doesntEmpty->add(output);
projects/mtg/src/MTGCardInstance.cpp
+8 -8
View File
@@ -69,8 +69,8 @@ MTGCardInstance::MTGCardInstance(MTGCard * card, MTGPlayerCards * arg_belongs_to
cardistargetted = 0;
cardistargetter = 0;
myconvertedcost = getManaCost()->getConvertedCost();
revealedLast = NULL;
MadnessPlay = false;
revealedLast = NULL;
MadnessPlay = false;
}
MTGCardInstance * MTGCardInstance::createSnapShot()
@@ -153,14 +153,14 @@ int MTGCardInstance::init()
data = this;
X = 0;
castX = 0;
setX = -1;
setX = -1;
return 1;
}
void MTGCardInstance::initMTGCI()
{
X = 0;
setX = -1;
setX = -1;
sample = "";
model = NULL;
isToken = false;
@@ -198,7 +198,7 @@ void MTGCardInstance::initMTGCI()
wasDealtDamage = false;
isDualWielding = false;
suspended = false;
isBestowed = false;
isBestowed = false;
castMethod = Constants::NOT_CAST;
mPropertiesChangedSinceLastUpdate = false;
stillNeeded = true;
@@ -228,7 +228,7 @@ void MTGCardInstance::initMTGCI()
imprintW = 0;
currentimprintName = "";
imprintedNames.clear();
CountedObjects = 0;
CountedObjects = 0;
for (int i = 0; i < ManaCost::MANA_PAID_WITH_SUSPEND +1; i++)
alternateCostPaid[i] = 0;
@@ -782,8 +782,8 @@ int MTGCardInstance::getCurrentToughness()
//check stack
bool MTGCardInstance::StackIsEmptyandSorcerySpeed()
{
Player * whoInterupts = getObserver()->isInterrupting;//leave this so we can actually debug who is interupting/current.
Player * whoCurrent = getObserver()->currentPlayer;
Player * whoInterupts = getObserver()->isInterrupting;//leave this so we can actually debug who is interupting/current.
Player * whoCurrent = getObserver()->currentPlayer;
if((getObserver()->mLayers->stackLayer()->count(0, NOT_RESOLVED) == 0) &&
(getObserver()->getCurrentGamePhase() == MTG_PHASE_FIRSTMAIN ||
getObserver()->getCurrentGamePhase() == MTG_PHASE_SECONDMAIN) &&
projects/mtg/src/MTGDeck.cpp
+11 -11
View File
@@ -107,17 +107,17 @@ int MTGAllCards::processConfLine(string &s, MTGCard *card, CardPrimitive * primi
case 'b': //buyback/Bestow
if (!primitive) primitive = NEW CardPrimitive();
if (key[1] == 'e' && key[2] == 's')
{ //bestow
if (!primitive) primitive = NEW CardPrimitive();
if (ManaCost * cost = primitive->getManaCost())
{
string value = val;
std::transform(value.begin(), value.end(), value.begin(), ::tolower);
cost->setBestow(ManaCost::parseManaCost(value));
}
}
else//buyback
if (key[1] == 'e' && key[2] == 's')
{ //bestow
if (!primitive) primitive = NEW CardPrimitive();
if (ManaCost * cost = primitive->getManaCost())
{
string value = val;
std::transform(value.begin(), value.end(), value.begin(), ::tolower);
cost->setBestow(ManaCost::parseManaCost(value));
}
}
else//buyback
if (ManaCost * cost = primitive->getManaCost())
{
string value = val;
projects/mtg/src/MTGGamePhase.cpp
+1 -1
View File
@@ -9,7 +9,7 @@ MTGGamePhase::MTGGamePhase(GameObserver* g, int id) :
animation = 0;
currentState = -1;
mFont = WResourceManager::Instance()->GetWFont(Fonts::MAIN_FONT);
if(mFont)
if(mFont)
mFont->SetBase(0); // using 2nd font
}
projects/mtg/src/MTGGameZones.cpp
+30 -30
View File
@@ -74,7 +74,7 @@ MTGPlayerCards::~MTGPlayerCards()
SAFE_DELETE(stack);
SAFE_DELETE(removedFromGame);
SAFE_DELETE(garbage);
SAFE_DELETE(reveal);
SAFE_DELETE(reveal);
SAFE_DELETE(temp);
SAFE_DELETE(playRestrictions);
}
@@ -92,7 +92,7 @@ void MTGPlayerCards::beforeBeginPhase()
stack->beforeBeginPhase();
removedFromGame->beforeBeginPhase();
garbage->beforeBeginPhase();
reveal->beforeBeginPhase();
reveal->beforeBeginPhase();
temp->beforeBeginPhase();
}
@@ -107,7 +107,7 @@ void MTGPlayerCards::setOwner(Player * player)
stack->setOwner(player);
garbage->setOwner(player);
garbageLastTurn->setOwner(player);
reveal->setOwner(player);
reveal->setOwner(player);
temp->setOwner(player);
}
@@ -275,7 +275,7 @@ void MTGPlayerCards::init()
exile = removedFromGame;
garbage = NEW MTGGameZone();
garbageLastTurn = garbage;
reveal = NEW MTGGameZone();
reveal = NEW MTGGameZone();
temp = NEW MTGGameZone();
playRestrictions = NEW PlayRestrictions();
@@ -374,12 +374,12 @@ MTGCardInstance * MTGPlayerCards::putInZone(MTGCardInstance * card, MTGGameZone
}
}
//all cards that go from the hand to the graveyard is ALWAYS a discard.
if ((to == g->players[0]->game->graveyard || to == g->players[1]->game->graveyard) && (from == g->players[0]->game->hand || from
== g->players[1]->game->hand))
{
card->discarded = true;
}
//all cards that go from the hand to the graveyard is ALWAYS a discard.
if ((to == g->players[0]->game->graveyard || to == g->players[1]->game->graveyard) && (from == g->players[0]->game->hand || from
== g->players[1]->game->hand))
{
card->discarded = true;
}
//When a card is moved from inPlay to inPlay (controller change, for example), it is still the same object
if ((to == g->players[0]->game->inPlay || to == g->players[1]->game->inPlay) && (from == g->players[0]->game->inPlay || from
@@ -1019,12 +1019,12 @@ MTGGameZone * MTGGameZone::intToZone(int zoneId, Player * p, Player * p2)
case STACK:
return p->game->stack;
case MY_REVEAL:
return p->game->reveal;
case OPPONENT_REVEAL:
return p->opponent()->game->reveal;
case REVEAL:
return p->game->reveal;
case MY_REVEAL:
return p->game->reveal;
case OPPONENT_REVEAL:
return p->opponent()->game->reveal;
case REVEAL:
return p->game->reveal;
}
if (!p2) return NULL;
@@ -1048,8 +1048,8 @@ MTGGameZone * MTGGameZone::intToZone(int zoneId, Player * p, Player * p2)
case TARGET_CONTROLLER_STACK:
return p2->game->stack;
case TARGET_CONTROLLER_REVEAL:
return p2->game->reveal;
case TARGET_CONTROLLER_REVEAL:
return p2->game->reveal;
default:
return NULL;
@@ -1149,16 +1149,16 @@ MTGGameZone * MTGGameZone::intToZone(GameObserver *g, int zoneId, MTGCardInstanc
return source->playerTarget->game->stack;
else return source->controller()->game->stack;
case TARGET_OWNER_REVEAL:
return target->owner->game->reveal;
case REVEAL:
return target->owner->game->reveal;
case OWNER_REVEAL:
return target->owner->game->reveal;
case TARGETED_PLAYER_REVEAL:
if (source->playerTarget)
return source->playerTarget->game->reveal;
else return source->controller()->game->reveal;
case TARGET_OWNER_REVEAL:
return target->owner->game->reveal;
case REVEAL:
return target->owner->game->reveal;
case OWNER_REVEAL:
return target->owner->game->reveal;
case TARGETED_PLAYER_REVEAL:
if (source->playerTarget)
return source->playerTarget->game->reveal;
else return source->controller()->game->reveal;
default:
return NULL;
@@ -1187,7 +1187,7 @@ int MTGGameZone::zoneStringToId(string zoneName)
"mystack", "opponentstack", "targetownerstack", "targetcontrollerstack", "ownerstack", "stack","targetedpersonsstack",
"myreveal", "opponentreveal", "targetownerreveal", "targetcontrollerreveal", "ownerreveal", "reveal","targetedpersonsreveal",
"myreveal", "opponentreveal", "targetownerreveal", "targetcontrollerreveal", "ownerreveal", "reveal","targetedpersonsreveal",
};
@@ -1210,7 +1210,7 @@ int MTGGameZone::zoneStringToId(string zoneName)
MY_STACK, OPPONENT_STACK, TARGET_OWNER_STACK, TARGET_CONTROLLER_STACK, OWNER_STACK, STACK,TARGETED_PLAYER_STACK,
MY_REVEAL, OPPONENT_REVEAL, TARGET_OWNER_REVEAL, TARGET_CONTROLLER_REVEAL, OWNER_REVEAL, REVEAL,TARGETED_PLAYER_REVEAL };
MY_REVEAL, OPPONENT_REVEAL, TARGET_OWNER_REVEAL, TARGET_CONTROLLER_REVEAL, OWNER_REVEAL, REVEAL,TARGETED_PLAYER_REVEAL };
int max = sizeof(values) / sizeof *(values);
projects/mtg/src/MTGRules.cpp
+282 -282
View File
@@ -49,10 +49,10 @@ PermanentAbility(observer, _id)
Angel[i] = 0;
dragonbonusgranted[i] = false;
dragon[i] = 0;
eldrazibonusgranted[i] = false;
eldrazi[i] = 0;
werewolfbonusgranted[i] = false;
werewolf[i] = 0;
eldrazibonusgranted[i] = false;
eldrazi[i] = 0;
werewolfbonusgranted[i] = false;
werewolf[i] = 0;
}
}
@@ -175,10 +175,10 @@ int MTGEventBonus::receiveEvent(WEvent * event)
Angel[currentPlayer->getId()]++;
if(e->card->hasType("dragon")||e->card->hasType("wurm")||e->card->hasType("drake")||e->card->hasType("snake")||e->card->hasType("hydra"))
dragon[currentPlayer->getId()]++;
if (e->card->hasType("eldrazi"))
eldrazi[currentPlayer->getId()]++;
if (e->card->hasType("werewolf") || e->card->hasType("wolf"))
werewolf[currentPlayer->getId()]++;
if (e->card->hasType("eldrazi"))
eldrazi[currentPlayer->getId()]++;
if (e->card->hasType("werewolf") || e->card->hasType("wolf"))
werewolf[currentPlayer->getId()]++;
}
if(toys[currentPlayer->getId()] > 30 && !toybonusgranted[currentPlayer->getId()])
{
@@ -236,16 +236,16 @@ int MTGEventBonus::receiveEvent(WEvent * event)
grantAward("Teeth And Scales!",300);
dragonbonusgranted[currentPlayer->getId()] = true;
}
if (eldrazi[currentPlayer->getId()] > 30 && !eldrazibonusgranted[currentPlayer->getId()])
{
grantAward("Colorblind!", 300);
eldrazibonusgranted[currentPlayer->getId()] = true;
}
if (werewolf[currentPlayer->getId()] > 30 && !werewolfbonusgranted[currentPlayer->getId()])
{
grantAward("Full Moon!", 300);
werewolfbonusgranted[currentPlayer->getId()] = true;
}
if (eldrazi[currentPlayer->getId()] > 30 && !eldrazibonusgranted[currentPlayer->getId()])
{
grantAward("Colorblind!", 300);
eldrazibonusgranted[currentPlayer->getId()] = true;
}
if (werewolf[currentPlayer->getId()] > 30 && !werewolfbonusgranted[currentPlayer->getId()])
{
grantAward("Full Moon!", 300);
werewolfbonusgranted[currentPlayer->getId()] = true;
}
}
}
//bonus for dealing 100+ damage from a single source
@@ -383,65 +383,65 @@ int MTGPutInPlayRule::reactToClick(MTGCardInstance * card)
return 0;
Player * player = game->currentlyActing();
ManaCost * cost = card->getManaCost();
ManaCost * playerMana = player->getManaPool();
///////announce X cost///////
if ((cost->hasX() || cost->hasSpecificX()) && card->setX == -1)
{
vector<MTGAbility*>selection;
int options = cost->hasSpecificX() ? 20 : (playerMana->getConvertedCost() - cost->getConvertedCost()) + 1;
//you can set up to 20 for specific X, if you cant afford it, it cancels. I couldnt think of a equation that would
//give me the correct amount sorry.
for (int i = 0; i < options; ++i)
{
ManaCost * playerMana = player->getManaPool();
///////announce X cost///////
if ((cost->hasX() || cost->hasSpecificX()) && card->setX == -1)
{
vector<MTGAbility*>selection;
int options = cost->hasSpecificX() ? 20 : (playerMana->getConvertedCost() - cost->getConvertedCost()) + 1;
//you can set up to 20 for specific X, if you cant afford it, it cancels. I couldnt think of a equation that would
//give me the correct amount sorry.
for (int i = 0; i < options; ++i)
{
MTGAbility * setX = NEW AAWhatsX(game, game->mLayers->actionLayer()->getMaxId(), card, card, i, this);
MTGAbility * setCardX = setX->clone();
setCardX->oneShot = true;
selection.push_back(setCardX);
SAFE_DELETE(setX);
}
if (selection.size())
{
MTGAbility * a1 = NEW MenuAbility(game, this->GetId(), card, card, false, selection);
game->mLayers->actionLayer()->currentActionCard = card;
a1->resolve();
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////
//////X is set, below we set sunburst for X if needed and cast or reset the card.//////
//////107.3a If a spell or activated ability has a mana cost, alternative cost, //////
//////additional cost, and / or activation cost with an{ X }, [-X], or X in it, //////
//////and the value of X isn’t defined by the text of that spell or ability, the //////
//////controller of that spell or ability chooses and announces the value of X as//////
//////part of casting the spell or activating the ability. //////
//////(See rule 601, “Casting Spells.”) While a spell is on the stack, any X in //////
//////its mana cost or in any alternative cost or additional cost it has equals //////
//////the announced value.While an activated ability is on the stack, any X in //////
//////its activation cost equals the announced value. //////
///////////////////////////////////////////////////////////////////////////////////////
if (card->setX > -1)
{
ManaCost * Xcost = NEW ManaCost();
Xcost->copy(cost);
Xcost->add(Constants::MTG_COLOR_ARTIFACT, card->setX);
Xcost->remove(7, 1);
if (playerMana->canAfford(Xcost))
{
cost->copy(Xcost);
SAFE_DELETE(Xcost);
}
else
{
if (card->setX > -1)
card->setX = -1;
SAFE_DELETE(Xcost);
return 0;
}
}
//////////////////////////////////////////
////cards without X contenue from here////
//////////////////////////////////////////
MTGAbility * setX = NEW AAWhatsX(game, game->mLayers->actionLayer()->getMaxId(), card, card, i, this);
MTGAbility * setCardX = setX->clone();
setCardX->oneShot = true;
selection.push_back(setCardX);
SAFE_DELETE(setX);
}
if (selection.size())
{
MTGAbility * a1 = NEW MenuAbility(game, this->GetId(), card, card, false, selection);
game->mLayers->actionLayer()->currentActionCard = card;
a1->resolve();
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////
//////X is set, below we set sunburst for X if needed and cast or reset the card.//////
//////107.3a If a spell or activated ability has a mana cost, alternative cost, //////
//////additional cost, and / or activation cost with an{ X }, [-X], or X in it, //////
//////and the value of X isn’t defined by the text of that spell or ability, the //////
//////controller of that spell or ability chooses and announces the value of X as//////
//////part of casting the spell or activating the ability. //////
//////(See rule 601, “Casting Spells.”) While a spell is on the stack, any X in //////
//////its mana cost or in any alternative cost or additional cost it has equals //////
//////the announced value.While an activated ability is on the stack, any X in //////
//////its activation cost equals the announced value. //////
///////////////////////////////////////////////////////////////////////////////////////
if (card->setX > -1)
{
ManaCost * Xcost = NEW ManaCost();
Xcost->copy(cost);
Xcost->add(Constants::MTG_COLOR_ARTIFACT, card->setX);
Xcost->remove(7, 1);
if (playerMana->canAfford(Xcost))
{
cost->copy(Xcost);
SAFE_DELETE(Xcost);
}
else
{
if (card->setX > -1)
card->setX = -1;
SAFE_DELETE(Xcost);
return 0;
}
}
//////////////////////////////////////////
////cards without X contenue from here////
//////////////////////////////////////////
//this handles extra cost payments at the moment a card is played.
if (cost->isExtraPaymentSet())
{
@@ -456,7 +456,7 @@ int MTGPutInPlayRule::reactToClick(MTGCardInstance * card)
game->mExtraPayment = cost->extraCosts;
return 0;
}
ManaCost * previousManaPool = NEW ManaCost(player->getManaPool());
int payResult = player->getManaPool()->pay(card->getManaCost());
if (card->getManaCost()->getKicker() && (OptionKicker::KICKER_ALWAYS == options[Options::KICKERPAYMENT].number || card->controller()->isAI()))
@@ -570,9 +570,9 @@ int MTGKickerRule::isReactingToClick(MTGCardInstance * card, ManaCost *)
ManaCost * withKickerCost= NEW ManaCost(card->getManaCost());
withKickerCost->add(card->getManaCost()->getKicker());
//cost reduction/recalculation must be here or outside somehow...
//no recalculations beyound this point, reactToClick is the function that
//happens only with the assumption that you could actually pay for it, any calculations after will
//have negitive effects. this function is basically "can i play this card?"
//no recalculations beyound this point, reactToClick is the function that
//happens only with the assumption that you could actually pay for it, any calculations after will
//have negitive effects. this function is basically "can i play this card?"
#ifdef WIN32
withKickerCost->Dump();
#endif
@@ -787,61 +787,61 @@ int MTGAlternativeCostRule::reactToClick(MTGCardInstance * card, ManaCost *alter
Player * player = game->currentlyActing();
ManaPool * playerMana = player->getManaPool();
///////announce X cost///////
if ((alternateCost->hasX() || alternateCost->hasSpecificX()) && card->setX == -1)
{
vector<MTGAbility*>selection;
int options = alternateCost->hasSpecificX()? 20 : (playerMana->getConvertedCost() - alternateCost->getConvertedCost()) + 1;
//you can set up to 20 for specific X, if you cant afford it, it cancels. I couldnt think of a equation that would
//give me the correct amount sorry.
for (int i = 0; i < options; ++i)
{
///////announce X cost///////
if ((alternateCost->hasX() || alternateCost->hasSpecificX()) && card->setX == -1)
{
vector<MTGAbility*>selection;
int options = alternateCost->hasSpecificX()? 20 : (playerMana->getConvertedCost() - alternateCost->getConvertedCost()) + 1;
//you can set up to 20 for specific X, if you cant afford it, it cancels. I couldnt think of a equation that would
//give me the correct amount sorry.
for (int i = 0; i < options; ++i)
{
MTGAbility * setX = NEW AAWhatsX(game, game->mLayers->actionLayer()->getMaxId(), card, card, i, this);
MTGAbility * setCardX = setX->clone();
setCardX->oneShot = true;
selection.push_back(setCardX);
SAFE_DELETE(setX);
}
if (selection.size())
{
MTGAbility * a1 = NEW MenuAbility(game, this->GetId(), card, card, false, selection);
game->mLayers->actionLayer()->currentActionCard = card;
a1->resolve();
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////
//////X is set, below we set sunburst for X if needed and cast or reset the card.//////
//////107.3a If a spell or activated ability has a mana cost, alternative cost, //////
//////additional cost, and / or activation cost with an{ X }, [-X], or X in it, //////
//////and the value of X isn’t defined by the text of that spell or ability, the //////
//////controller of that spell or ability chooses and announces the value of X as//////
//////part of casting the spell or activating the ability. //////
//////(See rule 601, “Casting Spells.”) While a spell is on the stack, any X in //////
//////its mana cost or in any alternative cost or additional cost it has equals //////
//////the announced value.While an activated ability is on the stack, any X in //////
//////its activation cost equals the announced value. //////
///////////////////////////////////////////////////////////////////////////////////////
if (card->setX > -1)
{
ManaCost * Xcost = NEW ManaCost();
Xcost->copy(alternateCost);
Xcost->add(Constants::MTG_COLOR_ARTIFACT, card->setX);
Xcost->remove(7, 1);//remove the X
if (playerMana->canAfford(Xcost))
{
alternateCost->copy(Xcost);
SAFE_DELETE(Xcost);
}
else
{
if (card->setX > -1)
card->setX = -1;
SAFE_DELETE(Xcost);
return 0;
}
}
MTGAbility * setX = NEW AAWhatsX(game, game->mLayers->actionLayer()->getMaxId(), card, card, i, this);
MTGAbility * setCardX = setX->clone();
setCardX->oneShot = true;
selection.push_back(setCardX);
SAFE_DELETE(setX);
}
if (selection.size())
{
MTGAbility * a1 = NEW MenuAbility(game, this->GetId(), card, card, false, selection);
game->mLayers->actionLayer()->currentActionCard = card;
a1->resolve();
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////
//////X is set, below we set sunburst for X if needed and cast or reset the card.//////
//////107.3a If a spell or activated ability has a mana cost, alternative cost, //////
//////additional cost, and / or activation cost with an{ X }, [-X], or X in it, //////
//////and the value of X isn’t defined by the text of that spell or ability, the //////
//////controller of that spell or ability chooses and announces the value of X as//////
//////part of casting the spell or activating the ability. //////
//////(See rule 601, “Casting Spells.”) While a spell is on the stack, any X in //////
//////its mana cost or in any alternative cost or additional cost it has equals //////
//////the announced value.While an activated ability is on the stack, any X in //////
//////its activation cost equals the announced value. //////
///////////////////////////////////////////////////////////////////////////////////////
if (card->setX > -1)
{
ManaCost * Xcost = NEW ManaCost();
Xcost->copy(alternateCost);
Xcost->add(Constants::MTG_COLOR_ARTIFACT, card->setX);
Xcost->remove(7, 1);//remove the X
if (playerMana->canAfford(Xcost))
{
alternateCost->copy(Xcost);
SAFE_DELETE(Xcost);
}
else
{
if (card->setX > -1)
card->setX = -1;
SAFE_DELETE(Xcost);
return 0;
}
}
//this handles extra cost payments at the moment a card is played.
@@ -898,7 +898,7 @@ int MTGAlternativeCostRule::reactToClick(MTGCardInstance * card, ManaCost *alter
{
ManaCost * c = spellCost->Diff(alternateCost);
copy->X = card->setX;
copy->X = card->setX;
copy->castX = copy->X;
delete c;
}
@@ -1049,11 +1049,11 @@ int MTGRetraceRule::isReactingToClick(MTGCardInstance * card, ManaCost * mana)
Player * player = game->currentlyActing();
if(!card->getManaCost()->getRetrace())
return 0;
if (!player->game->graveyard->hasCard(card))
{
return 0;
}
ManaCost * retraceCost = card->getManaCost()->getRetrace();
if (!player->game->graveyard->hasCard(card))
{
return 0;
}
ManaCost * retraceCost = card->getManaCost()->getRetrace();
if(retraceCost->extraCosts)
for(unsigned int i = 0; i < retraceCost->extraCosts->costs.size();i++)
{
@@ -1364,25 +1364,25 @@ MTGAlternativeCostRule(observer, _id)
int MTGPayZeroRule::isReactingToClick(MTGCardInstance * card, ManaCost * mana)
{
if (!card->has(Constants::PAYZERO))
return 0;
Player * player = game->currentlyActing();
if (card->isLand() || (!player->game->graveyard->hasCard(card) && !player->game->exile->hasCard(card) && !player->game->hand->hasCard(card)))
{
//only allowed to pay zero for cards in library??? above is "if you dont have it in hand, grave, or exile"
return 0;
}
if ((!card->has(Constants::CANPLAYFROMGRAVEYARD) && player->game->graveyard->hasCard(card)) || (!card->has(Constants::CANPLAYFROMEXILE) && player->game->exile->hasCard(card)))
{
return 0;
}
ManaCost * cost = NEW ManaCost(ManaCost::parseManaCost("{0}", NULL, NULL));
ManaCost * newCost = card->computeNewCost(card, cost, cost);
if (newCost->extraCosts)
for (unsigned int i = 0; i < newCost->extraCosts->costs.size(); i++)
{
newCost->extraCosts->costs[i]->setSource(card);
}
if (!card->has(Constants::PAYZERO))
return 0;
Player * player = game->currentlyActing();
if (card->isLand() || (!player->game->graveyard->hasCard(card) && !player->game->exile->hasCard(card) && !player->game->hand->hasCard(card)))
{
//only allowed to pay zero for cards in library??? above is "if you dont have it in hand, grave, or exile"
return 0;
}
if ((!card->has(Constants::CANPLAYFROMGRAVEYARD) && player->game->graveyard->hasCard(card)) || (!card->has(Constants::CANPLAYFROMEXILE) && player->game->exile->hasCard(card)))
{
return 0;
}
ManaCost * cost = NEW ManaCost(ManaCost::parseManaCost("{0}", NULL, NULL));
ManaCost * newCost = card->computeNewCost(card, cost, cost);
if (newCost->extraCosts)
for (unsigned int i = 0; i < newCost->extraCosts->costs.size(); i++)
{
newCost->extraCosts->costs[i]->setSource(card);
}
if(card->has(Constants::CANPLAYFROMGRAVEYARD))
CustomName = "Zero Cast From Graveyard";
else if(card->has(Constants::CANPLAYFROMEXILE))
@@ -1432,19 +1432,19 @@ int MTGOverloadRule::isReactingToClick(MTGCardInstance * card, ManaCost * mana)
{
if (!card->has(Constants::OVERLOAD))
return 0;
if (card->isLand())
{
return 0;
}
Player * player = card->controller();
if (!player->game->graveyard->hasCard(card) && !player->game->exile->hasCard(card) && !player->game->hand->hasCard(card))
{
return 0;
}
if ((!card->has(Constants::CANPLAYFROMGRAVEYARD) && player->game->graveyard->hasCard(card)) || (!card->has(Constants::CANPLAYFROMEXILE) && player->game->exile->hasCard(card)))
{
return 0;
}
if (card->isLand())
{
return 0;
}
Player * player = card->controller();
if (!player->game->graveyard->hasCard(card) && !player->game->exile->hasCard(card) && !player->game->hand->hasCard(card))
{
return 0;
}
if ((!card->has(Constants::CANPLAYFROMGRAVEYARD) && player->game->graveyard->hasCard(card)) || (!card->has(Constants::CANPLAYFROMEXILE) && player->game->exile->hasCard(card)))
{
return 0;
}
ManaCost * newCost = card->getManaCost()->getAlternative();
if(newCost->extraCosts)
for(unsigned int i = 0; i < newCost->extraCosts->costs.size();i++)
@@ -1484,64 +1484,64 @@ MTGOverloadRule * MTGOverloadRule::clone() const
///////////////////////////////////////////////////////////////////////////////////////////////////
//bestow
MTGBestowRule::MTGBestowRule(GameObserver* observer, int _id) :
MTGAlternativeCostRule(observer, _id)
MTGAlternativeCostRule(observer, _id)
{
aType = MTGAbility::BESTOW_COST;
aType = MTGAbility::BESTOW_COST;
}
int MTGBestowRule::isReactingToClick(MTGCardInstance * card, ManaCost * mana)
{
if (!card->model)
return 0;
if (!card->model->data->getManaCost()->getBestow())
return 0;
if (card->isInPlay(game))
return 0;
if (card->isLand())
{
return 0;
}
if (!card->controller()->inPlay()->hasType("creature") && !card->controller()->opponent()->inPlay()->hasType("creature"))
{
return 0;
}
ManaCost * newCost = card->getManaCost()->getBestow();
if (newCost->extraCosts)
for (unsigned int i = 0; i < newCost->extraCosts->costs.size(); i++)
{
newCost->extraCosts->costs[i]->setSource(card);
}
return MTGAlternativeCostRule::isReactingToClick(card, mana, newCost);
if (!card->model)
return 0;
if (!card->model->data->getManaCost()->getBestow())
return 0;
if (card->isInPlay(game))
return 0;
if (card->isLand())
{
return 0;
}
if (!card->controller()->inPlay()->hasType("creature") && !card->controller()->opponent()->inPlay()->hasType("creature"))
{
return 0;
}
ManaCost * newCost = card->getManaCost()->getBestow();
if (newCost->extraCosts)
for (unsigned int i = 0; i < newCost->extraCosts->costs.size(); i++)
{
newCost->extraCosts->costs[i]->setSource(card);
}
return MTGAlternativeCostRule::isReactingToClick(card, mana, newCost);
}
int MTGBestowRule::reactToClick(MTGCardInstance * card)
{
if (!isReactingToClick(card))
return 0;
//this new method below in all alternative cost type causes a memleak, however, you cant safedelete the cost here as it cause a crash
//TODO::::we need to get to the source of this leak and fix it.
ManaCost * newCost = card->getManaCost()->getBestow();
if (newCost->extraCosts)
for (unsigned int i = 0; i < newCost->extraCosts->costs.size(); i++)
{
newCost->extraCosts->costs[i]->setSource(card);
}
if (!isReactingToClick(card))
return 0;
//this new method below in all alternative cost type causes a memleak, however, you cant safedelete the cost here as it cause a crash
//TODO::::we need to get to the source of this leak and fix it.
ManaCost * newCost = card->getManaCost()->getBestow();
if (newCost->extraCosts)
for (unsigned int i = 0; i < newCost->extraCosts->costs.size(); i++)
{
newCost->extraCosts->costs[i]->setSource(card);
}
card->paymenttype = MTGAbility::BESTOW_COST;
card->spellTargetType = "creature|battlefield";
return MTGAlternativeCostRule::reactToClick(card, newCost, ManaCost::MANA_PAID_WITH_BESTOW, false);
card->paymenttype = MTGAbility::BESTOW_COST;
card->spellTargetType = "creature|battlefield";
return MTGAlternativeCostRule::reactToClick(card, newCost, ManaCost::MANA_PAID_WITH_BESTOW, false);
}
ostream& MTGBestowRule::toString(ostream& out) const
{
out << "MTGBestowRule ::: (";
return MTGAbility::toString(out) << ")";
out << "MTGBestowRule ::: (";
return MTGAbility::toString(out) << ")";
}
MTGBestowRule * MTGBestowRule::clone() const
{
return NEW MTGBestowRule(*this);
return NEW MTGBestowRule(*this);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1732,19 +1732,19 @@ int MTGAttackRule::receiveEvent(WEvent *e)
for (int i = 0; i < z->nb_cards; i++)
{
MTGCardInstance * card = z->cards[i];
if (card->isAttacker() && card->has(Constants::NOSOLO))
{
TargetChooserFactory tf(game);
TargetChooser * tc = tf.createTargetChooser("creature[attacking]", NULL);
int Check = card->controller()->game->battlefield->countByCanTarget(tc);
if (Check <2)
card->initAttackersDefensers();
}
if (card->isAttacker() && card->has(Constants::DETHRONE))
{
if (p->opponent()->life >= p->life)
card->counters->addCounter(1, 1);
}
if (card->isAttacker() && card->has(Constants::NOSOLO))
{
TargetChooserFactory tf(game);
TargetChooser * tc = tf.createTargetChooser("creature[attacking]", NULL);
int Check = card->controller()->game->battlefield->countByCanTarget(tc);
if (Check <2)
card->initAttackersDefensers();
}
if (card->isAttacker() && card->has(Constants::DETHRONE))
{
if (p->opponent()->life >= p->life)
card->counters->addCounter(1, 1);
}
if (!card->isAttacker() && !event->from->isExtra && card->has(Constants::MUSTATTACK))//cards are only required to attack in the real attack phase of a turn.
reactToClick(card);
if (!card->isAttacker() && card->has(Constants::TREASON) && p->isAI())
@@ -2058,49 +2058,49 @@ PermanentAbility(observer, _id)
int MTGBlockRule::receiveEvent(WEvent *e)
{
if (dynamic_cast<WEventBlockersChosen*>(e))
{//do not refactor, these are keep seperate for readability.
Player * p = game->currentPlayer;
if (dynamic_cast<WEventBlockersChosen*>(e))
{//do not refactor, these are keep seperate for readability.
Player * p = game->currentPlayer;
vector<MTGCardInstance *> Attacker;
MTGGameZone * k = p->game->inPlay;
for (int i = 0; i < k->nb_cards; i++)
{
MTGCardInstance * card = k->cards[i];
if (card->isAttacker())
{
Attacker.push_back(card);
}
}
//force cards that must block, to block whatever is first found. players have a chance to set thier own
//but if ignored we do it for them.
if (Attacker.size())
{
MTGGameZone * tf = p->opponent()->game->inPlay;
for (size_t i = 0; i < tf->cards.size(); i++)
{
MTGCardInstance * card = tf->cards[i];
if (card->has(Constants::MUSTBLOCK) && !card->defenser && card->canBlock())
{//force mustblockers to block the first thing theyre allowed to block if player leaves blockers with them
//unassigned as a block.
for (size_t i = 0; i < Attacker.size(); i++)
{
if (card->canBlock(Attacker[i]) && !card->defenser)
{
blocker = NEW AABlock(card->getObserver(), -1, card, NULL);
blocker->oneShot = true;
blocker->forceDestroy = 1;
blocker->canBeInterrupted = false;
blocker->target = Attacker[i];
blocker->resolve();
SAFE_DELETE(blocker);
}
}
vector<MTGCardInstance *> Attacker;
MTGGameZone * k = p->game->inPlay;
for (int i = 0; i < k->nb_cards; i++)
{
MTGCardInstance * card = k->cards[i];
if (card->isAttacker())
{
Attacker.push_back(card);
}
}
//force cards that must block, to block whatever is first found. players have a chance to set thier own
//but if ignored we do it for them.
if (Attacker.size())
{
MTGGameZone * tf = p->opponent()->game->inPlay;
for (size_t i = 0; i < tf->cards.size(); i++)
{
MTGCardInstance * card = tf->cards[i];
if (card->has(Constants::MUSTBLOCK) && !card->defenser && card->canBlock())
{//force mustblockers to block the first thing theyre allowed to block if player leaves blockers with them
//unassigned as a block.
for (size_t i = 0; i < Attacker.size(); i++)
{
if (card->canBlock(Attacker[i]) && !card->defenser)
{
blocker = NEW AABlock(card->getObserver(), -1, card, NULL);
blocker->oneShot = true;
blocker->forceDestroy = 1;
blocker->canBeInterrupted = false;
blocker->target = Attacker[i];
blocker->resolve();
SAFE_DELETE(blocker);
}
}
}
}
}
}
}
}
if (dynamic_cast<WEventBlockersChosen*>(e))
{
@@ -2120,23 +2120,23 @@ int MTGBlockRule::receiveEvent(WEvent *e)
}
}
//if a card with menace is not blocked by 2 or more, remove any known blockers and attacking as normal.
MTGGameZone * z = p->game->inPlay;
for (int i = 0; i < z->nb_cards; i++)
{
MTGCardInstance * card = z->cards[i];
if (card->has(Constants::MENACE) && card->blockers.size() < 2)
{
while (card->blockers.size())
{
MTGCardInstance * blockingCard = card->blockers.front();
blockingCard->toggleDefenser(NULL);
}
}
}
//if a card with menace is not blocked by 2 or more, remove any known blockers and attacking as normal.
MTGGameZone * z = p->game->inPlay;
for (int i = 0; i < z->nb_cards; i++)
{
MTGCardInstance * card = z->cards[i];
if (card->has(Constants::MENACE) && card->blockers.size() < 2)
{
while (card->blockers.size())
{
MTGCardInstance * blockingCard = card->blockers.front();
blockingCard->toggleDefenser(NULL);
}
}
}
}
}
return 1;
@@ -2906,7 +2906,7 @@ int MTGPersistRule::receiveEvent(WEvent * event)
}
AAMover *putinplay = NEW AAMover(game, game->mLayers->actionLayer()->getMaxId(), copy, copy,"ownerbattlefield",code,NULL,undying,persist);
putinplay->oneShot = true;
game->mLayers->actionLayer()->garbage.push_back(putinplay);
game->mLayers->actionLayer()->garbage.push_back(putinplay);
putinplay->fireAbility();
return 1;
}
projects/mtg/src/ManaCost.cpp
+51 -51
View File
@@ -153,7 +153,7 @@ ManaCost * ManaCost::parseManaCost(string s, ManaCost * _manaCost, MTGCardInstan
}
break;
case 'e':
//Exile
//Exile
manaCost->addExtraCost(NEW ExileTargetCost(tc));
break;
case 'h': //bounce (move to Hand)
@@ -179,12 +179,12 @@ ManaCost * ManaCost::parseManaCost(string s, ManaCost * _manaCost, MTGCardInstan
}
break;
case 'd': //DiscardRandom cost
if (value.find("delve") != string::npos)
{
if(!tc)
tc = tcf.createTargetChooser("*|mygraveyard", c);
manaCost->addExtraCost(NEW Delve(tc));
}
if (value.find("delve") != string::npos)
{
if(!tc)
tc = tcf.createTargetChooser("*|mygraveyard", c);
manaCost->addExtraCost(NEW Delve(tc));
}
else if (value == "d")
{
manaCost->addExtraCost(NEW DiscardRandomCost(tc));
@@ -259,12 +259,12 @@ ManaCost * ManaCost::parseManaCost(string s, ManaCost * _manaCost, MTGCardInstan
break;
case 'c': //Counters or cycle
{
if (value.find("convoke") != string::npos)
{
if (!tc)
tc = tcf.createTargetChooser("creature|mybattlefield", c);
manaCost->addExtraCost(NEW Convoke(tc));
}
if (value.find("convoke") != string::npos)
{
if (!tc)
tc = tcf.createTargetChooser("creature|mybattlefield", c);
manaCost->addExtraCost(NEW Convoke(tc));
}
else if(value == "chosencolor")
{
if(c)
@@ -389,22 +389,22 @@ ManaCost::ManaCost(ManaCost * manaCost)
{
cost[i] = manaCost->getCost(i);
}
hybrids = manaCost->hybrids;
kicker = NEW ManaCost(manaCost->kicker);
if (kicker)
kicker->isMulti = manaCost->isMulti;
hybrids = manaCost->hybrids;
kicker = NEW ManaCost(manaCost->kicker);
if (kicker)
kicker->isMulti = manaCost->isMulti;
Retrace = NEW ManaCost( manaCost->Retrace );
BuyBack = NEW ManaCost( manaCost->BuyBack );
alternative = NEW ManaCost( manaCost->alternative );
FlashBack = NEW ManaCost( manaCost->FlashBack );
morph = NEW ManaCost( manaCost->morph );
suspend = NEW ManaCost( manaCost->suspend );
Bestow = NEW ManaCost(manaCost->Bestow);
extraCosts = NULL;
if (manaCost->extraCosts)
{
extraCosts = manaCost->extraCosts->clone();
}
Bestow = NEW ManaCost(manaCost->Bestow);
extraCosts = NULL;
if (manaCost->extraCosts)
{
extraCosts = manaCost->extraCosts->clone();
}
manaUsedToCast = NULL;
xColor = manaCost->xColor;
}
@@ -431,12 +431,12 @@ ManaCost::ManaCost(const ManaCost& manaCost)
FlashBack = NEW ManaCost( manaCost.FlashBack );
morph = NEW ManaCost( manaCost.morph );
suspend = NEW ManaCost( manaCost.suspend );
Bestow = NEW ManaCost(manaCost.Bestow);
extraCosts = NULL;
if (manaCost.extraCosts)
{
extraCosts = manaCost.extraCosts->clone();
}
Bestow = NEW ManaCost(manaCost.Bestow);
extraCosts = NULL;
if (manaCost.extraCosts)
{
extraCosts = manaCost.extraCosts->clone();
}
manaUsedToCast = NULL;
xColor = manaCost.xColor;
@@ -459,7 +459,7 @@ ManaCost & ManaCost::operator= (const ManaCost & manaCost)
FlashBack = manaCost.FlashBack;
morph = manaCost.morph;
suspend = manaCost.suspend;
Bestow = manaCost.Bestow;
Bestow = manaCost.Bestow;
manaUsedToCast = manaCost.manaUsedToCast;
xColor = manaCost.xColor;
}
@@ -476,7 +476,7 @@ ManaCost::~ManaCost()
SAFE_DELETE(Retrace);
SAFE_DELETE(morph);
SAFE_DELETE(suspend);
SAFE_DELETE(Bestow);
SAFE_DELETE(Bestow);
SAFE_DELETE(manaUsedToCast);
cost.erase(cost.begin() ,cost.end());
@@ -558,7 +558,7 @@ void ManaCost::init()
Retrace = NULL;
morph = NULL;
suspend = NULL;
Bestow = NULL;
Bestow = NULL;
manaUsedToCast = NULL;
isMulti = false;
xColor = -1;
@@ -583,7 +583,7 @@ void ManaCost::resetCosts()
SAFE_DELETE(Retrace);
SAFE_DELETE(morph);
SAFE_DELETE(suspend);
SAFE_DELETE(Bestow);
SAFE_DELETE(Bestow);
}
void ManaCost::copy(ManaCost * _manaCost)
@@ -650,12 +650,12 @@ void ManaCost::copy(ManaCost * _manaCost)
suspend = NEW ManaCost();
suspend->copy(_manaCost->suspend);
}
SAFE_DELETE(Bestow);
if (_manaCost->Bestow)
{
Bestow = NEW ManaCost();
Bestow->copy(_manaCost->Bestow);
}
SAFE_DELETE(Bestow);
if (_manaCost->Bestow)
{
Bestow = NEW ManaCost();
Bestow->copy(_manaCost->Bestow);
}
xColor = _manaCost->xColor;
}
@@ -1120,7 +1120,7 @@ void ManaPool::Empty()
SAFE_DELETE(Retrace);
SAFE_DELETE(morph);
SAFE_DELETE(suspend);
SAFE_DELETE(Bestow);
SAFE_DELETE(Bestow);
SAFE_DELETE(manaUsedToCast);
init();
WEvent * e = NEW WEventEmptyManaPool(this);
@@ -1150,8 +1150,8 @@ int ManaPool::remove(int color, int value)
int ManaPool::add(int color, int value, MTGCardInstance * source, bool extra)
{
if (color == Constants::MTG_COLOR_ARTIFACT)
color = Constants::MTG_COLOR_WASTE;
if (color == Constants::MTG_COLOR_ARTIFACT)
color = Constants::MTG_COLOR_WASTE;
int result = ManaCost::add(color, value);
for (int i = 0; i < value; ++i)
{
@@ -1171,15 +1171,15 @@ int ManaPool::add(ManaCost * _cost, MTGCardInstance * source)
{
if (!_cost)
return 0;
//while colorless is still exactly the same, there are now cards that require
//true colorless mana, ei:eldrazi. so whenever we add mana, we now replace it with the
//new type. keeping the old type intact for payment methods {1}{c} ....
int replaceArtifact = _cost->getCost(Constants::MTG_COLOR_ARTIFACT);
if (replaceArtifact)
{
_cost->add(Constants::MTG_COLOR_WASTE, replaceArtifact);
_cost->remove(Constants::MTG_COLOR_ARTIFACT, replaceArtifact);
}
//while colorless is still exactly the same, there are now cards that require
//true colorless mana, ei:eldrazi. so whenever we add mana, we now replace it with the
//new type. keeping the old type intact for payment methods {1}{c} ....
int replaceArtifact = _cost->getCost(Constants::MTG_COLOR_ARTIFACT);
if (replaceArtifact)
{
_cost->add(Constants::MTG_COLOR_WASTE, replaceArtifact);
_cost->remove(Constants::MTG_COLOR_ARTIFACT, replaceArtifact);
}
int result = ManaCost::add(_cost);
for (int i = 0; i < Constants::NB_Colors; i++)
{
projects/mtg/src/Rules.cpp
+1 -1
View File
@@ -419,7 +419,7 @@ void Rules::initGame(GameObserver *g, bool currentPlayerSet)
initState.playerData[i].player->game->hand,
initState.playerData[i].player->game->inPlay,
initState.playerData[i].player->game->exile,
initState.playerData[i].player->game->reveal };
initState.playerData[i].player->game->reveal };
for (int j = 0; j < 5; j++)
{
MTGGameZone * zone = playerZones[j];
projects/mtg/src/TargetChooser.cpp
+19 -19
View File
@@ -156,11 +156,11 @@ TargetChooser * TargetChooserFactory::createTargetChooser(string s, MTGCardInsta
{
zones[nbzones++] = MTGGameZone::ALL_ZONES;
}
else if (zoneName.compare("reveal") == 0)
{
zones[nbzones++] = MTGGameZone::MY_REVEAL;
zones[nbzones++] = MTGGameZone::OPPONENT_REVEAL;
}
else if (zoneName.compare("reveal") == 0)
{
zones[nbzones++] = MTGGameZone::MY_REVEAL;
zones[nbzones++] = MTGGameZone::OPPONENT_REVEAL;
}
else if (zoneName.compare("graveyard") == 0)
{
zones[nbzones++] = MTGGameZone::MY_GRAVEYARD;
@@ -642,15 +642,15 @@ TargetChooser * TargetChooserFactory::createTargetChooser(string s, MTGCardInsta
}
}
if (attribute.find("colorless") != string::npos)
{
attributefound = 1;
for (int cid = 1; cid < Constants::NB_Colors; cid++)
{
cd->SetExclusionColor(cid);
}
cd->mode = CardDescriptor::CD_OR;
}
if (attribute.find("colorless") != string::npos)
{
attributefound = 1;
for (int cid = 1; cid < Constants::NB_Colors; cid++)
{
cd->SetExclusionColor(cid);
}
cd->mode = CardDescriptor::CD_OR;
}
if (attribute.find("chosencolor") != string::npos)
{
@@ -822,7 +822,7 @@ TargetChooser::TargetChooser(GameObserver *observer, MTGCardInstance * card, int
TargetsList(), observer(observer)
{
forceTargetListReady = 0;
forceTargetListReadyByPlayer = 0;
forceTargetListReadyByPlayer = 0;
source = card;
targetter = card;
maxtargets = _maxtargets;
@@ -905,10 +905,10 @@ int TargetChooser::ForceTargetListReady()
int TargetChooser::targetsReadyCheck()
{
if (targetMin == false && !targets.size() && forceTargetListReadyByPlayer)
{
return TARGET_OK_FULL;//we have no min amount for targets and 0 targets is a valid amount player called for a forced finish.
}
if (targetMin == false && !targets.size() && forceTargetListReadyByPlayer)
{
return TARGET_OK_FULL;//we have no min amount for targets and 0 targets is a valid amount player called for a forced finish.
}
if (!targets.size())
{
return TARGET_NOK;
projects/mtg/src/TargetsList.cpp
+6 -6
View File
@@ -20,15 +20,15 @@ int TargetsList::addTarget(Targetable * target)
{
if (!alreadyHasTarget(target))
{
TargetChooser * tc = target->getObserver()->getCurrentTargetChooser();
if(!tc || (tc && tc->maxtargets == 1))
{
if (dynamic_cast<TargetChooser*>(this)->maxtargets > int(getNbTargets()))
{
targets.push_back(target);
return 1;
}
if (dynamic_cast<TargetChooser*>(this)->maxtargets > int(getNbTargets()))
{
targets.push_back(target);
return 1;
}
//because this was originally coded with targets as an array
//we have to add this conditional to insure that cards with single target effects
//and abilities that seek the nextcardtarget still work correctly.
projects/mtg/src/WEvent.cpp
+1 -1
View File
@@ -123,7 +123,7 @@ WEventTarget::WEventTarget(MTGCardInstance * card,MTGCardInstance * source) :
WEventCardUpdate(card),card(card),source(source)
{
card->cardistargetted = 1;
if(source)
if(source)
source->cardistargetter = 1;
}