Merge pull request #5157 from ninthworld/master

Add Star Wars Expansion sets to the Star Wars set

Mage.Client/src/main/java/org/mage/plugins/card/dl/sources/GrabbagImageSource.java

@@ -357,10 +357,81 @@ public enum GrabbagImageSource implements CardImageSource {
         singleLinks.put("SWS/Yoda, Jedi Master", "6arN1Hl.png");
         singleLinks.put("SWS/Y-Wing", "aQQ5zwA.jpg");
         singleLinks.put("SWS/Zam Wesell", "ToG0C1r.jpg");
+        singleLinks.put("SWS/Astromech Droid", "v0TpHMh.jpg");
+        singleLinks.put("SWS/Buried Ruin", "QkmIWYg.png");
+        singleLinks.put("SWS/Flame Trooper", "RkY7KFJ.jpg");
+        singleLinks.put("SWS/Force Stasis", "FavLrcY.jpg");
+        singleLinks.put("SWS/Salvage Trader", "qGwk7Bn.jpg");
+        singleLinks.put("SWS/Outer Rim Gang", "kEjKQGy.png");
+        singleLinks.put("SWS/Rathtar", "CYhHRqF.png");
+        singleLinks.put("SWS/Riot Trooper", "PusvaQB.jpg");
+        singleLinks.put("SWS/Sins of the Father", "32YHTPB.jpg");
+        singleLinks.put("SWS/Upsilon-class Shuttle", "Le3F3oW.jpg");
+        singleLinks.put("SWS/Finn", "TU2LI2q.jpg");
+        singleLinks.put("SWS/General Hux", "UpWfcV6.png");
+        singleLinks.put("SWS/Poe Dameron", "v8i21dn.png");
+        singleLinks.put("SWS/Rey", "7n5ZZFA.png");
+        singleLinks.put("SWS/Kylo Ren", "fFzDMTz.png");
+        singleLinks.put("SWS/TIE Striker", "6b5GDUQ.jpg");
+        singleLinks.put("SWS/Bludgeoning Pain", "ap5k3Wl.jpg");
+        singleLinks.put("SWS/Force Protection", "GrOQLHO.jpg");
+        singleLinks.put("SWS/Gerrera's Revolutionary", "FQFE1Jt.jpg");
+        singleLinks.put("SWS/Thermal Detonator", "gTPLM83.jpg");
+        singleLinks.put("SWS/Hammerhead Corvette", "IlhOAGv.jpg");
+        singleLinks.put("SWS/U-Wing", "FmoRCmG.jpg");
+        singleLinks.put("SWS/Bor Gullet", "jXafYHX.jpg");
+        singleLinks.put("SWS/Imperial Hovertank", "6X1wL4d.jpg");
+        singleLinks.put("SWS/Occupation", "h4mmkA5.jpg");
+        singleLinks.put("SWS/Resistance", "lbNhA59.jpg");
+        singleLinks.put("SWS/Jyn Erso and Cassian Andor", "o0SCGiJ.jpg");
+        singleLinks.put("SWS/Chirrut Imwe", "wgtXfUF.jpg");
+        singleLinks.put("SWS/Director Krennic", "52PGsH5.jpg");
+        singleLinks.put("SWS/Vader's Command", "7Lql6UT.jpg");
+        singleLinks.put("SWS/Delay Tactic", "ubmzD1m.jpg");
+        singleLinks.put("SWS/Resistance Bomber", "Sudfkd7.jpg");
+        singleLinks.put("SWS/Mouse Droid", "oO0p8QE.jpg");
+        singleLinks.put("SWS/First Order Dreadnought", "80pO9Cc.jpg");
+        singleLinks.put("SWS/TIE Silencer", "7yeYIjX.jpg");
+        singleLinks.put("SWS/Canto Bight Enforcer", "VKPQVsn.jpg");
+        singleLinks.put("SWS/Cantonica Casino", "7LiSvy6.jpg");
+        singleLinks.put("SWS/Fathier", "0oKquQp.jpg");
+        singleLinks.put("SWS/Code Slice", "7uNASji.jpg");
+        singleLinks.put("SWS/Captain Phasma", "LWujx1B.jpg");
+        singleLinks.put("SWS/Force Telepathy", "e90hswX.jpg");
+        singleLinks.put("SWS/Praetorian Trooper", "pjS1wyS.jpg");
+        singleLinks.put("SWS/Supreme Leader Snoke", "eewWiKE.jpg");
+        singleLinks.put("SWS/Sai Tok", "FVn29tT.jpg");
+        singleLinks.put("SWS/Porg Nest", "8DnNZKc.jpg");
+        singleLinks.put("SWS/Inspire", "7lIXhtd.jpg");
+        singleLinks.put("SWS/Force Projection", "5EfOwyn.jpg");
+        singleLinks.put("SWS/Luke Skywalker, the Last Jedi", "WMmQcyD.jpg");
+        singleLinks.put("SWS/Vulptex", "30WeCkw.jpg");
+        singleLinks.put("SWS/Glorious Charge", "yJwvKzk.jpg");
+        singleLinks.put("SWS/Plains-520b", "Fx59r9J.jpg");
+        singleLinks.put("SWS/Island-520a", "jIPpWp5.jpg");
+        singleLinks.put("SWS/Conscription", "An01yAe.jpg");
+        singleLinks.put("SWS/Afterburn", "2ydqSvT.jpg");
+        singleLinks.put("SWS/Corellian Gunship", "mZdDQWH.jpg");
+        singleLinks.put("SWS/Despair", "TLTddMI.jpg");
+        singleLinks.put("SWS/Dryden Vos", "6LbtUzN.jpg");
+        singleLinks.put("SWS/Droid Uprising", "aWuoxho.jpg");
+        singleLinks.put("SWS/Gamble", "Hwzr60O.jpg");
+        singleLinks.put("SWS/Han Solo, Scrumrat", "Hqj39dG.jpg");
+        singleLinks.put("SWS/Mud Trooper", "af8JaDy.jpg");
+        singleLinks.put("SWS/Enfys Nest", "pstVfQg.jpg");
+        singleLinks.put("SWS/Kalevan Star Yacht", "nHmSizp.jpg");
+        singleLinks.put("SWS/Maelstrom Blockade", "sUYT0pc.jpg");
+        singleLinks.put("SWS/Range Trooper", "kXGvTkE.jpg");
+        singleLinks.put("SWS/Tobias Beckett", "hzm6ilE.jpg");
+        singleLinks.put("SWS/Underground Forum", "FH2pRfU.jpg");
+        singleLinks.put("SWS/Chewbacca, the Beast", "Zb5TitZ.jpg");
+
         // Emblems
         singleLinks.put("SWS/Emblem Obi-Wan Kenobi", "Qyc10aT.png");
         singleLinks.put("SWS/Aurra Sing", "BLWbVJC.png");
         singleLinks.put("SWS/Yoda", "zH0sYxg.png");
+        singleLinks.put("SWS/Emblem Luke Skywalker", "kHELZDJ.jpg");
+
         // Tokens
         singleLinks.put("SWS/Ewok", "N2MvJyr.png");
         singleLinks.put("SWS/B-Wing", "oH62AUD.png");
@@ -372,6 +443,8 @@ public enum GrabbagImageSource implements CardImageSource {
         singleLinks.put("SWS/Royal Guard", "9tqE8vL.png");
         singleLinks.put("SWS/Tusken Raider", "gPMiSmP.png");
         singleLinks.put("SWS/Droid", "4PRrWFF.png");
+        singleLinks.put("SWS/Trooper 2", "tcxvGOn.jpg");
+        singleLinks.put("SWS/Porg", "HBjt1A3.jpg");
     }
 
     @Override

Mage.Sets/src/mage/cards/a/Afterburn.java

@@ -0,0 +1,47 @@
+package mage.cards.a;
+
+import java.util.UUID;
+
+import mage.abilities.Mode;
+import mage.abilities.effects.common.RemoveFromCombatTargetEffect;
+import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
+import mage.abilities.keyword.FirstStrikeAbility;
+import mage.abilities.keyword.HasteAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Duration;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Afterburn extends CardImpl {
+
+    public Afterburn(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{R}");
+        
+
+        // Choose One -
+        //   Target creature gains haste and first strike until end of turn.
+        this.getSpellAbility().addEffect(new GainAbilityTargetEffect(HasteAbility.getInstance(), Duration.EndOfTurn).setText("Target creature gains haste"));
+        this.getSpellAbility().addEffect(new GainAbilityTargetEffect(FirstStrikeAbility.getInstance(), Duration.EndOfTurn).setText("and first strike until end of turn"));
+        this.getSpellAbility().addTarget(new TargetCreaturePermanent());
+
+        //   Remove target creature from combat.
+        Mode mode = new Mode();
+        mode.getEffects().add(new RemoveFromCombatTargetEffect());
+        mode.getTargets().add(new TargetCreaturePermanent());
+        this.getSpellAbility().addMode(mode);
+    }
+
+    public Afterburn(final Afterburn card) {
+        super(card);
+    }
+
+    @Override
+    public Afterburn copy() {
+        return new Afterburn(this);
+    }
+}

Mage.Sets/src/mage/cards/a/AstromechDroid.java

@@ -0,0 +1,63 @@
+package mage.cards.a;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.costs.common.TapSourceCost;
+import mage.abilities.effects.common.continuous.BoostTargetEffect;
+import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
+import mage.abilities.keyword.RepairAbility;
+import mage.abilities.keyword.VigilanceAbility;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.mageobject.SubtypePredicate;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class AstromechDroid extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("starship creature");
+
+    static {
+        filter.add(new SubtypePredicate(SubType.STARSHIP));
+    }
+
+    public AstromechDroid(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{W}");
+        
+        this.subtype.add(SubType.DROID);
+        this.power = new MageInt(0);
+        this.toughness = new MageInt(1);
+
+        // {T}: Target starship creature you control gets +1/+1 and gains vigilance until end of turn.
+        Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD,
+                new BoostTargetEffect(1, 1, Duration.EndOfTurn)
+                    .setText("Target starship creature you control gets +1/+1"),
+                new TapSourceCost());
+        ability.addEffect(new GainAbilityTargetEffect(VigilanceAbility.getInstance(), Duration.EndOfTurn)
+                    .setText("and gains vigilance until end of turn"));
+        ability.addTarget(new TargetCreaturePermanent(filter));
+        this.addAbility(ability);
+
+        // Repair 4
+        this.addAbility(new RepairAbility(4));
+    }
+
+    public AstromechDroid(final AstromechDroid card) {
+        super(card);
+    }
+
+    @Override
+    public AstromechDroid copy() {
+        return new AstromechDroid(this);
+    }
+}

Mage.Sets/src/mage/cards/b/BludgeoningPain.java

@@ -0,0 +1,36 @@
+package mage.cards.b;
+
+import java.util.UUID;
+import mage.abilities.effects.common.TapTargetEffect;
+import mage.abilities.effects.common.continuous.BoostTargetEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Duration;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class BludgeoningPain extends CardImpl {
+
+    public BludgeoningPain(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{B}");
+
+
+        // Target creature gets -2/-2 until end of turn. Tap that creature.
+        this.getSpellAbility().addEffect(new BoostTargetEffect(-2, -2, Duration.EndOfTurn));
+        this.getSpellAbility().addEffect(new TapTargetEffect());
+        this.getSpellAbility().addTarget(new TargetCreaturePermanent());
+    }
+
+    public BludgeoningPain(final BludgeoningPain card) {
+        super(card);
+    }
+
+    @Override
+    public BludgeoningPain copy() {
+        return new BludgeoningPain(this);
+    }
+}

Mage.Sets/src/mage/cards/b/BorGullet.java

@@ -0,0 +1,42 @@
+package mage.cards.b;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.effects.common.discard.DiscardCardYouChooseTargetEffect;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.target.common.TargetOpponent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class BorGullet extends CardImpl {
+
+    public BorGullet(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{U}{B}");
+        
+        this.subtype.add(SubType.HORROR);
+        this.subtype.add(SubType.CEPHALID);
+        this.power = new MageInt(4);
+        this.toughness = new MageInt(4);
+
+        // When Bor Gullet enters the battlefield, target opponent reveals his or her hand. You choose a card from it. That player discards that card.
+        Ability ability = new EntersBattlefieldTriggeredAbility(new DiscardCardYouChooseTargetEffect());
+        ability.addTarget(new TargetOpponent());
+        this.addAbility(ability);
+    }
+
+    public BorGullet(final BorGullet card) {
+        super(card);
+    }
+
+    @Override
+    public BorGullet copy() {
+        return new BorGullet(this);
+    }
+}

Mage.Sets/src/mage/cards/c/CantoBightEnforcer.java

@@ -0,0 +1,48 @@
+package mage.cards.c;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.effects.common.counter.AddCountersSourceEffect;
+import mage.abilities.effects.common.counter.AddCountersTargetEffect;
+import mage.abilities.keyword.BountyAbility;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.counters.CounterType;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class CantoBightEnforcer extends CardImpl {
+
+    public CantoBightEnforcer(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{B}");
+        
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.HUNTER);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(2);
+
+        // When Canto Bight Enforcer enters the battlefield, you may put a bounty counter on target creature.
+        Ability ability = new EntersBattlefieldTriggeredAbility(new AddCountersTargetEffect(CounterType.BOUNTY.createInstance()), true);
+        ability.addTarget(new TargetCreaturePermanent());
+        this.addAbility(ability);
+
+        // Bounty - Whenever a creature an opponent controls with a bounty counter on it dies, put a +1/+1 counter on Canto Bight Enforcer.
+        this.addAbility(new BountyAbility(new AddCountersSourceEffect(CounterType.P1P1.createInstance())));
+    }
+
+    public CantoBightEnforcer(final CantoBightEnforcer card) {
+        super(card);
+    }
+
+    @Override
+    public CantoBightEnforcer copy() {
+        return new CantoBightEnforcer(this);
+    }
+}

Mage.Sets/src/mage/cards/c/CantonicaCasino.java

@@ -0,0 +1,79 @@
+package mage.cards.c;
+
+import java.util.UUID;
+
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.costs.common.TapSourceCost;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.common.RollDiceEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Outcome;
+import mage.game.Game;
+import mage.players.Player;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class CantonicaCasino extends CardImpl {
+
+    public CantonicaCasino(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT}, "{2}");
+        
+
+        // {T}: Roll two six-sided dice. If you roll doubles, gain 10 life. Otherwise, lose 1 life.
+        this.addAbility(new SimpleActivatedAbility(new CantonicaCasinoEffect(), new TapSourceCost()));
+    }
+
+    public CantonicaCasino(final CantonicaCasino card) {
+        super(card);
+    }
+
+    @Override
+    public CantonicaCasino copy() {
+        return new CantonicaCasino(this);
+    }
+}
+
+class CantonicaCasinoEffect extends OneShotEffect {
+
+    public CantonicaCasinoEffect() {
+        super(Outcome.Neutral);
+        staticText = "Roll two six-sided dice. If you roll doubles, gain 10 life. Otherwise, lose 1 life";
+    }
+
+    public CantonicaCasinoEffect(final CantonicaCasinoEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Player you = game.getPlayer(source.getControllerId());
+        if(you != null) {
+            // Roll two six-sided dice
+            int dice1 = you.rollDice(game, 6);
+            int dice2 = you.rollDice(game, 6);
+
+            if(dice1 == dice2) {
+                // If you roll doubles, gain 10 life
+                you.gainLife(10, game, source);
+                return false;
+            }
+            else {
+                // Otherwise, lose 1 life
+                you.loseLife(1, game, false);
+                return false;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public CantonicaCasinoEffect copy() {
+        return new CantonicaCasinoEffect(this);
+    }
+}

Mage.Sets/src/mage/cards/c/CaptainPhasma.java

@@ -0,0 +1,67 @@
+package mage.cards.c;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.costs.mana.ManaCostsImpl;
+import mage.abilities.effects.common.CreateTokenEffect;
+import mage.abilities.effects.common.continuous.GainAbilityControlledEffect;
+import mage.abilities.effects.common.search.SearchLibraryPutInHandEffect;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.filter.common.FilterCreatureCard;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.Predicates;
+import mage.filter.predicate.mageobject.SubtypePredicate;
+import mage.filter.predicate.permanent.TokenPredicate;
+import mage.game.permanent.token.TrooperToken;
+import mage.target.common.TargetCardInLibrary;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class CaptainPhasma extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("Nontoken trooper creatures");
+    private static final FilterCreatureCard filterCard = new FilterCreatureCard("Trooper card");
+
+    static {
+        filter.add(new SubtypePredicate(SubType.TROOPER));
+        filter.add(Predicates.not(new TokenPredicate()));
+        filterCard.add(new SubtypePredicate(SubType.TROOPER));
+    }
+
+    public CaptainPhasma(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{W}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.TROOPER);
+        this.power = new MageInt(4);
+        this.toughness = new MageInt(4);
+
+        // Nontoken Trooper creatures you control have "When this creature enters the battlefield, create 1/1/ white Trooper creature token."
+        Ability ability = new EntersBattlefieldTriggeredAbility(new CreateTokenEffect(new TrooperToken())
+                .setText("When this creature enters the battlefield, create a 1/1 white Trooper creature token"),
+                false, true);
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD,
+                new GainAbilityControlledEffect(ability, Duration.WhileOnBattlefield, filter, false)));
+
+        // {W}{U}{B}{R}{G}: Search your library for a Trooper creature card, reveal it, put it into your hand, then shuffle your library.
+        this.addAbility(new SimpleActivatedAbility(new SearchLibraryPutInHandEffect(new TargetCardInLibrary(filterCard), true, true), new ManaCostsImpl("{W}{U}{B}{R}{G}")));
+    }
+
+    public CaptainPhasma(final CaptainPhasma card) {
+        super(card);
+    }
+
+    @Override
+    public CaptainPhasma copy() {
+        return new CaptainPhasma(this);
+    }
+}

Mage.Sets/src/mage/cards/c/ChewbaccaTheBeast.java

@@ -0,0 +1,60 @@
+package mage.cards.c;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.AttacksTriggeredAbility;
+import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
+import mage.abilities.keyword.IndestructibleAbility;
+import mage.abilities.keyword.PartnerWithAbility;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.mageobject.AnotherTargetPredicate;
+import mage.filter.predicate.permanent.AnotherPredicate;
+import mage.filter.predicate.permanent.AttackingPredicate;
+import mage.filter.predicate.permanent.ControllerPredicate;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class ChewbaccaTheBeast extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("another target attacking creature you control");
+
+    static {
+        filter.add(new ControllerPredicate(TargetController.YOU));
+        filter.add(new AnotherPredicate());
+        filter.add(new AttackingPredicate());
+    }
+
+    public ChewbaccaTheBeast(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{G}{G}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.WOOKIEE);
+        this.subtype.add(SubType.WARRIOR);
+        this.power = new MageInt(3);
+        this.toughness = new MageInt(3);
+
+        // Partner with Han Solo, Scrumrat
+        this.addAbility(new PartnerWithAbility("Han Solo, Scrumrat"));
+
+        // Whenever Chewbacca, the Beast attacks, another target attacking creature you control gains indestructible until end of turn.
+        Ability ability = new AttacksTriggeredAbility(new GainAbilityTargetEffect(IndestructibleAbility.getInstance(), Duration.EndOfTurn), false);
+        ability.addTarget(new TargetCreaturePermanent(filter));
+        this.addAbility(ability);
+    }
+
+    public ChewbaccaTheBeast(final ChewbaccaTheBeast card) {
+        super(card);
+    }
+
+    @Override
+    public ChewbaccaTheBeast copy() {
+        return new ChewbaccaTheBeast(this);
+    }
+}

Mage.Sets/src/mage/cards/c/ChirrutImwe.java

@@ -0,0 +1,100 @@
+package mage.cards.c;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.costs.mana.ManaCostsImpl;
+import mage.abilities.effects.ContinuousEffectImpl;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.common.PreventCombatDamageToSourceEffect;
+import mage.constants.SubType;
+import mage.constants.SuperType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Duration;
+import mage.constants.Layer;
+import mage.constants.Outcome;
+import mage.constants.SubLayer;
+import mage.constants.Zone;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class ChirrutImwe extends CardImpl {
+
+    public ChirrutImwe(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{G}{W}{U}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.MONK);
+        this.power = new MageInt(3);
+        this.toughness = new MageInt(3);
+
+        // Chirrut Imwe can block up to two additional creatures.
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new ChirrutImweEffect()));
+        
+        // {1}{W}: Prevent all combat damage that would be dealt to Chirrut Imwe until end of turn.
+        Effect effect = new PreventCombatDamageToSourceEffect(Duration.EndOfTurn);
+        effect.setText("Prevent all combat damage that would be dealt to {this} until end of turn");
+        this.addAbility(new SimpleActivatedAbility(Zone.BATTLEFIELD, effect, new ManaCostsImpl("{1}{W}")));
+    }
+
+    public ChirrutImwe(final ChirrutImwe card) {
+        super(card);
+    }
+
+    @Override
+    public ChirrutImwe copy() {
+        return new ChirrutImwe(this);
+    }
+}
+
+class ChirrutImweEffect extends ContinuousEffectImpl {
+    
+    public ChirrutImweEffect() {
+        super(Duration.WhileOnBattlefield, Outcome.Benefit);
+        staticText = "{this} can block up to two additional creatures";
+    }
+    
+    public ChirrutImweEffect(final ChirrutImweEffect effect) {
+        super(effect);
+    }
+    
+    @Override
+    public ChirrutImweEffect copy() {
+        return new ChirrutImweEffect(this);
+    }
+    
+    @Override
+    public boolean apply(Layer layer, SubLayer sublayer, Ability source, Game game) {
+        Permanent perm = game.getPermanent(source.getSourceId());
+        if(perm != null) {
+            switch(layer) {
+                case RulesEffects:
+                    // maxBlocks = 0 equals to "can block any number of creatures"
+                    if(perm.getMaxBlocks() > 0) {
+                        perm.setMaxBlocks(perm.getMaxBlocks() + 2);
+                    }
+                    break;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        return false;
+    }
+
+    @Override
+    public boolean hasLayer(Layer layer) {
+        return layer == Layer.RulesEffects;
+    }
+}

Mage.Sets/src/mage/cards/c/CodeSlice.java

@@ -0,0 +1,50 @@
+package mage.cards.c;
+
+import java.util.UUID;
+
+import mage.abilities.effects.common.combat.CantBlockAllEffect;
+import mage.abilities.effects.common.counter.AddCountersTargetEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Duration;
+import mage.counters.CounterType;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.mageobject.CardTypePredicate;
+import mage.filter.predicate.permanent.CounterPredicate;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class CodeSlice extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("Artifact creatures with bounty counters on them");
+
+    static {
+        filter.add(new CardTypePredicate(CardType.ARTIFACT));
+        filter.add(new CounterPredicate(CounterType.BOUNTY));
+    }
+
+    public CodeSlice(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{R}");
+        
+
+        // Put a bounty counter on target creature.
+        this.getSpellAbility().addEffect(new AddCountersTargetEffect(CounterType.BOUNTY.createInstance()));
+        this.getSpellAbility().addTarget(new TargetCreaturePermanent());
+
+        // Artifact creatures with bounty counters on them can't block this turn.
+        this.getSpellAbility().addEffect(new CantBlockAllEffect(filter, Duration.EndOfTurn));
+    }
+
+    public CodeSlice(final CodeSlice card) {
+        super(card);
+    }
+
+    @Override
+    public CodeSlice copy() {
+        return new CodeSlice(this);
+    }
+}

Mage.Sets/src/mage/cards/c/Conscription.java

@@ -0,0 +1,49 @@
+package mage.cards.c;
+
+import java.util.UUID;
+
+import mage.abilities.effects.common.continuous.BecomesChosenCreatureTypeTargetEffect;
+import mage.abilities.effects.common.continuous.BecomesCreatureTypeTargetEffect;
+import mage.abilities.effects.common.continuous.GainControlTargetEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.ComparisonType;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.mageobject.PowerPredicate;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Conscription extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("creature with power 2 or less");
+
+    static {
+        filter.add(new PowerPredicate(ComparisonType.FEWER_THAN, 3));
+    }
+
+    public Conscription(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{2}{U}{U}");
+        
+
+        // Gain control of target creature with power 2 or less. It becomes a Trooper in addition to its other types.
+        this.getSpellAbility().addEffect(new GainControlTargetEffect(Duration.EndOfGame));
+        this.getSpellAbility().addEffect(new BecomesCreatureTypeTargetEffect(Duration.EndOfGame, SubType.TROOPER, false)
+                .setText("It becomes a Trooper in addition to its other types"));
+        this.getSpellAbility().addTarget(new TargetCreaturePermanent(filter));
+    }
+
+    public Conscription(final Conscription card) {
+        super(card);
+    }
+
+    @Override
+    public Conscription copy() {
+        return new Conscription(this);
+    }
+}

