Fold DeckCard into BaseCard for now

server/swu/game/Deck.ts

@@ -4,17 +4,16 @@ import { BaseLocationCard } from './card/baseLocationCard';
 import { LeaderCard } from './card/leaderCard';
 import BaseCard from './card/basecard';
 import { cards } from './cards';
-import DeckCard from './card/deckcard';
 import Player from './player';
 
 export class Deck {
     constructor(public data: any) {}
 
     prepare(player: Player) {
         const result = {
-            deckCards: [] as DeckCard[],
+            deckCards: [] as BaseCard[],
             outOfPlayCards: [],
-            outsideTheGameCards: [] as DeckCard[],
+            outsideTheGameCards: [] as BaseCard[],
             base: undefined as BaseLocationCard | undefined,
             leader: undefined as LeaderCard | undefined,
             allCards: [] as BaseCard[]
@@ -23,9 +22,9 @@ export class Deck {
         //deck
         for (const { count, card } of this.data.deckCards ?? []) {
             for (let i = 0; i < count; i++) {
-                const CardConstructor = cards.get(card.id) ?? DeckCard;
+                const CardConstructor = cards.get(card.id) ?? BaseCard;
                 // @ts-ignore
-                const deckCard: DeckCard = new CardConstructor(player, card);
+                const deckCard: BaseCard = new CardConstructor(player, card);
                 deckCard.location = Locations.Deck;
                 result.deckCards.push(deckCard);
             }
@@ -55,9 +54,9 @@ export class Deck {
         }
 
         for (const cardData of this.data.outsideTheGameCards ?? []) {
-            const CardConstructor = cards.get(cardData.id) ?? DeckCard;
+            const CardConstructor = cards.get(cardData.id) ?? BaseCard;
             // @ts-ignore
-            const card: DeckCard = new CardConstructor(player, cardData);
+            const card: BaseCard = new CardConstructor(player, cardData);
             card.location = Locations.OutsideTheGame;
             result.outsideTheGameCards.push(card);
         }

server/swu/game/Interfaces.ts

@@ -2,7 +2,6 @@ import type { AbilityContext } from './AbilityContext';
 import type { TriggeredAbilityContext } from './TriggeredAbilityContext';
 import type { GameAction } from './gameActions/GameAction';
 import type BaseCard = require('./card/basecard');
-import type DeckCard = require('./card/deckcard');
 import type CardAbility = require('./CardTextAbility');
 import type { AttackProperties } from './gameActions/AttackAction';
 import type { Players, TargetModes, CardTypes, Locations, EventNames, Phases } from './Constants';
@@ -39,8 +38,8 @@ interface TargetAbility extends BaseTarget {
 export interface InitiateAttack extends AttackProperties {
     opponentChoosesAttackTarget?: boolean;
     opponentChoosesAttacker?: boolean;
-    attackerCondition?: (card: DeckCard, context: TriggeredAbilityContext) => boolean;
-    targetCondition?: (card: DeckCard, context: TriggeredAbilityContext) => boolean;
+    attackerCondition?: (card: BaseCard, context: TriggeredAbilityContext) => boolean;
+    targetCondition?: (card: BaseCard, context: TriggeredAbilityContext) => boolean;
 }
 
 // interface TargetToken extends BaseTarget {
@@ -107,7 +106,7 @@ type EffectArg =
     | number
     | string
     | Player
-    | DeckCard
+    | BaseCard
     | { id: string; label: string; name: string; facedown: boolean; type: CardTypes }
     | EffectArg[];
 

server/swu/game/PlayableLocation.ts

@@ -1,16 +1,15 @@
 import type { Locations, PlayTypes } from './Constants';
-import type DeckCard from './card/deckcard';
 import type Player from './player';
 
 export class PlayableLocation {
     public constructor(
         public playingType: PlayTypes,
         private player: Player,
         private location: Locations,
-        public cards = new Set<DeckCard>()
+        public cards = new Set<BaseCard>()
     ) {}
 
-    public contains(card: DeckCard) {
+    public contains(card: BaseCard) {
         if (this.cards.size > 0 && !this.cards.has(card)) {
             return false;
         }

server/swu/game/attack/Attack.ts

@@ -1,7 +1,6 @@
 import { GameObject } from '../GameObject';
 import { EffectNames, EventNames, Locations, isArena } from '../Constants';
 import { EventRegistrar } from '../EventRegistrar';
-import type DeckCard from '../card/deckcard';
 import type Game from '../game';
 import type Player from '../player';
 import { AbilityContext } from '../AbilityContext';
@@ -23,20 +22,20 @@ type StatisticTotal = typeof InvalidStats | number;
 export class Attack extends GameObject {
     #bidFinished = false;
     #modifiers = new WeakMap<Player, AttackAbilities>();
-    loser?: DeckCard[];
+    loser?: BaseCard[];
     losingPlayer?: Player;
     previousAttack?: Attack;
-    winner?: DeckCard[];
+    winner?: BaseCard[];
     winningPlayer?: Player;
     finalDifference?: number;
     private eventRegistrar?: EventRegistrar;
 
     constructor(
         public game: Game,
-        public attacker: DeckCard,
-        public target: DeckCard,
+        public attacker: BaseCard,
+        public target: BaseCard,
         public properties: {
-            targetCondition?: (card: DeckCard, context: AbilityContext) => boolean;
+            targetCondition?: (card: BaseCard, context: AbilityContext) => boolean;
         },
         public attackingPlayer = attacker.controller
     ) {
@@ -55,7 +54,7 @@ export class Attack extends GameObject {
         return this.loser?.[0].controller;
     }
 
-    get participants(): undefined | DeckCard[] {
+    get participants(): undefined | BaseCard[] {
         return [...[this.attacker], this.target];
     }
 
@@ -138,7 +137,7 @@ export class Attack extends GameObject {
         }
     }
 
-    #getTotalPower(involvedUnit: DeckCard, player: Player): StatisticTotal {
+    #getTotalPower(involvedUnit: BaseCard, player: Player): StatisticTotal {
         if (!isArena(involvedUnit.location)) {
             return InvalidStats;
         }