added new legend & pw rule, trigger & event

added new pw & legend rule (i just leave the old rules behind and
disabled it), added phasesin, faceup, copiedacard event, added facedup &
phasedin trigger.

projects/mtg/src/AllAbilities.cpp

@@ -1674,6 +1674,7 @@ int AACopier::resolve()
                 }
             }
         }
+        currentAbilities.clear();
         return 1;
     }
     return 0;
@@ -3284,6 +3285,8 @@ int AAMorph::resolve()
                 }
             }
         }
+        WEvent * e = NEW WEventCardFaceUp(_target);
+        game->receiveEvent(e);
         currentAbilities.clear();
         testDestroy();
     }

projects/mtg/src/GameObserver.cpp

@@ -859,6 +859,9 @@ void GameObserver::gameStateBasedEffects()
                 card->phasedTurn = turn;
                 if(card->view)
                     card->view->alpha = 255;
+                //add event phases in here
+                WEvent * evphasein = NEW WEventCardPhasesIn(card);
+                receiveEvent(evphasein);
             }
             if (card->target && isInPlay(card->target) && (card->hasSubtype(Subtypes::TYPE_EQUIPMENT) || card->hasSubtype(Subtypes::TYPE_AURA)))
             {

projects/mtg/src/GuiPlay.cpp

@@ -426,6 +426,10 @@ int GuiPlay::receiveEventPlus(WEvent * e)
         Replace();
     else if (dynamic_cast<WEventCardTransforms*> (e))
         Replace();
+    else if (dynamic_cast<WEventCardCopiedACard*> (e))
+        Replace();
+    else if (dynamic_cast<WEventCardFaceUp*> (e))
+        Replace();
     Replace();
     return 0;
 }

projects/mtg/src/MTGAbility.cpp

@@ -1036,6 +1036,14 @@ TriggeredAbility * AbilityFactory::parseTrigger(string s, string, int id, Spell
     if (TargetChooser *tc = parseSimpleTC(s,"transformed", card))
         return NEW TrCardTransformed(observer, id, card, tc,once);
 
+    //Card Faces Up
+    if (TargetChooser *tc = parseSimpleTC(s,"facedup", card))
+        return NEW TrCardFaceUp(observer, id, card, tc,once);
+
+    //Card Phases In
+    if (TargetChooser *tc = parseSimpleTC(s,"phasedin", card))
+        return NEW TrCardPhasesIn(observer, id, card, tc,once);
+
 //CombatTrigger
     //Card card attacked and is blocked
     found = s.find("combat(");
@@ -1478,14 +1486,16 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
     found = s.find("legendrule");
     if(found != string::npos)
     {
-        observer->addObserver(NEW MTGLegendRule(observer, -1));
+        //observer->addObserver(NEW MTGLegendRule(observer, -1));
+        observer->addObserver(NEW MTGNewLegend(observer, -1));
         return NULL;
     }
     //this handles the planeswalker named legend rule which is dramatically different from above.
     found = s.find("planeswalkerrule");
     if(found != string::npos)
     {
-        observer->addObserver(NEW MTGPlaneWalkerRule(observer, -1));
+        //observer->addObserver(NEW MTGPlaneWalkerRule(observer, -1));
+        observer->addObserver(NEW MTGNewPlaneswalker(observer, -1));
         return NULL;
     }
     found = s.find("planeswalkerdamage");

projects/mtg/src/MTGCardInstance.cpp

@@ -169,6 +169,11 @@ void MTGCardInstance::copy(MTGCardInstance * card)
     backupTargets = this->backupTargets;
     storedCard = oldStored;
     miracle = false;
+
+    
+    //add event here copied a card...
+    WEvent * e = NEW WEventCardCopiedACard(this);
+    getObserver()->receiveEvent(e);
 }
 
 MTGCardInstance::~MTGCardInstance()
@@ -849,6 +854,22 @@ int MTGCardInstance::countDuplicateCardNames()
     return count;
 }
 