Mage.Sets/src/mage/cards/c/CorellianGunship.java

@@ -0,0 +1,45 @@
+package mage.cards.c;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.effects.common.DamageTargetEffect;
+import mage.abilities.keyword.SpaceflightAbility;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.target.common.TargetPlayerOrPlaneswalker;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class CorellianGunship extends CardImpl {
+
+    public CorellianGunship(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{R}");
+        
+        this.subtype.add(SubType.STARSHIP);
+        this.power = new MageInt(1);
+        this.toughness = new MageInt(1);
+
+        // Spaceflight
+        this.addAbility(SpaceflightAbility.getInstance());
+
+        // When Corellian Gunship enters the battlefield, it deals 1 damage to target player or planeswalker.
+        Ability ability = new EntersBattlefieldTriggeredAbility(new DamageTargetEffect(1));
+        ability.addTarget(new TargetPlayerOrPlaneswalker());
+        this.addAbility(ability);
+    }
+
+    public CorellianGunship(final CorellianGunship card) {
+        super(card);
+    }
+
+    @Override
+    public CorellianGunship copy() {
+        return new CorellianGunship(this);
+    }
+}

Mage.Sets/src/mage/cards/d/DarthTyranusCountOfSerenno.java

@@ -31,9 +31,9 @@ import mage.target.common.TargetCreaturePermanent;
  *
  * @author Styxo
  */
-public final class DarthTyranus extends CardImpl {
+public final class DarthTyranusCountOfSerenno extends CardImpl {
 
-    public DarthTyranus(UUID ownerId, CardSetInfo setInfo) {
+    public DarthTyranusCountOfSerenno(UUID ownerId, CardSetInfo setInfo) {
         super(ownerId,setInfo,new CardType[]{CardType.PLANESWALKER},"{1}{W}{U}{B}");
         this.subtype.add(SubType.DOOKU);
 
@@ -55,13 +55,13 @@ public final class DarthTyranus extends CardImpl {
         this.addAbility(ability);
     }
 
-    public DarthTyranus(final DarthTyranus card) {
+    public DarthTyranusCountOfSerenno(final DarthTyranusCountOfSerenno card) {
         super(card);
     }
 
     @Override
-    public DarthTyranus copy() {
-        return new DarthTyranus(this);
+    public DarthTyranusCountOfSerenno copy() {
+        return new DarthTyranusCountOfSerenno(this);
     }
 }
 

Mage.Sets/src/mage/cards/d/DelayTactic.java

@@ -0,0 +1,91 @@
+package mage.cards.d;
+
+import java.util.UUID;
+
+import mage.abilities.Ability;
+import mage.abilities.Mode;
+import mage.abilities.effects.ContinuousEffect;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.common.DontUntapInControllersNextUntapStepTargetEffect;
+import mage.abilities.effects.common.DontUntapInPlayersNextUntapStepAllEffect;
+import mage.abilities.effects.common.continuous.GainAbilityAllEffect;
+import mage.abilities.effects.common.continuous.GainAbilityControlledEffect;
+import mage.abilities.keyword.HexproofAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Duration;
+import mage.constants.Outcome;
+import mage.filter.StaticFilters;
+import mage.filter.common.FilterControlledCreaturePermanent;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.permanent.ControllerIdPredicate;
+import mage.game.Game;
+import mage.players.Player;
+import mage.target.TargetPlayer;
+import mage.target.common.TargetOpponent;
+import mage.target.targetpointer.FixedTarget;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class DelayTactic extends CardImpl {
+
+    public DelayTactic(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{U}");
+        
+
+        // Choose one -
+        //   Creatures you control gain hexproof until end of turn.
+        this.getSpellAbility().addEffect(new GainAbilityAllEffect(HexproofAbility.getInstance(), Duration.EndOfTurn, new FilterControlledCreaturePermanent())
+            .setText("Creatures you control gain hexproof until end of turn"));
+
+        //   Creatures target opponent controls don't untap during his or her next untap step.
+        Mode mode = new Mode();
+        mode.getEffects().add(new DelayTacticEffect());
+        mode.getTargets().add(new TargetOpponent());
+        this.getSpellAbility().addMode(mode);
+    }
+
+    public DelayTactic(final DelayTactic card) {
+        super(card);
+    }
+
+    @Override
+    public DelayTactic copy() {
+        return new DelayTactic(this);
+    }
+}
+
+// Based on ManaVaporsEffect
+class DelayTacticEffect extends OneShotEffect {
+
+    DelayTacticEffect() {
+        super(Outcome.Benefit);
+        this.staticText = "Creatures target opponent controls don't untap during his or her next untap step";
+    }
+
+    DelayTacticEffect(final DelayTacticEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public DelayTacticEffect copy() {
+        return new DelayTacticEffect(this);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Player targetPlayer = game.getPlayer(getTargetPointer().getFirst(game, source));
+        if (targetPlayer != null) {
+            FilterCreaturePermanent filter = new FilterCreaturePermanent();
+            filter.add(new ControllerIdPredicate(targetPlayer.getId()));
+            ContinuousEffect effect = new DontUntapInPlayersNextUntapStepAllEffect(filter);
+            effect.setTargetPointer(new FixedTarget(targetPlayer.getId()));
+            game.addEffect(effect, source);
+            return true;
+        }
+        return false;
+    }
+}

Mage.Sets/src/mage/cards/d/Despair.java

@@ -0,0 +1,36 @@
+package mage.cards.d;
+
+import java.util.UUID;
+
+import mage.abilities.effects.common.SacrificeControllerEffect;
+import mage.abilities.effects.common.SacrificeOpponentsEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.filter.common.FilterControlledCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Despair extends CardImpl {
+
+    private static final FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("creature");
+
+    public Despair(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{B}{B}");
+        
+
+        // Each opponent sacrifices a creature.
+        this.getSpellAbility().addEffect(new SacrificeOpponentsEffect(filter));
+    }
+
+    public Despair(final Despair card) {
+        super(card);
+    }
+
+    @Override
+    public Despair copy() {
+        return new Despair(this);
+    }
+}

Mage.Sets/src/mage/cards/d/DirectorKrennic.java

@@ -0,0 +1,60 @@
+package mage.cards.d;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.common.LeavesBattlefieldTriggeredAbility;
+import mage.abilities.effects.common.CreateTokenEffect;
+import mage.abilities.effects.common.DestroyTargetEffect;
+import mage.constants.SubType;
+import mage.constants.SuperType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.filter.FilterPermanent;
+import mage.filter.predicate.mageobject.CardTypePredicate;
+import mage.filter.predicate.mageobject.SupertypePredicate;
+import mage.game.permanent.token.TrooperToken2;
+import mage.target.TargetPermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class DirectorKrennic extends CardImpl {
+
+    private static final FilterPermanent filterLand = new FilterPermanent("basic land");
+    
+    static {
+        filterLand.add(new CardTypePredicate(CardType.LAND));
+        filterLand.add(new SupertypePredicate(SuperType.BASIC));
+    }
+    
+    public DirectorKrennic(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{B}{B}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.ADVISOR);
+        this.power = new MageInt(3);
+        this.toughness = new MageInt(4);
+
+        // When Director Krennic enters the battlefield, create two 1/1 black Trooper creature tokens.
+        this.addAbility(new EntersBattlefieldTriggeredAbility(new CreateTokenEffect(new TrooperToken2(), 2)));
+        
+        // When Director Krennic leaves the battlefield, destroy target basic land.
+        Ability ability = new LeavesBattlefieldTriggeredAbility(new DestroyTargetEffect(), false);
+        ability.addTarget(new TargetPermanent(filterLand));
+        this.addAbility(ability);
+    }
+
+    public DirectorKrennic(final DirectorKrennic card) {
+        super(card);
+    }
+
+    @Override
+    public DirectorKrennic copy() {
+        return new DirectorKrennic(this);
+    }
+}

Mage.Sets/src/mage/cards/d/DroidUprising.java

@@ -0,0 +1,46 @@
+package mage.cards.d;
+
+import java.util.UUID;
+
+import mage.abilities.effects.common.CreateTokenEffect;
+import mage.abilities.effects.common.TapAllEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.Predicates;
+import mage.filter.predicate.mageobject.CardTypePredicate;
+import mage.game.permanent.token.DroidToken;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class DroidUprising extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("nonartifact creatures");
+
+    static {
+        filter.add(Predicates.not(new CardTypePredicate(CardType.ARTIFACT)));
+    }
+
+    public DroidUprising(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{2}{W}{W}");
+        
+
+        // Tap all nonartifact creatures.
+        this.getSpellAbility().addEffect(new TapAllEffect(filter));
+
+        // Create two colorless 1/1 Droid artifact creature tokens.
+        this.getSpellAbility().addEffect(new CreateTokenEffect(new DroidToken(), 2));
+    }
+
+    public DroidUprising(final DroidUprising card) {
+        super(card);
+    }
+
+    @Override
+    public DroidUprising copy() {
+        return new DroidUprising(this);
+    }
+}

Mage.Sets/src/mage/cards/d/DrydenVos.java

@@ -0,0 +1,57 @@
+package mage.cards.d;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.effects.common.DamageTargetEffect;
+import mage.abilities.effects.common.counter.AddCountersTargetEffect;
+import mage.abilities.keyword.BountyAbility;
+import mage.constants.SubType;
+import mage.constants.SuperType;
+import mage.abilities.keyword.MenaceAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.counters.CounterType;
+import mage.target.common.TargetAnyTarget;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class DrydenVos extends CardImpl {
+
+    public DrydenVos(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{B}{R}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.ROGUE);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(3);
+
+        // Menace
+        this.addAbility(new MenaceAbility());
+
+        // When Dryden Vos enters the battlefield, put a bounty counter on target creature.
+        Ability ability = new EntersBattlefieldTriggeredAbility(new AddCountersTargetEffect(CounterType.BOUNTY.createInstance()));
+        ability.addTarget(new TargetCreaturePermanent());
+        this.addAbility(ability);
+
+        // Bounty - Whenever a creature an opponent controls with a bounty counter on it dies, Dryden Vos deals 2 damage to any target.
+        Ability ability2 = new BountyAbility(new DamageTargetEffect(2));
+        ability2.addTarget(new TargetAnyTarget());
+        this.addAbility(ability2);
+    }
+
+    public DrydenVos(final DrydenVos card) {
+        super(card);
+    }
+
+    @Override
+    public DrydenVos copy() {
+        return new DrydenVos(this);
+    }
+}

Mage.Sets/src/mage/cards/e/EnfysNest.java

@@ -0,0 +1,88 @@
+package mage.cards.e;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.common.ExileTargetEffect;
+import mage.constants.Outcome;
+import mage.constants.SubType;
+import mage.constants.SuperType;
+import mage.abilities.keyword.VigilanceAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+import mage.players.Player;
+import mage.target.common.TargetOpponentsCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class EnfysNest extends CardImpl {
+
+    public EnfysNest(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{G}{W}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.REBEL);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(1);
+
+        // Vigilance
+        this.addAbility(VigilanceAbility.getInstance());
+
+        // Whenever Enfys Nest enters the battlefield, you may exile target creature an opponent controls. If you do, that player gains life equal to that creature's power.
+        Ability ability = new EntersBattlefieldTriggeredAbility(new EnfysNestEffect(), true);
+        ability.addTarget(new TargetOpponentsCreaturePermanent());
+        this.addAbility(ability);
+    }
+
+    public EnfysNest(final EnfysNest card) {
+        super(card);
+    }
+
+    @Override
+    public EnfysNest copy() {
+        return new EnfysNest(this);
+    }
+}
+
+class EnfysNestEffect extends ExileTargetEffect {
+
+    public EnfysNestEffect() {
+        super();
+        staticText = "you may exile target creature an opponent controls. If you do, that player gains life equal to that creature's power";
+    }
+
+    public EnfysNestEffect(final EnfysNestEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Permanent permanent = game.getPermanentOrLKIBattlefield(source.getFirstTarget());
+        if(permanent != null) {
+            // you may exile target creature an opponent controls
+            if(!super.apply(game, source)) {
+                return false;
+            }
+
+            // If you do, that player gains life equal to that creature's power.
+            Player player = game.getPlayer(permanent.getControllerId());
+            player.gainLife(permanent.getPower().getValue(), game, source);
+
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public EnfysNestEffect copy() {
+        return new EnfysNestEffect(this);
+    }
+}

Mage.Sets/src/mage/cards/f/Fathier.java

@@ -0,0 +1,40 @@
+package mage.cards.f;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.keyword.MonstrosityAbility;
+import mage.constants.SubType;
+import mage.abilities.keyword.HasteAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Fathier extends CardImpl {
+
+    public Fathier(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{R}{R}");
+        
+        this.subtype.add(SubType.BEAST);
+        this.power = new MageInt(3);
+        this.toughness = new MageInt(3);
+
+        // Haste
+        this.addAbility(HasteAbility.getInstance());
+
+        // {4}{R}{R}: Monstrosity 2.
+        this.addAbility(new MonstrosityAbility("{4}{R}{R}", 2));
+    }
+
+    public Fathier(final Fathier card) {
+        super(card);
+    }
+
+    @Override
+    public Fathier copy() {
+        return new Fathier(this);
+    }
+}

Mage.Sets/src/mage/cards/f/Finn.java

@@ -0,0 +1,59 @@
+package mage.cards.f;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldControlledTriggeredAbility;
+import mage.abilities.dynamicvalue.common.PermanentsOnBattlefieldCount;
+import mage.abilities.effects.common.GainLifeEffect;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.filter.StaticFilters;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.Predicates;
+import mage.filter.predicate.mageobject.CardTypePredicate;
+import mage.filter.predicate.mageobject.NamePredicate;
+import mage.filter.predicate.permanent.ControllerPredicate;
+import mage.filter.predicate.permanent.TokenPredicate;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Finn extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("{this} or another nontoken creature you control");
+
+    static {
+        filter.add(new ControllerPredicate(TargetController.YOU));
+        filter.add(Predicates.not(new TokenPredicate()));
+    }
+
+    public Finn(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{G}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.TROOPER);
+        this.subtype.add(SubType.SOLDIER);
+        this.power = new MageInt(3);
+        this.toughness = new MageInt(3);
+
+        // Whenever Finn or another nontoken creature you control enters the battlefield under your control, you gain 1 life for each nontoken creature you control.
+        this.addAbility(new EntersBattlefieldControlledTriggeredAbility(Zone.BATTLEFIELD,
+                new GainLifeEffect(new PermanentsOnBattlefieldCount(filter))
+                    .setText("you gain 1 life for each nontoken creature you control"),
+                filter, false));
+    }
+
+    public Finn(final Finn card) {
+        super(card);
+    }
+
+    @Override
+    public Finn copy() {
+        return new Finn(this);
+    }
+}

Mage.Sets/src/mage/cards/f/FirstOrderDreadnought.java

@@ -0,0 +1,49 @@
+package mage.cards.f;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.costs.common.TapSourceCost;
+import mage.abilities.costs.mana.ManaCostsImpl;
+import mage.abilities.effects.common.DestroyTargetEffect;
+import mage.abilities.keyword.SpaceflightAbility;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class FirstOrderDreadnought extends CardImpl {
+
+    public FirstOrderDreadnought(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{4}{B}{B}");
+        
+        this.subtype.add(SubType.STARSHIP);
+        this.power = new MageInt(5);
+        this.toughness = new MageInt(6);
+
+        // Spaceflight
+        this.addAbility(SpaceflightAbility.getInstance());
+
+        // {2}{B}, {T}: Destroy target creature.
+        Ability ability = new SimpleActivatedAbility(new DestroyTargetEffect(), new ManaCostsImpl("{2}{B}"));
+        ability.addCost(new TapSourceCost());
+        ability.addTarget(new TargetCreaturePermanent());
+        this.addAbility(ability);
+    }
+
+    public FirstOrderDreadnought(final FirstOrderDreadnought card) {
+        super(card);
+    }
+
+    @Override
+    public FirstOrderDreadnought copy() {
+        return new FirstOrderDreadnought(this);
+    }
+}

Mage.Sets/src/mage/cards/f/FlameTrooper.java

@@ -0,0 +1,50 @@
+package mage.cards.f;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.effects.common.continuous.GainAbilityControlledEffect;
+import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
+import mage.abilities.keyword.MenaceAbility;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.mageobject.SubtypePredicate;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class FlameTrooper extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("Trooper creatures");
+
+    static {
+        filter.add(new SubtypePredicate(SubType.TROOPER));
+    }
+
+    public FlameTrooper(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{R}");
+        
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.TROOPER);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(2);
+
+        // Trooper creatures you control have menace.
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new GainAbilityControlledEffect(new MenaceAbility(), Duration.WhileOnBattlefield, filter, false)));
+    }
+
+    public FlameTrooper(final FlameTrooper card) {
+        super(card);
+    }
+
+    @Override
+    public FlameTrooper copy() {
+        return new FlameTrooper(this);
+    }
+}

Mage.Sets/src/mage/cards/f/ForceProjection.java

@@ -0,0 +1,95 @@
+package mage.cards.f;
+
+import java.util.UUID;
+
+import mage.abilities.Ability;
+import mage.abilities.TriggeredAbility;
+import mage.abilities.common.BecomesTargetTriggeredAbility;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.common.CreateTokenCopyTargetEffect;
+import mage.abilities.effects.common.SacrificeSourceEffect;
+import mage.abilities.effects.keyword.ScryEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Outcome;
+import mage.constants.SubType;
+import mage.constants.Zone;
+import mage.filter.FilterSpell;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+import mage.players.Player;
+import mage.target.common.TargetControlledCreaturePermanent;
+import mage.target.common.TargetCreaturePermanent;
+import mage.target.targetpointer.FixedTarget;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class ForceProjection extends CardImpl {
+
+    public ForceProjection(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{1}{U}{U}");
+        
+
+        // Create a token that is a copy of target creature you control except that it is an Illusion in addition to its other types and gains "When this creature becomes the target of a spell, sacrifice it."
+        this.getSpellAbility().addEffect(new ForceProjectionEffect());
+        this.getSpellAbility().addTarget(new TargetControlledCreaturePermanent());
+
+        // Scry 2.
+        this.getSpellAbility().addEffect(new ScryEffect(2));
+    }
+
+    public ForceProjection(final ForceProjection card) {
+        super(card);
+    }
+
+    @Override
+    public ForceProjection copy() {
+        return new ForceProjection(this);
+    }
+}
+
+class ForceProjectionEffect extends OneShotEffect {
+
+    public ForceProjectionEffect() {
+        super(Outcome.Copy);
+        this.staticText = "Create a token that is a copy of target creature you control except that it is an Illusion " +
+                "in addition to its other types and gains \"When this creature becomes the target of a spell, sacrifice it.\"";
+    }
+
+    public ForceProjectionEffect(final ForceProjectionEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public ForceProjectionEffect copy() {
+        return new ForceProjectionEffect(this);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Player controller = game.getPlayer(source.getControllerId());
+        Permanent permanent = game.getPermanentOrLKIBattlefield(getTargetPointer().getFirst(game, source));
+        if (controller != null && permanent != null) {
+            // Create a token that is a copy of target creature
+            CreateTokenCopyTargetEffect effect = new CreateTokenCopyTargetEffect(source.getControllerId(), null, true);
+            effect.setTargetPointer(new FixedTarget(permanent, game));
+
+            // except that it is an Illusion in addition to its other types
+            effect.setAdditionalSubType(SubType.SPIRIT);
+            effect.apply(game, source);
+
+            // and gains "When this creature becomes the target of a spell, sacrifice it."
+            Effect sacrificeEffect = new SacrificeSourceEffect();
+            sacrificeEffect.setTargetPointer(new FixedTarget(effect.getAddedPermanent().get(0), game));
+            TriggeredAbility ability = new BecomesTargetTriggeredAbility(sacrificeEffect, new FilterSpell());
+            game.addTriggeredAbility(ability);
+
+            return true;
+        }
+        return false;
+    }
+}

Mage.Sets/src/mage/cards/f/ForceProtection.java

@@ -0,0 +1,36 @@
+package mage.cards.f;
+
+import java.util.UUID;
+import mage.abilities.effects.common.continuous.GainProtectionFromColorTargetEffect;
+import mage.abilities.effects.keyword.ScryEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Duration;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class ForceProtection extends CardImpl {
+
+    public ForceProtection(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{W}");
+        
+
+        // Target creature you control gains protection from color of your choice until end of turn. Scry 1.
+        this.getSpellAbility().addEffect(new GainProtectionFromColorTargetEffect(Duration.EndOfTurn));
+        this.getSpellAbility().addTarget(new TargetCreaturePermanent()); 
+        this.getSpellAbility().addEffect(new ScryEffect(1));
+    }
+
+    public ForceProtection(final ForceProtection card) {
+        super(card);
+    }
+
+    @Override
+    public ForceProtection copy() {
+        return new ForceProtection(this);
+    }
+}

Mage.Sets/src/mage/cards/f/ForceStasis.java

@@ -0,0 +1,59 @@
+package mage.cards.f;
+
+import java.util.UUID;
+
+import mage.abilities.Mode;
+import mage.abilities.effects.common.DontUntapInControllersNextUntapStepTargetEffect;
+import mage.abilities.effects.common.ReturnToHandTargetEffect;
+import mage.abilities.effects.common.TapTargetEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.TargetController;
+import mage.filter.FilterSpell;
+import mage.filter.predicate.mageobject.CardTypePredicate;
+import mage.filter.predicate.permanent.ControllerPredicate;
+import mage.target.TargetSpell;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class ForceStasis extends CardImpl {
+
+    private static final FilterSpell filter = new FilterSpell("instant or sorcery spell you don't control");
+
+    static {
+        filter.add(new ControllerPredicate(TargetController.NOT_YOU));
+        filter.add(new CardTypePredicate(CardType.INSTANT));
+        filter.add(new CardTypePredicate(CardType.SORCERY));
+    }
+
+    public ForceStasis(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{U}");
+        
+
+        // Choose one -
+        //   Tap target creature. It doesn't untap during its controller's next untap step.
+        getSpellAbility().addEffect(new TapTargetEffect());
+        getSpellAbility().addEffect(new DontUntapInControllersNextUntapStepTargetEffect()
+                .setText("It doesn't untap during its controller's next untap step"));
+        getSpellAbility().addTarget(new TargetCreaturePermanent());
+
+        //   Return target instant or sorcery spell you don't control to its owner's hand.
+        Mode mode = new Mode();
+        mode.getEffects().add(new ReturnToHandTargetEffect());
+        mode.getTargets().add(new TargetSpell(filter));
+        this.getSpellAbility().addMode(mode);
+    }
+
+    public ForceStasis(final ForceStasis card) {
+        super(card);
+    }
+
+    @Override
+    public ForceStasis copy() {
+        return new ForceStasis(this);
+    }
+}

Mage.Sets/src/mage/cards/f/ForceTelepathy.java

@@ -0,0 +1,38 @@
+package mage.cards.f;
+
+import java.util.UUID;
+
+import mage.abilities.effects.common.RevealHandTargetEffect;
+import mage.abilities.effects.keyword.ScryEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.target.TargetPlayer;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class ForceTelepathy extends CardImpl {
+
+    public ForceTelepathy(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{U/B}");
+        
+
+        // Target player reveals his or her hand.
+        this.getSpellAbility().addEffect(new RevealHandTargetEffect().setText("Target player reveals his or her hand"));
+        this.getSpellAbility().addTarget(new TargetPlayer());
+
+        // Scry 2
+        this.getSpellAbility().addEffect(new ScryEffect(2));
+    }
+
+    public ForceTelepathy(final ForceTelepathy card) {
+        super(card);
+    }
+
+    @Override
+    public ForceTelepathy copy() {
+        return new ForceTelepathy(this);
+    }
+}

Mage.Sets/src/mage/cards/g/GeneralHux.java

@@ -0,0 +1,62 @@
+package mage.cards.g;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldControlledTriggeredAbility;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.costs.mana.ManaCostsImpl;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.common.continuous.BoostSourceEffect;
+import mage.abilities.effects.common.continuous.GainAbilitySourceEffect;
+import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.Predicates;
+import mage.filter.predicate.mageobject.NamePredicate;
+import mage.filter.predicate.permanent.ControllerPredicate;
+import mage.filter.predicate.permanent.TokenPredicate;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class GeneralHux extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("{this} or another nontoken creature you control");
+
+    static {
+        filter.add(new ControllerPredicate(TargetController.YOU));
+        filter.add(Predicates.not(new TokenPredicate()));
+    }
+
+    public GeneralHux(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{B}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.ADVISOR);
+        this.power = new MageInt(3);
+        this.toughness = new MageInt(3);
+
+        // Whenever General Hux or another nontoken creature enters the battlefield under your control, until end of turn, target creature gains "{B}: This creature gets +1/+1 until end of turn."
+        Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD,
+                new BoostSourceEffect(1, 1, Duration.EndOfTurn)
+                        .setText("This creature gets +1/+1 until end of turn"),
+                new ManaCostsImpl("{B}"));
+        Effect effect = new GainAbilitySourceEffect(ability, Duration.EndOfTurn);
+        effect.setText("until end of turn, target creature gains");
+        this.addAbility(new EntersBattlefieldControlledTriggeredAbility(Zone.BATTLEFIELD, effect, filter, false));
+    }
+
+    public GeneralHux(final GeneralHux card) {
+        super(card);
+    }
+
+    @Override
+    public GeneralHux copy() {
+        return new GeneralHux(this);
+    }
+}

