d5f3e4cfea
Also fixed the project includes so that we don't need to always use the indirect include path, ie: #include "../include/foo.h" -> #include "foo.h" I'm don't know much about make files - if I busted the linux build, mea culpa, but I think we're okay on that front too. For future reference, here's the most straightforward link on the topic of adding pch support to make files: http://www.mercs-eng.com/~hulud/index.php?2008/06/13/6-writing-a-good-makefile-for-a-c-project
659 lines
17 KiB
C++
659 lines
17 KiB
C++
#include "PrecompiledHeader.h"
|
|
|
|
#include "MTGGameZones.h"
|
|
#include "Player.h"
|
|
#include "GameOptions.h"
|
|
#include "WEvent.h"
|
|
#include "MTGDeck.h"
|
|
|
|
#if defined (WIN32) || defined (LINUX)
|
|
#include <time.h>
|
|
#endif
|
|
|
|
//------------------------------
|
|
//Players Game
|
|
//------------------------------
|
|
|
|
MTGPlayerCards::MTGPlayerCards(int * idList, int idListSize){
|
|
init();
|
|
int i;
|
|
for (i=0;i<idListSize;i++){
|
|
MTGCard * card = GameApp::collection->getCardById(idList[i]);
|
|
if (card){
|
|
MTGCardInstance * newCard = NEW MTGCardInstance(card, this);
|
|
library->addCard(newCard);
|
|
}
|
|
}
|
|
}
|
|
|
|
MTGPlayerCards::MTGPlayerCards(MTGDeck * deck){
|
|
init();
|
|
initDeck(deck);
|
|
}
|
|
|
|
|
|
void MTGPlayerCards::initDeck(MTGDeck * deck){
|
|
resetLibrary();
|
|
map<int,int>::iterator it;
|
|
for (it = deck->cards.begin(); it!=deck->cards.end(); it++){
|
|
MTGCard * card = deck->getCardById(it->first);
|
|
if (card){
|
|
for (int i = 0; i < it->second; i++){
|
|
MTGCardInstance * newCard = NEW MTGCardInstance(card, this);
|
|
library->addCard(newCard);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
MTGPlayerCards::~MTGPlayerCards(){
|
|
SAFE_DELETE(library);
|
|
SAFE_DELETE(graveyard);
|
|
SAFE_DELETE(hand);
|
|
SAFE_DELETE(inPlay);
|
|
SAFE_DELETE(stack);
|
|
SAFE_DELETE(removedFromGame);
|
|
SAFE_DELETE(garbage);
|
|
SAFE_DELETE(temp);
|
|
}
|
|
|
|
void MTGPlayerCards::setOwner(Player * player){
|
|
library->setOwner(player);
|
|
graveyard->setOwner(player);
|
|
hand->setOwner(player);
|
|
inPlay->setOwner(player);
|
|
removedFromGame->setOwner(player);
|
|
stack->setOwner(player);
|
|
garbage->setOwner(player);
|
|
temp->setOwner(player);
|
|
}
|
|
|
|
void MTGPlayerCards::initGame(int shuffle, int draw){
|
|
if (shuffle) library->shuffle();
|
|
if (draw){
|
|
for (int i=0;i<7;i++){
|
|
drawFromLibrary();
|
|
}
|
|
}
|
|
}
|
|
|
|
void MTGPlayerCards::drawFromLibrary(){
|
|
if (!library->nb_cards) {
|
|
int cantlosers = 0;
|
|
MTGGameZone * z = library->owner->game->inPlay;
|
|
int nbcards = z->nb_cards;
|
|
for (int i = 0; i < nbcards; ++i){
|
|
MTGCardInstance * c = z->cards[i];
|
|
if (c->has(Constants::CANTLOSE) || c->has(Constants::CANTMILLLOSE)){
|
|
cantlosers++;
|
|
}
|
|
}
|
|
MTGGameZone * k = library->owner->opponent()->game->inPlay;
|
|
int onbcards = k->nb_cards;
|
|
for (int m = 0; m < onbcards; ++m){
|
|
MTGCardInstance * e = k->cards[m];
|
|
if (e->has(Constants::CANTWIN)){
|
|
cantlosers++;
|
|
}
|
|
}
|
|
if(cantlosers < 1){
|
|
GameObserver::GetInstance()->gameOver = library->owner;}
|
|
return;
|
|
}
|
|
MTGCardInstance * toMove = library->cards[library->nb_cards-1];
|
|
library->lastCardDrawn = toMove;
|
|
putInZone(toMove, library, hand);
|
|
}
|
|
|
|
void MTGPlayerCards::resetLibrary(){
|
|
SAFE_DELETE(library);
|
|
library = NEW MTGLibrary();
|
|
}
|
|
|
|
void MTGPlayerCards::init(){
|
|
library = NEW MTGLibrary();
|
|
graveyard = NEW MTGGraveyard();
|
|
hand = NEW MTGHand();
|
|
inPlay = NEW MTGInPlay();
|
|
battlefield=inPlay;
|
|
|
|
stack = NEW MTGStack();
|
|
removedFromGame = NEW MTGRemovedFromGame();
|
|
exile = removedFromGame;
|
|
garbage = NEW MTGGameZone();
|
|
temp = NEW MTGGameZone();
|
|
}
|
|
|
|
|
|
void MTGPlayerCards::showHand(){
|
|
hand->debugPrint();
|
|
}
|
|
|
|
MTGCardInstance * MTGPlayerCards::putInGraveyard(MTGCardInstance * card){
|
|
MTGCardInstance * copy = NULL;
|
|
MTGGraveyard * grave = card->owner->game->graveyard;
|
|
if (inPlay->hasCard(card)){
|
|
copy = putInZone(card,inPlay, grave);
|
|
}else if (stack->hasCard(card)){
|
|
copy = putInZone(card,stack, grave);
|
|
}else{
|
|
copy = putInZone(card,hand, grave);
|
|
}
|
|
return copy;
|
|
|
|
}
|
|
|
|
MTGCardInstance * MTGPlayerCards::putInExile(MTGCardInstance * card){
|
|
MTGCardInstance * copy = NULL;
|
|
MTGRemovedFromGame * exile = card->owner->game->exile;
|
|
if (inPlay->hasCard(card)){
|
|
copy = putInZone(card,inPlay, exile);
|
|
}else if (stack->hasCard(card)){
|
|
copy = putInZone(card,stack, exile);
|
|
}else if(graveyard->hasCard(card)){
|
|
copy = putInZone(card,graveyard, exile);
|
|
}else{
|
|
copy = putInZone(card,hand, exile);
|
|
}
|
|
return copy;
|
|
}
|
|
MTGCardInstance * MTGPlayerCards::putInLibrary(MTGCardInstance * card){
|
|
MTGCardInstance * copy = NULL;
|
|
MTGLibrary * library = card->owner->game->library;
|
|
MTGHand * hand = card->owner->game->hand;
|
|
if (inPlay->hasCard(card)){
|
|
copy = putInZone(card,inPlay, library);
|
|
}else if (stack->hasCard(card)){
|
|
copy = putInZone(card,stack, library);
|
|
}else if(graveyard->hasCard(card)){
|
|
copy = putInZone(card,graveyard, library);
|
|
}else{
|
|
copy = putInZone(card,hand, library);
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
MTGCardInstance * MTGPlayerCards::putInHand(MTGCardInstance * card){
|
|
MTGCardInstance * copy = NULL;
|
|
MTGHand * hand = card->owner->game->hand;
|
|
if (inPlay->hasCard(card)){
|
|
copy = putInZone(card,inPlay, hand);
|
|
}else if (stack->hasCard(card)){
|
|
copy = putInZone(card,stack, hand);
|
|
}else if(graveyard->hasCard(card)){
|
|
copy = putInZone(card,graveyard, hand);
|
|
}else{
|
|
copy = putInZone(card,hand, hand);
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
MTGCardInstance * MTGPlayerCards::putInZone(MTGCardInstance * card, MTGGameZone * from, MTGGameZone * to){
|
|
MTGCardInstance * copy = NULL;
|
|
GameObserver *g = GameObserver::GetInstance();
|
|
if (!from || !to) return card; //Error check
|
|
|
|
int doCopy = 1;
|
|
//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 == g->players[1]->game->inPlay)){
|
|
doCopy = 0;
|
|
}
|
|
|
|
if ((copy = from->removeCard(card,doCopy))){
|
|
if (options[Options::SFXVOLUME].number > 0){
|
|
if (to == g->players[0]->game->graveyard || to == g->players[1]->game->graveyard){
|
|
if (card->isCreature()){
|
|
JSample * sample = resources.RetrieveSample("graveyard.wav");
|
|
if (sample) JSoundSystem::GetInstance()->PlaySample(sample);
|
|
}
|
|
}
|
|
}
|
|
|
|
MTGCardInstance * ret = copy;
|
|
|
|
|
|
to->addCard(copy);
|
|
|
|
|
|
//The "Temp" zone are purely for code purposes, and we don't want the abilities engine to
|
|
//Trigger when cards move in this zone
|
|
// Additionally, when they mve "from" this zone,
|
|
// we trick the engine into believing that they moved from the zone the card was previously in
|
|
// See http://code.google.com/p/wagic/issues/detail?id=335
|
|
{
|
|
if (to == g->players[0]->game->temp || to == g->players[1]->game->temp){
|
|
//don't send event when moving to temp
|
|
return ret;
|
|
}
|
|
|
|
if (from == g->players[0]->game->temp || from == g->players[1]->game->temp){
|
|
//remove temporary stuff
|
|
MTGCardInstance * previous = copy->previous;
|
|
MTGCardInstance * previous2 = previous->previous;
|
|
from = previous->previousZone;
|
|
copy->previous = previous2;
|
|
if (previous2) previous2->next = copy;
|
|
previous->previous = NULL;
|
|
previous->next = NULL;
|
|
SAFE_DELETE(previous);
|
|
}
|
|
}
|
|
|
|
GameObserver *g = GameObserver::GetInstance();
|
|
WEvent * e = NEW WEventZoneChange(copy, from, to);
|
|
g->receiveEvent(e);
|
|
|
|
return ret;
|
|
}
|
|
return card; //Error
|
|
}
|
|
|
|
void MTGPlayerCards::discardRandom(MTGGameZone * from,MTGCardInstance * source){
|
|
if (!from->nb_cards)
|
|
return;
|
|
int r = WRand() % (from->nb_cards);
|
|
WEvent * e = NEW WEventCardDiscard(from->cards[r]);
|
|
GameObserver * game = GameObserver::GetInstance();
|
|
game->receiveEvent(e);
|
|
putInZone(from->cards[r],from, graveyard);
|
|
}
|
|
|
|
int MTGPlayerCards::isInPlay(MTGCardInstance * card){
|
|
if (inPlay->hasCard(card)){
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------
|
|
// Zones specific code
|
|
//--------------------------------------
|
|
|
|
MTGGameZone::MTGGameZone() : nb_cards(0), lastCardDrawn(NULL), needShuffle(false) {
|
|
}
|
|
|
|
MTGGameZone::~MTGGameZone(){
|
|
for (int i=0; i<nb_cards; i++) {
|
|
delete cards[i];
|
|
}
|
|
}
|
|
|
|
void MTGGameZone::setOwner(Player * player){
|
|
for (int i=0; i<nb_cards; i++) {
|
|
cards[i]->owner = player;
|
|
cards[i]->lastController = player;
|
|
}
|
|
owner = player;
|
|
}
|
|
|
|
MTGCardInstance * MTGGameZone::removeCard(MTGCardInstance * card, int createCopy){
|
|
assert(nb_cards < 10000);
|
|
int i;
|
|
cardsMap.erase(card);
|
|
for (i=0; i<(nb_cards); i++) {
|
|
if (cards[i] == card){
|
|
card->currentZone = NULL;
|
|
nb_cards--;
|
|
cards.erase(cards.begin()+i);
|
|
MTGCardInstance * copy = card;
|
|
//if (card->isToken) //TODO better than this ?
|
|
// return card;
|
|
//card->lastController = card->controller();
|
|
if (createCopy) {
|
|
copy = NEW MTGCardInstance(card->model,card->owner->game);
|
|
copy->previous = card;
|
|
copy->view = card->view;
|
|
copy->isToken = card->isToken;
|
|
copy->X = card->X;
|
|
|
|
//stupid bug with tokens...
|
|
if (card->model == card)
|
|
copy->model = copy;
|
|
if (card->data == card)
|
|
copy->data = copy;
|
|
|
|
card->next = copy;
|
|
}
|
|
copy->previousZone = this;
|
|
return copy;
|
|
}
|
|
}
|
|
return NULL;
|
|
|
|
}
|
|
|
|
MTGCardInstance * MTGGameZone::hasCard(MTGCardInstance * card){
|
|
if (card->currentZone == this) return card;
|
|
return NULL;
|
|
|
|
}
|
|
|
|
int MTGGameZone::countByType(const char * value){
|
|
int result = 0 ;
|
|
for (int i=0; i<(nb_cards); i++) {
|
|
if (cards[i]->hasType(value)){
|
|
result++;
|
|
}
|
|
}
|
|
return result;
|
|
|
|
}
|
|
|
|
MTGCardInstance * MTGGameZone::findByName(string name){
|
|
for (int i=0; i<(nb_cards); i++) {
|
|
if (cards[i]->name == name){
|
|
return cards[i];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int MTGGameZone::hasType(const char * value){
|
|
for (int i=0; i<(nb_cards); i++) {
|
|
if (cards[i]->hasType(value)){
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int MTGGameZone::hasAbility(int ability){
|
|
for (int i=0; i<(nb_cards); i++) {
|
|
if (cards[i]->basicAbilities[ability]){
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
void MTGGameZone::cleanupPhase(){
|
|
for (int i=0; i<(nb_cards); i++)
|
|
(cards[i])->cleanup();
|
|
}
|
|
|
|
void MTGGameZone::shuffle(){
|
|
int i;
|
|
for (i=0; i<(nb_cards); i++) {
|
|
int r = i + (WRand() % (nb_cards-i)); // Random remaining position.
|
|
MTGCardInstance * temp = cards[i]; cards[i] = cards[r]; cards[r] = temp;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void MTGGameZone::addCard(MTGCardInstance * card){
|
|
if (!card) return;
|
|
cards.push_back(card);
|
|
nb_cards++;
|
|
cardsMap[card] = 1;
|
|
card->lastController = this->owner;
|
|
card->currentZone = this;
|
|
|
|
}
|
|
|
|
|
|
void MTGGameZone::debugPrint(){
|
|
for (int i = 0; i < nb_cards; i++)
|
|
std::cerr << cards[i]->getName() << endl;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//------------------------------
|
|
MTGCardInstance * MTGInPlay::getNextAttacker(MTGCardInstance * previous){
|
|
int foundprevious = 0;
|
|
if (previous == NULL){
|
|
foundprevious = 1;
|
|
}
|
|
for (int i = 0; i < nb_cards; i ++){
|
|
MTGCardInstance * current = cards[i];
|
|
if (current == previous){
|
|
foundprevious = 1;
|
|
}else if (foundprevious && current->isAttacker()){
|
|
return current;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void MTGInPlay::untapAll(){
|
|
int i;
|
|
for (i = 0; i < nb_cards; i ++){
|
|
MTGCardInstance * card = cards[i];
|
|
card->setUntapping();
|
|
if (!card->basicAbilities[Constants::DOESNOTUNTAP]){
|
|
if(card->frozen < 1) {card->attemptUntap();}
|
|
if(card->frozen >= 1) {card->frozen = 0;}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------
|
|
void MTGLibrary::shuffleTopToBottom(int nbcards){
|
|
if (nbcards>nb_cards) nbcards = nb_cards;
|
|
if (nbcards < 0) return;
|
|
MTGCardInstance * _cards[MTG_MAX_PLAYER_CARDS];
|
|
for (int i= nb_cards-nbcards; i<(nb_cards); i++) {
|
|
int r = i + (WRand() % (nbcards-i)); // Random remaining position.
|
|
MTGCardInstance * temp = cards[i]; cards[i] = cards[r]; cards[r] = temp;
|
|
}
|
|
for (int i= 0; i < nbcards; i++){
|
|
_cards[i] = cards[nb_cards - 1 - i];
|
|
}
|
|
for (int i = nbcards; i < nb_cards; i++){
|
|
_cards[i] = cards[i - nb_cards];
|
|
}
|
|
for (int i=0 ; i < nb_cards; i++){
|
|
cards[i] = _cards[i];
|
|
}
|
|
}
|
|
|
|
|
|
MTGGameZone * MTGGameZone::intToZone(int zoneId, MTGCardInstance * source,MTGCardInstance * target){
|
|
Player *p, *p2;
|
|
GameObserver * g = GameObserver::GetInstance();
|
|
if (!source) p = g->currentlyActing();
|
|
else p = source->controller();
|
|
if (!target){
|
|
p2 = p;
|
|
target = source;//hack ?
|
|
}
|
|
else p2 = target->controller();
|
|
|
|
switch(zoneId){
|
|
case MY_GRAVEYARD: return p->game->graveyard;
|
|
case OPPONENT_GRAVEYARD: return p->opponent()->game->graveyard;
|
|
case TARGET_OWNER_GRAVEYARD : return target->owner->game->graveyard;
|
|
case TARGET_CONTROLLER_GRAVEYARD: return p2->game->graveyard;
|
|
case GRAVEYARD : return target->owner->game->graveyard;
|
|
case OWNER_GRAVEYARD : return target->owner->game->graveyard;
|
|
|
|
case MY_BATTLEFIELD : return p->game->inPlay;
|
|
case OPPONENT_BATTLEFIELD : return p->opponent()->game->inPlay;
|
|
case TARGET_OWNER_BATTLEFIELD : return target->owner->game->inPlay;
|
|
case TARGET_CONTROLLER_BATTLEFIELD : return p2->game->inPlay;
|
|
case BATTLEFIELD : return p->game->inPlay;
|
|
case OWNER_BATTLEFIELD : return target->owner->game->inPlay;
|
|
|
|
case MY_HAND : return p->game->hand;
|
|
case OPPONENT_HAND : return p->opponent()->game->hand;
|
|
case TARGET_OWNER_HAND : return target->owner->game->hand;
|
|
case TARGET_CONTROLLER_HAND : return p2->game->hand;
|
|
case HAND : return target->owner->game->hand;
|
|
case OWNER_HAND : return target->owner->game->hand;
|
|
|
|
case MY_EXILE : return p->game->removedFromGame;
|
|
case OPPONENT_EXILE : return p->opponent()->game->removedFromGame;
|
|
case TARGET_OWNER_EXILE : return target->owner->game->removedFromGame;
|
|
case TARGET_CONTROLLER_EXILE : return p2->game->removedFromGame;
|
|
case EXILE : return target->owner->game->removedFromGame;
|
|
case OWNER_EXILE : return target->owner->game->removedFromGame;
|
|
|
|
case MY_LIBRARY : return p->game->library;
|
|
case OPPONENT_LIBRARY : return p->opponent()->game->library;
|
|
case TARGET_OWNER_LIBRARY : return target->owner->game->library;
|
|
case TARGET_CONTROLLER_LIBRARY : return p2->game->library;
|
|
case LIBRARY : return p->game->library;
|
|
case OWNER_LIBRARY: return target->owner->game->library;
|
|
|
|
case MY_STACK : return p->game->stack;
|
|
case OPPONENT_STACK : return p->opponent()->game->stack;
|
|
case TARGET_OWNER_STACK : return target->owner->game->stack;
|
|
case TARGET_CONTROLLER_STACK : return p2->game->stack;
|
|
case STACK : return p->game->stack;
|
|
case OWNER_STACK: return target->owner->game->stack;
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
int MTGGameZone::zoneStringToId(string zoneName){
|
|
const char * strings[] = {
|
|
"mygraveyard",
|
|
"opponentgraveyard",
|
|
"targetownergraveyard",
|
|
"targetcontrollergraveyard",
|
|
"ownergraveyard",
|
|
"graveyard",
|
|
|
|
"myinplay",
|
|
"opponentinplay",
|
|
"targetownerinplay",
|
|
"targetcontrollerinplay",
|
|
"ownerinplay",
|
|
"inplay",
|
|
|
|
"mybattlefield",
|
|
"opponentbattlefield",
|
|
"targetownerbattlefield",
|
|
"targetcontrollerbattlefield",
|
|
"ownerbattlefield",
|
|
"battlefield",
|
|
|
|
"myhand",
|
|
"opponenthand",
|
|
"targetownerhand",
|
|
"targetcontrollerhand",
|
|
"ownerhand",
|
|
"hand",
|
|
|
|
"mylibrary",
|
|
"opponentlibrary",
|
|
"targetownerlibrary",
|
|
"targetcontrollerlibrary",
|
|
"ownerlibrary",
|
|
"library",
|
|
|
|
"myremovedfromgame",
|
|
"opponentremovedfromgame",
|
|
"targetownerremovedfromgame",
|
|
"targetcontrollerremovedfromgame",
|
|
"ownerremovedfromgame",
|
|
"removedfromgame",
|
|
|
|
"myexile",
|
|
"opponentexile",
|
|
"targetownerexile",
|
|
"targetcontrollerexile",
|
|
"ownerexile",
|
|
"exile",
|
|
|
|
"mystack",
|
|
"opponentstack",
|
|
"targetownerstack",
|
|
"targetcontrollerstack",
|
|
"ownerstack",
|
|
"stack",
|
|
|
|
};
|
|
|
|
int values[] = {
|
|
MY_GRAVEYARD,
|
|
OPPONENT_GRAVEYARD,
|
|
TARGET_OWNER_GRAVEYARD ,
|
|
TARGET_CONTROLLER_GRAVEYARD,
|
|
OWNER_GRAVEYARD ,
|
|
GRAVEYARD,
|
|
|
|
MY_BATTLEFIELD,
|
|
OPPONENT_BATTLEFIELD,
|
|
TARGET_OWNER_BATTLEFIELD ,
|
|
TARGET_CONTROLLER_BATTLEFIELD,
|
|
OWNER_BATTLEFIELD ,
|
|
BATTLEFIELD,
|
|
|
|
MY_BATTLEFIELD,
|
|
OPPONENT_BATTLEFIELD,
|
|
TARGET_OWNER_BATTLEFIELD ,
|
|
TARGET_CONTROLLER_BATTLEFIELD,
|
|
OWNER_BATTLEFIELD ,
|
|
BATTLEFIELD,
|
|
|
|
MY_HAND,
|
|
OPPONENT_HAND,
|
|
TARGET_OWNER_HAND ,
|
|
TARGET_CONTROLLER_HAND,
|
|
OWNER_HAND ,
|
|
HAND,
|
|
|
|
MY_LIBRARY,
|
|
OPPONENT_LIBRARY,
|
|
TARGET_OWNER_LIBRARY ,
|
|
TARGET_CONTROLLER_LIBRARY,
|
|
OWNER_LIBRARY ,
|
|
LIBRARY,
|
|
|
|
MY_EXILE,
|
|
OPPONENT_EXILE,
|
|
TARGET_OWNER_EXILE ,
|
|
TARGET_CONTROLLER_EXILE,
|
|
OWNER_EXILE ,
|
|
EXILE,
|
|
|
|
MY_EXILE,
|
|
OPPONENT_EXILE,
|
|
TARGET_OWNER_EXILE ,
|
|
TARGET_CONTROLLER_EXILE,
|
|
OWNER_EXILE ,
|
|
EXILE,
|
|
|
|
MY_STACK,
|
|
OPPONENT_STACK,
|
|
TARGET_OWNER_STACK ,
|
|
TARGET_CONTROLLER_STACK,
|
|
OWNER_STACK ,
|
|
STACK,
|
|
};
|
|
|
|
int max = sizeof(values) / sizeof*(values);
|
|
|
|
for (int i = 0; i < max; ++i){
|
|
if(zoneName.compare(strings[i]) == 0){
|
|
return values[i];
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
MTGGameZone * MTGGameZone::stringToZone(string zoneName, MTGCardInstance * source,MTGCardInstance * target){
|
|
return intToZone(zoneStringToId(zoneName), source,target);
|
|
}
|
|
|
|
ostream& MTGGameZone::toString(ostream& out) const { return out << "Unknown zone"; }
|
|
ostream& MTGLibrary::toString(ostream& out) const { return out << "Library " << *owner; }
|
|
ostream& MTGGraveyard::toString(ostream& out) const { return out << "Graveyard " << *owner; }
|
|
ostream& MTGHand::toString(ostream& out) const { return out << "Hand " << *owner; }
|
|
ostream& MTGRemovedFromGame::toString(ostream& out) const { return out << "RemovedFromGame " << *owner; }
|
|
ostream& MTGStack::toString(ostream& out) const { return out << "Stack " << *owner; }
|
|
ostream& MTGInPlay::toString(ostream& out) const { return out << "InPlay " << *owner; }
|
|
ostream& operator<<(ostream& out, const MTGGameZone& z)
|
|
{
|
|
return z.toString(out);
|
|
}
|