+int MTGCardInstance::countDuplicateCardTypes()
+{
+    int count = 0;
+
+    if(observer)
+    {
+        int nb_cards = controller()->game->battlefield->nb_cards;
+        for(int x = 0; x < nb_cards; x++)
+        {
+            if(controller()->game->battlefield->cards[x] != this && controller()->game->battlefield->cards[x]->types == this->types)
+                count+=1;
+        }
+    }
+    return count;
+}
+
 //check can produce mana
 int MTGCardInstance::canproduceMana(int color)
 {

projects/mtg/src/MTGRules.cpp

@@ -3228,15 +3228,244 @@ MTGTokensCleanup * MTGTokensCleanup::clone() const
     return NEW MTGTokensCleanup(*this);
 }
 
-/* Legend Rule */
-MTGLegendRule::MTGLegendRule(GameObserver* observer, int _id) :
-ListMaintainerAbility(observer, _id)
+//new legend rule
+MTGNewLegend::MTGNewLegend(GameObserver* observer, int _id) :
+PermanentAbility(observer, _id)
 {
     tcL = NULL;
     Legendrule = NULL;
     LegendruleAbility = NULL;
     LegendruleGeneric = NULL;
 }
+
+int MTGNewLegend::receiveEvent(WEvent * e)
+{
+    if(game->getCurrentTargetChooser() || game->mLayers->actionLayer()->isWaitingForAnswer())
+            return 0;
+    if (WEventZoneChange* ev1 = dynamic_cast<WEventZoneChange*>(e))
+    {
+        if (ev1->to == game->players[0]->game->inPlay || ev1->to == game->players[1]->game->inPlay)
+        {
+            MTGCardInstance * card = ev1->card;
+             if(card && card->countDuplicateCardNames() > 1 && card->hasType(Subtypes::TYPE_LEGENDARY))
+            {
+                CheckLegend(card);
+                return 1;
+            }
+        }
+    }
+    else if(WEventCardControllerChange* ev2 = dynamic_cast<WEventCardControllerChange*>(e))
+    {
+        MTGCardInstance * card = ev2->card;
+        if(card && card->countDuplicateCardNames() > 1 && card->hasType(Subtypes::TYPE_LEGENDARY))
+        {
+            CheckLegend(card);
+            return 1;
+        }
+    }
+    else if(WEventCardTransforms* ev3 =  dynamic_cast<WEventCardTransforms*>(e))
+    {
+        MTGCardInstance * card = ev3->card;
+        if(card && card->countDuplicateCardNames() > 1 && card->hasType(Subtypes::TYPE_LEGENDARY))
+        {
+            CheckLegend(card);
+            return 1;
+        }
+    }
+    else if(WEventCardCopiedACard* ev4 =  dynamic_cast<WEventCardCopiedACard*>(e))
+    {
+        MTGCardInstance * card = ev4->card;
+        if(card && card->countDuplicateCardNames() > 1 && card->hasType(Subtypes::TYPE_LEGENDARY))
+        {
+            CheckLegend(card);
+            return 1;
+        }
+    }
+    else if(WEventCardFaceUp* ev5 =  dynamic_cast<WEventCardFaceUp*>(e))
+    {
+        MTGCardInstance * card = ev5->card;
+        if(card && card->countDuplicateCardNames() > 1 && card->hasType(Subtypes::TYPE_LEGENDARY))
+        {
+            CheckLegend(card);
+            return 1;
+        }
+    }
+    else if(WEventCardPhasesIn* ev6 =  dynamic_cast<WEventCardPhasesIn*>(e))
+    {
+        MTGCardInstance * card = ev6->card;
+        if(card && card->countDuplicateCardNames() > 1 && card->hasType(Subtypes::TYPE_LEGENDARY))
+        {
+            CheckLegend(card);
+            return 1;
+        }
+    }
+    return 0;
+}
+int MTGNewLegend::CheckLegend(MTGCardInstance * card)
+{
+    if(!card)
+        return 0;
+    if(card->isPhased)
+        return 0;
+    if (card->hasType(Subtypes::TYPE_LEGENDARY) && card->controller()->game->inPlay->hasCard(card))
+        if(card->has(Constants::NOLEGEND)||card->controller()->opponent()->inPlay()->hasAbility(Constants::NOLEGENDRULE)||card->controller()->inPlay()->hasAbility(Constants::NOLEGENDRULE))
+            return 0;
+    if(card->countDuplicateCardNames() <= 1)
+        return 0;
+
+    MoveLegend(card);
+    return 1;
+}
+void MTGNewLegend::MoveLegend(MTGCardInstance * card)
+{
+    game->LPWeffect = true;
+    vector<MTGAbility*>selection;
+    MTGCardInstance * myClone = NEW MTGCardInstance(card, card->controller()->game);
+    TargetChooserFactory tfL(game);
+    tcL = tfL.createTargetChooser("*[share!name!]|mybattlefield",myClone);
+    tcL->targetter = NULL;
+    tcL->maxtargets = 1;
+    Legendrule = NEW AAMover(game, game->mLayers->actionLayer()->getMaxId(), myClone, NULL,"ownergraveyard","Put in Graveyard");
+    Legendrule->oneShot = true;
+    Legendrule->canBeInterrupted = false;
+    LegendruleAbility = NEW GenericTargetAbility(game, "","",game->mLayers->actionLayer()->getMaxId(), myClone,tcL, Legendrule->clone());
+    SAFE_DELETE(Legendrule);
+    LegendruleAbility->oneShot = true;
+    LegendruleAbility->canBeInterrupted = false;
+    LegendruleGeneric = NEW GenericAddToGame(game, game->mLayers->actionLayer()->getMaxId(), myClone,NULL,LegendruleAbility->clone());
+    SAFE_DELETE(LegendruleAbility);
+    LegendruleGeneric->oneShot = true;
+    selection.push_back(LegendruleGeneric->clone());
+    SAFE_DELETE(LegendruleGeneric);
+    MTGAbility * menuChoice = NEW MenuAbility(game, game->mLayers->actionLayer()->getMaxId(), NULL, myClone,true,selection,card->controller(),"Legendary Rule");
+    menuChoice->addToGame();
+    return;
+}
+MTGNewLegend * MTGNewLegend::clone() const
+{
+    return NEW MTGNewLegend(*this);
+}
+//new pw rule
+MTGNewPlaneswalker::MTGNewPlaneswalker(GameObserver* observer, int _id) :
+PermanentAbility(observer, _id)
+{
+    tcP = NULL;
+    PWrule = NULL;
+    PWruleAbility = NULL;
+    PWruleGeneric = NULL;
+}
+
+int MTGNewPlaneswalker::receiveEvent(WEvent * e)
+{
+    if(game->getCurrentTargetChooser() || game->mLayers->actionLayer()->isWaitingForAnswer())
+            return 0;
+    if (WEventZoneChange* ev1 = dynamic_cast<WEventZoneChange*>(e))
+    {
+        if (ev1->to == game->players[0]->game->inPlay || ev1->to == game->players[1]->game->inPlay)
+        {
+            MTGCardInstance * card = ev1->card;
+            if(card && card->hasType(Subtypes::TYPE_PLANESWALKER))
+            {
+                CheckPW(card);
+                return 1;
+            }
+        }
+    }
+    else if(WEventCardControllerChange* ev2 = dynamic_cast<WEventCardControllerChange*>(e))
+    {
+        MTGCardInstance * card = ev2->card;
+        if(card && card->hasType(Subtypes::TYPE_PLANESWALKER))
+        {
+            CheckPW(card);
+            return 1;
+        }
+    }
+    else if(WEventCardTransforms* ev3 =  dynamic_cast<WEventCardTransforms*>(e))
+    {
+        MTGCardInstance * card = ev3->card;
+        if(card && card->hasType(Subtypes::TYPE_PLANESWALKER))
+        {
+            CheckPW(card);
+            return 1;
+        }
+    }
+    else if(WEventCardCopiedACard* ev4 =  dynamic_cast<WEventCardCopiedACard*>(e))
+    {
+        MTGCardInstance * card = ev4->card;
+        if(card && card->hasType(Subtypes::TYPE_PLANESWALKER))
+        {
+            CheckPW(card);
+            return 1;
+        }
+    }
+    else if(WEventCardFaceUp* ev5 =  dynamic_cast<WEventCardFaceUp*>(e))
+    {
+        MTGCardInstance * card = ev5->card;
+        if(card && card->hasType(Subtypes::TYPE_PLANESWALKER))
+        {
+            CheckPW(card);
+            return 1;
+        }
+    }
+    else if(WEventCardPhasesIn* ev6 =  dynamic_cast<WEventCardPhasesIn*>(e))
+    {
+        MTGCardInstance * card = ev6->card;
+        if(card && card->hasType(Subtypes::TYPE_PLANESWALKER))
+        {
+            CheckPW(card);
+            return 1;
+        }
+    }
+    return 0;
+}
+int MTGNewPlaneswalker::CheckPW(MTGCardInstance * card)
+{
+    if(!card)
+        return 0;
+    if(card->isPhased)
+        return 0;
+    if(card->countDuplicateCardTypes() < 1)
+        return 0;
+
+    MovePW(card);
+    return 1;
+}
+void MTGNewPlaneswalker::MovePW(MTGCardInstance * card)
+{
+    game->LPWeffect = true;
+    vector<MTGAbility*>selection;
+    MTGCardInstance * myClone = NEW MTGCardInstance(card, card->controller()->game);
+    TargetChooserFactory tfL(game);
+    tcP = tfL.createTargetChooser("planeswalker[share!types!]|mybattlefield",myClone);
+    tcP->targetter = NULL;
+    tcP->maxtargets = 1;
+    PWrule = NEW AAMover(game, game->mLayers->actionLayer()->getMaxId(), myClone, NULL,"ownergraveyard","Put in Graveyard");
+    PWrule->oneShot = true;
+    PWrule->canBeInterrupted = false;
+    PWruleAbility = NEW GenericTargetAbility(game, "","",game->mLayers->actionLayer()->getMaxId(), myClone,tcP, PWrule->clone());
+    SAFE_DELETE(PWrule);
+    PWruleAbility->oneShot = true;
+    PWruleAbility->canBeInterrupted = false;
+    PWruleGeneric = NEW GenericAddToGame(game, game->mLayers->actionLayer()->getMaxId(), myClone,NULL,PWruleAbility->clone());
+    SAFE_DELETE(PWruleAbility);
+    PWruleGeneric->oneShot = true;
+    selection.push_back(PWruleGeneric->clone());
+    SAFE_DELETE(PWruleGeneric);
+    MTGAbility * menuChoice = NEW MenuAbility(game, game->mLayers->actionLayer()->getMaxId(), NULL, myClone,true,selection,card->controller(),"Planeswalker Uniqueness Rule");
+    menuChoice->addToGame();
+    return;
+}
+MTGNewPlaneswalker * MTGNewPlaneswalker::clone() const
+{
+    return NEW MTGNewPlaneswalker(*this);
+}
+////end new////
+///old below///
+/* Legend Rule */
+MTGLegendRule::MTGLegendRule(GameObserver* observer, int _id) :
+ListMaintainerAbility(observer, _id)
+{
+}
 ;
 
 int MTGLegendRule::canBeInList(MTGCardInstance * card)
