1778 lines
48 KiB
C++
1778 lines
48 KiB
C++
#include "PrecompiledHeader.h"
|
|
|
|
#include "ExtraCost.h"
|
|
#include "TargetChooser.h"
|
|
#include "MTGCardInstance.h"
|
|
#include "Translate.h"
|
|
#include "Player.h"
|
|
#include "Counters.h"
|
|
#include "AllAbilities.h"
|
|
|
|
#if (__cplusplus > 199711L) || (_MSC_VER >= 1700)
|
|
//#include <unique_ptr>
|
|
typedef std::unique_ptr<ManaCost> ManaCostPtr;
|
|
#elif defined(QT_CONFIG)
|
|
#include <QScopedPointer>
|
|
class ManaCostPtr : public QScopedPointer<ManaCost>
|
|
{
|
|
public:
|
|
ManaCostPtr(ManaCost*m) : QScopedPointer(m){
|
|
};
|
|
ManaCost* get() const {return data();};
|
|
|
|
};
|
|
#else
|
|
#include <boost/scoped_ptr.hpp>
|
|
typedef boost::scoped_ptr<ManaCost> ManaCostPtr;
|
|
#endif
|
|
|
|
SUPPORT_OBJECT_ANALYTICS(ExtraCost)
|
|
|
|
ExtraCost::ExtraCost(const std::string& inCostRenderString, TargetChooser *_tc, ManaCost * _costToPay)
|
|
: tc(_tc),costToPay(_costToPay), source(NULL), target(NULL), mCostRenderString(inCostRenderString)
|
|
{
|
|
if (tc)
|
|
tc->targetter = NULL;
|
|
}
|
|
|
|
ExtraCost::~ExtraCost()
|
|
{
|
|
SAFE_DELETE(costToPay);
|
|
SAFE_DELETE(tc);
|
|
}
|
|
|
|
int ExtraCost::setSource(MTGCardInstance * _source)
|
|
{
|
|
source = _source;
|
|
if (tc)
|
|
{
|
|
tc->source = _source;
|
|
// this keeps the target chooser from being unable to select a creature with shroud/protections.
|
|
tc->targetter = NULL;
|
|
tc->Owner = source->controller();
|
|
}
|
|
else
|
|
{
|
|
target = _source;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void ExtraCost::Render()
|
|
{
|
|
if (!mCostRenderString.empty())
|
|
{
|
|
WFont * mFont = WResourceManager::Instance()->GetWFont(Fonts::MAIN_FONT);
|
|
mFont->SetScale(DEFAULT_MAIN_FONT_SCALE);
|
|
mFont->SetColor(ARGB(255,255,255,255));
|
|
mFont->DrawString(mCostRenderString, 40, 20, JGETEXT_LEFT);
|
|
}
|
|
}
|
|
|
|
int ExtraCost::setPayment(MTGCardInstance * card)
|
|
{
|
|
int result = 0;
|
|
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.
|
|
if (result)
|
|
{
|
|
target = card;
|
|
}
|
|
}
|
|
if (costToPay && source->controller()->getManaPool()->canAfford(costToPay,card->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
result = 1;
|
|
}
|
|
return result;
|
|
}
|
|
//extra added manacost, or add a manacost as the cost of extra
|
|
ExtraManaCost * ExtraManaCost::clone() const
|
|
{
|
|
ExtraManaCost * ec = NEW ExtraManaCost(*this);
|
|
return ec;
|
|
}
|
|
|
|
ExtraManaCost::ExtraManaCost(ManaCost * costToPay)
|
|
: ExtraCost("\nCost:",NULL, costToPay)
|
|
{
|
|
}
|
|
|
|
int ExtraManaCost::tryToSetPayment(MTGCardInstance * card)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
int ExtraManaCost::isPaymentSet()
|
|
{
|
|
if (!source->controller()->getManaPool()->canAfford(costToPay,source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int ExtraManaCost::canPay()
|
|
{
|
|
if(!source->controller()->getManaPool()->canAfford(costToPay,source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int ExtraManaCost::doPay()
|
|
{
|
|
if (!source->controller()->getManaPool()->canAfford(costToPay,source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
return 0;
|
|
|
|
source->controller()->getManaPool()->pay(costToPay);
|
|
return 1;
|
|
}
|
|
|
|
//Snow cost
|
|
SnowCost * SnowCost::clone() const
|
|
{
|
|
SnowCost * ec = NEW SnowCost(*this);
|
|
return ec;
|
|
}
|
|
|
|
SnowCost::SnowCost() :
|
|
ExtraCost("Snow Mana")
|
|
{
|
|
}
|
|
|
|
int SnowCost::isPaymentSet()
|
|
{
|
|
if (source->controller()->getManaPool()->getConvertedCost())
|
|
{
|
|
int result = 0;
|
|
result += source->controller()->snowManaG;
|
|
result += source->controller()->snowManaU;
|
|
result += source->controller()->snowManaR;
|
|
result += source->controller()->snowManaB;
|
|
result += source->controller()->snowManaW;
|
|
result += source->controller()->snowManaC;
|
|
if (result)
|
|
{
|
|
if ((source->controller()->snowManaC && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{1}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY))) ||
|
|
(source->controller()->snowManaG && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{g}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY))) ||
|
|
(source->controller()->snowManaU && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{u}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY))) ||
|
|
(source->controller()->snowManaR && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{r}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY))) ||
|
|
(source->controller()->snowManaB && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{b}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY))) ||
|
|
(source->controller()->snowManaW && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{w}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY))) ||
|
|
(source->controller()->snowManaC && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{c}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int SnowCost::canPay()
|
|
{
|
|
return isPaymentSet();
|
|
}
|
|
|
|
int SnowCost::doPay()
|
|
{
|
|
if (source->controller()->getManaPool()->getConvertedCost())
|
|
{
|
|
int result = 0;
|
|
result += source->controller()->snowManaG;
|
|
result += source->controller()->snowManaU;
|
|
result += source->controller()->snowManaR;
|
|
result += source->controller()->snowManaB;
|
|
result += source->controller()->snowManaW;
|
|
result += source->controller()->snowManaC;
|
|
if (result)
|
|
{
|
|
// Avoided double payments for Snow Mana cost
|
|
if (source->controller()->snowManaC && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{1}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
//source->controller()->getManaPool()->pay(ManaCost::parseManaCost("{1}",NULL,source));
|
|
source->controller()->snowManaC -= 1;
|
|
}
|
|
else if (source->controller()->snowManaG && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{g}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
//source->controller()->getManaPool()->pay(ManaCost::parseManaCost("{g}",NULL,source));
|
|
source->controller()->snowManaG -= 1;
|
|
}
|
|
else if (source->controller()->snowManaU && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{u}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
//source->controller()->getManaPool()->pay(ManaCost::parseManaCost("{u}",NULL,source));
|
|
source->controller()->snowManaU -= 1;
|
|
}
|
|
else if (source->controller()->snowManaR && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{r}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
//source->controller()->getManaPool()->pay(ManaCost::parseManaCost("{r}",NULL,source));
|
|
source->controller()->snowManaR -= 1;
|
|
}
|
|
else if (source->controller()->snowManaB && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{b}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
//source->controller()->getManaPool()->pay(ManaCost::parseManaCost("{b}",NULL,source));
|
|
source->controller()->snowManaB -= 1;
|
|
}
|
|
else if (source->controller()->snowManaW && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{w}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
//source->controller()->getManaPool()->pay(ManaCost::parseManaCost("{w}",NULL,source));
|
|
source->controller()->snowManaW -= 1;
|
|
}
|
|
else if (source->controller()->snowManaC && source->controller()->getManaPool()->canAfford(ManaCost::parseManaCost("{c}",NULL,source),source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
//source->controller()->getManaPool()->pay(ManaCost::parseManaCost("{c}",NULL,source));
|
|
source->controller()->snowManaC -= 1;
|
|
}
|
|
else
|
|
return 0;
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//Energy Cost
|
|
EnergyCost * EnergyCost::clone() const
|
|
{
|
|
EnergyCost * ec = NEW EnergyCost(*this);
|
|
return ec;
|
|
}
|
|
|
|
EnergyCost::EnergyCost(int enc) :
|
|
ExtraCost("Energy"),enc(enc)
|
|
{
|
|
}
|
|
|
|
int EnergyCost::canPay()
|
|
{
|
|
if(source->controller()->energyCount >= enc)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int EnergyCost::doPay()
|
|
{
|
|
if(source->controller()->energyCount)
|
|
{
|
|
source->controller()->energyCount -= enc;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//life cost
|
|
LifeCost * LifeCost::clone() const
|
|
{
|
|
LifeCost * ec = NEW LifeCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
LifeCost::LifeCost(TargetChooser *_tc)
|
|
: ExtraCost("Life", _tc)
|
|
{
|
|
}
|
|
|
|
int LifeCost::canPay()
|
|
{
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
if (!_target)
|
|
return 0;
|
|
if (_target->controller()->life <= 0 || _target->controller()->inPlay()->hasAbility(Constants::CANTCHANGELIFE) ||
|
|
_target->controller()->opponent()->game->battlefield->hasAbility(Constants::CANTPAYLIFE) ||
|
|
_target->controller()->game->battlefield->hasAbility(Constants::CANTPAYLIFE))
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int LifeCost::doPay()
|
|
{
|
|
if (!target)
|
|
return 0;
|
|
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
|
|
_target->controller()->loseLife(1, source);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
|
|
//Specific life cost
|
|
SpecificLifeCost * SpecificLifeCost::clone() const
|
|
{
|
|
SpecificLifeCost * ec = NEW SpecificLifeCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
SpecificLifeCost::SpecificLifeCost(TargetChooser *_tc, int slc)
|
|
: ExtraCost("Life", _tc), slc(slc)
|
|
{
|
|
}
|
|
|
|
int SpecificLifeCost::canPay()
|
|
{
|
|
if(source->controller()->life >= slc && !source->controller()->inPlay()->hasAbility(Constants::CANTCHANGELIFE) &&
|
|
!source->controller()->opponent()->game->battlefield->hasAbility(Constants::CANTPAYLIFE) &&
|
|
!source->controller()->game->battlefield->hasAbility(Constants::CANTPAYLIFE))
|
|
{
|
|
return 1;
|
|
}
|
|
/*MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
if(_target->controller()->life >= slc && !_target->controller()->inPlay()->hasAbility(Constants::CANTCHANGELIFE) &&
|
|
!_target->controller()->opponent()->game->battlefield->hasAbility(Constants::CANTPAYLIFE) &&
|
|
!_target->controller()->game->battlefield->hasAbility(Constants::CANTPAYLIFE))
|
|
{
|
|
return 1;
|
|
}*/
|
|
return 0;
|
|
}
|
|
|
|
int SpecificLifeCost::doPay()
|
|
{
|
|
if (!target)
|
|
return 0;
|
|
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
|
|
_target->controller()->loseLife(slc, source);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
|
|
//life or Mana cost
|
|
LifeorManaCost * LifeorManaCost::clone() const
|
|
{
|
|
LifeorManaCost * ec = NEW LifeorManaCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
ManaCost * LifeorManaCost::getManaCost()
|
|
{
|
|
return &manaCost;
|
|
}
|
|
|
|
LifeorManaCost::LifeorManaCost(TargetChooser *_tc, string manaType)
|
|
: ExtraCost("Phyrexian Mana", _tc), manaType(manaType)
|
|
{
|
|
string buildType ="{";
|
|
buildType.append(manaType);
|
|
buildType.append("}");
|
|
ManaCostPtr cost(ManaCost::parseManaCost(buildType));
|
|
manaCost.copy(cost.get());
|
|
}
|
|
|
|
int LifeorManaCost::canPay()
|
|
{
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
if ( _target->controller()->life <= 1 || _target->controller()->inPlay()->hasAbility(Constants::CANTCHANGELIFE) ||
|
|
_target->controller()->opponent()->game->battlefield->hasAbility(Constants::CANTPAYLIFE) ||
|
|
_target->controller()->game->battlefield->hasAbility(Constants::CANTPAYLIFE))
|
|
{
|
|
return _target->controller()->getManaPool()->canAfford(getManaCost(),_target->has(Constants::ANYTYPEOFMANAABILITY));
|
|
}
|
|
else if((_target->controller()->life > 1 || _target->controller()->getManaPool()->canAfford(getManaCost(),_target->has(Constants::ANYTYPEOFMANAABILITY))) &&
|
|
(!_target->controller()->inPlay()->hasAbility(Constants::CANTCHANGELIFE) &&
|
|
!_target->controller()->opponent()->game->battlefield->hasAbility(Constants::CANTPAYLIFE) &&
|
|
!_target->controller()->game->battlefield->hasAbility(Constants::CANTPAYLIFE)))
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int LifeorManaCost::doPay()
|
|
{
|
|
if (!target)
|
|
return 0;
|
|
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
if (_target->controller()->getManaPool()->canAfford(&manaCost,_target->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
_target->controller()->getManaPool()->pay(&manaCost);
|
|
}
|
|
else
|
|
{
|
|
_target->controller()->loseLife(2, source);
|
|
}
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
|
|
//discard a card at random as a cost
|
|
//DiscardRandom cost
|
|
DiscardRandomCost * DiscardRandomCost::clone() const
|
|
{
|
|
DiscardRandomCost * ec = NEW DiscardRandomCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
DiscardRandomCost::DiscardRandomCost(TargetChooser *_tc)
|
|
: ExtraCost("Discard Random", _tc)
|
|
{
|
|
}
|
|
|
|
int DiscardRandomCost::canPay()
|
|
{
|
|
MTGGameZone * z = target->controller()->game->hand;
|
|
int nbcards = z->nb_cards;
|
|
if (nbcards < 1)
|
|
return 0;
|
|
if (nbcards == 1 && z->hasCard(source))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
int DiscardRandomCost::doPay()
|
|
{
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
if (target)
|
|
{
|
|
source->storedCard = target->createSnapShot();
|
|
_target->controller()->game->discardRandom(_target->controller()->game->hand, source);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
//a choosen discard
|
|
|
|
DiscardCost * DiscardCost::clone() const
|
|
{
|
|
DiscardCost * ec = NEW DiscardCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
DiscardCost::DiscardCost(TargetChooser *_tc) :
|
|
ExtraCost("Discard", _tc)
|
|
{
|
|
}
|
|
|
|
int DiscardCost::doPay()
|
|
{
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
if (target)
|
|
{
|
|
source->storedCard = target->createSnapShot();
|
|
WEvent * e = NEW WEventCardDiscard(target);
|
|
GameObserver * game = target->owner->getObserver();
|
|
game->receiveEvent(e);
|
|
_target->controller()->game->putInGraveyard(_target);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//cycling
|
|
CycleCost * CycleCost::clone() const
|
|
{
|
|
CycleCost * ec = NEW CycleCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
CycleCost::CycleCost(TargetChooser *_tc) :
|
|
ExtraCost("Cycle", _tc)
|
|
{
|
|
}
|
|
|
|
int CycleCost::doPay()
|
|
{
|
|
MTGCardInstance * _source = (MTGCardInstance *) source;
|
|
if (_source)
|
|
{
|
|
WEvent * e = NEW WEventCardDiscard(target);//cycling sends 2 events one for the discard and one for the specific cycle trigger
|
|
GameObserver * game = _source->owner->getObserver();
|
|
game->receiveEvent(e);
|
|
WEvent * e2 = NEW WEventCardCycle(_source);
|
|
game->receiveEvent(e2);
|
|
_source->controller()->game->putInGraveyard(_source);
|
|
_source->controller()->cycledCount++;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//to library cost
|
|
ToLibraryCost * ToLibraryCost::clone() const
|
|
{
|
|
ToLibraryCost * ec = NEW ToLibraryCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
ToLibraryCost::ToLibraryCost(TargetChooser *_tc)
|
|
: ExtraCost("Move to Library", _tc)
|
|
{
|
|
}
|
|
|
|
int ToLibraryCost::doPay()
|
|
{
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
if (target)
|
|
{
|
|
source->storedCard = target->createSnapShot();
|
|
_target->controller()->game->putInLibrary(target);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//to graveyard cost
|
|
ToGraveCost * ToGraveCost::clone() const
|
|
{
|
|
ToGraveCost * ec = NEW ToGraveCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
ToGraveCost::ToGraveCost(TargetChooser *_tc)
|
|
: ExtraCost("Move to Graveyard", _tc)
|
|
{
|
|
}
|
|
|
|
int ToGraveCost::doPay()
|
|
{
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
if (target)
|
|
{
|
|
source->storedCard = target->createSnapShot();
|
|
_target->controller()->game->putInGraveyard(target);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//Mill yourself as a cost
|
|
MillCost * MillCost::clone() const
|
|
{
|
|
MillCost * ec = NEW MillCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
MillCost::MillCost(TargetChooser *_tc)
|
|
: ExtraCost("Deplete", _tc)
|
|
{
|
|
}
|
|
|
|
int MillCost::canPay()
|
|
{
|
|
MTGGameZone * z = target?target->controller()->game->library:source->controller()->game->library;
|
|
int nbcards = z->nb_cards;
|
|
if (nbcards < 1)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
int MillCost::doPay()
|
|
{
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
if (target)
|
|
{
|
|
source->storedCard = (MTGCardInstance*)_target->controller()->game->library->cards[_target->controller()->game->library->nb_cards - 1]->createSnapShot();
|
|
_target->controller()->game->putInZone(
|
|
_target->controller()->game->library->cards[_target->controller()->game->library->nb_cards - 1],
|
|
_target->controller()->game->library, _target->controller()->game->graveyard);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
MillExileCost::MillExileCost(TargetChooser *_tc)
|
|
: MillCost(_tc)
|
|
{
|
|
// override the base string here
|
|
mCostRenderString = "Deplete To Exile";
|
|
}
|
|
|
|
int MillExileCost::doPay()
|
|
{
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
source->storedCard = (MTGCardInstance*)_target->controller()->game->library->cards[_target->controller()->game->library->nb_cards - 1]->createSnapShot();
|
|
if (target)
|
|
{
|
|
_target->controller()->game->putInZone(
|
|
_target->controller()->game->library->cards[_target->controller()->game->library->nb_cards - 1],
|
|
_target->controller()->game->library, _target->controller()->game->exile);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//sac all lands cost
|
|
SacLandsCost * SacLandsCost::clone() const
|
|
{
|
|
SacLandsCost * ec = NEW SacLandsCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
SacLandsCost::SacLandsCost(TargetChooser *_tc)
|
|
: ExtraCost("Sacrifice All Lands", _tc)
|
|
{
|
|
}
|
|
|
|
int SacLandsCost::doPay()
|
|
{
|
|
MTGGameZone * zone = source->controller()->game->inPlay;
|
|
for (int j = zone->nb_cards - 1; j >= 0; j--)
|
|
{
|
|
MTGCardInstance * card = zone->cards[j];
|
|
if(card->isLand() && !card->has(Constants::CANTBESACRIFIED))
|
|
{
|
|
if (card)
|
|
{
|
|
MTGCardInstance * beforeCard = card;
|
|
source->storedCard = card->createSnapShot();
|
|
card->controller()->game->putInGraveyard(card);
|
|
WEvent * e = NEW WEventCardSacrifice(beforeCard,card);
|
|
GameObserver * game = card->owner->getObserver();
|
|
game->receiveEvent(e);
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//unattach cost
|
|
|
|
UnattachCost * UnattachCost::clone() const
|
|
{
|
|
UnattachCost * ec = NEW UnattachCost(*this);
|
|
return ec;
|
|
}
|
|
|
|
UnattachCost::UnattachCost(MTGCardInstance * realSource)
|
|
: ExtraCost("Unattach"),rSource(realSource)
|
|
{
|
|
}
|
|
|
|
int UnattachCost::isPaymentSet()
|
|
{
|
|
if (rSource && !rSource->target)
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int UnattachCost::canPay()
|
|
{
|
|
return isPaymentSet();
|
|
}
|
|
|
|
int UnattachCost::doPay()
|
|
{
|
|
MTGCardInstance * _source = (MTGCardInstance *) source;
|
|
if(_source != rSource)
|
|
_source = rSource;//for debugging purposes I let it set what it thinks is the source.
|
|
if (_source)
|
|
{
|
|
GameObserver * game = _source->getObserver();
|
|
for (size_t i = 1; i < game->mLayers->actionLayer()->mObjects.size(); i++)
|
|
{
|
|
MTGAbility * a = ((MTGAbility *) game->mLayers->actionLayer()->mObjects[i]);
|
|
AEquip * eq = dynamic_cast<AEquip*> (a);
|
|
if (eq && eq->source == _source)
|
|
{
|
|
((AEquip*)a)->unequip();
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//Tap cost
|
|
TapCost * TapCost::clone() const
|
|
{
|
|
TapCost * ec = NEW TapCost(*this);
|
|
return ec;
|
|
}
|
|
|
|
TapCost::TapCost()
|
|
: ExtraCost("Tap")
|
|
{
|
|
}
|
|
|
|
int TapCost::isPaymentSet()
|
|
{
|
|
if (source && (source->isTapped() || source->hasSummoningSickness()))
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int TapCost::canPay()
|
|
{
|
|
return isPaymentSet();
|
|
}
|
|
|
|
int TapCost::doPay()
|
|
{
|
|
MTGCardInstance * _source = (MTGCardInstance *) source;
|
|
if (_source)
|
|
{
|
|
_source->tap();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
//unTap cost
|
|
UnTapCost * UnTapCost::clone() const
|
|
{
|
|
UnTapCost * ec = NEW UnTapCost(*this);
|
|
return ec;
|
|
}
|
|
|
|
UnTapCost::UnTapCost() :
|
|
ExtraCost("Untap")
|
|
{
|
|
}
|
|
|
|
int UnTapCost::isPaymentSet()
|
|
{
|
|
/*602.5a A creature's activated ability with the tap symbol ({T}) or the untap symbol ({Q})
|
|
* in its activation cost can't be activated unless the creature has been under its
|
|
* controller's control since the start of his or her most recent turn.
|
|
* Ignore this rule for creatures with haste (see rule 702.10). As of 6/1/2014 Comprehensive Rules
|
|
*/
|
|
if (source && (!source->isTapped() || source->hasSummoningSickness()))
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int UnTapCost::canPay()
|
|
{
|
|
return isPaymentSet();
|
|
}
|
|
|
|
int UnTapCost::doPay()
|
|
{
|
|
MTGCardInstance * _source = (MTGCardInstance *) source;
|
|
if (_source)
|
|
{
|
|
_source->untap();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//Tap target cost
|
|
TapTargetCost * TapTargetCost::clone() const
|
|
{
|
|
TapTargetCost * ec = NEW TapTargetCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
TapTargetCost::TapTargetCost(TargetChooser *_tc, bool crew)
|
|
: ExtraCost("Tap Target", _tc), crew(crew)
|
|
{
|
|
}
|
|
|
|
int TapTargetCost::isPaymentSet()
|
|
{
|
|
if (target && target->isTapped())
|
|
{
|
|
tc->removeTarget(target);
|
|
target->isExtraCostTarget = false;
|
|
target = NULL;
|
|
return 0;
|
|
}
|
|
if (crew && target && target->has(Constants::CANTCREW))
|
|
{
|
|
tc->removeTarget(target);
|
|
target->isExtraCostTarget = false;
|
|
target = NULL;
|
|
return 0;
|
|
}
|
|
if (target)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int TapTargetCost::doPay()
|
|
{
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
|
|
if (target)
|
|
{
|
|
source->storedCard = target->createSnapShot();
|
|
_target->tap();
|
|
//crew ability
|
|
if(crew)
|
|
{
|
|
if(_target->getCrewAbility().size())
|
|
{
|
|
AbilityFactory af(_target->getObserver());
|
|
MTGAbility * a = af.parseMagicLine(_target->getCrewAbility(), -1, NULL, source,false,true);
|
|
MTGAbility * crewAbility = a->clone();
|
|
SAFE_DELETE(a);
|
|
crewAbility->oneShot = true;
|
|
crewAbility->canBeInterrupted = false;
|
|
crewAbility->target = source;
|
|
crewAbility->resolve();
|
|
SAFE_DELETE(crewAbility);
|
|
}
|
|
}
|
|
//end
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//untap other as a cost
|
|
UnTapTargetCost * UnTapTargetCost::clone() const
|
|
{
|
|
UnTapTargetCost * ec = NEW UnTapTargetCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
UnTapTargetCost::UnTapTargetCost(TargetChooser *_tc)
|
|
: ExtraCost("Untap Target", _tc)
|
|
{
|
|
}
|
|
|
|
int UnTapTargetCost::isPaymentSet()
|
|
{
|
|
if (target && !target->isTapped())
|
|
{
|
|
tc->removeTarget(target);
|
|
target->isExtraCostTarget = false;
|
|
target = NULL;
|
|
return 0;
|
|
}
|
|
if (target)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int UnTapTargetCost::doPay()
|
|
{
|
|
MTGCardInstance * _target = (MTGCardInstance *) target;
|
|
|
|
if (target)
|
|
{
|
|
source->storedCard = target->createSnapShot();
|
|
_target->untap();
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//exile as cost
|
|
ExileTargetCost * ExileTargetCost::clone() const
|
|
{
|
|
ExileTargetCost * ec = NEW ExileTargetCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
ExileTargetCost::ExileTargetCost(TargetChooser *_tc)
|
|
: ExtraCost("Exile Target", _tc)
|
|
{
|
|
}
|
|
|
|
int ExileTargetCost::doPay()
|
|
{
|
|
|
|
if (target)
|
|
{
|
|
source->storedCard = target->createSnapShot();
|
|
target->controller()->game->putInExile(target);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//Bounce as cost
|
|
BounceTargetCost * BounceTargetCost::clone() const
|
|
{
|
|
BounceTargetCost * ec = NEW BounceTargetCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
BounceTargetCost::BounceTargetCost(TargetChooser *_tc)
|
|
: ExtraCost("Move to Hand", _tc)
|
|
{
|
|
}
|
|
|
|
int BounceTargetCost::doPay()
|
|
{
|
|
|
|
if (target)
|
|
{
|
|
source->storedCard = target->createSnapShot();
|
|
target->controller()->game->putInHand(target);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//Bounce as cost for ninja
|
|
Ninja * Ninja::clone() const
|
|
{
|
|
Ninja * ec = NEW Ninja(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
Ninja::Ninja(TargetChooser *_tc) :
|
|
ExtraCost("Choose Unblocked Card", _tc)
|
|
{
|
|
}
|
|
|
|
int Ninja::canPay()
|
|
{
|
|
if(source->getObserver()->getCurrentGamePhase() != MTG_PHASE_COMBATBLOCKERS)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
int Ninja::isPaymentSet()
|
|
{
|
|
if (target && ((target->isAttacker() && target->isBlocked()) ||
|
|
target->isAttacker() < 1 ||
|
|
target->getObserver()->getCurrentGamePhase() != MTG_PHASE_COMBATBLOCKERS))
|
|
{
|
|
tc->removeTarget(target);
|
|
target = NULL;
|
|
return 0;
|
|
}
|
|
if (target)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int Ninja::doPay()
|
|
{
|
|
if (target)
|
|
{
|
|
target->controller()->game->putInHand(target);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//endbouncetargetcostforninja
|
|
|
|
//Convoke
|
|
Convoke * Convoke::clone() const
|
|
{
|
|
Convoke * ec = NEW Convoke(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
Convoke::Convoke(TargetChooser *_tc) :
|
|
ExtraCost("Choose Cards To Tap", _tc)
|
|
{
|
|
}
|
|
|
|
int Convoke::canPay()
|
|
{
|
|
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->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
target = NULL;
|
|
SAFE_DELETE(toReduce);
|
|
return 0;
|
|
}
|
|
if (target && (source->controller()->getManaPool()->canAfford(toReduce,target->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
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,source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
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;
|
|
}
|
|
|
|
//DELVE
|
|
Delve * Delve::clone() const
|
|
{
|
|
Delve * ec = NEW Delve(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
Delve::Delve(TargetChooser *_tc) :
|
|
ExtraCost("Choose Cards To Exile", _tc)
|
|
{
|
|
}
|
|
|
|
int Delve::canPay()
|
|
{
|
|
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,source->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
target = NULL;
|
|
SAFE_DELETE(toReduce);
|
|
return 0;
|
|
}
|
|
if (target && (source->controller()->getManaPool()->canAfford(toReduce,source->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
if (target->getObserver()->guiOpenDisplay)
|
|
target->getObserver()->ButtonPressed(target->getObserver()->guiOpenDisplay);
|
|
SAFE_DELETE(toReduce);
|
|
return 1;
|
|
}
|
|
SAFE_DELETE(toReduce);
|
|
return 0;
|
|
}
|
|
|
|
int Delve::doPay()
|
|
{
|
|
if (target && tc->getNbTargets())
|
|
{
|
|
ManaCost * toReduce = NEW ManaCost(source->getManaCost());
|
|
|
|
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;
|
|
}
|
|
|
|
//IMPROVISE
|
|
Improvise * Improvise::clone() const
|
|
{
|
|
Improvise * ec = NEW Improvise(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
Improvise::Improvise(TargetChooser *_tc) :
|
|
ExtraCost("Choose Artifacts to Tap", _tc)
|
|
{
|
|
}
|
|
|
|
int Improvise::canPay()
|
|
{
|
|
return isPaymentSet();
|
|
}
|
|
|
|
int Improvise::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->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
target = NULL;
|
|
SAFE_DELETE(toReduce);
|
|
return 0;
|
|
}
|
|
if (target && (source->controller()->getManaPool()->canAfford(toReduce,target->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
/*if (target->getObserver()->guiOpenDisplay)
|
|
target->getObserver()->ButtonPressed(target->getObserver()->guiOpenDisplay);*/
|
|
SAFE_DELETE(toReduce);
|
|
return 1;
|
|
}
|
|
SAFE_DELETE(toReduce);
|
|
return 0;
|
|
}
|
|
|
|
int Improvise::doPay()
|
|
{
|
|
if (target && tc->getNbTargets())
|
|
{
|
|
ManaCost * toReduce = NEW ManaCost(source->getManaCost());
|
|
|
|
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->tap();
|
|
}
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
///////////////
|
|
//Sacrifice target as cost for Offering
|
|
Offering * Offering::clone() const
|
|
{
|
|
Offering * ec = NEW Offering(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
Offering::Offering(TargetChooser *_tc,bool emerge) :
|
|
ExtraCost("Choose Creature to Offer", _tc), emerge(emerge)
|
|
{
|
|
}
|
|
|
|
int Offering::canPay()
|
|
{
|
|
if (target && target->has(Constants::CANTBESACRIFIED))
|
|
return 0;
|
|
if (emerge)
|
|
{
|
|
if (target)
|
|
{
|
|
ManaCost * reduced = NEW ManaCost(source->getManaCost()->getAlternative());
|
|
reduced->extraCosts = NULL;
|
|
reduced->remove(Constants::MTG_COLOR_ARTIFACT, target->getManaCost()->getConvertedCost());
|
|
|
|
if (target && (!source->controller()->getManaPool()->canAfford(reduced,source->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
tc->removeTarget(target);
|
|
target = NULL;
|
|
SAFE_DELETE(reduced);
|
|
return 0;
|
|
}
|
|
if (target && source->controller()->getManaPool()->canAfford(reduced,source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
SAFE_DELETE(reduced);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (target)
|
|
{
|
|
ManaCost * diff = source->getManaCost()->Diff(target->getManaCost());
|
|
if (target && (!source->controller()->getManaPool()->canAfford(source->getManaCost()->Diff(target->getManaCost()),source->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
SAFE_DELETE(diff);
|
|
tc->removeTarget(target);
|
|
target = NULL;
|
|
return 0;
|
|
}
|
|
if (target && (source->controller()->getManaPool()->canAfford(source->getManaCost()->Diff(target->getManaCost()),source->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
SAFE_DELETE(diff);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Offering::isPaymentSet()
|
|
{
|
|
if (emerge)
|
|
{
|
|
if (target)
|
|
{
|
|
ManaCost * reduced = NEW ManaCost(source->getManaCost()->getAlternative());
|
|
reduced->extraCosts = NULL;
|
|
reduced->remove(Constants::MTG_COLOR_ARTIFACT, target->getManaCost()->getConvertedCost());
|
|
|
|
if (target && (!source->controller()->getManaPool()->canAfford(reduced,source->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
tc->removeTarget(target);
|
|
target = NULL;
|
|
SAFE_DELETE(reduced);
|
|
return 0;
|
|
}
|
|
if (target && source->controller()->getManaPool()->canAfford(reduced,source->has(Constants::ANYTYPEOFMANAABILITY)))
|
|
{
|
|
SAFE_DELETE(reduced);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (target)
|
|
{
|
|
ManaCost * diff = source->getManaCost()->Diff(target->getManaCost());
|
|
if (target && (!source->controller()->getManaPool()->canAfford(diff,source->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
SAFE_DELETE(diff);
|
|
tc->removeTarget(target);
|
|
target = NULL;
|
|
return 0;
|
|
}
|
|
if (target && (source->controller()->getManaPool()->canAfford(diff,source->has(Constants::ANYTYPEOFMANAABILITY))))
|
|
{
|
|
SAFE_DELETE(diff);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Offering::doPay()
|
|
{
|
|
if (target)
|
|
{
|
|
if (emerge)
|
|
{
|
|
ManaCost * reduced = NEW ManaCost(source->getManaCost()->getAlternative());
|
|
reduced->extraCosts = NULL;
|
|
reduced->remove(Constants::MTG_COLOR_ARTIFACT, target->getManaCost()->getConvertedCost());
|
|
target->controller()->getManaPool()->pay(reduced);
|
|
SAFE_DELETE(reduced);
|
|
}
|
|
else
|
|
{
|
|
ManaCost * diff = source->getManaCost()->Diff(target->getManaCost());
|
|
target->controller()->getManaPool()->pay(diff);
|
|
SAFE_DELETE(diff);
|
|
}
|
|
MTGCardInstance * beforeCard = target;
|
|
source->storedCard = target->createSnapShot();
|
|
target->controller()->game->putInGraveyard(target);
|
|
WEvent * e = NEW WEventCardSacrifice(beforeCard,target);
|
|
GameObserver * game = target->owner->getObserver();
|
|
game->receiveEvent(e);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------
|
|
|
|
SacrificeCost * SacrificeCost::clone() const
|
|
{
|
|
SacrificeCost * ec = NEW SacrificeCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
return ec;
|
|
}
|
|
|
|
SacrificeCost::SacrificeCost(TargetChooser *_tc)
|
|
: ExtraCost("Sacrifice", _tc)
|
|
{
|
|
}
|
|
|
|
int SacrificeCost::canPay()
|
|
{
|
|
if (target && target->has(Constants::CANTBESACRIFIED))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
int SacrificeCost::doPay()
|
|
{
|
|
if (target)
|
|
{
|
|
MTGCardInstance * beforeCard = target;
|
|
source->storedCard = target->createSnapShot();
|
|
target->controller()->game->putInGraveyard(target);
|
|
WEvent * e = NEW WEventCardSacrifice(beforeCard,target);
|
|
GameObserver * game = target->owner->getObserver();
|
|
game->receiveEvent(e);
|
|
target = NULL;
|
|
if (tc)
|
|
tc->initTargets();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//Counter costs
|
|
|
|
CounterCost * CounterCost::clone() const
|
|
{
|
|
CounterCost * ec = NEW CounterCost(*this);
|
|
if (tc)
|
|
ec->tc = tc->clone();
|
|
|
|
if (counter)
|
|
ec->counter = NEW Counter(counter->target, counter->name.c_str(), counter->power, counter->toughness);
|
|
|
|
//TODO: counter can be NULL at this point, what do we set ec->counter->nb to if it is?
|
|
if (ec->counter != NULL)
|
|
ec->counter->nb = counter->nb;
|
|
|
|
return ec;
|
|
}
|
|
|
|
CounterCost::CounterCost(Counter * _counter, TargetChooser *_tc) :
|
|
ExtraCost("Counters", _tc)
|
|
{
|
|
counter = _counter;
|
|
hasCounters = 0;
|
|
}
|
|
|
|
int CounterCost::setPayment(MTGCardInstance *card)
|
|
{
|
|
if (tc)
|
|
{
|
|
int result = tc->addTarget(card);
|
|
if (result)
|
|
{
|
|
if (counter->nb >= 0)
|
|
return 1; //add counters always possible
|
|
target = card;
|
|
Counter * targetCounter = target->counters->hasCounter(counter->name.c_str(), counter->power, counter->toughness);
|
|
if (targetCounter && targetCounter->nb >= -counter->nb)
|
|
{
|
|
hasCounters = 1;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int CounterCost::isPaymentSet()
|
|
{
|
|
if (!target)
|
|
return 0;
|
|
if (counter->nb >= 0)
|
|
return 1; //add counters always possible
|
|
Counter * targetCounter = target->counters->hasCounter(counter->name.c_str(), counter->power, counter->toughness);
|
|
if (targetCounter && targetCounter->nb >= -counter->nb)
|
|
{
|
|
hasCounters = 1;
|
|
}
|
|
if (target && hasCounters)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int CounterCost::canPay()
|
|
{
|
|
// if target needs to be chosen, then move on.
|
|
if (tc)
|
|
return 1;
|
|
if (counter->nb >= 0)
|
|
return 1; //add counters always possible
|
|
// otherwise, move on only if target has enough counters
|
|
Counter * targetCounter = NULL;
|
|
if(target)
|
|
{
|
|
targetCounter = target->counters->hasCounter(counter->name.c_str(), counter->power, counter->toughness);
|
|
|
|
}
|
|
else
|
|
{
|
|
targetCounter = source->counters->hasCounter(counter->name.c_str(), counter->power, counter->toughness);
|
|
}
|
|
if (targetCounter && targetCounter->nb >= -counter->nb)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int CounterCost::doPay()
|
|
{
|
|
if (!target)
|
|
return 0;
|
|
|
|
//Add counters as a cost
|
|
if (counter->nb >= 0)
|
|
{
|
|
int totalcounters = 0;
|
|
for (int i = 0; i < counter->nb; i++)
|
|
{
|
|
target->counters->addCounter(counter->name.c_str(), counter->power, counter->toughness);
|
|
totalcounters++;
|
|
}
|
|
WEvent * w = NEW WEventTotalCounters(target->counters, counter->name.c_str(), counter->power, counter->toughness, true, false, totalcounters, true, source);
|
|
dynamic_cast<WEventTotalCounters*>(w)->targetCard = target->counters->target;
|
|
target->getObserver()->receiveEvent(w);
|
|
if (tc)
|
|
tc->initTargets();
|
|
target = NULL;
|
|
return 1;
|
|
}
|
|
|
|
//remove counters as a cost
|
|
if (hasCounters)
|
|
{
|
|
int totalcounters = 0;
|
|
for (int i = 0; i < -counter->nb; i++)
|
|
{
|
|
target->counters->removeCounter(counter->name.c_str(), counter->power, counter->toughness);
|
|
totalcounters++;
|
|
}
|
|
WEvent * w = NEW WEventTotalCounters(target->counters, counter->name.c_str(), counter->power, counter->toughness, false, true, totalcounters, true, source);
|
|
dynamic_cast<WEventTotalCounters*>(w)->targetCard = target->counters->target;
|
|
target->getObserver()->receiveEvent(w);
|
|
hasCounters = 0;
|
|
if (tc)
|
|
tc->initTargets();
|
|
target = NULL;
|
|
return 1;
|
|
}
|
|
if (tc)
|
|
tc->initTargets();
|
|
target = NULL;
|
|
return 0;
|
|
}
|
|
|
|
CounterCost::~CounterCost()
|
|
{
|
|
SAFE_DELETE(counter);
|
|
}
|
|
|
|
//
|
|
//Container
|
|
//
|
|
ExtraCosts::ExtraCosts()
|
|
{
|
|
action = NULL;
|
|
source = NULL;
|
|
}
|
|
|
|
ExtraCosts * ExtraCosts::clone() const
|
|
{
|
|
ExtraCosts * ec = NEW ExtraCosts(*this);
|
|
ec->costs.clear();
|
|
for (size_t i = 0; i < costs.size(); i++)
|
|
{
|
|
ec->costs.push_back(costs[i]->clone());
|
|
}
|
|
return ec;
|
|
}
|
|
|
|
void ExtraCosts::Render()
|
|
{
|
|
//TODO cool window and stuff...
|
|
for (size_t i = 0; i < costs.size(); i++)
|
|
{
|
|
costs[i]->Render();
|
|
}
|
|
}
|
|
|
|
int ExtraCosts::setAction(MTGAbility * _action, MTGCardInstance * _card)
|
|
{
|
|
action = _action;
|
|
source = _card;
|
|
source->storedCard = NULL;
|
|
for (size_t i = 0; i < costs.size(); i++)
|
|
{
|
|
costs[i]->setSource(_card);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int ExtraCosts::reset()
|
|
{
|
|
action = NULL;
|
|
source->storedCard = NULL;
|
|
source = NULL;
|
|
//TODO set all payments to "unset"
|
|
return 1;
|
|
}
|
|
|
|
int ExtraCosts::tryToSetPayment(MTGCardInstance * card)
|
|
{
|
|
for (size_t i = 0; i < costs.size(); i++)
|
|
{
|
|
if(!costs[i]->isPaymentSet())
|
|
{
|
|
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)}
|
|
}
|
|
}
|
|
|
|
}
|
|
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))
|
|
{
|
|
//card->isExtraCostTarget = true;//moved to gameobserver, flawed logic was setting this to true even when it wasnt really a target
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ExtraCosts::isPaymentSet()
|
|
{
|
|
for (size_t i = 0; i < costs.size(); i++)
|
|
{
|
|
if (!costs[i]->isPaymentSet())
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int ExtraCosts::canPay()
|
|
{
|
|
for (size_t i = 0; i < costs.size(); i++)
|
|
{
|
|
if (!costs[i]->canPay())
|
|
{
|
|
if(costs[i]->target)
|
|
costs[i]->target->isExtraCostTarget = false;
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int ExtraCosts::doPay()
|
|
{
|
|
int result = 0;
|
|
for (size_t i = 0; i < costs.size(); i++)
|
|
{
|
|
if(costs[i]->target)//todo deprecate this let gameobserver control this.
|
|
{
|
|
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
|
|
result += costs[i]->doPay();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
ExtraCosts::~ExtraCosts()
|
|
{
|
|
for (size_t i = 0; i < costs.size(); i++)
|
|
{
|
|
SAFE_DELETE(costs[i]);
|
|
}
|
|
}
|
|
|
|
void ExtraCosts::Dump()
|
|
{
|
|
DebugTrace("=====\nDumping ExtraCosts=====\n");
|
|
DebugTrace("NbElements: " << costs.size());
|
|
}
|