CardTraitChanges: as Record

forge-game/src/main/java/forge/game/card/CardTraitChanges.java

@@ -1,6 +1,5 @@
 package forge.game.card;
 
-import com.google.common.collect.Lists;
 import forge.game.replacement.ReplacementEffect;
 import forge.game.spellability.SpellAbility;
 import forge.game.staticability.StaticAbility;
@@ -8,74 +7,45 @@ import forge.game.trigger.Trigger;
 
 import java.util.Collection;
 import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
 
-public class CardTraitChanges implements Cloneable {
-
-    private List<Trigger> triggers = Lists.newArrayList();
-    private List<ReplacementEffect> replacements = Lists.newArrayList();
-    private List<SpellAbility> abilities = Lists.newArrayList();
-    private List<StaticAbility> staticAbilities = Lists.newArrayList();
-
-    private List<SpellAbility> removedAbilities = Lists.newArrayList();
-
-    private boolean removeAll = false;
-    private boolean removeNonMana = false;
-
-    public CardTraitChanges(Collection<SpellAbility> spells, Collection<SpellAbility> removedAbilities,
-            Collection<Trigger> trigger, Collection<ReplacementEffect> res, Collection<StaticAbility> st,
-            boolean removeAll, boolean removeNonMana) {
-        if (spells != null) {
-            this.abilities.addAll(spells);
-        }
-        if (removedAbilities != null) {
-            this.removedAbilities.addAll(removedAbilities);
-        }
-        if (trigger != null) {
-            this.triggers.addAll(trigger);
-        }
-        if (res != null) {
-            this.replacements.addAll(res);
-        }
-        if (st != null) {
-            this.staticAbilities.addAll(st);
-        }
-
-        this.removeAll |= removeAll;
-        this.removeNonMana |= removeNonMana;
-    }
+public record CardTraitChanges(Collection<SpellAbility> abilities, Collection<SpellAbility> removedAbilities,
+        Collection<Trigger> triggers, Collection<ReplacementEffect> replacements, Collection<StaticAbility> staticAbilities,
+        boolean removeAll, boolean removeNonMana) {
 
     /**
      * @return the triggers
      */
     public Collection<Trigger> getTriggers() {
-        return triggers;
+        return Objects.requireNonNullElse(triggers, List.of());
     }
     /**
      * @return the replacements
      */
     public Collection<ReplacementEffect> getReplacements() {
-        return replacements;
+        return Objects.requireNonNullElse(replacements, List.of());
     }
 
     /**
      * @return the abilities
      */
     public Collection<SpellAbility> getAbilities() {
-        return abilities;
+        return Objects.requireNonNullElse(abilities, List.of());
     }
 
     /**
      * @return the abilities
      */
     public Collection<SpellAbility> getRemovedAbilities() {
-        return removedAbilities;
+        return Objects.requireNonNullElse(removedAbilities, List.of());
     }
 
     /**
      * @return the staticAbilities
      */
     public Collection<StaticAbility> getStaticAbilities() {
-        return staticAbilities;
+        return Objects.requireNonNullElse(staticAbilities, List.of());
     }
 
     public boolean isRemoveAll() {
@@ -87,53 +57,30 @@ public class CardTraitChanges implements Cloneable {
     }
 
     public CardTraitChanges copy(Card host, boolean lki) {
-        try {
-            CardTraitChanges result = (CardTraitChanges) super.clone();
-
-            result.abilities = Lists.newArrayList();
-            for (SpellAbility sa : this.abilities) {
-                result.abilities.add(sa.copy(host, lki));
-            }
-            result.removedAbilities = Lists.newArrayList();
-            for (SpellAbility sa : this.removedAbilities) {
-                result.removedAbilities.add(sa.copy(host, lki));
-            }
-
-            result.triggers = Lists.newArrayList();
-            for (Trigger tr : this.triggers) {
-                result.triggers.add(tr.copy(host, lki));
-            }
-
-            result.replacements = Lists.newArrayList();
-            for (ReplacementEffect re : this.replacements) {
-                result.replacements.add(re.copy(host, lki));
-            }
-
-            result.staticAbilities = Lists.newArrayList();
-            for (StaticAbility sa : this.staticAbilities) {
-                result.staticAbilities.add(sa.copy(host, lki));
-            }
-
-            return result;
-        } catch (final Exception ex) {
-            throw new RuntimeException("CardTraitChanges : clone() error", ex);
-        }
+        return new CardTraitChanges(
+                this.getAbilities().stream().map(sa -> sa.copy(host, lki)).collect(Collectors.toList()),
+                this.getRemovedAbilities().stream().map(sa -> sa.copy(host, lki)).collect(Collectors.toList()),
+                this.getTriggers().stream().map(tr -> tr.copy(host, lki)).collect(Collectors.toList()),
+                this.getReplacements().stream().map(tr -> tr.copy(host, lki)).collect(Collectors.toList()),
+                this.getStaticAbilities().stream().map(st -> st.copy(host, lki)).collect(Collectors.toList()),
+                removeAll, removeNonMana
+        );
     }
 
     public void changeText() {
-        for (SpellAbility sa : this.abilities) {
+        for (SpellAbility sa : this.getAbilities()) {
             sa.changeText();
         }
 
-        for (Trigger tr : this.triggers) {
+        for (Trigger tr : this.getTriggers()) {
             tr.changeText();
         }
 
-        for (ReplacementEffect re : this.replacements) {
+        for (ReplacementEffect re : this.getReplacements()) {
             re.changeText();
         }
 
-        for (StaticAbility sa : this.staticAbilities) {
+        for (StaticAbility sa : this.getStaticAbilities()) {
             sa.changeText();
         }
     }