@@ -3257,43 +3486,19 @@ int MTGLegendRule::added(MTGCardInstance * card)
 {
     map<MTGCardInstance *, bool>::iterator it;
     int destroy = 0;
-    //vector<MTGCardInstance*>oldCards;
+    vector<MTGCardInstance*>oldCards;
     for (it = cards.begin(); it != cards.end(); it++)
     {
         MTGCardInstance * comparison = (*it).first;
         if (comparison != card && comparison->controller() == card->controller() && !(comparison->getName().compare(card->getName())))
             if (!(game->getCurrentTargetChooser() || game->mLayers->actionLayer()->isWaitingForAnswer()))
             {
-                //oldCards.push_back(comparison);
+                oldCards.push_back(comparison);
                 destroy = 1;
                 game->LPWeffect = true;
             }
     }
     if(destroy)
-    {
-        vector<MTGAbility*>selection;
-        MTGCardInstance * myClone = NEW MTGCardInstance(card, card->controller()->game);
-        TargetChooserFactory tfL(game);
-        tcL = tfL.createTargetChooser("*[share!name!]|mybattlefield",myClone);
-        tcL->targetter = NULL;
-        tcL->maxtargets = 1;
-        Legendrule = NEW AAMover(game, game->mLayers->actionLayer()->getMaxId(), myClone, NULL,"ownergraveyard","Put in Graveyard");
-        Legendrule->oneShot = true;
-        Legendrule->canBeInterrupted = false;
-        LegendruleAbility = NEW GenericTargetAbility(game, "","",game->mLayers->actionLayer()->getMaxId(), myClone,tcL, Legendrule->clone());
-        SAFE_DELETE(Legendrule);
-        LegendruleAbility->oneShot = true;
-        LegendruleAbility->canBeInterrupted = false;
-        LegendruleGeneric = NEW GenericAddToGame(game, game->mLayers->actionLayer()->getMaxId(), myClone,NULL,LegendruleAbility->clone());
-        SAFE_DELETE(LegendruleAbility);
-        LegendruleGeneric->oneShot = true;
-        selection.push_back(LegendruleGeneric->clone());
-        SAFE_DELETE(LegendruleGeneric);
-        MTGAbility * menuChoice = NEW MenuAbility(game, game->mLayers->actionLayer()->getMaxId(), NULL, myClone,true,selection,card->controller(),"Legendary Rule");
-        menuChoice->addToGame();
-    }
-    //reverted to old since this new code conflicts with reveal targetchooser
-    /*if(destroy)
     {
         vector<MTGAbility*>selection;
         MultiAbility * multi = NEW MultiAbility(game, game->mLayers->actionLayer()->getMaxId(), card, card, NULL);
@@ -3312,7 +3517,7 @@ int MTGLegendRule::added(MTGCardInstance * card)
         selection.push_back(b1);
         MTGAbility * menuChoice = NEW MenuAbility(game, game->mLayers->actionLayer()->getMaxId(), card, card,true,selection,card->controller(),"Legendary Rule");
         menuChoice->addToGame();
-    }*/
+    }
     return 1;
 }
 
