setSdkCard(sdkCard, showBaseState, actionToShowStateFor, actionEventTypeToShowStateFor) {
    // update card if different
    if (this.sdkCard != sdkCard) {
      // reset last card
      if (this.sdkCard != null) {
        if (this.cardSprite != null) {
          this.cardSprite.destroy();
          this.cardSprite = null;
        }
        if (this._signatureCardRing != null) {
          this._signatureCardRing.destroy();
          this._signatureCardRing = null;
        }
        if (this._signatureCardSprite != null) {
          this._signatureCardSprite.destroy();
          this._signatureCardSprite = null;
        }
        if (this._unitShadow != null) {
          this._unitShadow.fadeToInvisible();
        }
        this.stopShowingPrismatic();
      }

      // update card always after resetting last and before showing new
      this._super(sdkCard);

      // reset visual state for new card
      this.resetShow();
      this._containerNode.setVisible(false);

      if (sdkCard != null) {
        if (showBaseState == null) { showBaseState = true; }
        this.setShowBaseState(showBaseState);
        this.setActionToShowStateFor(actionToShowStateFor);
        this.setActionEventTypeToShowStateFor(actionEventTypeToShowStateFor);

        const isPrismatic = SDK.Cards.getIsPrismaticCardId(sdkCard.getId());

        Promise.all([
          this.whenRequiredResourcesReady(),
          this.whenResourcesReady(this.getCardResourceRequestId()),
        ])
          .spread((requiredRequestId, cardResourceRequestId) => {
            if (!this.getAreResourcesValid(requiredRequestId) || !this.getAreResourcesValid(cardResourceRequestId)) return; // load invalidated or resources changed

            this._containerNode.setVisible(true);
            /*
           // TODO: per faction card backgrounds
           var factionBgIdentifier = sdkCard.factionId == SDK.Factions.Neutral ? "neutral" : "f"+sdkCard.factionId;
           var bgSpriteIdentifier;
           if (sdkCard instanceof SDK.Entity) {
           bgSpriteIdentifier = RSX["card_" + factionBgIdentifier + "_unit"].img;
           } else if (sdkCard instanceof SDK.Artifact) {
           bgSpriteIdentifier = RSX["card_" + factionBgIdentifier + "_artifact"].img;
           } else {
           bgSpriteIdentifier = RSX["card_" + factionBgIdentifier + "_spell"].img;
           }
           */
            // neutral card background
            let bgSpriteIdentifier;
            if (sdkCard instanceof SDK.Entity) {
              bgSpriteIdentifier = isPrismatic ? RSX.card_neutral_prismatic_unit.img : RSX.card_neutral_unit.img;
            } else if (sdkCard instanceof SDK.Artifact) {
              bgSpriteIdentifier = isPrismatic ? RSX.card_neutral_prismatic_artifact.img : RSX.card_neutral_artifact.img;
            } else {
              bgSpriteIdentifier = isPrismatic ? RSX.card_neutral_prismatic_spell.img : RSX.card_neutral_spell.img;
            }
            this.cardBackgroundSpriteIdentifier = bgSpriteIdentifier;
            this.cardBackgroundSprite.setTexture(cc.textureCache.getTextureForKey(bgSpriteIdentifier));

            // card options
            const cardOptions = _.extend({}, sdkCard.getCardOptions());
            cardOptions.spriteIdentifier = sdkCard.getAnimResource() && sdkCard.getAnimResource().idle;
            cardOptions.antiAlias = false;

            // card sprite
            this.cardSprite = GlowSprite.create(cardOptions);
            if (cardOptions.scale == null) {
              this.cardSprite.setScale(CONFIG.SCALE);
            }
            this._containerNodeFront.addChild(this.cardSprite, 0);

            let cardSpritePosition;
            if (sdkCard instanceof SDK.Unit) {
              if (sdkCard.isOwnedByPlayer2()) {
                this.cardSprite.setFlippedX(true);
              }

              this.cardSprite.setAnchorPoint(cc.p(0.5, 0));
              cardSpritePosition = cc.p(0.0, 8);
            } else {
              cardSpritePosition = cc.p(0.0, 75);
            }

            const cardSpriteOffset = cardOptions.offset;
            if (cardSpriteOffset != null) {
              cardSpritePosition.x += cardSpriteOffset.x;
              cardSpritePosition.y += cardSpriteOffset.y;
            }
            this.cardSprite.setPosition(cardSpritePosition);

            // shadow
            if (!(sdkCard instanceof SDK.Tile)) {
              this._unitShadow.fadeTo(0.0, (SDK.Cards.getIsPrismaticCardId(sdkCard.getId()) ? 200.0 : 150.0));
              if (sdkCard instanceof SDK.Unit) {
                this._unitShadow.setPosition(0.0, 43);
              } else {
                this._unitShadow.setPosition(0.0, 45);
              }
            }

            if (sdkCard instanceof SDK.Entity && sdkCard.getWasGeneral()) {
              // hide mana sprites
              this._manaGemSprite.setVisible(false);

              const referenceSignatureCard = sdkCard.getReferenceSignatureCard();
              if (referenceSignatureCard != null) {
                const signatureCardPosition = this._manaGemSprite.getPosition();
                signatureCardPosition.x += 3.0;
                signatureCardPosition.y -= 3.0;

                // signature card ring
                this._signatureCardRing = BaseSprite.create(RSX.signature_card_ring_small.img);
                this._signatureCardRing.setPosition(signatureCardPosition);
                this._staticContainerNodeFront.addChild(this._signatureCardRing);

                // signature card sprite
                const signatureCardOptions = _.extend({}, referenceSignatureCard.getCardOptions());
                signatureCardOptions.spriteIdentifier = referenceSignatureCard.getAnimResource() && referenceSignatureCard.getAnimResource().idle;
                signatureCardOptions.antiAlias = false;
                this._signatureCardSprite = BaseSprite.create(signatureCardOptions);
                this._signatureCardSprite.setPosition(signatureCardPosition);
                this._staticContainerNodeFront.addChild(this._signatureCardSprite);
              }
            } else {
              // show mana sprites
              this._manaGemSprite.setVisible(true);
            }

            if (!CONFIG.SHOW_PRISMATIC_ONLY_ON_INSPECT
            && !(sdkCard instanceof SDK.Tile)
            && SDK.Cards.getIsPrismaticCardId(sdkCard.getId())) {
              this.showPrismatic();
            }

            // rarity
            if (this.raritySprite != null) {
              this.raritySprite.setVisible(false);
              this.raritySprite = null;
            }

            switch (sdkCard.rarityId) {
            case SDK.Rarity.Common:
              this.raritySprite = this._raritySpriteCommon;
              break;
            case SDK.Rarity.Rare:
              this.raritySprite = this._raritySpriteRare;
              break;
            case SDK.Rarity.Epic:
              this.raritySprite = this._raritySpriteEpic;
              break;
            case SDK.Rarity.Legendary:
              this.raritySprite = this._raritySpriteLegendary;
              break;
            case SDK.Rarity.Mythron:
              this.raritySprite = this._raritySpriteMythron;
              break;
            }

            if (this.raritySprite != null) {
              this.raritySprite.setVisible(true);
            }

            // glow for select reveal
            if (this._outlineGlow != null) {
              this._outlineGlow.setVisible(false);
            }
            if (this._outlineGlowAlt != null) {
              this._outlineGlowAlt.setVisible(false);
            }

            if (sdkCard instanceof SDK.Entity) {
              this._outlineGlow = this._outlineGlowUnit;
              this._outlineGlowAlt = this._outlineGlowUnitAlt;
              this._outlineGlowBlurred = this._outlineGlowUnitBlurred;
            } else if (sdkCard instanceof SDK.Artifact) {
              this._outlineGlow = this._outlineGlowArtifact;
              this._outlineGlowAlt = this._outlineGlowArtifactAlt;
              this._outlineGlowBlurred = this._outlineGlowArtifactBlurred;
            } else {
              this._outlineGlow = this._outlineGlowSpell;
              this._outlineGlowAlt = this._outlineGlowSpellAlt;
              this._outlineGlowBlurred = this._outlineGlowSpellBlurred;
            }

            // start animated elements
            this.showInactiveAnimState();
          });

        if (sdkCard instanceof SDK.Entity && sdkCard.getWasGeneral()) {
          // hide mana label
          this.manaLabel.setVisible(false);
        } else {
          // show mana label
          this.manaLabel.setVisible(true);
        }

        // card name
        if (sdkCard.getName().length >= 23) {
          this.cardNameLabel.setFontSize(12);
        } else {
          this.cardNameLabel.setFontSize(14);
        }
        this.cardNameLabel.setString(sdkCard.getName().toUpperCase(), true);

        // race and type
        const raceId = sdkCard.getRaceId();
        const race = SDK.RaceFactory.raceForIdentifier(raceId);
        let raceName = race && race.name;
        const cardType = sdkCard.getType();
        let cardTypeColor;
        if (SDK.CardType.getIsArtifactCardType(cardType)) {
          cardTypeColor = { r: 237, g: 209, b: 68 };
        } else {
          cardTypeColor = { r: 144, g: 202, b: 207 };
        }
        if (!raceName) {
          if (SDK.CardType.getIsArtifactCardType(cardType)) {
            raceName = i18next.t('common.artifact_label');
          } else if (SDK.CardType.getIsSpellCardType(cardType)) {
            raceName = i18next.t('common.spell_label');
          } else if (SDK.CardType.getIsTileCardType(cardType)) {
            raceName = i18next.t('common.tile_label');
          } else if (sdkCard.getIsGeneral()) {
            raceName = i18next.t('common.general_label');
          } else {
            raceName = i18next.t('common.unit_label');
          }
        }
        this.cardTypeLabel.setString(raceName.toUpperCase(), true);
        this.cardTypeLabel.setFontFillColor(cardTypeColor);

        // description
        const description = sdkCard.getDescription(CONFIG.FORMATTING_ENGINE);
        let descriptionLength = description.length;
        if (description.includes('\n')) {
          descriptionLength += 15;
        }
        if (descriptionLength >= 110) {
          this.cardDescriptionLabel.setFontSize(11);
        } else {
          this.cardDescriptionLabel.setFontSize(13);
        }
        this.cardDescriptionLabel.setString(sdkCard.getDescription(CONFIG.FORMATTING_ENGINE), true);

        // faction name
        const faction = SDK.FactionFactory.factionForIdentifier(sdkCard.getFactionId());
        const factionName = faction ? faction.name.toUpperCase() : '';
        this.factionNameLabel.setString(factionName, true);

        // stats
        this.updateStats();
      }
    }
  }
Binds a skd card to this node, populating all sprites and visual data.
@param {SDK.Card} sdkCard
@param {Boolean} [showBaseState=true]
@param {Action} [actionToShowStateFor=null]
@param {String} [actionEventTypeToShowStateFor=null]