Provoke

also add aicode for Amplify cards

projects/mtg/src/GameObserver.cpp

@@ -984,6 +984,20 @@ void GameObserver::gameStateBasedEffects()
                 }
             }
         }
+        ///provoke clear///
+        if (mCurrentGamePhase == MTG_PHASE_COMBATEND)
+        {
+            for (int l = z->nb_cards - 1; l >= 0; l--)
+            {
+                MTGCardInstance * c = z->cards[l];
+                if(c)
+                {
+                    c->isProvoked = false;
+                    c->ProvokeTarget = NULL;
+                    c->Provoker = NULL;
+                }
+            }
+        }
         /////////////////////////////////////////////////
         //handle end of turn effects while we're at it.//
         /////////////////////////////////////////////////
@@ -1011,6 +1025,9 @@ void GameObserver::gameStateBasedEffects()
                 c->combatdamageToOpponent = false;
                 c->damageToCreature = false;
                 c->isAttacking = NULL;
+                c->isProvoked = false;
+                c->ProvokeTarget = NULL;
+                c->Provoker = NULL;
             }
             for (int jj = z->nb_cards - 1; jj >= 0; jj--)
             {

projects/mtg/src/MTGAbility.cpp

@@ -2910,6 +2910,36 @@ MTGAbility * AbilityFactory::parseMagicLine(string s, int id, Spell * spell, MTG
         return a;
     }
 
+    //provoke
+    found = s.find("provoke");
+    if (found != string::npos)
+    {
+        MTGAbility * a = NEW AProvoke(observer, id, card, target);
+        a->oneShot = 1;
+        if(storedAndAbility.size())
+        {
+            string stored = storedAndAbility;
+            storedAndAbility.clear();
+            ((AProvoke*)a)->andAbility = parseMagicLine(stored, id, spell, card);
+        }
+        return a;
+    }
+    //setblocker
+    found = s.find("setblocker");
+    if (found != string::npos)
+    {
+        MTGAbility * a = NEW AProvoke(observer, id, card, target);
+        a->oneShot = 1;
+        ((AProvoke*)a)->setblocker = true;
+        if(storedAndAbility.size())
+        {
+            string stored = storedAndAbility;
+            storedAndAbility.clear();
+            ((AProvoke*)a)->andAbility = parseMagicLine(stored, id, spell, card);
+        }
+        return a;
+    }
+
     //clone
     found = s.find("clone");
     if (found != string::npos)

projects/mtg/src/MTGCardInstance.cpp

@@ -242,6 +242,9 @@ void MTGCardInstance::initMTGCI()
     damageToOpponent = false;
     damageToController = false;
     damageToCreature = false;
+    isProvoked = false;
+    ProvokeTarget = NULL;
+    Provoker = NULL;
     wasDealtDamage = false;
     isDualWielding = false;
     suspended = false;

projects/mtg/src/MTGGameZones.cpp

@@ -1015,6 +1015,43 @@ MTGCardInstance * MTGInPlay::getNextLurer(MTGCardInstance * previous)
     return NULL;
 }
 
+MTGCardInstance * MTGInPlay::getNextProvoker(MTGCardInstance * previous, MTGCardInstance * thiscard)
+{
+    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() && thiscard->isProvoked && current->ProvokeTarget)
+        {
+            if(thiscard == current->ProvokeTarget)
+                return current;
+        }
+    }
+    return NULL;
+}
+
+MTGCardInstance * MTGInPlay::findAProvoker(MTGCardInstance * thiscard)
+{
+    for (int i = 0; i < nb_cards; i++)
+    {
+        MTGCardInstance * current = cards[i];
+        if (current->isAttacker() && current->ProvokeTarget)
+        {
+            if(current->ProvokeTarget == thiscard)
+                return current;
+        }
+    }
+    return NULL;
+}
+
 MTGCardInstance * MTGInPlay::findALurer()
 {
     for (int i = 0; i < nb_cards; i++)

projects/mtg/src/MTGRules.cpp

@@ -2259,23 +2259,31 @@ int MTGBlockRule::receiveEvent(WEvent *e)
             for (size_t i = 0; i < tf->cards.size(); i++)
             {
                 MTGCardInstance * card = tf->cards[i];
-                if (card->has(Constants::MUSTBLOCK) && !card->defenser && card->canBlock())
+                if ((card->has(Constants::MUSTBLOCK) || card->isProvoked) && !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->isProvoked)
                     {
-                        if (card->canBlock(Attacker[i]) && !card->defenser)
+                        for (size_t i = 0; i < Attacker.size(); i++)
                         {
-                            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 (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);
+                            }
                         }
                     }
-
+                    else
+                    {
+                        MTGCardInstance * provoker = card->Provoker;
+                            if(provoker && card->canBlock(provoker) && card->blockCost < 1)
+                                card->setDefenser(provoker);
+                    }
                 }
             }
 
@@ -2370,6 +2378,19 @@ int MTGBlockRule::reactToClick(MTGCardInstance * card)
         else
             card->toggleDefenser(NULL);
     }
+    else if(card->isProvoked)
+    {
+        while (!result)
+        {
+            currentOpponent = game->currentPlayer->game->inPlay->getNextProvoker(currentOpponent, card);
+            canDefend = card->toggleDefenser(currentOpponent);
+
+            DebugTrace("Defenser Toggle: " << card->getName() << endl
+                << "- canDefend: " << (canDefend == 0) << endl
+                << "- currentOpponent: " << currentOpponent);
+            result = (canDefend || currentOpponent == NULL);
+        }
+    }
     else
     {
         bool lured = false;

projects/mtg/src/TargetChooser.cpp

@@ -1819,9 +1819,20 @@ bool BlockableChooser::canTarget(Targetable * target,bool withoutProtections)
         }
         if(lured && card->controller()->inPlay()->hasAbility(Constants::LURE) && !card->has(Constants::LURE))
             return false;
+        //provoke
+        bool provoked = false;
+        MTGCardInstance * provoker = observer->currentPlayer->game->inPlay->findAProvoker(source);
+        if(provoker)
+        {
+            provoked = true;
+        }
+        if(provoked && source->isProvoked && !card->ProvokeTarget)
+            return false;
+        if(provoked && source->isProvoked && card->ProvokeTarget && card->ProvokeTarget != source)
+            return false;
         return true;
     }
-    return TypeTargetChooser::canTarget(target,withoutProtections);
+    return false;//TypeTargetChooser::canTarget(target,withoutProtections);
 }
 
 BlockableChooser* BlockableChooser::clone() const