- Added "This creature can't attack unless defending player controls an Island" and "When you control no Islands, sacrifice this creature" keywords.

- Added some new cards: Goblin Chieftain, Vodalian Knights, Fleeting Image, Merfolk Sovereign, corrected Dandan, bunch of other cards.

res/cards.txt

@@ -1,3 +1,155 @@
+Sea Monster
+4 U U
+Creature Serpent
+no text
+6/6
+This creature can't attack unless defending player controls an Island
+
+Red Cliffs Armada
+4 U
+Creature Human Soldier
+no text
+5/4
+This creature can't attack unless defending player controls an Island
+
+Manta Ray
+1 U U
+Creature Fish
+Manta Ray can't be blocked except by blue creatures.
+3/3
+This creature can't attack unless defending player controls an Island
+When you control no Islands, sacrifice this creature
+
+Ethereal Whiskergill
+3 U
+Creature Elemental
+no text
+4/3
+This creature can't attack unless defending player controls an Island
+Flying
+
+Armored Galleon
+4 U
+Creature Human Pirate
+no text
+5/4
+This creature can't attack unless defending player controls an Island
+
+Deep-Sea Serpent
+4 U U
+Creature Serpent
+no text
+5/5
+This creature can't attack unless defending player controls an Island
+
+Sea Serpent
+5 U
+Creature Serpent
+no text
+5/5
+This creature can't attack unless defending player controls an Island
+When you control no Islands, sacrifice this creature
+
+Slipstream Eel
+5 U U
+Creature Fish Beast
+no text
+6/6
+This creature can't attack unless defending player controls an Island
+Cycling:1 U
+
+Slipstream Serpent
+7 U
+Creature Serpent
+no text
+6/6
+Morph:5 U
+This creature can't attack unless defending player controls an Island
+When you control no Islands, sacrifice this creature
+
+Steam Frigate
+2 U
+Creature Human Pirate
+no text
+3/3
+This creature can't attack unless defending player controls an Island
+
+Wu Warship
+2 U
+Creature Human Soldier
+no text
+3/3
+This creature can't attack unless defending player controls an Island
+
+Goblin Chieftain
+1 R R
+Creature Goblin
+Haste Other Goblin creatures you control get +1/+1 and have haste.
+2/2
+
+Dwarven Pony
+R
+Creature Horse
+no text
+1/1
+
+Fleeting Image
+2 U
+Creature Illusion
+no text
+2/1
+Flying
+
+Dandan
+U U
+Creature Fish
+no text
+4/1
+This creature can't attack unless defending player controls an Island
+When you control no Islands, sacrifice this creature
+
+Pirate Ship
+4 U
+Creature Human Pirate
+no text
+4/3
+This creature can't attack unless defending player controls an Island
+When you control no Islands, sacrifice this creature
+
+Zhou You, Chief Commander
+5 U U
+Legendary Creature Human Soldier
+no text
+8/8
+This creature can't attack unless defending player controls an Island
+
+Vodalian Knights
+1 U U
+Creature Merfolk Knight
+no text
+2/2
+This creature can't attack unless defending player controls an Island
+When you control no Islands, sacrifice this creature
+KPump U:Flying
+
+Serendib Sorcerer
+1 U U
+Creature Human Wizard
+no text
+1/1
+
+Merfolk Sovereign
+1 U U
+Creature Merfolk
+Other Merfolk creatures you control get +1/+1.
+2/2
+
+Acolyte of Xathrid
+B
+Creature Human Cleric
+no text
+0/1
+
 Barren Glory
 4 W W
 Enchantment
@@ -10637,12 +10789,6 @@ Creature Merfolk
 no text
 2/1
 
-Dandan
-U U
-Creature Fish
-no text
-4/1
-
 Djinn of the Lamp
 5 U U
 Creature Djinn

res/main.properties

@@ -1,6 +1,6 @@
 program/mail=mtgrares@yahoo.com
 program/forum=http://www.slightlymagic.net/forum/viewforum.php?f=26