@@ -3339,10 +3544,6 @@ MTGLegendRule * MTGLegendRule::clone() const
 MTGPlaneWalkerRule::MTGPlaneWalkerRule(GameObserver* observer, int _id) :
 ListMaintainerAbility(observer, _id)
 {
-    tcP = NULL;
-    PWrule = NULL;
-    PWruleAbility = NULL;
-    PWruleGeneric = NULL;
 }
 ;
 
@@ -3361,43 +3562,19 @@ int MTGPlaneWalkerRule::added(MTGCardInstance * card)
 {
     map<MTGCardInstance *, bool>::iterator it;
     int destroy = 0;
-    //vector<MTGCardInstance*>oldCards;
+    vector<MTGCardInstance*>oldCards;
     for (it = cards.begin(); it != cards.end(); it++)
     {
         MTGCardInstance * comparison = (*it).first;
         if (comparison != card && comparison->types == card->types && comparison->controller() == card->controller())
             if (!(game->getCurrentTargetChooser() || game->mLayers->actionLayer()->isWaitingForAnswer()))
             {
-                //oldCards.push_back(comparison);
+                oldCards.push_back(comparison);
                 destroy = 1;
                 game->LPWeffect = true;
             }
     }
     if (destroy)
-    {
-        vector<MTGAbility*>selection;
-        MTGCardInstance * myClone = NEW MTGCardInstance(card, card->controller()->game);
-        TargetChooserFactory tfL(game);
-        tcP = tfL.createTargetChooser("planeswalker[share!types!]|mybattlefield",myClone);
-        tcP->targetter = NULL;
-        tcP->maxtargets = 1;
-        PWrule = NEW AAMover(game, game->mLayers->actionLayer()->getMaxId(), myClone, NULL,"ownergraveyard","Put in Graveyard");
-        PWrule->oneShot = true;
-        PWrule->canBeInterrupted = false;
-        PWruleAbility = NEW GenericTargetAbility(game, "","",game->mLayers->actionLayer()->getMaxId(), myClone,tcP, PWrule->clone());
-        SAFE_DELETE(PWrule);
-        PWruleAbility->oneShot = true;
-        PWruleAbility->canBeInterrupted = false;
-        PWruleGeneric = NEW GenericAddToGame(game, game->mLayers->actionLayer()->getMaxId(), myClone,NULL,PWruleAbility->clone());
-        SAFE_DELETE(PWruleAbility);
-        PWruleGeneric->oneShot = true;
-        selection.push_back(PWruleGeneric->clone());
-        SAFE_DELETE(PWruleGeneric);
-        MTGAbility * menuChoice = NEW MenuAbility(game, game->mLayers->actionLayer()->getMaxId(), NULL, myClone,true,selection,card->controller(),"Planeswalker Uniqueness Rule");
-        menuChoice->addToGame();
-    }
-    //reverted to old since this new code conflicts with reveal targetchooser
-    /*if (destroy)
     {
         vector<MTGAbility*>selection;
 
@@ -3417,7 +3594,7 @@ int MTGPlaneWalkerRule::added(MTGCardInstance * card)
         selection.push_back(b1);
         MTGAbility * menuChoice = NEW MenuAbility(game, game->mLayers->actionLayer()->getMaxId(), card, card,true,selection,card->controller(),"Planeswalker Rule");
         menuChoice->addToGame();
-    }*/
+    }
     return 1;
 }
 