Mage.Sets/src/mage/cards/g/GerrerasRevolutionary.java

@@ -0,0 +1,37 @@
+package mage.cards.g;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.common.AttacksEachCombatStaticAbility;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class GerrerasRevolutionary extends CardImpl {
+
+    public GerrerasRevolutionary(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{R}");
+        
+        this.subtype.add(SubType.BARABEL);
+        this.subtype.add(SubType.REBEL);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(1);
+
+        // Gerrera's Revolutionary attacks each turn if able.
+        this.addAbility(new AttacksEachCombatStaticAbility());
+    }
+
+    public GerrerasRevolutionary(final GerrerasRevolutionary card) {
+        super(card);
+    }
+
+    @Override
+    public GerrerasRevolutionary copy() {
+        return new GerrerasRevolutionary(this);
+    }
+}

Mage.Sets/src/mage/cards/h/HammerheadCorvette.java

@@ -0,0 +1,63 @@
+package mage.cards.h;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.AttacksTriggeredAbility;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.common.UntapTargetEffect;
+import mage.abilities.effects.common.combat.MustBeBlockedByTargetSourceEffect;
+import mage.abilities.keyword.SpaceflightAbility;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.mageobject.SubtypePredicate;
+import mage.filter.predicate.permanent.DefendingPlayerControlsPredicate;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class HammerheadCorvette extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("Starship creature defending player controls");
+    
+    static {
+        filter.add(new SubtypePredicate(SubType.STARSHIP));
+        filter.add(new DefendingPlayerControlsPredicate());
+    }
+    
+    public HammerheadCorvette(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{3}{G}");
+        
+        this.subtype.add(SubType.REBEL);
+        this.subtype.add(SubType.STARSHIP);
+        this.power = new MageInt(3);
+        this.toughness = new MageInt(3);
+
+        // Spaceflight
+        this.addAbility(SpaceflightAbility.getInstance());
+        
+        // Whenever Hammerhead Corvette attacks, you may untap target Starship creature defending player controls and have that creature block Hammerhead Corvette this turn if able.
+        Effect effect1 = new UntapTargetEffect();
+        Effect effect2 = new MustBeBlockedByTargetSourceEffect(Duration.EndOfTurn);
+        Ability ability = new AttacksTriggeredAbility(effect1, true,
+                "Whenever {this} attacks, you may uptap target Starship creature defending player controls and have that creature block {this} this turn if able");
+        ability.addEffect(effect2);
+        ability.addTarget(new TargetCreaturePermanent(filter));
+        this.addAbility(ability);
+    }
+
+    public HammerheadCorvette(final HammerheadCorvette card) {
+        super(card);
+    }
+
+    @Override
+    public HammerheadCorvette copy() {
+        return new HammerheadCorvette(this);
+    }
+}

Mage.Sets/src/mage/cards/h/HanSoloScrumrat.java

@@ -0,0 +1,102 @@
+package mage.cards.h;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.*;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.condition.common.MyTurnCondition;
+import mage.abilities.costs.mana.ManaCostsImpl;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.common.continuous.GainAbilitySourceEffect;
+import mage.abilities.effects.common.counter.AddCountersTargetEffect;
+import mage.abilities.keyword.FirstStrikeAbility;
+import mage.abilities.keyword.PartnerWithAbility;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.counters.CounterType;
+import mage.filter.common.FilterControlledCreaturePermanent;
+import mage.filter.predicate.permanent.AnotherPredicate;
+import mage.game.Game;
+import mage.game.events.GameEvent;
+import mage.game.permanent.Permanent;
+import mage.target.common.TargetControlledCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class HanSoloScrumrat extends CardImpl {
+
+    private static final FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("another target creature you control");
+
+    static {
+        filter.add(new AnotherPredicate());
+    }
+
+    public HanSoloScrumrat(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{W}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.ROGUE);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(2);
+
+        // Partner with Chewbacca, the Beast
+        this.addAbility(new PartnerWithAbility("Chewbacca, the Beast"));
+
+        // R: Han Solo, Scrumrat gains first strike until end of turn.
+        this.addAbility(new SimpleActivatedAbility(Zone.BATTLEFIELD, new GainAbilitySourceEffect(FirstStrikeAbility.getInstance(), Duration.EndOfTurn), new ManaCostsImpl("{R}")));
+
+        // Whenever Han Solo, Scrumrat deals damage during your turn, put a +1/+1 counter on another target creature you control.
+        Ability ability = new HanSoloScrumratTriggeredAbility();
+        ability.addTarget(new TargetControlledCreaturePermanent(filter));
+        this.addAbility(ability);
+    }
+
+    public HanSoloScrumrat(final HanSoloScrumrat card) {
+        super(card);
+    }
+
+    @Override
+    public HanSoloScrumrat copy() {
+        return new HanSoloScrumrat(this);
+    }
+}
+
+class HanSoloScrumratTriggeredAbility extends TriggeredAbilityImpl {
+
+    public HanSoloScrumratTriggeredAbility() {
+        super(Zone.BATTLEFIELD, new AddCountersTargetEffect(CounterType.P1P1.createInstance()), false);
+    }
+
+    public HanSoloScrumratTriggeredAbility(final HanSoloScrumratTriggeredAbility ability) {
+        super(ability);
+    }
+
+    @Override
+    public HanSoloScrumratTriggeredAbility copy() {
+        return new HanSoloScrumratTriggeredAbility(this);
+    }
+
+    @Override
+    public boolean checkEventType(GameEvent event, Game game) {
+        return event.getType() == GameEvent.EventType.DAMAGED_CREATURE
+                || event.getType() ==  GameEvent.EventType.DAMAGED_PLAYER
+                || event.getType() == GameEvent.EventType.DAMAGED_PLANESWALKER;
+    }
+
+    @Override
+    public boolean checkTrigger(GameEvent event, Game game) {
+        Permanent source = game.getPermanent(this.getSourceId());
+        return source != null
+                && game.isActivePlayer(source.getControllerId())
+                && event.getSourceId().equals(this.getSourceId());
+    }
+
+    @Override
+    public String getRule() {
+        return "Whenever {this} creature deals damage during your turn, " + super.getRule();
+    }
+}

Mage.Sets/src/mage/cards/i/ImperialHovertank.java

@@ -0,0 +1,84 @@
+package mage.cards.i;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.TriggeredAbilityImpl;
+import mage.abilities.common.AttacksCreatureYouControlTriggeredAbility;
+import mage.abilities.effects.common.GainLifeEffect;
+import mage.abilities.effects.common.LoseLifeTargetEffect;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.game.Game;
+import mage.game.events.GameEvent;
+import mage.game.permanent.Permanent;
+import mage.target.targetpointer.FixedTarget;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class ImperialHovertank extends CardImpl {
+
+    public ImperialHovertank(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{4}{W}{B}");
+        
+        this.subtype.add(SubType.TROOPER);
+        this.subtype.add(SubType.CONSTRUCT);
+        this.power = new MageInt(4);
+        this.toughness = new MageInt(4);
+
+        // Whenever a Trooper creature you control attacks, defending player loses 1 life and you gain 1 life.
+        this.addAbility(new ImperialHovertankTriggeredAbility());
+    }
+
+    public ImperialHovertank(final ImperialHovertank card) {
+        super(card);
+    }
+
+    @Override
+    public ImperialHovertank copy() {
+        return new ImperialHovertank(this);
+    }
+}
+
+class ImperialHovertankTriggeredAbility extends TriggeredAbilityImpl {
+
+    public ImperialHovertankTriggeredAbility() {
+        super(Zone.BATTLEFIELD, new LoseLifeTargetEffect(1));
+        this.addEffect(new GainLifeEffect(1));
+    }
+
+    public ImperialHovertankTriggeredAbility(final ImperialHovertankTriggeredAbility ability) {
+        super(ability);
+    }
+
+    @Override
+    public ImperialHovertankTriggeredAbility copy() {
+        return new ImperialHovertankTriggeredAbility(this);
+    }
+
+    @Override
+    public boolean checkEventType(GameEvent event, Game game) {
+        return event.getType() == GameEvent.EventType.ATTACKER_DECLARED;
+    }
+
+    @Override
+    public boolean checkTrigger(GameEvent event, Game game) {
+        Permanent source = game.getPermanent(event.getSourceId());
+        if (source != null && source.isControlledBy(controllerId) && source.hasSubtype(SubType.TROOPER, game)) {
+            UUID defendingPlayerId = game.getCombat().getDefendingPlayerId(event.getSourceId(), game);
+            this.getEffects().get(0).setTargetPointer(new FixedTarget(defendingPlayerId));
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public String getRule() {
+        return "Whenever a Trooper creature you control attacks, defending player loses 1 life and you gain 1 life.";
+    }
+}

Mage.Sets/src/mage/cards/i/Inspire.java

@@ -0,0 +1,39 @@
+package mage.cards.i;
+
+import java.util.UUID;
+
+import mage.abilities.effects.common.DrawCardSourceControllerEffect;
+import mage.abilities.effects.common.TapTargetEffect;
+import mage.abilities.effects.common.UntapTargetEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Inspire extends CardImpl {
+
+    public Inspire(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{U}");
+        
+
+        // Untap target creature.
+        this.getSpellAbility().addEffect(new UntapTargetEffect());
+        this.getSpellAbility().addTarget(new TargetCreaturePermanent());
+
+        // Draw a card.
+        this.getSpellAbility().addEffect(new DrawCardSourceControllerEffect(1));
+    }
+
+    public Inspire(final Inspire card) {
+        super(card);
+    }
+
+    @Override
+    public Inspire copy() {
+        return new Inspire(this);
+    }
+}

Mage.Sets/src/mage/cards/j/JynErsoAndCassianAndor.java

@@ -0,0 +1,50 @@
+package mage.cards.j;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.BeginningOfCombatTriggeredAbility;
+import mage.abilities.effects.common.continuous.BoostTargetEffect;
+import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
+import mage.abilities.keyword.HasteAbility;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.target.common.TargetControlledCreaturePermanent;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class JynErsoAndCassianAndor extends CardImpl {
+
+    public JynErsoAndCassianAndor(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{R}{W}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.REBEL);
+        this.power = new MageInt(4);
+        this.toughness = new MageInt(4);
+
+        // At the beginning of combat on your turn, target creature gets +1/+0 and gains haste until end of turn.
+        Ability ability = new BeginningOfCombatTriggeredAbility(
+                new BoostTargetEffect(1, 0, Duration.EndOfTurn)
+                    .setText("target creature gets +1/+0"),
+                TargetController.YOU, false);
+        ability.addEffect(new GainAbilityTargetEffect(HasteAbility.getInstance(), Duration.EndOfTurn)
+                .setText("and gains haste until end of turn"));
+        ability.addTarget(new TargetCreaturePermanent());
+        this.addAbility(ability);
+    }
+
+    public JynErsoAndCassianAndor(final JynErsoAndCassianAndor card) {
+        super(card);
+    }
+
+    @Override
+    public JynErsoAndCassianAndor copy() {
+        return new JynErsoAndCassianAndor(this);
+    }
+}

Mage.Sets/src/mage/cards/k/KalevanStarYacht.java

@@ -0,0 +1,50 @@
+package mage.cards.k;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.effects.common.DrawCardSourceControllerEffect;
+import mage.abilities.effects.common.LoseLifeSourceControllerEffect;
+import mage.abilities.effects.common.counter.AddCountersTargetEffect;
+import mage.abilities.keyword.SpaceflightAbility;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.counters.CounterType;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class KalevanStarYacht extends CardImpl {
+
+    public KalevanStarYacht(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{3}{B}");
+        
+        this.subtype.add(SubType.STARSHIP);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(3);
+
+        // Spaceflight
+        this.addAbility(SpaceflightAbility.getInstance());
+
+        // When Kalevan Star Yacht enters the battlefield, lose 1 life, draw a card, and put a bounty counter on up to one target creature.
+        Ability ability = new EntersBattlefieldTriggeredAbility(new LoseLifeSourceControllerEffect(1));
+        ability.addEffect(new DrawCardSourceControllerEffect(1));
+        ability.addEffect(new AddCountersTargetEffect(CounterType.BOUNTY.createInstance()));
+        ability.addTarget(new TargetCreaturePermanent(0, 1));
+        this.addAbility(ability);
+    }
+
+    public KalevanStarYacht(final KalevanStarYacht card) {
+        super(card);
+    }
+
+    @Override
+    public KalevanStarYacht copy() {
+        return new KalevanStarYacht(this);
+    }
+}

Mage.Sets/src/mage/cards/k/KyloRen.java

@@ -0,0 +1,114 @@
+package mage.cards.k;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.Mode;
+import mage.abilities.common.AttacksEachCombatStaticAbility;
+import mage.abilities.common.AttacksTriggeredAbility;
+import mage.abilities.dynamicvalue.DynamicValue;
+import mage.abilities.dynamicvalue.IntPlusDynamicValue;
+import mage.abilities.dynamicvalue.LockedInDynamicValue;
+import mage.abilities.dynamicvalue.common.CardsInControllerGraveyardCount;
+import mage.abilities.dynamicvalue.common.StaticValue;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.common.TapTargetEffect;
+import mage.abilities.effects.common.continuous.BoostSourceEffect;
+import mage.abilities.effects.common.continuous.BoostTargetEffect;
+import mage.constants.*;
+import mage.abilities.keyword.HasteAbility;
+import mage.abilities.keyword.FirstStrikeAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.filter.StaticFilters;
+import mage.filter.common.FilterCreatureCard;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.permanent.DefendingPlayerControlsPredicate;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+import mage.players.Player;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class KyloRen extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("creature defending player controls");
+
+    static {
+        filter.add(new DefendingPlayerControlsPredicate());
+    }
+
+    public KyloRen(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{U}{B}{R}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.SITH);
+        this.power = new MageInt(3);
+        this.toughness = new MageInt(3);
+
+        // Haste
+        this.addAbility(HasteAbility.getInstance());
+
+        // First strike
+        this.addAbility(FirstStrikeAbility.getInstance());
+
+        // Kylo Ren attacks each turn if able.
+        this.addAbility(new AttacksEachCombatStaticAbility());
+
+        // Whenever Kylo Ren attacks, it gets +1/+0 for each creature in your graveyard and you may tap target creature defending player controls.
+        CardsInControllerGraveyardCount value = new CardsInControllerGraveyardCount(StaticFilters.FILTER_CARD_CREATURE);
+        Effect effect = new BoostSourceEffect(value, new StaticValue(0), Duration.WhileOnBattlefield);
+        effect.setText("it gets +1/+0 for each creature in your graveyard");
+        Ability ability = new AttacksTriggeredAbility(effect, false);
+        ability.addEffect(new KyloRenTapTargetEffect());
+        ability.addTarget(new TargetCreaturePermanent(0, 1, filter, false));
+        this.addAbility(ability);
+    }
+
+    public KyloRen(final KyloRen card) {
+        super(card);
+    }
+
+    @Override
+    public KyloRen copy() {
+        return new KyloRen(this);
+    }
+}
+
+class KyloRenTapTargetEffect extends TapTargetEffect {
+
+    public KyloRenTapTargetEffect() {
+        super();
+    }
+
+    public KyloRenTapTargetEffect(final KyloRenTapTargetEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public KyloRenTapTargetEffect copy() {
+        return new KyloRenTapTargetEffect(this);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Permanent permanent = game.getPermanent(source.getSourceId());
+        Player player = game.getPlayer(source.getControllerId());
+        if(player != null && permanent != null) {
+            if(player.chooseUse(outcome, "Tap target creature defending player controls (" + permanent.getLogName() + ")", source, game)) {
+                super.apply(game, source);
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public String getText(Mode mode) {
+        return "and you may tap target creature defending player controls";
+    }
+}

Mage.Sets/src/mage/cards/l/LukeSkywalkerTheLastJedi.java

@@ -0,0 +1,69 @@
+package mage.cards.l;
+
+import java.util.UUID;
+
+import mage.abilities.Ability;
+import mage.abilities.LoyaltyAbility;
+import mage.abilities.common.PlanswalkerEntersWithLoyalityCountersAbility;
+import mage.abilities.effects.common.ExileSourceEffect;
+import mage.abilities.effects.common.GetEmblemEffect;
+import mage.abilities.effects.common.PutOnLibraryTargetEffect;
+import mage.abilities.effects.common.counter.AddCountersTargetEffect;
+import mage.constants.SubType;
+import mage.constants.SuperType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.counters.CounterType;
+import mage.filter.FilterPermanent;
+import mage.filter.StaticFilters;
+import mage.filter.predicate.Predicates;
+import mage.filter.predicate.mageobject.CardTypePredicate;
+import mage.game.command.emblems.LukeSkywalkerEmblem;
+import mage.target.TargetPermanent;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class LukeSkywalkerTheLastJedi extends CardImpl {
+
+    private static final FilterPermanent filter = new FilterPermanent("noncreature permanent");
+
+    static {
+        filter.add(Predicates.not(new CardTypePredicate(CardType.CREATURE)));
+    }
+
+    public LukeSkywalkerTheLastJedi(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.PLANESWALKER}, "{2}{G}{W}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.LUKE);
+        this.addAbility(new PlanswalkerEntersWithLoyalityCountersAbility(3));
+
+        // +1: Put two +1/+1 counters on up to one target creature.
+        Ability ability1 = new LoyaltyAbility(new AddCountersTargetEffect(CounterType.P1P1.createInstance(2)), 2);
+        ability1.addTarget(new TargetCreaturePermanent(0, 1));
+        this.addAbility(ability1);
+
+        // -3: Put target noncreature permanent on top of its owner's library.
+        Ability ability2 = new LoyaltyAbility(new PutOnLibraryTargetEffect(true), -3);
+        ability2.addTarget(new TargetPermanent(filter));
+        this.addAbility(ability2);
+
+        // -6: You get an emblem with "Prevent all damage that would be dealt to you during combat." Exile Luke Skywalker, the Last Jedi.
+        Ability ability3 = new LoyaltyAbility(new GetEmblemEffect(new LukeSkywalkerEmblem()), -6);
+        ability3.addEffect(new ExileSourceEffect());
+        this.addAbility(ability3);
+    }
+
+    public LukeSkywalkerTheLastJedi(final LukeSkywalkerTheLastJedi card) {
+        super(card);
+    }
+
+    @Override
+    public LukeSkywalkerTheLastJedi copy() {
+        return new LukeSkywalkerTheLastJedi(this);
+    }
+}

Mage.Sets/src/mage/cards/m/MaelstromBlockade.java

@@ -0,0 +1,34 @@
+package mage.cards.m;
+
+import java.util.UUID;
+
+import mage.abilities.effects.common.ExileTargetEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.target.common.TargetAttackingCreature;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class MaelstromBlockade extends CardImpl {
+
+    public MaelstromBlockade(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{2}{W/B}");
+        
+
+        // Exile target attacking creature.
+        this.getSpellAbility().addEffect(new ExileTargetEffect());
+        this.getSpellAbility().addTarget(new TargetAttackingCreature());
+    }
+
+    public MaelstromBlockade(final MaelstromBlockade card) {
+        super(card);
+    }
+
+    @Override
+    public MaelstromBlockade copy() {
+        return new MaelstromBlockade(this);
+    }
+}

Mage.Sets/src/mage/cards/m/MouseDroid.java

@@ -0,0 +1,41 @@
+package mage.cards.m;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.common.DiesTriggeredAbility;
+import mage.abilities.effects.common.DrawCardSourceControllerEffect;
+import mage.abilities.keyword.RepairAbility;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class MouseDroid extends CardImpl {
+
+    public MouseDroid(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{1}{U}");
+        
+        this.subtype.add(SubType.DROID);
+        this.power = new MageInt(0);
+        this.toughness = new MageInt(1);
+
+        // When Mouse Droid dies, draw a card.
+        this.addAbility(new DiesTriggeredAbility(new DrawCardSourceControllerEffect(1)));
+
+        // Repair 3
+        this.addAbility(new RepairAbility(3));
+    }
+
+    public MouseDroid(final MouseDroid card) {
+        super(card);
+    }
+
+    @Override
+    public MouseDroid copy() {
+        return new MouseDroid(this);
+    }
+}

Mage.Sets/src/mage/cards/m/MudTrooper.java

@@ -0,0 +1,59 @@
+package mage.cards.m;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.costs.mana.ColorlessManaCost;
+import mage.abilities.costs.mana.GenericManaCost;
+import mage.abilities.effects.common.continuous.BoostControlledEffect;
+import mage.abilities.effects.common.continuous.BoostSourceEffect;
+import mage.abilities.effects.common.continuous.GainAbilityControlledEffect;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.filter.common.FilterControlledCreaturePermanent;
+import mage.filter.predicate.mageobject.SubtypePredicate;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class MudTrooper extends CardImpl {
+
+    private static final FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("Trooper creatures you control");
+
+    static {
+        filter.add(new SubtypePredicate(SubType.TROOPER));
+    }
+
+    public MudTrooper(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{B}");
+        
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.TROOPER);
+        this.power = new MageInt(1);
+        this.toughness = new MageInt(1);
+
+        // Trooper creatures you control have "2: This creature gets +1/+1 until end of turn."
+        Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD,
+                new BoostSourceEffect(1, 1, Duration.EndOfTurn)
+                    .setText("This creature gets +1/+1 until end of turn"),
+                new GenericManaCost(2));
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD,
+                new GainAbilityControlledEffect(ability, Duration.WhileOnBattlefield, filter, false)));
+    }
+
+    public MudTrooper(final MudTrooper card) {
+        super(card);
+    }
+
+    @Override
+    public MudTrooper copy() {
+        return new MudTrooper(this);
+    }
+}