-program/version=MTG Forge -- official beta: 09/11/02, SVN revision: 87
+program/version=MTG Forge -- official beta: 09/11/02, SVN revision: 88
 
 tokens--file=AllTokens.txt
 

src/forge/CardFactory.java

@@ -13577,9 +13577,12 @@ public class CardFactory implements NewConstants {
           public boolean canPlayAI()
           {
              CardList list = new CardList(AllZone.Computer_Play.getCards());
+             if (list.size() > 0) {
 	             setTargetCard(CardFactoryUtil.AI_getBestCreature(list));
 	             return (getTargetCard() != null);
              }
+             return false;
+          }
        };
        ability.setBeforePayMana(CardFactoryUtil.input_targetCreature(ability));
        ability.setDescription("3, T: Put a +1/+1 counter on target creature.");

src/forge/CardFactory_Creatures.java

@@ -6036,7 +6036,7 @@ public class CardFactory_Creatures {
 
 
 	  //*************** START *********** START **************************
-	    else if(cardName.equals("Sorceress Queen"))
+	    else if(cardName.equals("Sorceress Queen") || cardName.equals("Serendib Sorcerer"))
 	    {
 	      final Ability_Tap ability = new Ability_Tap(card)
 	      {
@@ -6100,7 +6100,7 @@ public class CardFactory_Creatures {
 	        }//resolve()
 	      };//SpellAbility
 	      card.addSpellAbility(ability);
-	      ability.setDescription("tap: Target creature other than Sorceress Queen becomes 0/2 until end of turn.");
+	      ability.setDescription("tap: Target creature other than "+cardName +" becomes 0/2 until end of turn.");
 	      //this ability can target "this card" when it shouldn't be able to
 	      ability.setBeforePayMana(CardFactoryUtil.input_targetCreature_NoCost_TapAbility_NoTargetSelf(ability));
 	    }//*************** END ************ END **************************
@@ -6154,7 +6154,7 @@ public class CardFactory_Creatures {
 
 
 	    //*************** START *********** START **************************
-	    else if(cardName.equals("Mawcor"))
+	    else if(cardName.equals("Mawcor") || cardName.equals("Pirate Ship"))
 	    {
 	      final Ability_Tap ability = new Ability_Tap(card)
 	      {
@@ -6180,7 +6180,7 @@ public class CardFactory_Creatures {
 	        }//resolve()
 	      };//SpellAbility
 	      card.addSpellAbility(ability);
-	      ability.setDescription("tap: Mawcor deals 1 damage to target creature or player.");
+	      ability.setDescription("tap: "+ cardName +" deals 1 damage to target creature or player.");
 
 	      ability.setBeforePayMana(CardFactoryUtil.input_targetCreaturePlayer(ability, true));
 	    }//*************** END ************ END **************************
@@ -15851,6 +15851,240 @@ public class CardFactory_Creatures {
 		      card.addComesIntoPlayCommand(intoPlay);
 		    }//*************** END ************ END **************************
 	      
+	        //*************** START *********** START **************************
+            else if(cardName.equals("Acolyte of Xathrid"))
+            {
+               final SpellAbility ability = new Ability_Tap(card, "1 B")
+               {
+	               private static final long serialVersionUID = -560200331236516099L;
+	               public void resolve()
+	               {
+	                  String opponent = AllZone.GameAction.getOpponent(card.getController());
+	                  AllZone.GameAction.getPlayerLife(opponent).subtractLife(1);
+	               }
+	               public boolean canPlayAI()
+	               {
+	                  //computer should play ability if this creature doesn't attack
+	                  Combat c = ComputerUtil.getAttackers();
+	                  CardList list = new CardList(c.getAttackers());
+	
+	                  //could this creature attack?, if attacks, do not use ability
+	                  if (!list.contains(card)) {
+	                	  setTargetPlayer(Constant.Player.Human);
+	                	  return true;
+	                  }
+	                  return false;
+	               }
+              };//SpellAbility
+              card.addSpellAbility(ability);
+              ability.setDescription("1 B, tap: Target player loses 1 life.");
+              ability.setBeforePayMana(CardFactoryUtil.input_targetPlayer(ability));
+            }//*************** END ************ END **************************
+	      
+	      
+	    //*************** START *********** START **************************
+  	      else if(cardName.equals("Merfolk Sovereign"))
+  	      {
+  	        final Ability_Tap ability = new Ability_Tap(card, "0")
+  	        {
+			  private static final long serialVersionUID = -4663016921034366082L;
+
+			  public boolean canPlayAI() {return getMerfolk().size() != 0;}
+
+  	          public void chooseTargetAI()
+  	          {
+  	            AllZone.GameAction.sacrifice(card);
+
+  	            CardList merfolk = getMerfolk();
+  	            merfolk.shuffle();
+  	            setTargetCard(merfolk.get(0));
+  	          }
+
+  	          CardList getMerfolk()
+  	          {
+  	        	PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
+  	            CardList merfolk = new CardList(play.getCards());
+  	            merfolk = merfolk.filter(new CardListFilter()
+  	            {
+  	              public boolean addCard(Card c)
+  	              {
+  	                return c.isCreature() && c.getType().contains("Merfolk") && CardFactoryUtil.AI_doesCreatureAttack(c) && 
+  	                !c.equals(card) && !c.getKeyword().contains("Unblockable");
+  	              }
+  	            });
+  	            return merfolk;
+  	          }//getFlying()
+
+  	          public void resolve()
+  	          {
+  	            if(AllZone.GameAction.isCardInPlay(getTargetCard())  && CardFactoryUtil.canTarget(card, getTargetCard()) )
+  	            {
+  	              getTargetCard().addExtrinsicKeyword("Unblockable");
+  	            }
+
+  	            @SuppressWarnings("unused") // target
+  	  		    final Card[] target = {getTargetCard()};
+  	            AllZone.EndOfTurn.addUntil(new Command()
+  	            {
+				  private static final long serialVersionUID = -1884018112259809603L;
+
+				  public void execute()
+  	              {
+  	                if(AllZone.GameAction.isCardInPlay(getTargetCard()))
+  	                  getTargetCard().removeExtrinsicKeyword("Unblockable");
+  	              }
+  	            });
+  	          }//resolve()
+  	        };//SpellAbility
+
+  	        Input runtime = new Input()
+  	        {
+
+  	          private static final long serialVersionUID = 4512556936796509819L;
+
+			  public void showMessage()
+  	          {
+  	            CardList list = new CardList();
+  	            list.addAll(AllZone.Human_Play.getCards());
+  	            list.addAll(AllZone.Computer_Play.getCards());
+  	            list = list.filter(new CardListFilter()
+  	            {
+  	              public boolean addCard(Card c)
+  	              {
+  	                return c.isCreature() && c.getType().contains("Merfolk") && CardFactoryUtil.canTarget(card, c);
+  	              }
+  	            });
+
+  	            stopSetNext(CardFactoryUtil.input_targetSpecific(ability, list, "Select target Merfolk creature", Command.Blank,true));
+  	          }//showMessage()
+  	        };//Input
+
+  	        card.addSpellAbility(ability);
+  	        ability.setDescription("Tap: Target Merfolk creature is unblockable this turn.");
+  	        ability.setBeforePayMana(runtime);
+  	      }//*************** END ************ END **************************
+	      
+	      
+	    //*************** START *********** START **************************
+  	      else if(cardName.equals("Dwarven Pony"))
+  	      {
+  	        final Ability_Tap ability = new Ability_Tap(card, "1 R")
+  	        {
+			  private static final long serialVersionUID = 2626619319289064288L;
+
+			  public boolean canPlayAI() {return getDwarves().size() != 0;}
+
+  	          public void chooseTargetAI()
+  	          {
+  	            AllZone.GameAction.sacrifice(card);
+
+  	            CardList dwarves = getDwarves();
+  	            dwarves.shuffle();
+  	            setTargetCard(dwarves.get(0));
+  	          }
+
+  	          CardList getDwarves()
+  	          {
+  	        	PlayerZone hplay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
+  	        	CardList mountains = new CardList(hplay.getCards());
+  	        	mountains = mountains.getType("Mountain");
+  	        	if (mountains.size() == 0)
+  	        		return mountains;
+  	        	
+  	        	
+  	        	PlayerZone play = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
+  	            CardList dwarves = new CardList(play.getCards());
+  	            dwarves = dwarves.filter(new CardListFilter()
+  	            {
+  	              public boolean addCard(Card c)
+  	              {
+  	                return c.isCreature() && c.getType().contains("Dwarf") && CardFactoryUtil.AI_doesCreatureAttack(c) && 
+  	                !c.equals(card) && !c.getKeyword().contains("Mountainwalk");
+  	              }
+  	            });
+  	            return dwarves;
+  	          }//getFlying()
+
+  	          public void resolve()
+  	          {
+  	            if(AllZone.GameAction.isCardInPlay(getTargetCard())  && CardFactoryUtil.canTarget(card, getTargetCard()) )
+  	            {
+  	              getTargetCard().addExtrinsicKeyword("Mountainwalk");
+  	            }
+
+  	            @SuppressWarnings("unused") // target
+  	  		    final Card[] target = {getTargetCard()};
+  	            AllZone.EndOfTurn.addUntil(new Command()
+  	            {
+
+  	            	private static final long serialVersionUID = -6845643843049229106L;
+
+					public void execute()
+	  	              {
+	  	                if(AllZone.GameAction.isCardInPlay(getTargetCard()))
+	  	                  getTargetCard().removeExtrinsicKeyword("Mountainwalk");
+	  	              }
+  	            });
+  	          }//resolve()
+  	        };//SpellAbility
+
+  	        Input runtime = new Input()
+  	        {
+
+				private static final long serialVersionUID = -2962059144349469134L;
+
+				public void showMessage()
+	  	          {
+	  	            CardList list = new CardList();
+	  	            list.addAll(AllZone.Human_Play.getCards());
+	  	            list.addAll(AllZone.Computer_Play.getCards());
+	  	            list = list.filter(new CardListFilter()
+	  	            {
+	  	              public boolean addCard(Card c)
+	  	              {
+	  	                return c.isCreature() && c.getType().contains("Dwarf") && CardFactoryUtil.canTarget(card, c);
+	  	              }
+	  	            });
+	
+	  	            stopSetNext(CardFactoryUtil.input_targetSpecific(ability, list, "Select target Dwarf creature", Command.Blank,true));
+	  	          }//showMessage()
+	  	        };//Input
+
+  	        card.addSpellAbility(ability);
+  	        ability.setDescription("1 R, Tap: Target Dwarf creature gains mountainwalk until end of turn.");
+  	        ability.setBeforePayMana(runtime);
+  	      }//*************** END ************ END **************************
+	      
+	    //*************** START *********** START **************************
+  	    else if(cardName.equals("Fleeting Image"))
+  	    {
+  	    	final SpellAbility a1 = new Ability(card,"1 U")
+  	        {
+  	    	  public boolean canPlayAI()
+  	    	  {
+  	    		  return false;
+  	    	  }
+  	      	  public void resolve()
+  	            {
+  	      		  PlayerZone hand = AllZone.getZone(Constant.Zone.Hand, card.getOwner());
+  	      		  /*
+  	      		  AllZone.getZone(card).remove(card);
+  	      		  hand.add(card);
+  	      		  */
+  	      		  if (card.isToken())
+  	    			  AllZone.getZone(card).remove(card);
+  	    		  else
+  	    			  AllZone.GameAction.moveTo(hand, card);
+  	      		  
+  	            }
+  	        };//a1
+  	        
+  	        //card.clearSpellAbility();
+  	        card.addSpellAbility(a1);
+  	        a1.setStackDescription(card.getController() + " returns Fleeting Image back to its owner's hand.");
+  	        a1.setDescription("1 U: Return Fleeting Image to its owner's hand.");
+  	    
+  	   }//*************** END ************ END **************************
 
 	      	    
 	      // Cards with Cycling abilities

src/forge/CombatUtil.java

@@ -158,6 +158,12 @@ public class CombatUtil
     		!CardUtil.getColors(blocker).contains(Constant.Color.Red))
     		return false;
     }