projects/mtg/src/WEvent.cpp

@@ -236,11 +236,26 @@ WEventCardControllerChange::WEventCardControllerChange(MTGCardInstance * card) :
 {
 }
 
+WEventCardPhasesIn::WEventCardPhasesIn(MTGCardInstance * card) :
+    WEventCardUpdate(card)
+{
+}
+
+WEventCardFaceUp::WEventCardFaceUp(MTGCardInstance * card) :
+    WEventCardUpdate(card)
+{
+}
+
 WEventCardTransforms::WEventCardTransforms(MTGCardInstance * card) :
     WEventCardUpdate(card)
 {
 }
 
+WEventCardCopiedACard::WEventCardCopiedACard(MTGCardInstance * card) :
+    WEventCardUpdate(card)
+{
+}
+
 WEventCombatStepChange::WEventCombatStepChange(CombatStep step) :
     WEvent(), step(step)
 {
@@ -412,12 +427,30 @@ Targetable * WEventCardControllerChange::getTarget(int target)
     return NULL;
 }
 
+Targetable * WEventCardPhasesIn::getTarget(int target)
+{
+    if (target) return card;
+    return NULL;
+}
+
+Targetable * WEventCardFaceUp::getTarget(int target)
+{
+    if (target) return card;
+    return NULL;
+}
+
 Targetable * WEventCardTransforms::getTarget(int target)
 {
     if (target) return card;
     return NULL;
 }
 
+Targetable * WEventCardCopiedACard::getTarget(int target)
+{
+    if (target) return card;
+    return NULL;
+}
+
 Targetable * WEventplayerEnergized::getTarget(Player * player)
 {
     if (player) return player;