Mage.Sets/src/mage/cards/o/Occupation.java

@@ -0,0 +1,193 @@
+package mage.cards.o;
+
+import java.util.UUID;
+
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.costs.mana.ManaCostsImpl;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.ReplacementEffectImpl;
+import mage.abilities.effects.RestrictionEffect;
+import mage.abilities.effects.common.combat.CantAttackBlockTargetEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.*;
+import mage.game.Game;
+import mage.game.events.EntersTheBattlefieldEvent;
+import mage.game.events.GameEvent;
+import mage.game.permanent.Permanent;
+import mage.game.turn.Step;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Occupation extends CardImpl {
+
+    public Occupation(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{W}{B}");
+        
+
+        // Creatures your opponents control enter the battlefield tapped.
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new OccupationTapEffect()));
+
+        // {W}{B}: Target creature can't attack or block this turn, and its activated abilities can't be activated until end of turn.
+        Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD,
+                new OccupationOneShotEffect("Target creature can't attack or block this turn, and its activated abilities can't be activated until end of turn"),
+                new ManaCostsImpl("{W}{B}"));
+        ability.addTarget(new TargetCreaturePermanent());
+        this.addAbility(ability);
+    }
+
+    public Occupation(final Occupation card) {
+        super(card);
+    }
+
+    @Override
+    public Occupation copy() {
+        return new Occupation(this);
+    }
+}
+
+class OccupationTapEffect extends ReplacementEffectImpl {
+
+    OccupationTapEffect() {
+        super(Duration.WhileOnBattlefield, Outcome.Tap);
+        staticText = "Creatures your opponents control enter the battlefield tapped";
+    }
+
+    OccupationTapEffect(final OccupationTapEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public boolean replaceEvent(GameEvent event, Ability source, Game game) {
+        Permanent target = ((EntersTheBattlefieldEvent) event).getTarget();
+        if (target != null) {
+            target.setTapped(true);
+        }
+        return false;
+    }
+
+    @Override
+    public boolean checksEventType(GameEvent event, Game game) {
+        return event.getType() == GameEvent.EventType.ENTERS_THE_BATTLEFIELD;
+    }
+
+    @Override
+    public boolean applies(GameEvent event, Ability source, Game game) {
+        if (game.getOpponents(source.getControllerId()).contains(event.getPlayerId())) {
+            Permanent permanent = ((EntersTheBattlefieldEvent) event).getTarget();
+            if (permanent != null && permanent.isCreature()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public OccupationTapEffect copy() {
+        return new OccupationTapEffect(this);
+    }
+}
+
+class OccupationOneShotEffect extends OneShotEffect {
+
+    public OccupationOneShotEffect() {
+        super(Outcome.LoseAbility);
+    }
+
+    public OccupationOneShotEffect(String ruleText) {
+        super(Outcome.LoseAbility);
+        staticText = ruleText;
+    }
+
+    public OccupationOneShotEffect(final OccupationOneShotEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public OccupationOneShotEffect copy() {
+        return new OccupationOneShotEffect(this);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        OccupationRestrictionEffect effect = new OccupationRestrictionEffect();
+        game.addEffect(effect, source);
+        return true;
+    }
+}
+
+class OccupationRestrictionEffect extends RestrictionEffect {
+
+    public OccupationRestrictionEffect() {
+        super(Duration.Custom);
+        staticText = "";
+    }
+
+    public OccupationRestrictionEffect(final OccupationRestrictionEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public void init(Ability source, Game game) {
+        super.init(source, game);
+        for (UUID targetId : this.getTargetPointer().getTargets(game, source)) {
+            Permanent permanent = game.getPermanent(targetId);
+            if (permanent != null) {
+                permanent.addInfo("Can't attack or block and its activated abilities can't be activated." + getId(), "", game);
+            }
+        }
+    }
+
+    @Override
+    public boolean isInactive(Ability source, Game game) {
+        if (game.getPhase().getStep().getType() == PhaseStep.UNTAP
+                && game.getStep().getStepPart() == Step.StepPart.PRE) {
+            if (game.isActivePlayer(source.getControllerId())
+                    || game.getPlayer(source.getControllerId()).hasReachedNextTurnAfterLeaving()) {
+                for (UUID targetId : this.getTargetPointer().getTargets(game, source)) {
+                    Permanent permanent = game.getPermanent(targetId);
+                    if (permanent != null) {
+                        permanent.addInfo("Can't attack or block and its activated abilities can't be activated." + getId(), "", game);
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean applies(Permanent permanent, Ability source, Game game) {
+        if (this.targetPointer.getTargets(game, source).contains(permanent.getId())) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean canAttack(Game game) {
+        return false;
+    }
+
+    @Override
+    public boolean canBlock(Permanent attacker, Permanent blocker, Ability source, Game game) {
+        return false;
+    }
+
+    @Override
+    public boolean canUseActivatedAbilities(Permanent permanent, Ability source, Game game) {
+        return false;
+    }
+
+    @Override
+    public OccupationRestrictionEffect copy() {
+        return new OccupationRestrictionEffect(this);
+    }
+
+}

Mage.Sets/src/mage/cards/o/OuterRimGang.java

@@ -0,0 +1,49 @@
+package mage.cards.o;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.effects.common.continuous.BoostAllEffect;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.counters.CounterType;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.permanent.CounterPredicate;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class OuterRimGang extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("each creature with a bounty counter on it");
+
+    static {
+        filter.add(new CounterPredicate(CounterType.BOUNTY));
+    }
+
+    public OuterRimGang(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{B}{R}{G}");
+        
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.ROGUE);
+        this.subtype.add(SubType.HUNTER);
+        this.power = new MageInt(4);
+        this.toughness = new MageInt(4);
+
+        // When Outer Rim Gang enters the battlefield, each creature with a bounty counter on it gets -2/-2 until end of turn.
+        this.addAbility(new EntersBattlefieldTriggeredAbility(new BoostAllEffect(-2, -2, Duration.EndOfTurn, filter, false)));
+    }
+
+    public OuterRimGang(final OuterRimGang card) {
+        super(card);
+    }
+
+    @Override
+    public OuterRimGang copy() {
+        return new OuterRimGang(this);
+    }
+}

Mage.Sets/src/mage/cards/o/OuterRimSlaver.java

@@ -12,6 +12,8 @@ import mage.cards.CardSetInfo;
 import mage.constants.CardType;
 import mage.constants.SubType;
 import mage.counters.CounterType;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.mageobject.AnotherTargetPredicate;
 import mage.target.common.TargetCreaturePermanent;
 
 /**
@@ -30,8 +32,14 @@ public final class OuterRimSlaver extends CardImpl {
         // When Outer Rim Slaver enters the battlefield, you may put a bounty counter on target creature. If you do, another target creature fights that creature
         Ability ability = new EntersBattlefieldTriggeredAbility(new AddCountersTargetEffect(CounterType.BOUNTY.createInstance()), true);
         ability.addEffect(new FightTargetsEffect("another target creature fights that creature"));
-        ability.addTarget(new TargetCreaturePermanent());
-        ability.addTarget(new TargetCreaturePermanent());
+        TargetCreaturePermanent target = new TargetCreaturePermanent();
+        target.setTargetTag(1);
+        ability.addTarget(target);
+        FilterCreaturePermanent filter = new FilterCreaturePermanent();
+        filter.add(new AnotherTargetPredicate(2));
+        TargetCreaturePermanent target2 = new TargetCreaturePermanent(filter);
+        target2.setTargetTag(2);
+        ability.addTarget(target2);
         this.addAbility(ability);
     }
 

Mage.Sets/src/mage/cards/p/PoeDameron.java

@@ -0,0 +1,54 @@
+package mage.cards.p;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.common.EntersBattlefieldControlledTriggeredAbility;
+import mage.abilities.effects.common.continuous.BoostAllEffect;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.Predicates;
+import mage.filter.predicate.mageobject.NamePredicate;
+import mage.filter.predicate.mageobject.SubtypePredicate;
+import mage.filter.predicate.permanent.ControllerPredicate;
+import mage.filter.predicate.permanent.TokenPredicate;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class PoeDameron extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("{this} or another nontoken creature you control");
+    private static final FilterCreaturePermanent filterStarship = new FilterCreaturePermanent("starship creatures you control");
+
+    static {
+        filter.add(new ControllerPredicate(TargetController.YOU));
+        filter.add(Predicates.not(new TokenPredicate()));
+        filterStarship.add(new ControllerPredicate(TargetController.YOU));
+        filterStarship.add(new SubtypePredicate(SubType.STARSHIP));
+    }
+
+    public PoeDameron(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{W}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.SOLDIER);
+        this.power = new MageInt(3);
+        this.toughness = new MageInt(3);
+
+        // Whenever Poe Dameron or another nontoken creature enters the battlefield under your control, starship creatures you control get +1/+1 until end of turn.
+        this.addAbility(new EntersBattlefieldControlledTriggeredAbility(Zone.BATTLEFIELD, new BoostAllEffect(1, 1, Duration.EndOfTurn, filterStarship, false), filter, false));
+    }
+
+    public PoeDameron(final PoeDameron card) {
+        super(card);
+    }
+
+    @Override
+    public PoeDameron copy() {
+        return new PoeDameron(this);
+    }
+}

Mage.Sets/src/mage/cards/p/PorgNest.java

@@ -0,0 +1,44 @@
+package mage.cards.p;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.common.BeginningOfUpkeepTriggeredAbility;
+import mage.abilities.effects.common.CreateTokenEffect;
+import mage.constants.SubType;
+import mage.abilities.keyword.DefenderAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.TargetController;
+import mage.constants.Zone;
+import mage.game.permanent.token.PorgToken;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class PorgNest extends CardImpl {
+
+    public PorgNest(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{G}");
+        
+        this.subtype.add(SubType.BIRD);
+        this.power = new MageInt(0);
+        this.toughness = new MageInt(2);
+
+        // Defender
+        this.addAbility(DefenderAbility.getInstance());
+
+        // At the beginning of your upkeep, create a 0/1 green Bird creature token named Porg with "{G}: Monstrosity 1."
+        this.addAbility(new BeginningOfUpkeepTriggeredAbility(Zone.BATTLEFIELD, new CreateTokenEffect(new PorgToken()), TargetController.YOU, false));
+    }
+
+    public PorgNest(final PorgNest card) {
+        super(card);
+    }
+
+    @Override
+    public PorgNest copy() {
+        return new PorgNest(this);
+    }
+}

Mage.Sets/src/mage/cards/p/PraetorianTrooper.java

@@ -0,0 +1,49 @@
+package mage.cards.p;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.effects.common.continuous.GainAbilityControlledEffect;
+import mage.abilities.keyword.DoubleStrikeAbility;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.mageobject.SubtypePredicate;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class PraetorianTrooper extends CardImpl {
+
+    private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("Trooper creatures");
+
+    static {
+        filter.add(new SubtypePredicate(SubType.TROOPER));
+    }
+
+    public PraetorianTrooper(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{R}");
+        
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.TROOPER);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(2);
+
+        // Trooper creatures you control have double strike.
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new GainAbilityControlledEffect(DoubleStrikeAbility.getInstance(), Duration.WhileOnBattlefield, filter, false)));
+    }
+
+    public PraetorianTrooper(final PraetorianTrooper card) {
+        super(card);
+    }
+
+    @Override
+    public PraetorianTrooper copy() {
+        return new PraetorianTrooper(this);
+    }
+}

Mage.Sets/src/mage/cards/r/RangeTrooper.java

@@ -0,0 +1,92 @@
+package mage.cards.r;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.MageObject;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.common.delayed.AtTheBeginOfNextEndStepDelayedTriggeredAbility;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.common.ReturnToBattlefieldUnderOwnerControlTargetEffect;
+import mage.abilities.effects.common.continuous.GainAbilityControlledEffect;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.filter.common.FilterControlledCreaturePermanent;
+import mage.filter.predicate.mageobject.SubtypePredicate;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+import mage.target.common.TargetCreaturePermanent;
+import mage.target.targetpointer.FixedTarget;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class RangeTrooper extends CardImpl {
+
+    private static final FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("Trooper creatures you control");
+
+    static {
+        filter.add(new SubtypePredicate(SubType.TROOPER));
+    }
+
+    public RangeTrooper(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{W}");
+        
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.TROOPER);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(2);
+
+        // Trooper creatures you control have "When this creature enters that battlefield, you may exile target creature. Return that creature to the battlefield at the beginning of the next end step."
+        Ability ability = new EntersBattlefieldTriggeredAbility(new RangeTrooperEffect(), true, true);
+        ability.addTarget(new TargetCreaturePermanent());
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD,
+                new GainAbilityControlledEffect(ability, Duration.WhileOnBattlefield, filter, false)));
+    }
+
+    public RangeTrooper(final RangeTrooper card) {
+        super(card);
+    }
+
+    @Override
+    public RangeTrooper copy() {
+        return new RangeTrooper(this);
+    }
+}
+
+class RangeTrooperEffect extends OneShotEffect {
+
+    public RangeTrooperEffect() {
+        super(Outcome.Detriment);
+        staticText = "When this creature enters the battlefield, you may exile target creature. Return that creature to the battlefield at the beginning of the next end step";
+    }
+
+    public RangeTrooperEffect(final RangeTrooperEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Permanent permanent = game.getPermanent(source.getFirstTarget());
+        MageObject sourceObject = game.getObject(source.getSourceId());
+        if (permanent != null && sourceObject != null) {
+            if (permanent.moveToExile(source.getSourceId(), sourceObject.getIdName(), source.getSourceId(), game)) {
+                Effect effect = new ReturnToBattlefieldUnderOwnerControlTargetEffect();
+                effect.setText("Return that card to the battlefield under its owner's control at the beginning of the next end step");
+                effect.setTargetPointer(new FixedTarget(source.getFirstTarget(), game));
+                game.addDelayedTriggeredAbility(new AtTheBeginOfNextEndStepDelayedTriggeredAbility(effect), source);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public RangeTrooperEffect copy() {
+        return new RangeTrooperEffect(this);
+    }
+}

Mage.Sets/src/mage/cards/r/Rathtar.java

@@ -0,0 +1,49 @@
+package mage.cards.r;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.BecomesMonstrousSourceTriggeredAbility;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.effects.common.combat.BlocksIfAbleTargetEffect;
+import mage.abilities.keyword.MonstrosityAbility;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Rathtar extends CardImpl {
+
+    public Rathtar(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{R}{G}");
+        
+        this.subtype.add(SubType.BEAST);
+        this.power = new MageInt(4);
+        this.toughness = new MageInt(4);
+
+        // {5}{G}{G}: Monstrosity 2.
+        this.addAbility(new MonstrosityAbility("{5}{G}{G}", 2));
+
+        // When Rathtar becomes monstrous, any number of target creatures must block it this turn if able.
+        Ability ability = new BecomesMonstrousSourceTriggeredAbility(
+                new BlocksIfAbleTargetEffect(Duration.EndOfTurn).setText("any number of target creatures must block it this turn if able"));
+        ability.addTarget(new TargetCreaturePermanent(0, Integer.MAX_VALUE));
+        this.addAbility(ability);
+    }
+
+    public Rathtar(final Rathtar card) {
+        super(card);
+    }
+
+    @Override
+    public Rathtar copy() {
+        return new Rathtar(this);
+    }
+}

Mage.Sets/src/mage/cards/r/Resistance.java

@@ -0,0 +1,60 @@
+package mage.cards.r;
+
+import java.util.UUID;
+
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldControlledTriggeredAbility;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.costs.mana.ManaCostsImpl;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.common.DamagePlayersEffect;
+import mage.abilities.effects.common.combat.AttacksIfAbleTargetEffect;
+import mage.abilities.effects.common.combat.BlocksIfAbleTargetEffect;
+import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
+import mage.abilities.keyword.AttacksThisTurnMarkerAbility;
+import mage.abilities.keyword.BlocksThisTurnMarkerAbility;
+import mage.abilities.keyword.HasteAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.*;
+import mage.filter.StaticFilters;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Resistance extends CardImpl {
+
+    public Resistance(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{R}{W}");
+        
+
+        // Whenever a creature enters the battlefield under your control, Resistance deals 1 damage to each opponent.
+        this.addAbility(new EntersBattlefieldControlledTriggeredAbility(Zone.BATTLEFIELD, new DamagePlayersEffect(1, TargetController.OPPONENT), StaticFilters.FILTER_PERMANENT_CREATURE, false));
+
+        // {R}{W}: Target creature gains haste until end of turn and must attack or block this turn if able.
+        Ability ability = new SimpleActivatedAbility(
+                new GainAbilityTargetEffect(HasteAbility.getInstance(), Duration.EndOfTurn)
+                        .setText("Target creature gains haste until end of turn"),
+                new ManaCostsImpl("{R}{W}"));
+        ability.addEffect(new AttacksIfAbleTargetEffect(Duration.EndOfTurn).setText("and must attack"));
+        //ability.addEffect(new GainAbilityTargetEffect(AttacksThisTurnMarkerAbility.getInstance(), Duration.EndOfTurn, "").setText(""));
+        ability.addEffect(new BlocksIfAbleTargetEffect(Duration.EndOfTurn).setText("or block this turn if able"));
+        //ability.addEffect(new GainAbilityTargetEffect(BlocksThisTurnMarkerAbility.getInstance(), Duration.EndOfTurn, "").setText(""));
+        ability.addTarget(new TargetCreaturePermanent());
+        this.addAbility(ability);
+    }
+
+    public Resistance(final Resistance card) {
+        super(card);
+    }
+
+    @Override
+    public Resistance copy() {
+        return new Resistance(this);
+    }
+}

Mage.Sets/src/mage/cards/r/ResistanceBomber.java

@@ -0,0 +1,60 @@
+package mage.cards.r;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldAbility;
+import mage.abilities.condition.common.SourceAttackingCondition;
+import mage.abilities.costs.common.RemoveCountersSourceCost;
+import mage.abilities.decorator.ConditionalActivatedAbility;
+import mage.abilities.effects.common.DamageTargetEffect;
+import mage.abilities.effects.common.counter.AddCountersSourceEffect;
+import mage.abilities.keyword.SpaceflightAbility;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.counters.CounterType;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class ResistanceBomber extends CardImpl {
+
+    public ResistanceBomber(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{3}{R}");
+        
+        this.subtype.add(SubType.REBEL);
+        this.subtype.add(SubType.STARSHIP);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(2);
+
+        // Spaceflight
+        this.addAbility(SpaceflightAbility.getInstance());
+
+        // Resistance Bomber enters the battlefield with a charge counter on it.
+        this.addAbility(new EntersBattlefieldAbility(
+                new AddCountersSourceEffect(CounterType.CHARGE.createInstance())
+                    .setText("with a charge counter on it")));
+
+        // Remove a charge counter from Resistance Bomber: Resistance Bomber deals 5 damage to target creature. Activate this ability only if Resistance Bomber is attacking.
+        Ability ability = new ConditionalActivatedAbility(Zone.BATTLEFIELD,
+                new DamageTargetEffect(5),
+                new RemoveCountersSourceCost(CounterType.CHARGE.createInstance()),
+                SourceAttackingCondition.instance);
+        ability.addTarget(new TargetCreaturePermanent());
+        this.addAbility(ability);
+    }
+
+    public ResistanceBomber(final ResistanceBomber card) {
+        super(card);
+    }
+
+    @Override
+    public ResistanceBomber copy() {
+        return new ResistanceBomber(this);
+    }
+}

Mage.Sets/src/mage/cards/r/Rey.java

@@ -0,0 +1,97 @@
+package mage.cards.r;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldOrLeavesSourceTriggeredAbility;
+import mage.abilities.effects.OneShotEffect;
+import mage.cards.Card;
+import mage.cards.CardsImpl;
+import mage.constants.Outcome;
+import mage.constants.SubType;
+import mage.constants.SuperType;
+import mage.abilities.keyword.VigilanceAbility;
+import mage.abilities.keyword.FirstStrikeAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.game.Game;
+import mage.players.Player;
+import mage.target.TargetPlayer;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Rey extends CardImpl {
+
+    public Rey(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{G}{W}{U}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.KNIGHT);
+        this.power = new MageInt(3);
+        this.toughness = new MageInt(3);
+
+        // Vigilance
+        this.addAbility(VigilanceAbility.getInstance());
+
+        // First strike
+        this.addAbility(FirstStrikeAbility.getInstance());
+
+        // Whenever Rey enters or leaves the battlefield, reveal the top card of target player's library. You gain life equal to that card's converted mana cost.
+        Ability ability = new EntersBattlefieldOrLeavesSourceTriggeredAbility(new ReyEffect(), false);
+        ability.addTarget(new TargetPlayer());
+        this.addAbility(ability);
+    }
+
+    public Rey(final Rey card) {
+        super(card);
+    }
+
+    @Override
+    public Rey copy() {
+        return new Rey(this);
+    }
+}
+
+class ReyEffect extends OneShotEffect {
+
+    public ReyEffect() {
+        super(Outcome.Detriment);
+        staticText = "reveal the top card of target player's library. You gain life equal to that card's converted mana cost";
+    }
+
+    public ReyEffect(final ReyEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public ReyEffect copy() {
+        return new ReyEffect(this);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Player controller = game.getPlayer(source.getControllerId());
+        Player targetPlayer = game.getPlayer(targetPointer.getFirst(game, source));
+        if(targetPlayer != null && controller != null) {
+            if(targetPlayer.getLibrary().hasCards()) {
+                // reveal the top card of target player's library.
+                Card topCard = targetPlayer.getLibrary().getFromTop(game);
+                CardsImpl reveal = new CardsImpl();
+                reveal.add(topCard);
+                targetPlayer.revealCards(source, reveal, game);
+
+                // You gain life equal to that card's converted mana cost.
+                if (topCard != null) {
+                    controller.gainLife(topCard.getConvertedManaCost(), game, source);
+                }
+            }
+
+            return true;
+        }
+        return false;
+    }
+}

Mage.Sets/src/mage/cards/r/RiotTrooper.java

@@ -0,0 +1,50 @@
+package mage.cards.r;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.effects.common.combat.CanBlockAdditionalCreatureAllEffect;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.filter.common.FilterControlledCreaturePermanent;
+import mage.filter.predicate.mageobject.SubtypePredicate;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class RiotTrooper extends CardImpl {
+
+    private static final FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("trooper creatures you control");
+
+    static {
+        filter.add(new SubtypePredicate(SubType.TROOPER));
+    }
+
+    public RiotTrooper(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{W}");
+        
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.TROOPER);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(2);
+
+        // Each trooper creature you control can block an additional creature each combat.
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD,
+                new CanBlockAdditionalCreatureAllEffect(1, filter, Duration.WhileOnBattlefield)
+                    .setText("Each trooper creature you control can block an additional creature each combat")));
+    }
+
+    public RiotTrooper(final RiotTrooper card) {
+        super(card);
+    }
+
+    @Override
+    public RiotTrooper copy() {
+        return new RiotTrooper(this);
+    }
+}

Mage.Sets/src/mage/cards/s/SaiTok.java

@@ -0,0 +1,47 @@
+package mage.cards.s;
+
+import java.util.UUID;
+
+import mage.abilities.effects.common.DestroyTargetEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.ComparisonType;
+import mage.filter.FilterPermanent;
+import mage.filter.predicate.mageobject.CardTypePredicate;
+import mage.filter.predicate.mageobject.ConvertedManaCostPredicate;
+import mage.target.TargetPermanent;
+import mage.target.common.TargetCreatureOrPlaneswalker;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class SaiTok extends CardImpl {
+
+    private static final FilterPermanent filter = new FilterPermanent("creature or planeswalker if it has converted mana cost 4 or less");
+
+    static {
+        filter.add(new CardTypePredicate(CardType.CREATURE));
+        filter.add(new CardTypePredicate(CardType.PLANESWALKER));
+        filter.add(new ConvertedManaCostPredicate(ComparisonType.FEWER_THAN, 5));
+    }
+
+    public SaiTok(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{B}{B}");
+        
+
+        // Destroy target creature or planeswalker if it has converted mana cost 4 or less.
+        this.getSpellAbility().addEffect(new DestroyTargetEffect());
+        this.getSpellAbility().addTarget(new TargetPermanent(filter));
+    }
+
+    public SaiTok(final SaiTok card) {
+        super(card);
+    }
+
+    @Override
+    public SaiTok copy() {
+        return new SaiTok(this);
+    }
+}

Mage.Sets/src/mage/cards/s/SalvageTrader.java

@@ -0,0 +1,171 @@
+package mage.cards.s;
+
+import java.util.*;
+
+import mage.MageInt;
+import mage.MageObject;
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.costs.common.TapSourceCost;
+import mage.abilities.costs.mana.ManaCostsImpl;
+import mage.abilities.effects.ContinuousEffectImpl;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.common.continuous.ExchangeControlTargetEffect;
+import mage.cards.Cards;
+import mage.cards.CardsImpl;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.filter.common.FilterArtifactCard;
+import mage.filter.common.FilterArtifactPermanent;
+import mage.filter.predicate.mageobject.ConvertedManaCostPredicate;
+import mage.filter.predicate.permanent.ControllerPredicate;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+import mage.players.Player;
+import mage.target.Target;
+import mage.target.TargetCard;
+import mage.target.common.TargetArtifactPermanent;
+import mage.target.common.TargetControlledPermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class SalvageTrader extends CardImpl {
+
+    private static final FilterArtifactPermanent filterYou = new FilterArtifactPermanent("artifact you control");
+
+    static {
+        filterYou.add(new ControllerPredicate(TargetController.YOU));
+    }
+
+    public SalvageTrader(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{U}");
+        
+        this.subtype.add(SubType.CROLUTE);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(3);
+
+        // {T}: Exchange control of target artifact you control and target artifact an opponent controls with the same converted mana cost.
+        Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new SalvageTraderEffect(), new TapSourceCost());
+        ability.addTarget(new TargetArtifactPermanent(filterYou));
+        this.addAbility(ability);
+    }
+
+    public SalvageTrader(final SalvageTrader card) {
+        super(card);
+    }
+
+    @Override
+    public SalvageTrader copy() {
+        return new SalvageTrader(this);
+    }
+}
+
+// effect is based on JuxtaposeEffect
+// which is based on ExchangeControlTargetEffect
+class SalvageTraderEffect extends ContinuousEffectImpl {
+
+    private final Map<UUID, Integer> zoneChangeCounter;
+    private final Map<UUID, UUID> lockedControllers;
+
+    public SalvageTraderEffect() {
+        super(Duration.EndOfGame, Layer.ControlChangingEffects_2, SubLayer.NA, Outcome.GainControl);
+        staticText = "Exchange control of target artifact you control and target artifact an opponent controls with the same converted mana cost";
+
+        this.zoneChangeCounter = new HashMap<>();
+        this.lockedControllers = new HashMap<>();
+    }
+
+    public SalvageTraderEffect(final SalvageTraderEffect effect) {
+        super(effect);
+
+        this.zoneChangeCounter = new HashMap<>(effect.zoneChangeCounter);
+        this.lockedControllers = new HashMap<>(effect.lockedControllers);
+    }
+
+    @Override
+    public void init(Ability source, Game game) {
+        Player you = game.getPlayer(source.getControllerId());
+        Permanent permanent1 = game.getPermanent(targetPointer.getFirst(game, source));
+        MageObject sourceObject = game.getCard(source.getSourceId());
+
+        if(you != null && permanent1 != null) {
+            FilterArtifactCard filterArtifactCard = new FilterArtifactCard();
+            filterArtifactCard.add(new ControllerPredicate(TargetController.OPPONENT));
+            filterArtifactCard.add(new SpellZonePredicate(Zone.BATTLEFIELD));
+            filterArtifactCard.add(new ConvertedManaCostPredicate(ComparisonType.EQUAL_TO, permanent1.getConvertedManaCost()));
+
+            FilterArtifactPermanent filterArtifactPermanent = new FilterArtifactPermanent();
+            filterArtifactPermanent.add(new ControllerPredicate(TargetController.OPPONENT));
+            filterArtifactPermanent.add(new ConvertedManaCostPredicate(ComparisonType.EQUAL_TO, permanent1.getConvertedManaCost()));
+
+            Cards cards = new CardsImpl();
+            for(Permanent permanent : game.getBattlefield().getAllActivePermanents(filterArtifactPermanent, game)) {
+                cards.add(permanent);
+            }
+
+            Player opponent = null;
+            Permanent permanent2 = null;
+            TargetCard targetCard = new TargetCard(Zone.BATTLEFIELD, filterArtifactCard);
+            if(you.choose(Outcome.Benefit, cards, targetCard, game)) {
+                permanent2 = game.getPermanent(targetCard.getFirstTarget());
+                if(permanent2 != null) {
+                    opponent = game.getPlayer(permanent2.getControllerId());
+                }
+            }
+
+            if (opponent != null) {
+                // exchange works only for two different controllers
+                if (permanent1.isControlledBy(permanent2.getControllerId())) {
+                    // discard effect if controller of both permanents is the same
+                    discard();
+                    return;
+                }
+                this.lockedControllers.put(permanent1.getId(), permanent2.getControllerId());
+                this.zoneChangeCounter.put(permanent1.getId(), permanent1.getZoneChangeCounter(game));
+                this.lockedControllers.put(permanent2.getId(), permanent1.getControllerId());
+                this.zoneChangeCounter.put(permanent2.getId(), permanent2.getZoneChangeCounter(game));
+
+                permanent1.changeControllerId(opponent.getId(), game);
+                permanent2.changeControllerId(you.getId(), game);
+                game.informPlayers(new StringBuilder(sourceObject != null ? sourceObject.getLogName() : "").append(": ").append(you.getLogName())
+                        .append(" and ").append(opponent.getLogName()).append(" exchange control of ").append(permanent1.getLogName())
+                        .append(" and ").append(permanent2.getName()).toString());
+            } else {
+                // discard if there are less than 2 permanents
+                discard();
+            }
+        }
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Set<UUID> toDelete = new HashSet<>();
+        for (Map.Entry<UUID, Integer> entry : zoneChangeCounter.entrySet()) {
+            Permanent permanent = game.getPermanent(entry.getKey());
+            if (permanent == null || permanent.getZoneChangeCounter(game) != entry.getValue()) {
+                // control effect cease if the same permanent is no longer on the battlefield
+                toDelete.add(entry.getKey());
+                continue;
+            }
+            permanent.changeControllerId(lockedControllers.get(permanent.getId()), game);
+        }
+        if (!toDelete.isEmpty()) {
+            for (UUID uuid : toDelete) {
+                zoneChangeCounter.remove(uuid);
+            }
+            if (zoneChangeCounter.isEmpty()) {
+                discard();
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public SalvageTraderEffect copy() {
+        return new SalvageTraderEffect(this);
+    }
+}

Mage.Sets/src/mage/cards/s/SinsOfTheFather.java

@@ -0,0 +1,79 @@
+package mage.cards.s;
+
+import java.util.UUID;
+
+import mage.abilities.Ability;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.OneShotEffect;
+import mage.cards.Card;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Outcome;
+import mage.filter.common.FilterInstantOrSorceryCard;
+import mage.game.Game;
+import mage.players.Player;
+import mage.target.TargetPlayer;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class SinsOfTheFather extends CardImpl {
+
+    public SinsOfTheFather(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{1}{B}");
+        
+
+        // Exile target player's graveyard. That player loses 1 life for each instant or sorcery card exiled this way.
+        this.getSpellAbility().addTarget(new TargetPlayer());
+        this.getSpellAbility().addEffect(new SinsOfTheFatherEffect());
+    }
+
+    public SinsOfTheFather(final SinsOfTheFather card) {
+        super(card);
+    }
+
+    @Override
+    public SinsOfTheFather copy() {
+        return new SinsOfTheFather(this);
+    }
+}
+
+class SinsOfTheFatherEffect extends OneShotEffect {
+
+    private static final FilterInstantOrSorceryCard filter = new FilterInstantOrSorceryCard();
+
+    public SinsOfTheFatherEffect() {
+        super(Outcome.Detriment);
+        staticText = "Exile target player's graveyard. That player loses 1 life for each instant or sorcery card exiled this way";
+    }
+
+    public SinsOfTheFatherEffect(final SinsOfTheFatherEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Player you = game.getPlayer(source.getControllerId());
+        Player targetPlayer = game.getPlayer(source.getFirstTarget());
+        if(you != null && targetPlayer != null) {
+            int exiledCards = 0;
+            for(Card card : targetPlayer.getGraveyard().getCards(game)) {
+                if(filter.match(card, game)) {
+                    if(card.moveToExile(null, "", source.getSourceId(), game)) {
+                        exiledCards++;
+                    }
+                }
+            }
+            targetPlayer.loseLife(exiledCards, game, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public SinsOfTheFatherEffect copy() {
+        return new SinsOfTheFatherEffect(this);
+    }
+}

Mage.Sets/src/mage/cards/s/SupremeLeaderSnoke.java

@@ -0,0 +1,156 @@
+package mage.cards.s;
+
+import java.util.Iterator;
+import java.util.UUID;
+
+import mage.abilities.Ability;
+import mage.abilities.LoyaltyAbility;
+import mage.abilities.common.PlanswalkerEntersWithLoyalityCountersAbility;
+import mage.abilities.common.delayed.AtTheBeginOfNextEndStepDelayedTriggeredAbility;
+import mage.abilities.costs.Cost;
+import mage.abilities.costs.common.PayVariableLoyaltyCost;
+import mage.abilities.dynamicvalue.DynamicValue;
+import mage.abilities.dynamicvalue.common.OpponentsLostLifeCount;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.common.*;
+import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
+import mage.abilities.effects.common.continuous.GainControlTargetEffect;
+import mage.abilities.effects.common.counter.AddCountersTargetEffect;
+import mage.abilities.keyword.HasteAbility;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.counters.Counter;
+import mage.counters.CounterType;
+import mage.filter.FilterCard;
+import mage.filter.StaticFilters;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.mageobject.ConvertedManaCostPredicate;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+import mage.players.Player;
+import mage.players.PlayerList;
+import mage.target.common.TargetCreaturePermanent;
+import mage.watchers.common.PlayerLostLifeNonCombatWatcher;
+import mage.watchers.common.PlayerLostLifeWatcher;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class SupremeLeaderSnoke extends CardImpl {
+
+    UUID ability3Id;
+
+    public SupremeLeaderSnoke(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.PLANESWALKER}, "{U}{B}{R}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.SNOKE);
+        this.addAbility(new PlanswalkerEntersWithLoyalityCountersAbility(3));
+
+        // +1: Put a loyalty counter on Supreme Leader Snoke for each life lost by all opponents from noncombat sources this turn.
+        Ability ability1 = new LoyaltyAbility(new SupremeLeaderSnokeCounterEffect(CounterType.LOYALTY.createInstance()), 1);
+        this.addAbility(ability1);
+
+        // -1: Draw a card and lose 1 life.
+        Ability ability2 = new LoyaltyAbility(new DrawCardSourceControllerEffect(1), -1);
+        ability2.addEffect(new LoseLifeSourceControllerEffect(1).setText("and lose 1 life"));
+        this.addAbility(ability2);
+
+        // -X: Gain control of target creature with converted mana cost X. Untap that creature. It gains haste. Sacrifice that creature at the beginning of the next end step.
+        Ability ability3 = new LoyaltyAbility(new GainControlTargetEffect(Duration.WhileOnBattlefield)
+            .setText("Gain control of target creature with converted mana cost X"));
+        ability3.addEffect(new UntapTargetEffect().setText("Untap that creature"));
+        ability3.addEffect(new GainAbilityTargetEffect(HasteAbility.getInstance(), Duration.WhileOnBattlefield).setText("It gains haste"));
+        ability3.addEffect(new GainAbilityTargetEffect(new AtTheBeginOfNextEndStepDelayedTriggeredAbility(new SacrificeSourceEffect()), Duration.WhileOnBattlefield)
+            .setText("Sacrifice that creature at the beginning of the next end step"));
+        ability3Id = ability3.getOriginalId();
+        ability3.addTarget(new TargetCreaturePermanent());
+        this.addAbility(ability3);
+    }
+
+    @Override
+    public void adjustTargets(Ability ability, Game game) {
+        if (ability.getOriginalId().equals(ability3Id)) {
+            int cmc = 0;
+            for (Cost cost : ability.getCosts()) {
+                if (cost instanceof PayVariableLoyaltyCost) {
+                    cmc = ((PayVariableLoyaltyCost) cost).getAmount();
+                }
+            }
+            FilterCreaturePermanent newFilter = StaticFilters.FILTER_PERMANENT_CREATURE.copy();
+            newFilter.add(new ConvertedManaCostPredicate(ComparisonType.EQUAL_TO, cmc));
+            ability.getTargets().clear();
+            ability.addTarget(new TargetCreaturePermanent(newFilter));
+        }
+    }
+
+    public SupremeLeaderSnoke(final SupremeLeaderSnoke card) {
+        super(card);
+        this.ability3Id = card.ability3Id;
+    }
+
+    @Override
+    public SupremeLeaderSnoke copy() {
+        return new SupremeLeaderSnoke(this);
+    }
+}
+
+class OpponentNoncombatLostLifeCount implements DynamicValue {
+
+    @Override
+    public int calculate(Game game, Ability source, Effect effect) {
+        PlayerLostLifeNonCombatWatcher watcher = (PlayerLostLifeNonCombatWatcher) game.getState().getWatchers().get(PlayerLostLifeNonCombatWatcher.class.getSimpleName());
+        if(watcher != null) {
+            return watcher.getAllOppLifeLost(source.getControllerId(), game);
+        }
+        return 0;
+    }
+
+    @Override
+    public DynamicValue copy() {
+        return new OpponentNoncombatLostLifeCount();
+    }
+
+    @Override
+    public String getMessage() {
+        return "life lost by all opponents from noncombat sources this turn";
+    }
+}
+
+class SupremeLeaderSnokeCounterEffect extends OneShotEffect {
+
+    protected final Counter counter;
+
+    public SupremeLeaderSnokeCounterEffect(Counter counter) {
+        super(Outcome.Benefit);
+        this.counter = counter;
+        staticText = "Put a loyalty counter on {this} for each life lost by all opponents from noncombat sources this turn";
+    }
+
+    public SupremeLeaderSnokeCounterEffect(final SupremeLeaderSnokeCounterEffect effect) {
+        super(effect);
+        this.counter = effect.counter;
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Permanent permanent = game.getPermanent(source.getSourceId());
+        if(permanent != null) {
+            int amount = new OpponentNoncombatLostLifeCount().calculate(game, source, this);
+            if(amount > 0) {
+                Counter counterToAdd = counter.copy();
+                counterToAdd.add(amount - counter.getCount());
+                permanent.addCounters(counterToAdd, source, game);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public SupremeLeaderSnokeCounterEffect copy() {
+        return new SupremeLeaderSnokeCounterEffect(this);
+    }
+}

Mage.Sets/src/mage/cards/t/TIESilencer.java

@@ -0,0 +1,89 @@
+package mage.cards.t;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.AttacksTriggeredAbility;
+import mage.abilities.effects.Effect;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.common.DamagePlayersEffect;
+import mage.abilities.effects.common.DamageTargetEffect;
+import mage.abilities.keyword.SpaceflightAbility;
+import mage.constants.Outcome;
+import mage.constants.SubType;
+import mage.abilities.keyword.HasteAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.TargetController;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class TIESilencer extends CardImpl {
+
+    public TIESilencer(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{1}{B}{R}");
+        
+        this.subtype.add(SubType.STARSHIP);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(2);
+
+        // Haste
+        this.addAbility(HasteAbility.getInstance());
+
+        // Spaceflight
+        this.addAbility(SpaceflightAbility.getInstance());
+
+        // Whenever TIE Silencer attacks, it deals 1 damage to defending player and 1 damage to up to one target creature that player controls.
+        Ability ability = new AttacksTriggeredAbility(new TIESilencerEffect(), false);
+        ability.addTarget(new TargetCreaturePermanent(0, 1));
+        this.addAbility(ability);
+    }
+
+    public TIESilencer(final TIESilencer card) {
+        super(card);
+    }
+
+    @Override
+    public TIESilencer copy() {
+        return new TIESilencer(this);
+    }
+}
+
+class TIESilencerEffect extends OneShotEffect {
+
+    public TIESilencerEffect() {
+        super(Outcome.Damage);
+        staticText = "it deals 1 damage to defending player and 1 damage to up to one target creature that player controls";
+    }
+
+    public TIESilencerEffect(final TIESilencerEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        UUID defender = game.getCombat().getDefendingPlayerId(source.getSourceId(), game);
+        if(defender != null) {
+            game.damagePlayerOrPlaneswalker(defender, 1, source.getSourceId(), game, false, true);
+
+            UUID target = source.getTargets().getFirstTarget();
+            Permanent permanent = game.getPermanent(target);
+            if(permanent != null) {
+                permanent.damage(1, source.getSourceId(), game, false, true);
+            }
+
+            return true;
+        }
+        return false;
+    }
+
+    public TIESilencerEffect copy() {
+        return new TIESilencerEffect(this);
+    }
+}

Mage.Sets/src/mage/cards/t/TIEStriker.java

@@ -0,0 +1,36 @@
+package mage.cards.t;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.keyword.SpaceflightAbility;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class TIEStriker extends CardImpl {
+
+    public TIEStriker(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{1}{B}");
+        
+        this.subtype.add(SubType.STARSHIP);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(1);
+
+        // Spaceflight
+        this.addAbility(SpaceflightAbility.getInstance());
+    }
+
+    public TIEStriker(final TIEStriker card) {
+        super(card);
+    }
+
+    @Override
+    public TIEStriker copy() {
+        return new TIEStriker(this);
+    }
+}

Mage.Sets/src/mage/cards/t/ThermalDetonator.java

@@ -0,0 +1,51 @@
+package mage.cards.t;
+
+import java.util.UUID;
+
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.costs.common.SacrificeSourceCost;
+import mage.abilities.costs.mana.ManaCostsImpl;
+import mage.abilities.effects.common.DamageTargetEffect;
+import mage.abilities.keyword.SpaceflightAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.filter.common.FilterCreatureOrPlayer;
+import mage.filter.predicate.Predicates;
+import mage.filter.predicate.mageobject.AbilityPredicate;
+import mage.target.common.TargetCreatureOrPlayer;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class ThermalDetonator extends CardImpl {
+
+    private static final FilterCreatureOrPlayer filter = new FilterCreatureOrPlayer("creature without spaceflight or target player");
+
+    static {
+        filter.add(Predicates.not(new AbilityPredicate(SpaceflightAbility.class)));
+    }
+
+    public ThermalDetonator(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT}, "{1}");
+        
+
+        // {2}, Sacrifice Thermal Detonator: Thermal Detonator deals 2 damage to target creature without spaceflight or target player.
+        Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new DamageTargetEffect(2), new ManaCostsImpl("{2}"));
+        ability.addCost(new SacrificeSourceCost());
+        ability.addTarget(new TargetCreatureOrPlayer(filter));
+        this.addAbility(ability);
+    }
+
+    public ThermalDetonator(final ThermalDetonator card) {
+        super(card);
+    }
+
+    @Override
+    public ThermalDetonator copy() {
+        return new ThermalDetonator(this);
+    }
+}

Mage.Sets/src/mage/cards/t/TobiasBeckett.java

@@ -0,0 +1,185 @@
+package mage.cards.t;
+
+import java.util.Objects;
+import java.util.UUID;
+import mage.MageInt;
+import mage.MageObject;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.effects.*;
+import mage.abilities.effects.common.ExileCardsFromTopOfLibraryTargetEffect;
+import mage.abilities.effects.common.counter.AddCountersTargetEffect;
+import mage.abilities.keyword.BountyAbility;
+import mage.cards.Card;
+import mage.constants.*;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.counters.CounterType;
+import mage.game.ExileZone;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+import mage.players.ManaPoolItem;
+import mage.players.Player;
+import mage.target.common.TargetOpponentsCreaturePermanent;
+import mage.target.targetpointer.FixedTarget;
+import mage.util.CardUtil;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class TobiasBeckett extends CardImpl {
+
+    public TobiasBeckett(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{B}");
+        
+        this.addSuperType(SuperType.LEGENDARY);
+        this.subtype.add(SubType.HUMAN);
+        this.subtype.add(SubType.HUNTER);
+        this.power = new MageInt(4);
+        this.toughness = new MageInt(3);
+
+        // When Tobias Becket enters the battlefield, put a bounty counter on target creature an opponent controls.
+        Ability ability = new EntersBattlefieldTriggeredAbility(new AddCountersTargetEffect(CounterType.BOUNTY.createInstance()));
+        ability.addTarget(new TargetOpponentsCreaturePermanent());
+        this.addAbility(ability);
+
+        // Bounty - Whenever a creature an opponent controls with a bounty counter on it dies, exile the top card of that player's library. You may cast cards exiled this way and spend mana as though it were mana of any type to cast that spell.
+        this.addAbility(new BountyAbility(new TobiasBeckettEffect(), false, true));
+    }
+
+    public TobiasBeckett(final TobiasBeckett card) {
+        super(card);
+    }
+
+    @Override
+    public TobiasBeckett copy() {
+        return new TobiasBeckett(this);
+    }
+}
+
+// Based on GrenzoHavocRaiserEffect
+class TobiasBeckettEffect extends OneShotEffect {
+
+    public TobiasBeckettEffect() {
+        super(Outcome.Exile);
+        staticText = "exile the top card of that player's library. You may cast cards exiled this way and spend mana as though it were mana of any type to cast that spell";
+    }
+
+    public TobiasBeckettEffect(final TobiasBeckettEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Player controller = game.getPlayer(source.getControllerId());
+        if (controller != null) {
+            Permanent bountyTriggered = game.getPermanent(this.getTargetPointer().getFirst(game, source));
+            if(bountyTriggered != null) {
+                Player opponent = game.getPlayer(bountyTriggered.getControllerId());
+                if (opponent != null) {
+                    MageObject sourceObject = game.getObject(source.getSourceId());
+                    UUID exileId = CardUtil.getCardExileZoneId(game, source);
+                    Card card = opponent.getLibrary().getFromTop(game);
+                    if (card != null) {
+                        // move card to exile
+                        controller.moveCardToExileWithInfo(card, exileId, sourceObject.getIdName(), source.getSourceId(), game, Zone.LIBRARY, true);
+                        // Add effects only if the card has a spellAbility (e.g. not for lands).
+                        if (card.getSpellAbility() != null) {
+                            // allow to cast the card
+                            game.addEffect(new TobiasBeckettCastFromExileEffect(card.getId(), exileId), source);
+                            // and you may spend mana as though it were mana of any color to cast it
+                            ContinuousEffect effect = new TobiasBeckettSpendAnyManaEffect();
+                            effect.setTargetPointer(new FixedTarget(card.getId()));
+                            game.addEffect(effect, source);
+                        }
+                    }
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public TobiasBeckettEffect copy() {
+        return new TobiasBeckettEffect(this);
+    }
+}
+
+// Based on GrenzoHavocRaiserCastFromExileEffect
+class TobiasBeckettCastFromExileEffect extends AsThoughEffectImpl {
+
+    private UUID cardId;
+    private UUID exileId;
+
+    public TobiasBeckettCastFromExileEffect(UUID cardId, UUID exileId) {
+        super(AsThoughEffectType.PLAY_FROM_NOT_OWN_HAND_ZONE, Duration.EndOfGame, Outcome.Benefit);
+        staticText = "You may cast that card and you may spend mana as though it were mana of any color to cast it";
+        this.cardId = cardId;
+        this.exileId = exileId;
+    }
+
+    public TobiasBeckettCastFromExileEffect(final TobiasBeckettCastFromExileEffect effect) {
+        super(effect);
+        this.cardId = effect.cardId;
+        this.exileId = effect.exileId;
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        return true;
+    }
+
+    @Override
+    public TobiasBeckettCastFromExileEffect copy() {
+        return new TobiasBeckettCastFromExileEffect(this);
+    }
+
+    @Override
+    public boolean applies(UUID sourceId, Ability source, UUID affectedControllerId, Game game) {
+        if (sourceId.equals(cardId) && source.isControlledBy(affectedControllerId)) {
+            ExileZone exileZone = game.getState().getExile().getExileZone(exileId);
+            return exileZone != null && exileZone.contains(cardId);
+        }
+        return false;
+    }
+}
+
+// Based on GrenzoHavocRaiserSpendAnyManaEffect
+class TobiasBeckettSpendAnyManaEffect extends AsThoughEffectImpl implements AsThoughManaEffect {
+
+    public TobiasBeckettSpendAnyManaEffect() {
+        super(AsThoughEffectType.SPEND_OTHER_MANA, Duration.EndOfTurn, Outcome.Benefit);
+        staticText = "you may spend mana as though it were mana of any color to cast it";
+    }
+
+    public TobiasBeckettSpendAnyManaEffect(final TobiasBeckettSpendAnyManaEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        return true;
+    }
+
+    @Override
+    public TobiasBeckettSpendAnyManaEffect copy() {
+        return new TobiasBeckettSpendAnyManaEffect(this);
+    }
+
+    @Override
+    public boolean applies(UUID objectId, Ability source, UUID affectedControllerId, Game game) {
+        return source.isControlledBy(affectedControllerId)
+                && Objects.equals(objectId, ((FixedTarget) getTargetPointer()).getTarget())
+                && ((FixedTarget) getTargetPointer()).getZoneChangeCounter() + 1 == game.getState().getZoneChangeCounter(objectId)
+                && (((FixedTarget) getTargetPointer()).getZoneChangeCounter() + 1 == game.getState().getZoneChangeCounter(objectId))
+                && game.getState().getZone(objectId) == Zone.STACK;
+    }
+
+    @Override
+    public ManaType getAsThoughManaType(ManaType manaType, ManaPoolItem mana, UUID affectedControllerId, Ability source, Game game) {
+        return mana.getFirstAvailable();
+    }
+
+}

Mage.Sets/src/mage/cards/u/UWing.java

@@ -0,0 +1,73 @@
+package mage.cards.u;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.condition.Condition;
+import mage.abilities.condition.common.SourceTappedCondition;
+import mage.abilities.decorator.ConditionalContinuousEffect;
+import mage.abilities.effects.common.continuous.BoostSourceEffect;
+import mage.abilities.keyword.SpaceflightAbility;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class UWing extends CardImpl {
+
+    public UWing(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{2}{U}");
+        
+        this.subtype.add(SubType.REBEL);
+        this.subtype.add(SubType.STARSHIP);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(2);
+
+        // Spaceflight
+        this.addAbility(SpaceflightAbility.getInstance());
+
+        // As long as U-Wing is tapped, it gets +1/+0.
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new ConditionalContinuousEffect(
+                new BoostSourceEffect(1, 0, Duration.WhileOnBattlefield),
+                SourceTappedCondition.instance,
+                "As long as {this} is tapped, it gets +1/+0")));
+
+        // As long as U-Wing is untapped, it gets +0/+1.
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new ConditionalContinuousEffect(
+                new BoostSourceEffect(0, 1, Duration.WhileOnBattlefield),
+                SourceUntappedCondition.instance,
+                "As long as {this} is untapped, it gets +0/+1")));
+    }
+
+    public UWing(final UWing card) {
+        super(card);
+    }
+
+    @Override
+    public UWing copy() {
+        return new UWing(this);
+    }
+}
+
+enum SourceUntappedCondition implements Condition {
+
+    instance;
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Permanent permanent = game.getBattlefield().getPermanent(source.getSourceId());
+        if (permanent != null) {
+            return !permanent.isTapped();
+        }
+        return false;
+    }
+}

Mage.Sets/src/mage/cards/u/UndergroundForum.java

@@ -0,0 +1,62 @@
+package mage.cards.u;
+
+import java.util.UUID;
+
+import mage.Mana;
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleActivatedAbility;
+import mage.abilities.costs.common.TapSourceCost;
+import mage.abilities.costs.mana.ColorlessManaCost;
+import mage.abilities.costs.mana.GenericManaCost;
+import mage.abilities.effects.common.counter.AddCountersTargetEffect;
+import mage.abilities.effects.mana.AddManaChosenColorEffect;
+import mage.abilities.mana.ColorlessManaAbility;
+import mage.abilities.mana.ConditionalColoredManaAbility;
+import mage.abilities.mana.SimpleManaAbility;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.counters.CounterType;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class UndergroundForum extends CardImpl {
+
+    public UndergroundForum(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.LAND}, "");
+        
+
+        // T: Add {1}.
+        this.addAbility(new ColorlessManaAbility());
+
+        // {1}, {T}: Add {B}, {R}, or {G}.
+        Ability ability = new SimpleManaAbility(Zone.BATTLEFIELD, Mana.BlackMana(1), new GenericManaCost(1));
+        ability.addCost(new TapSourceCost());
+        this.addAbility(ability);
+        ability = new SimpleManaAbility(Zone.BATTLEFIELD, Mana.RedMana(1), new GenericManaCost(1));
+        ability.addCost(new TapSourceCost());
+        this.addAbility(ability);
+        ability = new SimpleManaAbility(Zone.BATTLEFIELD, Mana.GreenMana(1), new GenericManaCost(1));
+        ability.addCost(new TapSourceCost());
+        this.addAbility(ability);
+
+        // {2}, {T}: Put a bounty counter on target creature.
+        Ability ability2 = new SimpleActivatedAbility(Zone.BATTLEFIELD, new AddCountersTargetEffect(CounterType.BOUNTY.createInstance()), new GenericManaCost(2));
+        ability2.addCost(new TapSourceCost());
+        ability2.addTarget(new TargetCreaturePermanent());
+        this.addAbility(ability2);
+    }
+
+    public UndergroundForum(final UndergroundForum card) {
+        super(card);
+    }
+
+    @Override
+    public UndergroundForum copy() {
+        return new UndergroundForum(this);
+    }
+}

Mage.Sets/src/mage/cards/u/UpsilonClassShuttle.java

@@ -0,0 +1,50 @@
+package mage.cards.u;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.AttacksTriggeredAbility;
+import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
+import mage.abilities.keyword.SpaceflightAbility;
+import mage.constants.Duration;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.constants.Zone;
+import mage.target.common.TargetControlledCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class UpsilonClassShuttle extends CardImpl {
+
+    public UpsilonClassShuttle(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{5}");
+        
+        this.subtype.add(SubType.STARSHIP);
+        this.power = new MageInt(2);
+        this.toughness = new MageInt(3);
+
+        // Spaceflight
+        this.addAbility(SpaceflightAbility.getInstance());
+
+        // Whenever Upsilon-class Shuttle attacks, target creature you control gains spaceflight until end of turn.
+        Ability ability = new AttacksTriggeredAbility(
+                new GainAbilityTargetEffect(SpaceflightAbility.getInstance(), Duration.EndOfTurn)
+                    .setText("target creature you control gains spaceflight until end of turn"),
+                false);
+        ability.addTarget(new TargetControlledCreaturePermanent());
+        this.addAbility(ability);
+    }
+
+    public UpsilonClassShuttle(final UpsilonClassShuttle card) {
+        super(card);
+    }
+
+    @Override
+    public UpsilonClassShuttle copy() {
+        return new UpsilonClassShuttle(this);
+    }
+}

Mage.Sets/src/mage/cards/v/VadersCommand.java

@@ -0,0 +1,74 @@
+package mage.cards.v;
+
+import java.util.UUID;
+
+import mage.abilities.Mode;
+import mage.abilities.costs.common.PayLifeCost;
+import mage.abilities.effects.common.CounterUnlessPaysEffect;
+import mage.abilities.effects.common.DestroyTargetEffect;
+import mage.abilities.effects.common.GainLifeEffect;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.filter.FilterPermanent;
+import mage.filter.common.FilterCreaturePermanent;
+import mage.filter.predicate.Predicates;
+import mage.filter.predicate.mageobject.CardTypePredicate;
+import mage.target.TargetPermanent;
+import mage.target.TargetSpell;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class VadersCommand extends CardImpl {
+
+    private static final FilterPermanent filterPlaneswalker = new FilterPermanent("planeswalker");
+    private static final FilterCreaturePermanent filterNonArtifact = new FilterCreaturePermanent("nonartifact creature");
+
+    static {
+        filterPlaneswalker.add(new CardTypePredicate(CardType.PLANESWALKER));
+        filterNonArtifact.add(Predicates.not(new CardTypePredicate(CardType.ARTIFACT)));
+    }
+
+    public VadersCommand(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{2}{B}{B}");
+        
+
+        // Choose two -
+        this.getSpellAbility().getModes().setMinModes(2);
+        this.getSpellAbility().getModes().setMaxModes(2);
+
+        //   Counter target spell unless its controller pays 5 life.
+        this.getSpellAbility().addEffect(new CounterUnlessPaysEffect(new PayLifeCost(5))
+                .setText("Counter target spell unless its controller pays 5 life"));
+        this.getSpellAbility().addTarget(new TargetSpell());
+
+        //   Destroy target planeswalker.
+        Mode mode = new Mode();
+        mode.getEffects().add(new DestroyTargetEffect());
+        mode.getTargets().add(new TargetPermanent(filterPlaneswalker));
+        this.getSpellAbility().addMode(mode);
+
+        //   Destroy target nonartifact creature.
+        mode = new Mode();
+        mode.getEffects().add(new DestroyTargetEffect());
+        mode.getTargets().add(new TargetCreaturePermanent(filterNonArtifact));
+        this.getSpellAbility().addMode(mode);
+
+        //   Gain 5 life.
+        mode = new Mode();
+        mode.getEffects().add(new GainLifeEffect(5).setText("Gain 5 life"));
+        this.getSpellAbility().addMode(mode);
+    }
+
+    public VadersCommand(final VadersCommand card) {
+        super(card);
+    }
+
+    @Override
+    public VadersCommand copy() {
+        return new VadersCommand(this);
+    }
+}

Mage.Sets/src/mage/cards/v/Vulptex.java

@@ -0,0 +1,42 @@
+package mage.cards.v;
+
+import java.util.UUID;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.EntersBattlefieldTriggeredAbility;
+import mage.abilities.effects.common.counter.AddCountersTargetEffect;
+import mage.constants.SubType;
+import mage.cards.CardImpl;
+import mage.cards.CardSetInfo;
+import mage.constants.CardType;
+import mage.counters.CounterType;
+import mage.target.common.TargetCreaturePermanent;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class Vulptex extends CardImpl {
+
+    public Vulptex(UUID ownerId, CardSetInfo setInfo) {
+        super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{W}");
+        
+        this.subtype.add(SubType.FOX);
+        this.power = new MageInt(1);
+        this.toughness = new MageInt(1);
+
+        // When Vulptex enters the battlefield, put a +1/+1 counter on target creature.
+        Ability ability = new EntersBattlefieldTriggeredAbility(new AddCountersTargetEffect(CounterType.P1P1.createInstance()));
+        ability.addTarget(new TargetCreaturePermanent());
+        this.addAbility(ability);
+    }
+
+    public Vulptex(final Vulptex card) {
+        super(card);
+    }
+
+    @Override
+    public Vulptex copy() {
+        return new Vulptex(this);
+    }
+}

Mage.Sets/src/mage/sets/StarWars.java

@@ -35,6 +35,7 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Acquire Target", 65, Rarity.COMMON, mage.cards.a.AcquireTarget.class));
         cards.add(new SetCardInfo("Admiral Ackbar", 35, Rarity.RARE, mage.cards.a.AdmiralAckbar.class));
         cards.add(new SetCardInfo("Adroit Hateflayer", 162, Rarity.COMMON, mage.cards.a.AdroitHateflayer.class));
+        cards.add(new SetCardInfo("Afterburn", 600, Rarity.COMMON, mage.cards.a.Afterburn.class));
         cards.add(new SetCardInfo("Anakin Skywalker", 163, Rarity.MYTHIC, mage.cards.a.AnakinSkywalker.class));
         cards.add(new SetCardInfo("Ancient Holocron", 230, Rarity.UNCOMMON, mage.cards.a.AncientHolocron.class));
         cards.add(new SetCardInfo("Aqualish Bounty Hunter", 66, Rarity.COMMON, mage.cards.a.AqualishBountyHunter.class));
@@ -42,6 +43,7 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Arrest", 2, Rarity.COMMON, mage.cards.a.Arrest.class));
         cards.add(new SetCardInfo("Asajj Ventress", 164, Rarity.RARE, mage.cards.a.AsajjVentress.class));
         cards.add(new SetCardInfo("AT-ST", 128, Rarity.RARE, mage.cards.a.ATST.class));
+        cards.add(new SetCardInfo("Astromech Droid", 400, Rarity.COMMON, mage.cards.a.AstromechDroid.class));
         cards.add(new SetCardInfo("Aurra Sing, Bane of Jedi", 165, Rarity.MYTHIC, mage.cards.a.AurraSingBaneOfJedi.class));
         cards.add(new SetCardInfo("Bantha Herd", 3, Rarity.RARE, mage.cards.b.BanthaHerd.class));
         cards.add(new SetCardInfo("Bathe in Bacta", 129, Rarity.COMMON, mage.cards.b.BatheInBacta.class));
@@ -49,7 +51,10 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Bib Fortuna", 68, Rarity.RARE, mage.cards.b.BibFortuna.class));
         cards.add(new SetCardInfo("Black Market Dealer", 69, Rarity.UNCOMMON, mage.cards.b.BlackMarketDealer.class));
         cards.add(new SetCardInfo("Blind Worship", 166, Rarity.RARE, mage.cards.b.BlindWorship.class));
+        cards.add(new SetCardInfo("Bludgeoning Pain", 300, Rarity.COMMON, mage.cards.b.BludgeoningPain.class));
+        cards.add(new SetCardInfo("Buried Ruin", 401, Rarity.COMMON, mage.cards.b.BuriedRuin.class));
         cards.add(new SetCardInfo("Boba Fett", 167, Rarity.MYTHIC, mage.cards.b.BobaFett.class));
+        cards.add(new SetCardInfo("Bor Gullet", 301, Rarity.UNCOMMON, mage.cards.b.BorGullet.class));
         cards.add(new SetCardInfo("Bossk", 131, Rarity.RARE, mage.cards.b.Bossk.class));
         cards.add(new SetCardInfo("Bounty Collector", 132, Rarity.UNCOMMON, mage.cards.b.BountyCollector.class));
         cards.add(new SetCardInfo("Bounty Sniper", 98, Rarity.UNCOMMON, mage.cards.b.BountySniper.class));
@@ -57,14 +62,22 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Bull Rancor", 168, Rarity.RARE, mage.cards.b.BullRancor.class));
         cards.add(new SetCardInfo("C-3PO and R2D2", 169, Rarity.RARE, mage.cards.c.C3POAndR2D2.class));
         cards.add(new SetCardInfo("Cantina Band", 6, Rarity.COMMON, mage.cards.c.CantinaBand.class));
+        cards.add(new SetCardInfo("Canto Bight Enforcer", 500, Rarity.UNCOMMON, mage.cards.c.CantoBightEnforcer.class));
+        cards.add(new SetCardInfo("Cantonica Casino", 501, Rarity.RARE, mage.cards.c.CantonicaCasino.class));
+        cards.add(new SetCardInfo("Captain Phasma", 502, Rarity.RARE, mage.cards.c.CaptainPhasma.class));
         cards.add(new SetCardInfo("Capture", 99, Rarity.COMMON, mage.cards.c.Capture.class));
         cards.add(new SetCardInfo("Carbonite Chamber", 170, Rarity.UNCOMMON, mage.cards.c.CarboniteChamber.class));
         cards.add(new SetCardInfo("Chewbacca", 171, Rarity.RARE, mage.cards.c.Chewbacca.class));
+        cards.add(new SetCardInfo("Chewbacca, the Beast", 601, Rarity.RARE, mage.cards.c.ChewbaccaTheBeast.class));
         cards.add(new SetCardInfo("Chief Chirpa", 172, Rarity.RARE, mage.cards.c.ChiefChirpa.class));
+        cards.add(new SetCardInfo("Chirrut Imwe", 302, Rarity.RARE, mage.cards.c.ChirrutImwe.class));
         cards.add(new SetCardInfo("Cloaking Device", 38, Rarity.COMMON, mage.cards.c.CloakingDevice.class));
+        cards.add(new SetCardInfo("Code Slice", 503, Rarity.COMMON, mage.cards.c.CodeSlice.class));
         cards.add(new SetCardInfo("Commander Cody", 173, Rarity.RARE, mage.cards.c.CommanderCody.class));
         cards.add(new SetCardInfo("Condemn", 7, Rarity.UNCOMMON, mage.cards.c.Condemn.class));
+        cards.add(new SetCardInfo("Conscription", 602, Rarity.UNCOMMON, mage.cards.c.Conscription.class));
         cards.add(new SetCardInfo("Corellian Corvette", 133, Rarity.UNCOMMON, mage.cards.c.CorellianCorvette.class));
+        cards.add(new SetCardInfo("Corellian Gunship", 603, Rarity.COMMON, mage.cards.c.CorellianGunship.class));
         cards.add(new SetCardInfo("Crossfire", 100, Rarity.COMMON, mage.cards.c.Crossfire.class));
         cards.add(new SetCardInfo("Cruelty of the Sith", 174, Rarity.UNCOMMON, mage.cards.c.CrueltyOfTheSith.class));
         cards.add(new SetCardInfo("Cunning Abduction", 175, Rarity.RARE, mage.cards.c.CunningAbduction.class));
@@ -74,24 +87,34 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Dark Trooper", 231, Rarity.UNCOMMON, mage.cards.d.DarkTrooper.class));
         cards.add(new SetCardInfo("Darth Maul", 178, Rarity.RARE, mage.cards.d.DarthMaul.class));
         cards.add(new SetCardInfo("Darth Sidious, Sith Lord", 179, Rarity.MYTHIC, mage.cards.d.DarthSidiousSithLord.class));
-        cards.add(new SetCardInfo("Darth Tyranus", 180, Rarity.MYTHIC, mage.cards.d.DarthTyranus.class));
+        cards.add(new SetCardInfo("Darth Tyranus, Count of Serenno", 180, Rarity.MYTHIC, mage.cards.d.DarthTyranusCountOfSerenno.class));
         cards.add(new SetCardInfo("Darth Vader", 140, Rarity.MYTHIC, mage.cards.d.DarthVader.class));
         cards.add(new SetCardInfo("Death Trooper", 71, Rarity.UNCOMMON, mage.cards.d.DeathTrooper.class));
+        cards.add(new SetCardInfo("Delay Tactic", 504, Rarity.COMMON, mage.cards.d.DelayTactic.class));
         cards.add(new SetCardInfo("Deploy The Troops", 8, Rarity.UNCOMMON, mage.cards.d.DeployTheTroops.class));
+        cards.add(new SetCardInfo("Despair", 604, Rarity.UNCOMMON, mage.cards.d.Despair.class));
+        cards.add(new SetCardInfo("Director Krennic", 303, Rarity.RARE, mage.cards.d.DirectorKrennic.class));
         cards.add(new SetCardInfo("Doom Blade", 72, Rarity.UNCOMMON, mage.cards.d.DoomBlade.class));
         cards.add(new SetCardInfo("Droid Commando", 73, Rarity.COMMON, mage.cards.d.DroidCommando.class));
         cards.add(new SetCardInfo("Droid Factory", 239, Rarity.COMMON, mage.cards.d.DroidFactory.class));
         cards.add(new SetCardInfo("Droid Foundry", 240, Rarity.UNCOMMON, mage.cards.d.DroidFoundry.class));
+        cards.add(new SetCardInfo("Droid Uprising", 605, Rarity.UNCOMMON, mage.cards.d.DroidUprising.class));
         cards.add(new SetCardInfo("Droideka", 9, Rarity.UNCOMMON, mage.cards.d.Droideka.class));
         cards.add(new SetCardInfo("Drone Holocron", 232, Rarity.COMMON, mage.cards.d.DroneHolocron.class));
+        cards.add(new SetCardInfo("Dryden Vos", 606, Rarity.RARE, mage.cards.d.DrydenVos.class));
         cards.add(new SetCardInfo("Echo Base Commando", 181, Rarity.RARE, mage.cards.e.EchoBaseCommando.class));
         cards.add(new SetCardInfo("EMP Blast", 10, Rarity.UNCOMMON, mage.cards.e.EMPBlast.class));
+        cards.add(new SetCardInfo("Enfys Nest", 607, Rarity.MYTHIC, mage.cards.e.EnfysNest.class));
         cards.add(new SetCardInfo("Escape Pod", 11, Rarity.COMMON, mage.cards.e.EscapePod.class));
         cards.add(new SetCardInfo("Ewok Ambush", 134, Rarity.COMMON, mage.cards.e.EwokAmbush.class));
         cards.add(new SetCardInfo("Ewok Firedancers", 135, Rarity.COMMON, mage.cards.e.EwokFiredancers.class));
         cards.add(new SetCardInfo("Ewok Village", 241, Rarity.UNCOMMON, mage.cards.e.EwokVillage.class));
         cards.add(new SetCardInfo("Exogorth", 136, Rarity.RARE, mage.cards.e.Exogorth.class));
+        cards.add(new SetCardInfo("Fathier", 505, Rarity.COMMON, mage.cards.f.Fathier.class));
         cards.add(new SetCardInfo("Ferocity of the Underworld", 182, Rarity.UNCOMMON, mage.cards.f.FerocityOfTheUnderworld.class));
+        cards.add(new SetCardInfo("Finn", 402, Rarity.UNCOMMON, mage.cards.f.Finn.class));
+        cards.add(new SetCardInfo("First Order Dreadnought", 506, Rarity.MYTHIC, mage.cards.f.FirstOrderDreadnought.class));
+        cards.add(new SetCardInfo("Flame Trooper", 403, Rarity.COMMON, mage.cards.f.FlameTrooper.class));
         cards.add(new SetCardInfo("Flames of Remembrance", 102, Rarity.RARE, mage.cards.f.FlamesOfRemembrance.class));
         cards.add(new SetCardInfo("Force Choke", 183, Rarity.COMMON, mage.cards.f.ForceChoke.class));
         cards.add(new SetCardInfo("Force Denial", 39, Rarity.COMMON, mage.cards.f.ForceDenial.class));
@@ -99,25 +122,35 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Force Healing", 12, Rarity.COMMON, mage.cards.f.ForceHealing.class));
         cards.add(new SetCardInfo("Force Lightning", 103, Rarity.RARE, mage.cards.f.ForceLightning.class));
         cards.add(new SetCardInfo("Force Mastery", 184, Rarity.RARE, mage.cards.f.ForceMastery.class));
+        cards.add(new SetCardInfo("Force Projection", 507, Rarity.RARE, mage.cards.f.ForceProjection.class));
+        cards.add(new SetCardInfo("Force Protection", 304, Rarity.COMMON, mage.cards.f.ForceProtection.class));
         cards.add(new SetCardInfo("Force Pull", 137, Rarity.COMMON, mage.cards.f.ForcePull.class));
         cards.add(new SetCardInfo("Force Push", 40, Rarity.UNCOMMON, mage.cards.f.ForcePush.class));
         cards.add(new SetCardInfo("Force Reflex", 13, Rarity.COMMON, mage.cards.f.ForceReflex.class));
         cards.add(new SetCardInfo("Force Scream", 104, Rarity.UNCOMMON, mage.cards.f.ForceScream.class));
         cards.add(new SetCardInfo("Force Spark", 105, Rarity.COMMON, mage.cards.f.ForceSpark.class));
+        cards.add(new SetCardInfo("Force Stasis", 404, Rarity.COMMON, mage.cards.f.ForceStasis.class));
+        cards.add(new SetCardInfo("Force Telepathy", 508, Rarity.COMMON, mage.cards.f.ForceTelepathy.class));
         cards.add(new SetCardInfo("Forest", "268a", Rarity.LAND, mage.cards.basiclands.Forest.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
         cards.add(new SetCardInfo("Forest", "268b", Rarity.LAND, mage.cards.basiclands.Forest.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
         cards.add(new SetCardInfo("Forest", "268c", Rarity.LAND, mage.cards.basiclands.Forest.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
         cards.add(new SetCardInfo("Forest", "268d", Rarity.LAND, mage.cards.basiclands.Forest.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
         cards.add(new SetCardInfo("Fulfill Contract", 224, Rarity.COMMON, mage.cards.f.FulfillContract.class));
+        cards.add(new SetCardInfo("Gamble", 608, Rarity.RARE, mage.cards.g.Gamble.class));
         cards.add(new SetCardInfo("Gamorrean Prison Guard", 106, Rarity.UNCOMMON, mage.cards.g.GamorreanPrisonGuard.class));
         cards.add(new SetCardInfo("General Grievous", 185, Rarity.MYTHIC, mage.cards.g.GeneralGrievous.class));
+        cards.add(new SetCardInfo("General Hux", 405, Rarity.UNCOMMON, mage.cards.g.GeneralHux.class));
+        cards.add(new SetCardInfo("Gerrera's Revolutionary", 305, Rarity.COMMON, mage.cards.g.GerrerasRevolutionary.class));
         cards.add(new SetCardInfo("Gifted Initiate", 14, Rarity.COMMON, mage.cards.g.GiftedInitiate.class));
+        cards.add(new SetCardInfo("Glorious Charge", 509, Rarity.COMMON, mage.cards.g.GloriousCharge.class));
         cards.add(new SetCardInfo("Grand Moff Tarkin", 75, Rarity.RARE, mage.cards.g.GrandMoffTarkin.class));
         cards.add(new SetCardInfo("Greater Krayt Dragon", 186, Rarity.MYTHIC, mage.cards.g.GreaterKraytDragon.class));
         cards.add(new SetCardInfo("Greedo", 187, Rarity.RARE, mage.cards.g.Greedo.class));
         cards.add(new SetCardInfo("Gundark", 107, Rarity.UNCOMMON, mage.cards.g.Gundark.class));
         cards.add(new SetCardInfo("Gungan Captain", 41, Rarity.COMMON, mage.cards.g.GunganCaptain.class));
+        cards.add(new SetCardInfo("Hammerhead Corvette", 306, Rarity.UNCOMMON, mage.cards.h.HammerheadCorvette.class));
         cards.add(new SetCardInfo("Han Solo", 108, Rarity.RARE, mage.cards.h.HanSolo.class));
+        cards.add(new SetCardInfo("Han Solo, Scrumrat", 609, Rarity.RARE, mage.cards.h.HanSoloScrumrat.class));
         cards.add(new SetCardInfo("Hazard Trooper", 76, Rarity.UNCOMMON, mage.cards.h.HazardTrooper.class));
         cards.add(new SetCardInfo("Head Hunting", 77, Rarity.COMMON, mage.cards.h.HeadHunting.class));
         cards.add(new SetCardInfo("Heavy Trooper", 78, Rarity.COMMON, mage.cards.h.HeavyTrooper.class));
@@ -129,8 +162,10 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("IG-88B", 79, Rarity.RARE, mage.cards.i.IG88B.class));
         cards.add(new SetCardInfo("Images of the Past", 190, Rarity.COMMON, mage.cards.i.ImagesOfThePast.class));
         cards.add(new SetCardInfo("Imperial Gunner", 109, Rarity.COMMON, mage.cards.i.ImperialGunner.class));
+        cards.add(new SetCardInfo("Imperial Hovertank", 307, Rarity.UNCOMMON, mage.cards.i.ImperialHovertank.class));
         cards.add(new SetCardInfo("Impulsive Wager", 110, Rarity.COMMON, mage.cards.i.ImpulsiveWager.class));
         cards.add(new SetCardInfo("Insatiable Rakghoul", 80, Rarity.COMMON, mage.cards.i.InsatiableRakghoul.class));
+        cards.add(new SetCardInfo("Inspire", 510, Rarity.COMMON, mage.cards.i.Inspire.class));
         cards.add(new SetCardInfo("Interrogation", 81, Rarity.COMMON, mage.cards.i.Interrogation.class));
         cards.add(new SetCardInfo("Ion Cannon", 15, Rarity.COMMON, mage.cards.i.IonCannon.class));
         cards.add(new SetCardInfo("Iron Fist of the Empire", 191, Rarity.RARE, mage.cards.i.IronFistOfTheEmpire.class));
@@ -158,8 +193,11 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Jedi Training", 45, Rarity.UNCOMMON, mage.cards.j.JediTraining.class));
         cards.add(new SetCardInfo("Jump Trooper", 46, Rarity.UNCOMMON, mage.cards.j.JumpTrooper.class));
         cards.add(new SetCardInfo("Jungle Village", 245, Rarity.UNCOMMON, mage.cards.j.JungleVillage.class));
+        cards.add(new SetCardInfo("Jyn Erso and Cassian Andor", 308, Rarity.RARE, mage.cards.j.JynErsoAndCassianAndor.class));
+        cards.add(new SetCardInfo("Kalevan Star Yacht", 610, Rarity.UNCOMMON, mage.cards.k.KalevanStarYacht.class));
         cards.add(new SetCardInfo("Kamino Cloning Facility", 246, Rarity.RARE, mage.cards.k.KaminoCloningFacility.class));
         cards.add(new SetCardInfo("Ki-Adi-Mundi", 142, Rarity.RARE, mage.cards.k.KiAdiMundi.class));
+        cards.add(new SetCardInfo("Kylo Ren", 406, Rarity.MYTHIC, mage.cards.k.KyloRen.class));
         cards.add(new SetCardInfo("LAAT Gunship", 20, Rarity.UNCOMMON, mage.cards.l.LAATGunship.class));
         cards.add(new SetCardInfo("Lando Calrissian", 21, Rarity.RARE, mage.cards.l.LandoCalrissian.class));
         cards.add(new SetCardInfo("Legacy of the Beloved", 143, Rarity.RARE, mage.cards.l.LegacyOfTheBeloved.class));
@@ -167,7 +205,9 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Lightsaber", 234, Rarity.COMMON, mage.cards.l.Lightsaber.class));
         cards.add(new SetCardInfo("Loyal Tauntaun", 22, Rarity.COMMON, mage.cards.l.LoyalTauntaun.class));
         cards.add(new SetCardInfo("Luke Skywalker", 195, Rarity.MYTHIC, mage.cards.l.LukeSkywalker.class));
+        cards.add(new SetCardInfo("Luke Skywalker, the Last Jedi", 511, Rarity.MYTHIC, mage.cards.l.LukeSkywalkerTheLastJedi.class));
         cards.add(new SetCardInfo("Mace Windu", 47, Rarity.RARE, mage.cards.m.MaceWindu.class));
+        cards.add(new SetCardInfo("Maelstrom Blockade", 611, Rarity.COMMON, mage.cards.m.MaelstromBlockade.class));
         cards.add(new SetCardInfo("Maintenance Droid", 196, Rarity.COMMON, mage.cards.m.MaintenanceDroid.class));
         cards.add(new SetCardInfo("Maintenance Hangar", 23, Rarity.RARE, mage.cards.m.MaintenanceHangar.class));
         cards.add(new SetCardInfo("Mantellian Savrip", 144, Rarity.UNCOMMON, mage.cards.m.MantellianSavrip.class));
@@ -183,6 +223,8 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Mountain", "264b", Rarity.LAND, mage.cards.basiclands.Mountain.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
         cards.add(new SetCardInfo("Mountain", "264c", Rarity.LAND, mage.cards.basiclands.Mountain.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
         cards.add(new SetCardInfo("Mountain", "264d", Rarity.LAND, mage.cards.basiclands.Mountain.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
+        cards.add(new SetCardInfo("Mouse Droid", 512, Rarity.COMMON, mage.cards.m.MouseDroid.class));
+        cards.add(new SetCardInfo("Mud Trooper", 612, Rarity.UNCOMMON, mage.cards.m.MudTrooper.class));
         cards.add(new SetCardInfo("N-1 Starfighter", 225, Rarity.COMMON, mage.cards.n.N1Starfighter.class));
         cards.add(new SetCardInfo("Nebulon-B Frigate", 25, Rarity.COMMON, mage.cards.n.NebulonBFrigate.class));
         cards.add(new SetCardInfo("Neophyte Hateflayer", 82, Rarity.COMMON, mage.cards.n.NeophyteHateflayer.class));
@@ -193,10 +235,12 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Novice Bounty Hunter", 114, Rarity.COMMON, mage.cards.n.NoviceBountyHunter.class));
         cards.add(new SetCardInfo("Nute Gunray", 199, Rarity.RARE, mage.cards.n.NuteGunray.class));
         cards.add(new SetCardInfo("Obi-Wan Kenobi", 200, Rarity.MYTHIC, mage.cards.o.ObiWanKenobi.class));
+        cards.add(new SetCardInfo("Occupation", 309, Rarity.UNCOMMON, mage.cards.o.Occupation.class));
         cards.add(new SetCardInfo("Open Season", 83, Rarity.UNCOMMON, mage.cards.o.OpenSeason.class));
         cards.add(new SetCardInfo("Orbital Bombardment", 26, Rarity.RARE, mage.cards.o.OrbitalBombardment.class));
         cards.add(new SetCardInfo("Order 66", 84, Rarity.RARE, mage.cards.o.Order66.class));
         cards.add(new SetCardInfo("Ortolan Keyboardist", 50, Rarity.COMMON, mage.cards.o.OrtolanKeyboardist.class));
+        cards.add(new SetCardInfo("Outer Rim Gang", 407, Rarity.COMMON, mage.cards.o.OuterRimGang.class));
         cards.add(new SetCardInfo("Outer Rim Slaver", 201, Rarity.COMMON, mage.cards.o.OuterRimSlaver.class));
         cards.add(new SetCardInfo("Outlaw Holocron", 235, Rarity.COMMON, mage.cards.o.OutlawHolocron.class));
         cards.add(new SetCardInfo("Personal Energy Shield", 51, Rarity.COMMON, mage.cards.p.PersonalEnergyShield.class));
@@ -205,6 +249,9 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Plains", "252c", Rarity.LAND, mage.cards.basiclands.Plains.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
         cards.add(new SetCardInfo("Plains", "252d", Rarity.LAND, mage.cards.basiclands.Plains.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
         cards.add(new SetCardInfo("Plo Koon", 27, Rarity.RARE, mage.cards.p.PloKoon.class));
+        cards.add(new SetCardInfo("Poe Dameron", 408, Rarity.UNCOMMON, mage.cards.p.PoeDameron.class));
+        cards.add(new SetCardInfo("Porg Nest", 513, Rarity.UNCOMMON, mage.cards.p.PorgNest.class));
+        cards.add(new SetCardInfo("Praetorian Trooper", 514, Rarity.RARE, mage.cards.p.PraetorianTrooper.class));
         cards.add(new SetCardInfo("Precipice of Mortis", 202, Rarity.RARE, mage.cards.p.PrecipiceOfMortis.class));
         cards.add(new SetCardInfo("Predator's Strike", 151, Rarity.COMMON, mage.cards.p.PredatorsStrike.class));
         cards.add(new SetCardInfo("Preordain", 34, Rarity.UNCOMMON, mage.cards.p.Preordain.class));
@@ -214,19 +261,27 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Qui-Gon Jinn", 205, Rarity.RARE, mage.cards.q.QuiGonJinn.class));
         cards.add(new SetCardInfo("Raging Reek", 115, Rarity.COMMON, mage.cards.r.RagingReek.class));
         cards.add(new SetCardInfo("Rallying Fire", 116, Rarity.COMMON, mage.cards.r.RallyingFire.class));
+        cards.add(new SetCardInfo("Range Trooper", 613, Rarity.UNCOMMON, mage.cards.r.RangeTrooper.class));
+        cards.add(new SetCardInfo("Rathtar", 409, Rarity.COMMON, mage.cards.r.Rathtar.class));
         cards.add(new SetCardInfo("Ravenous Wampa", 226, Rarity.UNCOMMON, mage.cards.r.RavenousWampa.class));
         cards.add(new SetCardInfo("Regression", 152, Rarity.UNCOMMON, mage.cards.r.Regression.class));
         cards.add(new SetCardInfo("Republic Frigate", 53, Rarity.COMMON, mage.cards.r.RepublicFrigate.class));
         cards.add(new SetCardInfo("Repurpose", 85, Rarity.COMMON, mage.cards.r.Repurpose.class));
+        cards.add(new SetCardInfo("Resistance", 310, Rarity.UNCOMMON, mage.cards.r.Resistance.class));
+        cards.add(new SetCardInfo("Resistance Bomber", 515, Rarity.UNCOMMON, mage.cards.r.ResistanceBomber.class));
         cards.add(new SetCardInfo("Revenge", 117, Rarity.COMMON, mage.cards.r.Revenge.class));
+        cards.add(new SetCardInfo("Rey", 410, Rarity.RARE, mage.cards.r.Rey.class));
         cards.add(new SetCardInfo("Riding Ronto", 28, Rarity.UNCOMMON, mage.cards.r.RidingRonto.class));
+        cards.add(new SetCardInfo("Riot Trooper", 411, Rarity.COMMON, mage.cards.r.RiotTrooper.class));
         cards.add(new SetCardInfo("Rocket Trooper", 118, Rarity.RARE, mage.cards.r.RocketTrooper.class));
         cards.add(new SetCardInfo("Rogue's Passage", 248, Rarity.UNCOMMON, mage.cards.r.RoguesPassage.class));
         cards.add(new SetCardInfo("Rule of two", 86, Rarity.UNCOMMON, mage.cards.r.RuleOfTwo.class));
         cards.add(new SetCardInfo("Rumination", 54, Rarity.COMMON, mage.cards.r.Rumination.class));
         cards.add(new SetCardInfo("Rumor Monger", 206, Rarity.UNCOMMON, mage.cards.r.RumorMonger.class));
         cards.add(new SetCardInfo("Sabacc Game", 55, Rarity.UNCOMMON, mage.cards.s.SabaccGame.class));
+        cards.add(new SetCardInfo("Sai Tok", 516, Rarity.UNCOMMON, mage.cards.s.SaiTok.class));
         cards.add(new SetCardInfo("Salvage Squad", 207, Rarity.COMMON, mage.cards.s.SalvageSquad.class));
+        cards.add(new SetCardInfo("Salvage Trader", 412, Rarity.COMMON, mage.cards.s.SalvageTrader.class));
         cards.add(new SetCardInfo("Sand Trooper", 29, Rarity.COMMON, mage.cards.s.SandTrooper.class));
         cards.add(new SetCardInfo("Sarlacc Pit", 208, Rarity.RARE, mage.cards.s.SarlaccPit.class));
         cards.add(new SetCardInfo("Scout the Perimeter", 153, Rarity.COMMON, mage.cards.s.ScoutThePerimeter.class));
@@ -241,6 +296,7 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Shadow Trooper", 56, Rarity.COMMON, mage.cards.s.ShadowTrooper.class));
         cards.add(new SetCardInfo("Shock Trooper", 119, Rarity.UNCOMMON, mage.cards.s.ShockTrooper.class));
         cards.add(new SetCardInfo("Show of Dominance", 156, Rarity.UNCOMMON, mage.cards.s.ShowOfDominance.class));
+        cards.add(new SetCardInfo("Sins of the Father", 413, Rarity.COMMON, mage.cards.s.SinsOfTheFather.class));
         cards.add(new SetCardInfo("Sith Assassin", 87, Rarity.UNCOMMON, mage.cards.s.SithAssassin.class));
         cards.add(new SetCardInfo("Sith Citadel", 249, Rarity.UNCOMMON, mage.cards.s.SithCitadel.class));
         cards.add(new SetCardInfo("Sith Evoker", 88, Rarity.COMMON, mage.cards.s.SithEvoker.class));
@@ -262,6 +318,7 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Star Destroyer", 217, Rarity.RARE, mage.cards.s.StarDestroyer.class));
         cards.add(new SetCardInfo("Strike Team Commando", 227, Rarity.COMMON, mage.cards.s.StrikeTeamCommando.class));
         cards.add(new SetCardInfo("Super Battle Droid", 59, Rarity.COMMON, mage.cards.s.SuperBattleDroid.class));
+        cards.add(new SetCardInfo("Supreme Leader Snoke", 517, Rarity.MYTHIC, mage.cards.s.SupremeLeaderSnoke.class));
         cards.add(new SetCardInfo("Surprise Maneuver", 60, Rarity.COMMON, mage.cards.s.SurpriseManeuver.class));
         cards.add(new SetCardInfo("Swamp", "260a", Rarity.LAND, mage.cards.basiclands.Swamp.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
         cards.add(new SetCardInfo("Swamp", "260b", Rarity.LAND, mage.cards.basiclands.Swamp.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
@@ -279,17 +336,26 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("The Death Star", 1, Rarity.MYTHIC, mage.cards.t.TheDeathStar.class));
         cards.add(new SetCardInfo("TIE Bomber", 93, Rarity.UNCOMMON, mage.cards.t.TIEBomber.class));
         cards.add(new SetCardInfo("TIE Interceptor", 94, Rarity.COMMON, mage.cards.t.TIEInterceptor.class));
+        cards.add(new SetCardInfo("TIE Silencer", 518, Rarity.RARE, mage.cards.t.TIESilencer.class));
+        cards.add(new SetCardInfo("TIE Striker", 312, Rarity.COMMON, mage.cards.t.TIEStriker.class));
+        cards.add(new SetCardInfo("Thermal Detonator", 311, Rarity.COMMON, mage.cards.t.ThermalDetonator.class));
+        cards.add(new SetCardInfo("Tobias Beckett", 614, Rarity.RARE, mage.cards.t.TobiasBeckett.class));
         cards.add(new SetCardInfo("Trade Federation Battleship", 219, Rarity.RARE, mage.cards.t.TradeFederationBattleship.class));
         cards.add(new SetCardInfo("Tri-Fighter", 228, Rarity.COMMON, mage.cards.t.TriFighter.class));
         cards.add(new SetCardInfo("Trooper Armor", 237, Rarity.UNCOMMON, mage.cards.t.TrooperArmor.class));
         cards.add(new SetCardInfo("Trooper Commando", 157, Rarity.UNCOMMON, mage.cards.t.TrooperCommando.class));
         cards.add(new SetCardInfo("Twi'lek Seductress", 158, Rarity.COMMON, mage.cards.t.TwilekSeductress.class));
+        cards.add(new SetCardInfo("U-Wing", 313, Rarity.UNCOMMON, mage.cards.u.UWing.class));
         cards.add(new SetCardInfo("Ugnaught Scrap Worker", 61, Rarity.COMMON, mage.cards.u.UgnaughtScrapWorker.class));
+        cards.add(new SetCardInfo("Underground Forum", 615, Rarity.UNCOMMON, mage.cards.u.UndergroundForum.class));
         cards.add(new SetCardInfo("Underworld Slums", 251, Rarity.COMMON, mage.cards.u.UnderworldSlums.class));
         cards.add(new SetCardInfo("Unity of the Droids", 220, Rarity.UNCOMMON, mage.cards.u.UnityOfTheDroids.class));
         cards.add(new SetCardInfo("Unruly Sureshot", 95, Rarity.UNCOMMON, mage.cards.u.UnrulySureshot.class));
+        cards.add(new SetCardInfo("Upsilon-class Shuttle", 414, Rarity.COMMON, mage.cards.u.UpsilonClassShuttle.class));
         cards.add(new SetCardInfo("V-Wing", 126, Rarity.COMMON, mage.cards.v.VWing.class));
+        cards.add(new SetCardInfo("Vader's Command", 314, Rarity.RARE, mage.cards.v.VadersCommand.class));
         cards.add(new SetCardInfo("Vapor Snag", 62, Rarity.COMMON, mage.cards.v.VaporSnag.class));
+        cards.add(new SetCardInfo("Vulptex", 519, Rarity.COMMON, mage.cards.v.Vulptex.class));
         cards.add(new SetCardInfo("Weequay Beastmaster", 127, Rarity.UNCOMMON, mage.cards.w.WeequayBeastmaster.class));
         cards.add(new SetCardInfo("Wild Holocron", 238, Rarity.COMMON, mage.cards.w.WildHolocron.class));
         cards.add(new SetCardInfo("Wisdom of the Jedi", 221, Rarity.UNCOMMON, mage.cards.w.WisdomOfTheJedi.class));
@@ -301,5 +367,7 @@ public final class StarWars extends ExpansionSet {
         cards.add(new SetCardInfo("Y-Wing", 63, Rarity.UNCOMMON, mage.cards.y.YWing.class));
         cards.add(new SetCardInfo("Yoda, Jedi Master", 223, Rarity.MYTHIC, mage.cards.y.YodaJediMaster.class));
         cards.add(new SetCardInfo("Zam Wesell", 64, Rarity.RARE, mage.cards.z.ZamWesell.class));
+        cards.add(new SetCardInfo("Island", "520a", Rarity.LAND, mage.cards.basiclands.Island.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
+        cards.add(new SetCardInfo("Plains", "520b", Rarity.LAND, mage.cards.basiclands.Plains.class, new CardGraphicInfo(FrameStyle.ZEN_FULL_ART_BASIC, true)));
     }
 }

Mage/src/main/java/mage/constants/SubType.java

@@ -64,6 +64,7 @@ public enum SubType {
     AZRA("Azra", SubTypeSet.CreatureType),
     // B
     BADGER("Badger", SubTypeSet.CreatureType),
+    BARABEL("Barabel", SubTypeSet.CreatureType, true), // Star Wars
     BARBARIAN("Barbarian", SubTypeSet.CreatureType),
     BASILISK("Basilisk", SubTypeSet.CreatureType),
     BAT("Bat", SubTypeSet.CreatureType),
@@ -99,6 +100,7 @@ public enum SubType {
     COWARD("Coward", SubTypeSet.CreatureType),
     CRAB("Crab", SubTypeSet.CreatureType),
     CROCODILE("Crocodile", SubTypeSet.CreatureType),
+    CROLUTE("Crolute", SubTypeSet.CreatureType, true), // Star Wars
     CYBORG("Cyborg", SubTypeSet.CreatureType, true), // Star Wars
     CYCLOPS("Cyclops", SubTypeSet.CreatureType),
     // D
@@ -204,6 +206,7 @@ public enum SubType {
     LICID("Licid", SubTypeSet.CreatureType),
     LIZARD("Lizard", SubTypeSet.CreatureType),
     LOBSTER("Lobster", SubTypeSet.CreatureType, true), // Unglued
+    LUKE("Luke", SubTypeSet.PlaneswalkerType, true), // Star Wars
     // M
     MANTELLIAN("Mantellian", SubTypeSet.CreatureType, true), // Star Wars
     MANTICORE("Manticore", SubTypeSet.CreatureType),
@@ -312,6 +315,7 @@ public enum SubType {
     SPONGE("Sponge", SubTypeSet.CreatureType),
     SQUID("Squid", SubTypeSet.CreatureType),
     SQUIRREL("Squirrel", SubTypeSet.CreatureType),
+    SNOKE("Snoke", SubTypeSet.PlaneswalkerType, true), // Star Wars
     STARFISH("Starfish", SubTypeSet.CreatureType),
     STARSHIP("Starship", SubTypeSet.CreatureType, true), // Star Wars
     SULLUSTAN("Sullustan", SubTypeSet.CreatureType, true), // Star Wars

Mage/src/main/java/mage/game/GameImpl.java

@@ -1022,6 +1022,7 @@ public abstract class GameImpl implements Game, Serializable {
         watchers.add(new CastSpellLastTurnWatcher());
         watchers.add(new CastSpellYourLastTurnWatcher());
         watchers.add(new PlayerLostLifeWatcher());
+        watchers.add(new PlayerLostLifeNonCombatWatcher());
         watchers.add(new BlockedAttackerWatcher());
         watchers.add(new DamageDoneWatcher());
         watchers.add(new PlanarRollWatcher());

Mage/src/main/java/mage/game/command/emblems/LukeSkywalkerEmblem.java

@@ -0,0 +1,61 @@
+package mage.game.command.emblems;
+
+import mage.abilities.Ability;
+import mage.abilities.common.BeginningOfEndStepTriggeredAbility;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.effects.ContinuousEffectImpl;
+import mage.abilities.effects.PreventionEffectImpl;
+import mage.abilities.effects.common.CreateTokenEffect;
+import mage.abilities.effects.common.PreventAllDamageByAllPermanentsEffect;
+import mage.abilities.effects.common.PreventAllDamageToPlayersEffect;
+import mage.constants.*;
+import mage.game.Game;
+import mage.game.command.Emblem;
+import mage.game.events.GameEvent;
+import mage.game.permanent.token.CatToken2;
+import mage.game.turn.Phase;
+import mage.players.Player;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public class LukeSkywalkerEmblem extends Emblem {
+
+    // -6: You get an emblem with "Prevent all damage that would be dealt to you during combat." Exile Luke Skywalker, the Last Jedi.
+    public LukeSkywalkerEmblem() {
+        this.setName("Emblem Luke Skywalker");
+        this.setExpansionSetCodeForImage("SWS");
+        this.getAbilities().add(new SimpleStaticAbility(Zone.BATTLEFIELD, new LukeSkywalkerEmblemEffect()));
+    }
+}
+
+class LukeSkywalkerEmblemEffect extends PreventionEffectImpl {
+
+    public LukeSkywalkerEmblemEffect() {
+        super(Duration.Custom, Integer.MAX_VALUE, false);
+        staticText = "Prevent all damage that would be dealt to you during combat";
+    }
+
+    public LukeSkywalkerEmblemEffect(final LukeSkywalkerEmblemEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public LukeSkywalkerEmblemEffect copy() {
+        return new LukeSkywalkerEmblemEffect(this);
+    }
+
+    @Override
+    public boolean applies(GameEvent event, Ability source, Game game) {
+        if (game.getPhase().getType() == TurnPhase.COMBAT
+                && super.applies(event, source, game)
+                && event.getType() == GameEvent.EventType.DAMAGE_PLAYER) {
+            Player controller = game.getPlayer(source.getControllerId());
+            if (controller != null && game.getState().getPlayersInRange(controller.getId(), game).contains(event.getTargetId())) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

Mage/src/main/java/mage/game/permanent/token/PorgToken.java

@@ -0,0 +1,39 @@
+
+
+package mage.game.permanent.token;
+
+import mage.MageInt;
+import mage.abilities.keyword.MonstrosityAbility;
+import mage.constants.CardType;
+import mage.constants.SubType;
+
+import java.util.Collections;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class PorgToken extends TokenImpl {
+
+    public PorgToken() {
+        super("Porg", "0/1 green Bird creature token named Porg with \"{G}: Monstrosity 1.\"");
+        availableImageSetCodes.addAll(Collections.singletonList("SWS"));
+
+        cardType.add(CardType.CREATURE);
+        subtype.add(SubType.BIRD);
+
+        color.setGreen(true);
+        power = new MageInt(0);
+        toughness = new MageInt(1);
+
+        this.addAbility(new MonstrosityAbility("{G}", 1));
+    }
+
+    public PorgToken(final PorgToken token) {
+        super(token);
+    }
+
+    public PorgToken copy() {
+        return new PorgToken(this);
+    }
+}

Mage/src/main/java/mage/game/permanent/token/TrooperToken2.java

@@ -0,0 +1,36 @@
+
+package mage.game.permanent.token;
+
+import java.util.Collections;
+
+import mage.MageInt;
+import mage.constants.CardType;
+import mage.constants.SubType;
+
+/**
+ *
+ * @author NinthWorld
+ */
+public final class TrooperToken2 extends TokenImpl {
+
+    public TrooperToken2() {
+        super("Trooper", "1/1 black Trooper creature token");
+        availableImageSetCodes.addAll(Collections.singletonList("SWS"));
+        this.setTokenType(2);
+
+        cardType.add(CardType.CREATURE);
+        subtype.add(SubType.TROOPER);
+
+        color.setBlack(true);
+        power = new MageInt(1);
+        toughness = new MageInt(1);
+    }
+
+    public TrooperToken2(final TrooperToken2 token) {
+        super(token);
+    }
+
+    public TrooperToken2 copy() {
+        return new TrooperToken2(this);
+    }
+}

Mage/src/main/java/mage/watchers/common/PlayerLostLifeNonCombatWatcher.java

@@ -0,0 +1,84 @@
+
+package mage.watchers.common;
+
+import mage.constants.WatcherScope;
+import mage.game.Game;
+import mage.game.events.DamagedPlayerEvent;
+import mage.game.events.GameEvent;
+import mage.players.Player;
+import mage.watchers.Watcher;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.UUID;
+
+/*
+ * Counts amount of life lost from noncombat sources current or last turn by players.
+ * This watcher is automatically started in gameImpl.init for each game
+ *
+ * @author NinthWorld
+ */
+public class PlayerLostLifeNonCombatWatcher extends Watcher {
+
+    private final Map<UUID, Integer> amountOfLifeLostThisTurn = new HashMap<>();
+    private final Map<UUID, Integer> amountOfLifeLostLastTurn = new HashMap<>();
+
+    public PlayerLostLifeNonCombatWatcher() {
+        super(PlayerLostLifeNonCombatWatcher.class.getSimpleName(), WatcherScope.GAME);
+    }
+
+    public PlayerLostLifeNonCombatWatcher(final PlayerLostLifeNonCombatWatcher watcher) {
+        super(watcher);
+        for (Entry<UUID, Integer> entry : watcher.amountOfLifeLostThisTurn.entrySet()) {
+            amountOfLifeLostThisTurn.put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void watch(GameEvent event, Game game) {
+        if (event.getType() == GameEvent.EventType.LOST_LIFE && !event.getFlag()) {
+            UUID playerId = event.getPlayerId();
+            if (playerId != null) {
+                Integer amount = amountOfLifeLostThisTurn.get(playerId);
+                if (amount == null) {
+                    amount = event.getAmount();
+                } else {
+                    amount = amount + event.getAmount();
+                }
+                amountOfLifeLostThisTurn.put(playerId, amount);
+            }
+        }
+    }
+
+    public int getLiveLost(UUID playerId) {
+        return amountOfLifeLostThisTurn.getOrDefault(playerId, 0);
+    }
+
+    public int getAllOppLifeLost(UUID playerId, Game game) {
+        int amount = 0;
+        for (UUID opponentId : this.amountOfLifeLostThisTurn.keySet()) {
+            Player opponent = game.getPlayer(opponentId);
+            if (opponent != null && opponent.hasOpponent(playerId, game)) {
+                amount += this.amountOfLifeLostThisTurn.getOrDefault(opponentId, 0);
+            }
+        }
+        return amount;
+    }
+
+    public int getLiveLostLastTurn(UUID playerId) {
+        return amountOfLifeLostLastTurn.getOrDefault(playerId, 0);
+    }
+
+    @Override
+    public void reset() {
+        amountOfLifeLostLastTurn.clear();
+        amountOfLifeLostLastTurn.putAll(amountOfLifeLostThisTurn);
+        amountOfLifeLostThisTurn.clear();
+    }
+
+    @Override
+    public PlayerLostLifeNonCombatWatcher copy() {
+        return new PlayerLostLifeNonCombatWatcher(this);
+    }
+}

Utils/mtg-cards-data.txt

@@ -34231,4 +34231,70 @@ Mountain|Commander 2018|303|C||Basic Land - Mountain|||({T}: Add {R}.)|
 Mountain|Commander 2018|304|C||Basic Land - Mountain|||({T}: Add {R}.)|
 Forest|Commander 2018|305|C||Basic Land - Forest|||({T}: Add {G}.)|
 Forest|Commander 2018|306|C||Basic Land - Forest|||({T}: Add {G}.)|
-Forest|Commander 2018|307|C||Basic Land - Forest|||({T}: Add {G}.)|
+Forest|Commander 2018|307|C||Basic Land - Forest|||({T}: Add {G}.)|
+Bludgeoning Pain|Star Wars|300|C|{1}{B}|Instant|||Target creature gets -2/-2 until end of turn. Tap that creature.|
+Bor Gullet|Star Wars|301|U|{3}{U}{B}|Creature - Horror Cephalid|4|4|When Bor Gullet enters the battlefield, target opponent reveals his or her hand. You choose a card from it. That player discards that card.|
+Chirrut Imwe|Star Wars|302|R|{G}{W}{U}|Legendary Creature - Human Monk|3|3|Chirrut Imwe can block up to two additional creatures.${1}{W}: Prevent all combat damage that would be dealt to Chirrut Imwe until end of turn.|
+Director Krennic|Star Wars|303|R|{3}{B}{B}|Legendary Creature - Human Advisor|3|4|When Director Krennic enters the battlefield, create two 1/1 black Trooper creature tokens.$When Director Krennic leaves the battlefield, destroy target basic land.|
+Force Protection|Star Wars|304|C|{W}|Instant|||Target creature you control gains protection from color of your choice until end of turn. Scry 1.|
+Gerrera's Revolutionary|Star Wars|305|C|{R}|Creature - Barabel Rebel|2|1|Gerrera's Revolutionary attacks each turn if able.|
+Hammerhead Corvette|Star Wars|306|U|{3}{G}|Artifact Creature - Rebel Starship|3|3|Spaceflight$Whenever Hammerhead Corvette attacks, you may untap target Starship creature defending player controls and have that creature block Hammerhead Corvette this turn if able.|
+Imperial Hovertank|Star Wars|307|U|{4}{W}{B}|Artifact Creature - Trooper Construct|4|4|Whenever a Trooper creature you control attacks, defending player loses 1 life and you gain 1 life.|
+Jyn Erso and Cassian Andor|Star Wars|308|R|{2}{R}{W}|Legendary Creature - Human Rebel|4|4|At the beginning of combat on your turn, target creature gets +1/+0 and gains haste until end of turn.|
+Occupation|Star Wars|309|U|{W}{B}|Enchantment|||Creatures your opponents control enter the battlefield tapped.${W}{B}: Target creature can't attack or block this turn, and its activated abilities can't be activated until end of turn.|
+Resistance|Star Wars|310|U|{R}{W}|Enchantment|||Whenever a creature enters the battlefield under your control, Resistance deals 1 damage to each opponent.${R}{W}: Target creature gains haste until end of turn and must attack or block this turn if able.|
+Thermal Detonator|Star Wars|311|C|{1}|Artifact|||{2}, Sacrifice Thermal Detonator: Thermal Detonator deals 2 damage to target creature without spaceflight or target player.|
+TIE Striker|Star Wars|312|C|{1}{B}|Artifact Creature - Starship|2|1|Spaceflight|
+U-Wing|Star Wars|313|U|{2}{U}|Artifact Creature - Rebel Starship|2|2|Spaceflight$As long as U-Wing is tapped, it gets +1/+0.$As long as U-Wing is untapped, it gets +0/+1.|
+Vader's Command|Star Wars|314|R|{2}{B}{B}|Instant|||Choose two -$  Counter target spell unless its controller pays 5 life.$  Destroy target planeswalker.$  Destroy target nonartifact creature.$  Gain 5 life.|
+Astromech Droid|Star Wars|400|C|{W}|Artifact Creature - Droid|0|1|{T}: Target starship creature you control gets +1/+1 and gains vigilance until end of turn.$Repair 4|
+Buried Ruin|Star Wars|401|C||Land|||{T}: Add {1} to your mana pool.${2}, {T}, Sacrifice Buried Ruin: Return target artifact card from your graveyard to your hand.|
+Finn|Star Wars|402|U|{3}{G}|Legendary Creature - Human Trooper Soldier|3|3|Whenever Finn or another nontoken creature you control enters the battlefield under your control, you gain 1 life for each nontoken creature you control.|
+Flame Trooper|Star Wars|403|C|{2}{R}|Creature - Human Trooper|2|2|Trooper creatures you control have menace.|
+Force Stasis|Star Wars|404|C|{1}{U}|Instant|||Choose one -$  Tap target creature. It doesn't untap during its controller's next untap step.$  Return target instant or sorcery spell you don't control to its owner's hand.|
+General Hux|Star Wars|405|U|{3}{B}|Legendary Creature - Human Advisor|3|3|Whenever General Hux or another nontoken creature enters the battlefield under your control, until end of turn, target creature gains "{B}: This creature gets +1/+1 until end of turn."|
+Kylo Ren|Star Wars|406|M|{1}{U}{B}{R}|Legendary Creature - Human Sith|3|3|Haste, first strike$Kylo Ren attacks each turn if able.$Whenever Kylo Ren attacks, it gets +1/+0 for each creature in your graveyard and you may tap target creature defending player controls.|
+Outer Rim Gang|Star Wars|407|C|{2}{B}{R}{G}|Creature - Human Rogue Hunter|4|4|When Outer Rim Gang enters the battlefield, each creature with a bounty counter on it gets -2/-2 until end of turn.|
+Poe Dameron|Star Wars|408|U|{3}{W}|Legendary Creature - Human Soldier|3|3|Whenever Poe Dameron or another nontoken creature enters the battlefield under your control, starship creatures you control get +1/+1 until end of turn.|
+Rathtar|Star Wars|409|C|{2}{R}{G}|Creature - Beast|4|4|{5}{G}{G}: Monstrosity 2.$When Rathtar becomes monstrous, any number of target creatures must block it this turn if able.|
+Rey|Star Wars|410|R|{G}{W}{U}|Legendary Creature - Human Knight|3|3|Vigilance, first strike$Whenever Rey enters or leaves the battlefield, reveal the top card of target player's library. You gain life equal to that card's converted mana cost.|
+Riot Trooper|Star Wars|411|C|{2}{W}|Creature - Human Trooper|2|2|Each trooper creature you control can block an additional creature each combat.|
+Salvage Trader|Star Wars|412|C|{3}{U}|Creature - Crolute|2|3|{T}: Exchange control of target artifact you control and target artifact an opponent controls with the same converted mana cost.|
+Sins of the Father|Star Wars|413|C|{1}{B}|Sorcery|||Exile target player's graveyard. That player loses 1 life for each instant or sorcery card exiled this way.|
+Upsilon-class Shuttle|Star Wars|414|C|{5}|Artifact Creature - Starship|2|3|Spaceflight$Whenever Upsilon-class Shuttle attacks, target creature you control gains spaceflight until end of turn.|
+Canto Bight Enforcer|Star Wars|500|U|{1}{B}|Creature - Human Hunter|2|2|When Canto Bight Enforcer enters the battlefield, you may put a bounty counter on target creature.$Bounty - Whenever a creature an opponent controls with a bounty counter on it dies, put a +1/+1 counter on Canto Bight Enforcer.|
+Cantonica Casino|Star Wars|501|R|{2}|Artifact|||{T}: Roll two six-sided dice. If you roll doubles, gain 10 life. Otherwise, lose 1 life.|
+Captain Phasma|Star Wars|502|R|{4}{W}|Legendary Creature - Human Trooper|4|4|Nontoken Trooper creatures you control have "When this creature enters the battlefield, creature 1/1/ white Trooper creature token."${W}{U}{B}{R}{G}: Search your library for a Trooper creature card, reveal it, put it into your hand, then shuffle your library.|
+Code Slice|Star Wars|503|C|{R}|Sorcery|||Put a bounty counter on target creature.$Artifact creatures with bounty counters on them can't block this turn.|
+Delay Tactic|Star Wars|504|C|{1}{U}|Instant|||Choose one -$  Creatures you control gain hexproof until end of turn.$  Creatures target opponent controls don't untap during his or her next untap step.|
+Fathier|Star Wars|505|C|{2}{R}{R}|Creature - Beast|3|3|Haste${4}{R}{R}: Monstrosity 2.|
+First Order Dreadnought|Star Wars|506|M|{4}{B}{B}|Artifact Creature - Starship|5|6|Spaceflight${2}{B}, {T}: Destroy target creature.|
+Force Projection|Star Wars|507|R|{1}{U}{U}|Sorcery|||Create a token that is a copy of target creature except that it is an Illusion in addition to its other types and gains "When this creature becomes the target of a spell, sacrifice it."$Scry 2.|
+Force Telepathy|Star Wars|508|C|{UB}|Instant|||Target player reveals his or her hand.$Scry 2|
+Glorious Charge|Star Wars|509|C|{1}{W}|Instant|||Creatures you control get +1/+1 until end of turn.|
+Inspire|Star Wars|510|C|{1}{U}|Instant|||Untap target creature.$Draw a card.|
+Luke Skywalker, the Last Jedi|Star Wars|511|M|{2}{G}{W}|Legendary Planeswalker - Luke|||+1: Put two +1/+1 counters on up to one target creature.$-3: Put target noncreature permanent on top of its owner's library.$-6: You get an emblem with "Prevent all damage that would be dealt to you during combat." Exile Luke Skywalker, the Last Jedi.|
+Mouse Droid|Star Wars|512|C|{1}{U}|Artifact Creature - Droid|0|1|When Mouse Droid dies, draw a card.$Repair 3|
+Porg Nest|Star Wars|513|U|{2}{G}|Creature - Bird|0|2|Defender$At the beginning of your upkeep, create a 0/1 green Bird creature token named Porg with "{G}: Monstrosity 1."|
+Praetorian Trooper|Star Wars|514|R|{3}{R}|Creature - Human Trooper|2|2|Trooper creatures you control have double strike.|
+Resistance Bomber|Star Wars|515|U|{3}{R}|Artifact Creature - Rebel Starship|2|2|Spaceflight$Resistance Bomber enters the battlefield with a charge counter on it.$Remove a charge counter from Resistance Bomber: Resistance Bomber deals 5 damage to target creature. Activate this ability only if Resistance Bomber is attacking.|
+Sai Tok|Star Wars|516|U|{B}{B}|Instant|||Destroy target creature or planeswalker if it has converted mana cost 4 or less.|
+Supreme Leader Snoke|Star Wars|517|M|{U}{B}{R}|Legendary Planeswalker - Snoke|||+1: Put a loyalty counter on Supreme Leader Snoke for each life lost by all opponents from noncombat sources this turn.$-1: Draw a card and lose 1 life.$-X: Gain control of target creature with converted mana cost X. Untap that creature. It gains haste. Sacrifice that creature at the beginning of the next end step.|
+TIE Silencer|Star Wars|518|R|{1}{B}{R}|Artifact Creature - Starship|2|2|Haste$Spaceflight$Whenever TIE Silencer attacks, it deals 1 damage to defending player and 1 damage to up to one target creature that player controls.|
+Vulptex|Star Wars|519|C|{1}{W}|Creature - Fox|1|1|When Vulptex enters the battlefield, put a +1/+1 counter on target creature.|
+Afterburn|Star Wars|600|C|{R}|Instant|||Choose One -$  Target creature gains haste and first strike until end of turn.$  Remove target creature from combat.|
+Chewbacca, the Beast|Star Wars|601|R|{1}{G}{G}|Legendary Creature - Wookie Warrior|3|3|Partner with Han Solo, Scrumrat$Whenever Chewbacca, the Beast attacks, another target attacking creature you control gains indestructible until end of turn.|
+Conscription|Star Wars|602|U|{2}{U}{U}|Sorcery|||Gain control of target creature with power 2 or less. It becomes a Trooper in addition to its other types.|
+Corellian Gunship|Star Wars|603|C|{R}|Artifact Creature - Starship|1|1|Spaceflight$When Corellian Gunship enters the battlefield, it deals 1 damage to target player or planeswalker.|
+Despair|Star Wars|604|U|{B}{B}|Instant|||Each opponent sacrifices a creature.|
+Droid Uprising|Star Wars|605|U|{2}{W}{W}|Instant|||Tap all nonartifact creatures.$Create two colorless 1/1 Droid artifact creature tokens.|
+Dryden Vos|Star Wars|606|R|{1}{B}{R}|Legendary Creature - Human Rogue|2|3|Menace$When Dryden Vos enters the battlefield, put a bounty counter on target creature.$Bounty - Whenever a creature an opponent controls with a bounty counter on it dies, Dryden Vos deals 2 damage to any target.|
+Enfys Nest|Star Wars|607|M|{G}{W}|Legendary Creature - Human Rebel|2|1|Vigilance$Whenever Enfys Nest enters the battlefield, you may exile target creature an opponent controls. If you do, that player gains life equal to that creature's power.|
+Gamble|Star Wars|608|R|{R}|Sorcery|||Search you library for a card, put that card into your hand, discard a card at random, then shuffle your library.|
+Han Solo, Scrumrat|Star Wars|609|R|{2}{W}|Legendary Creature - Human Rogue|2|2|Partner with Chewbacca, the Beast$R: Han Solo, Scrumrat gains first strike until end of turn.$Whenever Han Solo, Scrumrat deals damage during your turn, put a +1/+1 counter on another target creature you control.|
+Kalevan Star Yacht|Star Wars|610|U|{3}{B}|Artifact Creature - Starship|2|3|Spaceflight$When Kalevan Star Yacht enters the battlefield, lose 1 life, draw a card, and put a bounty counter on up to one target creature.|
+Maelstrom Blockade|Star Wars|611|C|{2}{WB}|Instant|||Exile target attacking creature.|
+Mud Trooper|Star Wars|612|U|{B}|Creature - Human Trooper|1|1|Trooper creatures you control have "2: This creature gets +1/+1 until end of turn."|
+Range Trooper|Star Wars|613|U|{3}{W}|Creature - Human Trooper|2|2|Trooper creatures you control have "When this creature enters that battlefield, you may exile target creature. Return that creature to the battlefield at the beginning of the next end step."|
+Tobias Beckett|Star Wars|614|R|{3}{B}|Legendary Creature - Human Hunter|4|3|When Tobias Becket enters the battlefield, put a bounty counter on target creature an opponent controls.$Bounty - Whenever a creature an opponent controls with a bounty counter on it dies, exile the top card of that player's library. You may cast cards exiled this way and spend mana as though it were mana of any type to cast that spell.|
+Underground Forum|Star Wars|615|U||Land|||T: Add {1}.${1}, {T}: Add {B}, {R}, or {G}.${2}, {T}: Put a bounty counter on target creature.|