+    
+    if (attacker.getName().equals("Manta Ray"))
+    {
+    	if (!CardUtil.getColors(blocker).contains(Constant.Color.Blue))
+    		return false;
+    }
     /*
     if(attacker.getKeyword().contains("Flying"))
       return blocker.getKeyword().contains("Flying") ||
@@ -196,6 +202,18 @@ public class CombatUtil
 			moatPrevented = true;
 		}
 	}
+	
+	PlayerZone play = AllZone.getZone(Constant.Zone.Play,AllZone.GameAction.getOpponent(c.getController()));
+	CardList list = new CardList(play.getCards());
+	CardList temp = new CardList();
+	
+	if (c.getKeyword().contains("This creature can't attack unless defending player controls an Island"))
+	{
+		temp = list.getType("Island");
+		if (temp.isEmpty())
+			return false;
+	}
+	
     if(c.isTapped() || c.hasSickness() || c.getKeyword().contains("Defender") || moatPrevented || oppControlsBlazingArchon(c)
       || c.getKeyword().contains("This creature can't attack") || c.getKeyword().contains("This creature can't attack or block") )
       return false;

src/forge/GameActionUtil.java

@@ -4888,6 +4888,9 @@ public class GameActionUtil
 		Essence_Warden.execute();
 		Soul_Warden.execute();
 		Wirewood_Hivemaster.execute();
+		
+		Sacrifice_NoIslands.execute();
+		
 		//Angelic_Chorus.execute();
 		
 		/*
@@ -8792,6 +8795,99 @@ public class GameActionUtil
 		
 	};//Elvish_Champion_Other
 	
+	public static Command Goblin_Chieftain_Pump = new Command()
+	{
+
+		private static final long serialVersionUID = 395882142255572162L;
+		CardList gloriousAnthemList = new CardList();
+
+		public void execute()
+		{
+
+			CardList cList = gloriousAnthemList;
+			Card c;
+
+			for (int i = 0; i < cList.size(); i++)
+			{
+				c = cList.get(i);
+				c.addSemiPermanentAttackBoost(-1);
+				c.addSemiPermanentDefenseBoost(-1);
+				c.removeExtrinsicKeyword("Haste");
+			}
+			cList.clear();
+			PlayerZone[] zone = getZone("Goblin Chieftain");
+
+			// for each zone found add +1/+1 to each card
+			for (int outer = 0; outer < zone.length; outer++)
+			{
+				CardList creature = new CardList();
+				creature.addAll(AllZone.Human_Play.getCards());
+				creature.addAll(AllZone.Computer_Play.getCards());
+				creature = creature.getType("Goblin");
+
+				for (int i = 0; i < creature.size(); i++)
+				{
+					c = creature.get(i);
+					if (c.isCreature()
+							&& !c.getName().equals("Goblin Chieftain"))
+					{
+						c.addSemiPermanentAttackBoost(1);
+						c.addSemiPermanentDefenseBoost(1);
+						c.addExtrinsicKeyword("Haste");
+						gloriousAnthemList.add(c);
+					}
+
+				} // for
+			} // for
+
+		}// execute()
+
+	};//Goblin_Chieftain_Pump
+	
+	public static Command Goblin_Chieftain_Other = new Command()
+	{
+
+		private static final long serialVersionUID = -3107498901233064819L;
+		int otherLords=0;
+		
+		private int countOtherLords()
+		{
+			PlayerZone hPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
+			PlayerZone cPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
+			CardList lords = new CardList();
+			lords.addAll(hPlay.getCards());
+			lords.addAll(cPlay.getCards());
+			lords = lords.getName("Goblin Chieftain");
+			return lords.size()-1;
+
+		}
+
+		public void execute()
+		{
+
+			
+			CardList creature = new CardList();
+			creature.addAll(AllZone.Human_Play.getCards());
+			creature.addAll(AllZone.Computer_Play.getCards());
+			
+			creature = creature.getName("Goblin Chieftain");
+
+			for (int i = 0; i < creature.size(); i++)
+			{
+				Card c = creature.get(i);
+				otherLords = countOtherLords();
+				c.setOtherAttackBoost(otherLords);
+				c.setOtherDefenseBoost(otherLords);
+				if (!c.getExtrinsicKeyword().contains("Haste") && otherLords > 0)
+					c.addExtrinsicKeyword("Haste");
+				//else if (c.getExtrinsicKeyword().contains("Mountainwalk") && otherLords == 0 )
+					
+
+			}// for inner
+		}// execute()
+		
+	};//Goblin_Chieftain_Other
+	
 	
 	public static Command Goblin_King_Pump = new Command()
 	{
@@ -8886,6 +8982,90 @@ public class GameActionUtil
 		
 	};//Goblin_King_Other
 	
+	public static Command Merfolk_Sovereign_Pump = new Command()
+	{
+
+		private static final long serialVersionUID = -8250416279767429585L;
+		CardList gloriousAnthemList = new CardList();
+
+		public void execute()
+		{
+
+			CardList cList = gloriousAnthemList;
+			Card c;
+
+			for (int i = 0; i < cList.size(); i++)
+			{
+				c = cList.get(i);
+				c.addSemiPermanentAttackBoost(-1);
+				c.addSemiPermanentDefenseBoost(-1);
+			}
+			cList.clear();
+			PlayerZone[] zone = getZone("Merfolk Sovereign");
+
+			// for each zone found add +1/+1 to each card
+			for (int outer = 0; outer < zone.length; outer++)
+			{
+				CardList creature = new CardList();
+				creature.addAll(AllZone.Human_Play.getCards());
+				creature.addAll(AllZone.Computer_Play.getCards());
+				creature = creature.getType("Merfolk");
+
+				for (int i = 0; i < creature.size(); i++)
+				{
+					c = creature.get(i);
+					if (c.isCreature()
+							&& !c.getName().equals("Merfolk Sovereign"))
+					{
+						c.addSemiPermanentAttackBoost(1);
+						c.addSemiPermanentDefenseBoost(1);
+						gloriousAnthemList.add(c);
+					}
+
+				} // for
+			} // for
+
+		}// execute()
+
+	};//Merfolk_Sovereign_Pump 
+	
+	public static Command Merfolk_Sovereign_Other = new Command()
+	{
+		private static final long serialVersionUID = -179394803961615332L;
+		int otherLords=0;
+		
+		private int countOtherLords()
+		{
+			PlayerZone hPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Human);
+			PlayerZone cPlay = AllZone.getZone(Constant.Zone.Play, Constant.Player.Computer);
+			CardList lords = new CardList();
+			lords.addAll(hPlay.getCards());
+			lords.addAll(cPlay.getCards());
+			lords = lords.getName("Merfolk Sovereign");
+			return lords.size()-1;
+
+		}
+
+		public void execute()
+		{
+
+			
+			CardList creature = new CardList();
+			creature.addAll(AllZone.Human_Play.getCards());
+			creature.addAll(AllZone.Computer_Play.getCards());
+			
+			creature = creature.getName("Merfolk Sovereign");
+
+			for (int i = 0; i < creature.size(); i++)
+			{
+				Card c = creature.get(i);
+				otherLords = countOtherLords();
+				c.setOtherAttackBoost(otherLords);
+				c.setOtherDefenseBoost(otherLords);
+			}// for inner
+		}// execute()
+		
+	};//Merfolk_Sovereign_Other
 	
 	public static Command Lord_of_Atlantis_Pump = new Command()
 	{
@@ -9375,6 +9555,46 @@ public class GameActionUtil
 		
 	};
 	
+	public static Command Sacrifice_NoIslands = new Command()
+	{
+		
+		private static final long serialVersionUID = 8064452222949253952L;
+		int islands = 0;
+		public void execute()
+		{
+			CardList creature = new CardList();
+			creature.addAll(AllZone.Human_Play.getCards());
+			creature.addAll(AllZone.Computer_Play.getCards());
+			
+			creature = creature.filter(new CardListFilter()
+			{
+				public boolean addCard(Card c) {
+					return c.getKeyword().contains("When you control no Islands, sacrifice this creature");
+				}
+			});
+			
+			for (int i = 0; i < creature.size(); i++)
+			{
+				Card c = creature.get(i);
+				islands = countIslands(c);
+				if (islands == 0)
+				{
+					AllZone.GameAction.sacrifice(c);
+				}
+			}
+				
+		}//execute()
+		
+		private int countIslands(Card c)
+		{
+			PlayerZone play = AllZone.getZone(Constant.Zone.Play, c.getController());
+			CardList islands = new CardList(play.getCards());
+			islands = islands.getType("Island");
+			return islands.size();
+		}
+
+	};
+	
 	public static Command Zuberi = new Command()
 	{
 		private static final long serialVersionUID = -6283266522827930762L;
@@ -11344,8 +11564,12 @@ public class GameActionUtil
 		commands.put("Elvish_Champion_Other", Elvish_Champion_Other);
 		commands.put("Wizened_Cenn_Pump", Wizened_Cenn_Pump);
 		commands.put("Wizened_Cenn_Other", Wizened_Cenn_Other);
+		commands.put("Merfolk_Sovereign_Pump", Merfolk_Sovereign_Pump);
+		commands.put("Merfolk_Sovereign_Other", Merfolk_Sovereign_Other);
 		commands.put("Lord_of_Atlantis_Pump", Lord_of_Atlantis_Pump);
 		commands.put("Lord_of_Atlantis_Other", Lord_of_Atlantis_Other);
+		commands.put("Goblin_Chieftain_Pump", Goblin_Chieftain_Pump);
+		commands.put("Goblin_Chieftain_Other", Goblin_Chieftain_Other);
 		commands.put("Goblin_King_Pump", Goblin_King_Pump);
 		commands.put("Goblin_King_Other", Goblin_King_Other);
 		commands.put("Field_Marshal_Pump", Field_Marshal_Pump);

src/forge/StateBasedEffects.java

@@ -65,7 +65,9 @@ public class StateBasedEffects
 		cardToEffectsList.put("Privileged Position", new String[] {"Privileged_Position", "Privileged_Position_Other"});
 		cardToEffectsList.put("Elvish Archdruid", new String[] {"Elvish_Archdruid_Pump", "Elvish_Archdruid_Other"});
 		cardToEffectsList.put("Wizened Cenn", new String[] {"Wizened_Cenn_Pump", "Wizened_Cenn_Other"});
+		cardToEffectsList.put("Goblin Chieftain", new String[] {"Goblin_Chieftain_Pump", "Goblin_Chieftain_Other"});
 		cardToEffectsList.put("Goblin King", new String[] {"Goblin_King_Pump", "Goblin_King_Other"});
+		cardToEffectsList.put("Merfolk Sovereign", new String[] {"Merfolk_Sovereign_Pump", "Merfolk_Sovereign_Other"});
 		cardToEffectsList.put("Lord of Atlantis", new String[] {"Lord_of_Atlantis_Pump","Lord_of_Atlantis_Other"});
 		cardToEffectsList.put("Elvish Champion", new String[] {"Elvish_Champion_Pump","Elvish_Champion_Other"});
 		cardToEffectsList.put("Field Marshal", new String[] {"Field_Marshal_Pump", "Field_Marshal_Other"});
@@ -185,7 +187,7 @@ public class StateBasedEffects
 		for (int i=0;i<cards.size();i++)
 		{
 			Card c = cards.get(i);
-			if (cardToEffectsList.containsKey(c.getName()))
+			if (cardToEffectsList.containsKey(c.getName()) )
 			{
 				String[] effects = getCardToEffectsList().get(c.getName());
 				for (String effect : effects) {