Refactored ABlink: extracted common code as method "returnCardIntoPlay"

projects/mtg/include/AllAbilities.h

@@ -4426,13 +4426,15 @@ public:
     MTGCardInstance * Blinked;
     bool resolved;
     MTGAbility * stored;
-    ABlink(GameObserver* observer, int _id, MTGCardInstance * card, MTGCardInstance * _target,bool blinkueot=false,bool blinkForSource = false,bool blinkhand = false,MTGAbility * stored = NULL);
+    ABlink(GameObserver* observer, int _id, MTGCardInstance * card, MTGCardInstance * _target, bool blinkueot = false, bool blinkForSource = false, bool blinkhand = false, MTGAbility * stored = NULL);
     void Update(float dt);
     void resolveBlink();
     int resolve();
     const char * getMenuText();
     ABlink * clone() const;
     ~ABlink();
+private:
+    void returnCardIntoPlay(MTGCardInstance *_target);
 };
 
 //blinkinstant

projects/mtg/src/AllAbilities.cpp

@@ -4958,7 +4958,7 @@ APhaseActionGeneric::~APhaseActionGeneric()
 }
 
 //a blink
-ABlink::ABlink(GameObserver* observer, int _id, MTGCardInstance * card, MTGCardInstance * _target,bool blinkueot,bool blinkForSource,bool blinkhand,MTGAbility * stored) :
+ABlink::ABlink(GameObserver* observer, int _id, MTGCardInstance * card, MTGCardInstance * _target, bool blinkueot, bool blinkForSource, bool blinkhand, MTGAbility * stored) :
 MTGAbility(observer, _id, card),blinkueot(blinkueot),blinkForSource(blinkForSource),blinkhand(blinkhand),stored(stored)
 {
     target = _target;
@@ -4968,86 +4968,18 @@ MTGAbility(observer, _id, card),blinkueot(blinkueot),blinkForSource(blinkForSour
 
 void ABlink::Update(float dt)
 {
-    if(resolved == false)
+    if (resolved == false)
     {
         resolved = true;
         resolveBlink();
     }
 
-    if ((blinkueot && currentPhase == MTG_PHASE_ENDOFTURN)||(blinkForSource && !source->isInPlay(game)))
+    if ((blinkueot && currentPhase == MTG_PHASE_ENDOFTURN) || (blinkForSource && !source->isInPlay(game)))
     {
-        if(Blinked == NULL)
+        if (Blinked == NULL)
             MTGAbility::Update(dt);
         MTGCardInstance * _target = Blinked;
-        MTGCardInstance * Blinker = NULL;
+        returnCardIntoPlay(_target);
-        if(!blinkhand)
-            Blinker = _target->controller()->game->putInZone(_target, _target->currentZone,
-            _target->owner->game->battlefield);
-        if(blinkhand)
-        {
-            _target->controller()->game->putInZone(_target, _target->currentZone,
-                _target->owner->game->hand);
-            return;
-        }
-        Spell * spell = NEW Spell(game, Blinker);
-        spell->source->counters->init();
-        if(spell->source->hasSubtype(Subtypes::TYPE_AURA) && !blinkhand)
-        {
-            TargetChooserFactory tcf(game);
-            TargetChooser * tc = tcf.createTargetChooser(spell->source->spellTargetType,spell->source);
-            if(!tc->validTargetsExist())
-            {
-                spell->source->owner->game->putInExile(spell->source);
-                SAFE_DELETE(spell);
-                SAFE_DELETE(tc);
-                this->forceDestroy = 1;
-                return;
-            }
-
-            MTGGameZone * inplay = spell->source->owner->game->inPlay;
-            spell->source->target = NULL;
-            for(int i = game->getRandomGenerator()->random()%inplay->nb_cards;;i = game->getRandomGenerator()->random()%inplay->nb_cards)
-            {
-                if(tc->canTarget(inplay->cards[i]) && spell->source->target == NULL)
-                {
-                    spell->source->target = inplay->cards[i];
-                    spell->getNextCardTarget();
-                    spell->resolve();
-
-                    SAFE_DELETE(spell);
-                    SAFE_DELETE(tc);
-                    this->forceDestroy = 1;
-                    return;
-                }
-                if(!tc->validTargetsExist())
-                return;
-            }
-        }
-        spell->source->power = spell->source->origpower;
-        spell->source->toughness = spell->source->origtoughness;
-        spell->source->X = 0;
-        if(!spell->source->hasSubtype(Subtypes::TYPE_AURA))
-        {
-            spell->resolve();
-            if(stored)
-            {
-                MTGAbility * clonedStored = stored->clone();
-                clonedStored->target = spell->source;
-                if (clonedStored->oneShot)
-                {
-                    clonedStored->resolve();
-                    delete (clonedStored);
-                }
-                else
-                {
-                    clonedStored->addToGame();
-                }
-            }
-        }
-        delete spell;
-        this->forceDestroy = 1;
-        Blinker = NULL;
-        return;
     }
     MTGAbility::Update(dt);
 }
@@ -5081,73 +5013,84 @@ void ABlink::resolveBlink()
         Blinked = _target;
         if(!blinkueot && !blinkForSource)
         {
-            MTGCardInstance * Blinker = NULL;
+            returnCardIntoPlay(_target);
-            if(!blinkhand)
+        }
-                Blinker = _target->controller()->game->putInZone(_target, _target->currentZone,
+    }
-                _target->owner->game->battlefield);
+}
-            if(blinkhand)
-            {
-                _target->controller()->game->putInZone(_target, _target->currentZone,
-                    _target->owner->game->hand);
-                return;
-            }
-            Spell * spell = NEW Spell(game, Blinker);
-            spell->source->counters->init();
-            if(spell->source->hasSubtype(Subtypes::TYPE_AURA) && !blinkhand)
-            {
-                TargetChooserFactory tcf(game);
-                TargetChooser * tc = tcf.createTargetChooser(spell->source->spellTargetType,spell->source);
-                if(!tc->validTargetsExist())
-                {
-                    spell->source->owner->game->putInExile(spell->source);
-                    SAFE_DELETE(spell);
-                    SAFE_DELETE(tc);
-                    this->forceDestroy = 1;
-                    return;
-                }
 
-                MTGGameZone * inplay = spell->source->owner->game->inPlay;
+void ABlink::returnCardIntoPlay(MTGCardInstance* _target) {
-                spell->source->target = NULL;
+    MTGCardInstance * Blinker = NULL;
-                for(int i = game->getRandomGenerator()->random()%inplay->nb_cards;;i = game->getRandomGenerator()->random()%inplay->nb_cards)
+    if (!blinkhand)
-                {
+        Blinker = _target->controller()->game->putInZone(
-                    if(tc->canTarget(inplay->cards[i]) && spell->source->target == NULL)
+            _target,
-                    {
+            _target->currentZone,
-                        spell->source->target = inplay->cards[i];
+            _target->owner->game->battlefield);
-                        spell->getNextCardTarget();
+    if (blinkhand)
-                        spell->resolve();
+    {
-                        SAFE_DELETE(spell);
+        _target->controller()->game->putInZone(
-                        SAFE_DELETE(tc);
+            _target,
-                        this->forceDestroy = 1;
+            _target->currentZone,
-                        return;
+            _target->owner->game->hand);
-                    }
+        return;
-                }
+    }
-            }
+    Spell * spell = NEW Spell(game, Blinker);
-            spell->source->power = spell->source->origpower;
+    spell->source->counters->init();
-            spell->source->toughness = spell->source->origtoughness;
+    if (spell->source->hasSubtype(Subtypes::TYPE_AURA) && !blinkhand)
-            spell->source->X = 0;
+    {
-            spell->resolve();
+        TargetChooserFactory tcf(game);
-            if(stored)
+        TargetChooser * tc = tcf.createTargetChooser(
-            {
+            spell->source->spellTargetType,
-                MTGAbility * clonedStored = stored->clone();
+            spell->source);
-                clonedStored->target = spell->source;
+        if (!tc->validTargetsExist())
-                if (clonedStored->oneShot)
+        {
-                {
+            spell->source->owner->game->putInExile(spell->source);
-                    clonedStored->resolve();
-                    delete (clonedStored);
-                }
-                else
-                {
-                    clonedStored->addToGame();
-                }
-            }
             SAFE_DELETE(spell);
             SAFE_DELETE(tc);
             this->forceDestroy = 1;
-            if(stored)
+            return;
-            delete(stored);
+        }
-            Blinked = NULL;
+
+        MTGGameZone * inplay = spell->source->owner->game->inPlay;
+        spell->source->target = NULL;
+        for (int i = game->getRandomGenerator()->random()%inplay->nb_cards;;i = game->getRandomGenerator()->random()%inplay->nb_cards)
+        {
+            if(tc->canTarget(inplay->cards[i]) && spell->source->target == NULL)
+            {
+                spell->source->target = inplay->cards[i];
+                spell->getNextCardTarget();
+                spell->resolve();
+                SAFE_DELETE(spell);
+                SAFE_DELETE(tc);
+                this->forceDestroy = 1;
+                return;
+            }
         }
     }
+    spell->source->power = spell->source->origpower;
+    spell->source->toughness = spell->source->origtoughness;
+    spell->source->X = 0;
+    if (!spell->source->hasSubtype(Subtypes::TYPE_AURA)) {
+        spell->resolve();
+        if (stored)
+        {
+            MTGAbility * clonedStored = stored->clone();
+            clonedStored->target = spell->source;
+            if (clonedStored->oneShot)
+            {
+                clonedStored->resolve();
+                delete (clonedStored);
+            }
+            else
+            {
+                clonedStored->addToGame();
+            }
+        }
+    }
+    SAFE_DELETE(spell);
+    SAFE_DELETE(tc);
+    SAFE_DELETE(stored);
+    this->forceDestroy = 1;
+    Blinked = NULL;
 }
 
 int ABlink::resolve()