[Unity][C#]カードゲームにおいて、デッキ外から召喚するクリーチャーのPrefab描画をしたい

※長文となってしまったため、分けて投稿します

投稿に慣れていないため、分かりづらい点が多々あるかと思いますがよろしくお願い致します。
過不足があれば随時補足します。

使用アセット

CCGKit
マニュアル：https://www.ccgkit.com/wiki/index.php?title=Main_Page

実現したいこと

上記アセットを利用して、カードゲーム「ハースストーン」のコピーゲームを作成したいと考えています。
カードの能力拡張を行っているのですが、以下の点において作業が停滞しています。

・特定のカード(以下、カードAとします)を手札からボードに召喚(移動)した際、指定したカード(以下、トークンBとします)を別途、デッキ外から召喚する機能を実装したい

現状のクラス構成

各カードの情報はUnityのエディタ拡張により、JSON形式で保存しております。
以下に、あるカードの例を記します。

JSON
1            {
2                "cardTypeId": 0,
3                "name": "カード名を表す文字列(実際はUnicode表記です)",
4                "costs": [
5                    {
6                        "statId": 1,
7                        "value": 2,
8                        "$type": "CCGKit.PayResourceCost"
9                    }
10                ],
11                "properties": [
12                    {
13                        "value": "能力の内容を表現するための文字列(実際はUnicode表記です)",
14                        "name": "Text",
15                        "$type": "CCGKit.StringProperty"
16                    },
17                    {
18                        "value": "Creature",
19                        "name": "Picture",
20                        "$type": "CCGKit.StringProperty"
21                    },
22                    {
23                        "value": 2,
24                        "name": "MaxCopies",
25                        "$type": "CCGKit.IntProperty"
26                    },
27                    {
28                        "value": null,
29                        "name": "Material",
30                        "$type": "CCGKit.StringProperty"
31                    }
32                ],
33                "stats": [
34                    {
35                        "baseValue": 2,
36                        "statId": 0,
37                        "name": "Attack",
38                        "originalValue": 2,
39                        "minValue": 0,
40                        "maxValue": 99,
41                        "modifiers": []
42                    },
43                    {
44                        "baseValue": 3,
45                        "statId": 1,
46                        "name": "Life",
47                        "originalValue": 3,
48                        "minValue": 0,
49                        "maxValue": 99,
50                        "modifiers": []
51                    }
52                ],
53                "keywords": [],
54                "abilities": [
55                    {
56                        "trigger": {
57                            "zoneId": 2,
58                            "$type": "CCGKit.OnCardEnteredZoneTrigger"
59                        },
60                        "name": "heal 2",
61                        "type": "Triggered",
62                        "effect": {
63                            "value": {
64                                "constant": 2,
65                                "$type": "CCGKit.ConstantValue"
66                            },
67                            "duration": 0,
68                            "statId": 1,
69                            "gameZoneId": 2,
70                            "cardTypeId": 0,
71                            "$type": "CCGKit.IncreaseCardStatEffect"
72                        },
73                        "target": {
74                            "conditions": [],
75                            "$type": "CCGKit.TargetCard"
76                        },
77                        "$type": "CCGKit.TriggeredAbility"
78                    }
79                ],
80                "id": 1

これらを読み込み、一枚のカードを描画する処理を組んでいます。
これらの値はRuntimeCardクラスというクラスで管理されており、カードをハンドからボードに移動する際にもこのクラスを利用しているように見えます。

C#
1using System;
2using System.Collections.Generic;
3
4namespace CCGKit
5{
6    /// <summary>
7    /// This class represents a runtime instance of a card.
8    /// このクラスは、カードのランタイムインスタンス(プログラムの実行に必要な部品の集合)を表します。
9    /// </summary>
10    public class RuntimeCard
11    {
12        /// <summary>
13        /// The card identifier of this card.
14        /// カードの固有ID
15        /// </summary>
16        public int cardId;
17
18        /// <summary>
19        /// The instance identifier of this card.
20        /// このカードのインスタンス識別子。
21        /// </summary>
22        public int instanceId;
23
24        /// <summary>
25        /// The stats of this card, indexed by id.
26        /// このカードのスタッツはidで示されます。
27        /// </summary>
28        public Dictionary<int, Stat> stats = new Dictionary<int, Stat>();
29
30        /// <summary>
31        /// The stats of this card, indexed by name.
32        /// このカードのスタッツは名前で示されます。
33        /// card.namedStats["Attack"];みたいな書き方で値を取得できる
34        /// </summary>
35        public Dictionary<string, Stat> namedStats = new Dictionary<string, Stat>();
36
37        /// <summary>
38        /// The keywords of this card.
39        /// カードのキーワード
40        /// </summary>
41        public List<RuntimeKeyword> keywords = new List<RuntimeKeyword>();
42
43        /// <summary>
44        /// The player that owns this card.
45        /// このカードを所有しているプレイヤー。
46        /// </summary>
47        public PlayerInfo ownerPlayer;
48
49        /// <summary>
50        /// The type of this card.
51        /// カードタイプ
52        /// ミニオン or スペル
53        /// </summary>
54        public CardType cardType
55        {
56            get
57            {
58                var gameConfig = GameManager.Instance.config;
59                var libraryCard = gameConfig.GetCard(cardId);
60                return gameConfig.cardTypes.Find(x => x.id == libraryCard.cardTypeId);
61            }
62        }
63
64        /// <summary>
65        /// The callback that is called when a keyword is added to this card.
66        /// このカードにキーワードが追加されたときに呼び出されるコールバック。
67        /// </summary>
68        public Action<RuntimeKeyword> onKeywordAdded;
69
70        /// <summary>
71        /// The callback that is called when a keyword is removed from this card.
72        /// このカードからキーワードが削除されたときに呼び出されるコールバック。
73        /// </summary>
74        public Action<RuntimeKeyword> onKeywordRemoved;
75
76        /// <summary>
77        /// Adds a keyword to this card.
78        /// このカードにキーワードを追加する
79        /// </summary>
80        /// <param name="keyword">The identifier of the keyword.</param>
81        /// <param name="value">The value of the keyword.</param>
82        public void AddKeyword(int keyword, int value)
83        {
84            var k = keywords.Find(x => x.keywordId == keyword && x.valueId == value);
85            if (k == null)
86            {
87                k = new RuntimeKeyword();
88                k.keywordId = keyword;
89                k.valueId = value;
90                keywords.Add(k);
91                if (onKeywordAdded != null)
92                {
93                    onKeywordAdded(k);
94                }
95            }
96        }
97
98        /// <summary>
99        /// Removes a keyword from this card.
100        /// カードからキーワードを削除する
101        /// </summary>
102        /// <param name="keyword">The identifier of this keyword.</param>
103        /// <param name="value">The value of this keyword.</param>
104        public void RemoveKeyword(int keyword, int value)
105        {
106            var k = keywords.Find(x => x.keywordId == keyword && x.valueId == value);
107            if (k != null)
108            {
109                keywords.Remove(k);
110                if (onKeywordRemoved != null)
111                {
112                    onKeywordRemoved(k);
113                }
114            }
115        }
116
117        /// <summary>
118        /// Returns true if this card has the specified keyword and false otherwise.
119        /// このカードに指定されたキーワードがある場合はtrueを返し、そうでない場合はfalseを返します。
120        /// </summary>
121        /// <param name="name">The name of the keyword.</param>
122        /// <returns>True if this card has the specified keyword; false otherwise.</returns>
123        public bool HasKeyword(string name)
124        {
125            var gameConfig = GameManager.Instance.config;
126            var keywordId = -1;
127            var valueId = -1;
128            foreach (var keyword in gameConfig.keywords)
129            {
130                var selectedValue = keyword.values.FindIndex(x => x.value == name);
131                if (selectedValue != -1)
132                {
133                    keywordId = keyword.id;
134                    valueId = selectedValue;
135                    break;
136                }
137            }
138            var k = keywords.Find(x => x.keywordId == keywordId && x.valueId == valueId);
139            return k != null;
140        }
141    }
142}
143

SAM-tak

2018/04/30 11:43

ご自分で回答をつけてらっしゃいますが、追加情報という意図であればトップの質問文を編集して情報の追加を行うほうが良いと思います（ソースコードが見づら過ぎで…）

imohori708

2018/04/30 12:18

ご指摘ありがとうございます、字数制限のため止む無く分けて投稿してしまいました。回答を2つに分けましたが多少は改善されましたでしょうか。慣れないことが多く、ご指摘ありがたいです。

fiveHundred

2018/05/01 02:28

文字数オーバーするということは、それだけの長文を回答者が読まないといけないということになります。それだと回答しづらくなるので、文字数の範囲内になるように簡素にした方がよろしいかと思います（少なくとも私は回答する気になれないです）。内容を簡素にすることで分かりやすくなり、自己解決できるようになることもあります。

行動規範の内容に同意します

回答4件

追記です。
CardクラスとPopulateWithInfoメソッドそれぞれを下記に記します。
以下、カードクラス。

C#
1using System.Collections.Generic;
2
3using UnityEngine.Assertions;
4
5namespace CCGKit
6{
7    /// <summary>
8    /// This class represents a single card in the game.
9    /// このクラスは、ゲーム内の1枚のカードを表します。
10    /// </summary>
11    public class Card : Resource
12    {
13        /// <summary>
14        /// カードの所属陣営(追加)
15        /// </summary>
16        public static int groupId { get; set; }
17
18        /// <summary>
19        /// The current resource identifier.
20        /// 現在のリソース識別子(カードのユニークID)
21        /// </summary>
22        public static int currentId { get; set; }
23
24        /// <summary>
25        /// The type of this card.
26        /// このカードのタイプ。
27        /// </summary>
28        public int cardTypeId { get; set; }
29
30        /// <summary>
31        /// The name of this card.
32        /// このカードの名前。
33        /// </summary>
34        public string name { get; set; }
35
36        /// <summary>
37        /// The costs of this card.
38        /// このカードのコスト。
39        /// </summary>
40        public List<Cost> costs = new List<Cost>();
41
42        /// <summary>
43        /// The properties of this card.
44        /// このカードの特性。
45        /// </summary>
46        public List<Property> properties = new List<Property>();
47
48        /// <summary>
49        /// The stats of this card.
50        /// このカードのスタッツ情報。
51        /// </summary>
52        public List<Stat> stats = new List<Stat>();
53
54        /// <summary>
55        /// The keywords of this card.
56        /// このカードのキーワード。
57        /// </summary>
58        public List<RuntimeKeyword> keywords = new List<RuntimeKeyword>();
59
60        /// <summary>
61        /// The abilities of this card.
62        /// このカードの能力。
63        /// </summary>
64        public List<Ability> abilities = new List<Ability>();
65
66        /// <summary>
67        /// Constructor.
68        /// </summary>
69        public Card() : base(currentId++)
70        {
71        }
72
73        /// <summary>
74        /// Returns the value of the integer property with the specified name.
75        /// 指定された名前を持つ整数プロパティの値を返します。
76        /// </summary>
77        /// <param name="name">The name of the property.</param>
78        /// <returns>The value of the property.</returns>
79        public int GetIntProperty(string name)
80        {
81            var property = properties.Find(x => x.name == name && x is IntProperty);
82            Assert.IsNotNull(property);
83            return (property as IntProperty).value;
84        }
85
86        /// <summary>
87        /// Returns the value of the string property with the specified name.
88        /// 指定した名前の文字列プロパティの値を返します。
89        /// </summary>
90        /// <param name="name">The name of the property.</param>
91        /// <returns>The value of the property.</returns>
92        public string GetStringProperty(string name)
93        {
94            var property = properties.Find(x => x.name == name && x is StringProperty);
95            Assert.IsNotNull(property);
96            return (property as StringProperty).value;
97        }
98    }
99}
100

続いてPopulateWithInfoメソッド

C#
1    public virtual void PopulateWithInfo(RuntimeCard card)
2    {
3        this.card = card;
4
5        //ゲームの基本設定
6        var gameConfig = GameManager.Instance.config;
7        //カードのID一覧
8        var libraryCard = gameConfig.GetCard(card.cardId);
9        Assert.IsNotNull(libraryCard);
10        //カードの名前
11        nameText.text = libraryCard.name;
12
13        attackStat = card.namedStats["Attack"];
14        healthStat = card.namedStats["Life"];
15        attackText.text = attackStat.effectiveValue.ToString();
16        healthText.text = healthStat.effectiveValue.ToString();
17
18        pictureSprite.sprite = Resources.Load<Sprite>(string.Format("Images/{0}", libraryCard.GetStringProperty("Picture")));
19        var material = libraryCard.GetStringProperty("Material");
20        if (!string.IsNullOrEmpty(material))
21        {
22            pictureSprite.material = Resources.Load<Material>(string.Format("Materials/{0}", material));
23        }
24
25        onAttackStatChangedDelegate = (oldValue, newValue) =>
26        {
27            UpdateStatText(attackText, attackStat);
28        };
29        attackStat.onValueChanged += onAttackStatChangedDelegate;
30
31        onHealthStatChangedDelegate = (oldValue, newValue) =>
32        {
33            UpdateStatText(healthText, healthStat);
34        };
35        healthStat.onValueChanged += onHealthStatChangedDelegate;
36
37        //キーワードについての挙動
38        //属性追加時にいじるとこ(後日要編集)
39        var subtypes = gameConfig.keywords.Find(x => x.name == "Subtypes");
40        var impetus = subtypes.values.FindIndex(x => x.value == "Impetus");
41        var provoke = subtypes.values.FindIndex(x => x.value == "Provoke");
42        foreach (var keyword in libraryCard.keywords)
43        {
44            if (keyword.keywordId == subtypes.id)
45            {
46                if (keyword.valueId == impetus)
47                {
48                    hasImpetus = true;
49                }
50                else if (keyword.valueId == provoke)
51                {
52                    hasProvoke = true;
53                }
54            }
55        }
56
57        if (hasProvoke)
58        {
59            glowSprite.gameObject.SetActive(false);
60            shadowSprite.gameObject.SetActive(false);
61            shieldGlowSprite.gameObject.SetActive(true);
62            shieldShadowSprite.gameObject.SetActive(true);
63            shieldSprite.gameObject.SetActive(true);
64        }
65        SetHighlightingEnabled(false);
66        if (hasImpetus)
67        {
68            StopSleepingParticles();
69            if (ownerPlayer != null)
70            {
71                SetHighlightingEnabled(true);
72                isPlayable = true;
73            }
74        }
75    }

投稿2018/05/01 01:03

編集2018/05/01 01:11

imohori708

総合スコア10

cs
1    //ミニオンをボード上にプレハブ化
2    var boardCreature = Instantiate(boardCreaturePrefab);
3
4    var board = GameObject.Find("PlayerBoard");
5    boardCreature.tag = "PlayerOwned";
6    boardCreature.transform.parent = board.transform;
7    boardCreature.transform.position = new Vector2(1.9f * playerBoardCards.Count, 0);
8    boardCreature.GetComponent<BoardCreature>().ownerPlayer = this;
9    boardCreature.GetComponent<BoardCreature>().PopulateWithInfo(card);
10
11    currentCreature = boardCreature.GetComponent<BoardCreature>();

ここの部分をPopulateToken(Card card)のようなメソッドとしてくくり出して、カードAプレイ時に呼び出してやれば良いような気がします。

投稿2018/04/30 22:23

SAM-tak

総合スコア199

imohori708

2018/04/30 23:47

回答頂きありがとうございます。回答頂いたコードの7行目で引数として与えている変数cardはCradViewクラスです。参考としたコードでは、GUIでマウス左クリック時にぶつかったobjectを判定することによって値を取得してきているため、GUI描画のない、デッキやハンドの外からトークンBを選択することは出来ません。これを上記JSONファイルから読み取った情報のみを利用して、トークンBのCradViewクラスを作成するにはどのようなコードを組めば実現できますでしょうか。

SAM-tak

2018/05/01 00:48

`PlayCard(CardView card)`のなかでCardViewに依存している処理をしているのは`playerHandCards.Remove(card);`の部分や`Destroy(card.gameObject);`の部分だけだと思うので、CardViewではなくCardを渡してほぼ同じことをする処理は書けると思うんですよ。 PlayCardをコピペして別名を付けて、引数をCardにしてみて、文法エラーになったところを消すなり妥当な処理に書き換えるなりすればよいのでは。

SAM-tak

2018/05/01 00:51

なにげにCardで“すべての参照を検索”をしてみると、CCGKitに既にCardからぽんとミニオンを置くコードが既に存在しているかもしれませんが、それは無い、んですよね？

imohori708

2018/05/01 01:14

>なにげにCardで“すべての参照を検索”をしてみるとこちら、確認しましたがCardのみを引数に取ってミニオンをボード上に置く処理はありませんでした。確認が取れたのはRuntimeCardか、あるいはCardViewクラスを引数にしてミニオンを召喚するメソッドのみです。念のため、ソースコードにCardクラスとPopulateWithInfoメソッドをそれぞれ追記しました。「JSONファイルから値を取得して、トリガーとなるカードAの召喚と同時にトークンBを召喚」を実現するため、今一度アドバイス頂けると幸いです。

SAM-tak

2018/05/01 01:17

ではCardからRuntimeCardを生成できればいいと思うんですが、それは無いんですか？

SAM-tak

2018/05/01 01:32

いや、ちがう、PopulateWithInfo(RuntimeCard)は、CardViewのメンバで、これはCardViewをInstantiateした後初期化するためのもの、ですよね？となると、やはりPlayCardを改造してPopulateToken(Card)を作れということではないでしょうか。 PlayCardは何というクラスのメンバメソッドなのでしょう？

行動規範の内容に同意します

続き①です

以下、手札からボードにカードを召喚する箇所と思しきソースコード

C#
1    public void PlayCard(CardView card)
2    {
3        if (card.CanBePlayed(this))
4        {
5            gameUI.endTurnButton.SetEnabled(false);
6
7            var gameConfig = GameManager.Instance.config;
8            var libraryCard = gameConfig.GetCard(card.card.cardId);
9            //スペルかミニオンか
10            var cardType = gameConfig.cardTypes.Find(x => x.id == libraryCard.cardTypeId);
11            if (cardType.name == "Creature")
12            {
13                //ミニオンをボード上にプレハブ化
14                var boardCreature = Instantiate(boardCreaturePrefab);
15
16                var board = GameObject.Find("PlayerBoard");
17                boardCreature.tag = "PlayerOwned";
18                boardCreature.transform.parent = board.transform;
19                boardCreature.transform.position = new Vector2(1.9f * playerBoardCards.Count, 0);
20                boardCreature.GetComponent<BoardCreature>().ownerPlayer = this;
21                boardCreature.GetComponent<BoardCreature>().PopulateWithInfo(card.card);
22
23                //手札からプレイしたカードを消す
24                playerHandCards.Remove(card);
25                RearrangeHand();
26                playerBoardCards.Add(boardCreature.GetComponent<BoardCreature>());
27
28                //手札のカードのオブジェクトを削除
29                Destroy(card.gameObject);
30
31                currentCreature = boardCreature.GetComponent<BoardCreature>();
32
33                //ボードの描画処理
34                RearrangeBottomBoard(() =>{var triggeredAbilities = libraryCard.abilities.FindAll(x => x is TriggeredAbility);
35                    TriggeredAbility targetableAbility = null;
36                    foreach (var ability in triggeredAbilities)
37                    {
38                        var triggeredAbility = ability as TriggeredAbility;
39                        var trigger = triggeredAbility.trigger as OnCardEnteredZoneTrigger;
40                        if (trigger != null && trigger.zoneId == boardZone.zoneId && triggeredAbility.target is IUserTarget)
41                        {
42                            targetableAbility = triggeredAbility;
43                            break;
44                        }
45                    }
46
47                    // Preemptively move the card so that the effect solver can properly check the availability of targets
48                    // by also taking into account this card (that is trying to be played).
49                    //プレイしようとしているカードも考慮して、エフェクトソルバーがターゲットの使用可能性を適切にチェックできるように、先制してカードを移動します。
50                    playerInfo.namedZones["Hand"].RemoveCard(card.card);
51                    playerInfo.namedZones["Board"].AddCard(card.card);
52
53                    //ターゲットを取るアビリティがあり、且つターゲットがいる場合
54                    if (targetableAbility != null && effectSolver.AreTargetsAvailable(targetableAbility.effect, card.card, targetableAbility.target))
55                    {
56                        var targetingArrow = Instantiate(spellTargetingArrowPrefab).GetComponent<SpellTargetingArrow>();
57                        boardCreature.GetComponent<BoardCreature>().abilitiesTargetingArrow = targetingArrow;
58                        targetingArrow.effectTarget = targetableAbility.target;
59                        targetingArrow.targetType = targetableAbility.target.GetTarget();
60                        targetingArrow.onTargetSelected += () =>
61                        {
62                            PlayCreatureCard(card.card, targetingArrow.targetInfo);
63                            effectSolver.MoveCard(netId, card.card, "Hand", "Board", targetingArrow.targetInfo);
64                            currentCreature = null;
65                            gameUI.endTurnButton.SetEnabled(true);
66                        };
67                        targetingArrow.Begin(boardCreature.transform.localPosition);
68                    }
69                    else
70                    {
71                        PlayCreatureCard(card.card);
72                        effectSolver.MoveCard(netId, card.card, "Hand", "Board");
73                        currentCreature = null;
74                        gameUI.endTurnButton.SetEnabled(true);
75                    }
76                    boardCreature.GetComponent<BoardCreature>().fightTargetingArrowPrefab = fightTargetingArrowPrefab;
77                });
78            }
79            //スペルの場合
80            else if (cardType.name == "Spell")
81            {
82                var spellsPivot = GameObject.Find("PlayerSpellsPivot");
83                var sequence = DOTween.Sequence();
84                sequence.Append(card.transform.DOMove(spellsPivot.transform.position, 0.5f));
85                sequence.Insert(0, card.transform.DORotate(Vector3.zero, 0.2f));
86                sequence.Play().OnComplete(() =>
87                {
88                    card.GetComponent<SortingGroup>().sortingLayerName = "BoardCards";
89                    card.GetComponent<SortingGroup>().sortingOrder = 1000;
90
91                    var boardSpell = card.gameObject.AddComponent<BoardSpell>();
92
93                    var triggeredAbilities = libraryCard.abilities.FindAll(x => x is TriggeredAbility);
94                    TriggeredAbility targetableAbility = null;
95                    foreach (var ability in triggeredAbilities)
96                    {
97                        var triggeredAbility = ability as TriggeredAbility;
98                        var trigger = triggeredAbility.trigger as OnCardEnteredZoneTrigger;
99                        //トリガーがあり、ボードに入ることがトリガーで、且つユーザーがターゲットを指定している場合
100                        if (trigger != null && trigger.zoneId == boardZone.zoneId && triggeredAbility.target is IUserTarget)
101                        {
102                            targetableAbility = triggeredAbility;
103                            break;
104                        }
105                    }
106
107                    currentSpellCard = card;
108                    //ターゲットを取るアビリティがあり、且つターゲットがいる場合、ターゲットを指定してスペルの処理をする
109                    if (targetableAbility != null && effectSolver.AreTargetsAvailable(targetableAbility.effect, card.card, targetableAbility.target))
110                    {
111                        var targetingArrow = Instantiate(spellTargetingArrowPrefab).GetComponent<SpellTargetingArrow>();
112                        boardSpell.targetingArrow = targetingArrow;
113                        targetingArrow.effectTarget = targetableAbility.target;
114                        targetingArrow.targetType = targetableAbility.target.GetTarget();
115                        targetingArrow.onTargetSelected += () =>
116                        {
117                            PlaySpellCard(card.card, targetingArrow.targetInfo);
118                            effectSolver.MoveCard(netId, card.card, "Hand", "Board", targetingArrow.targetInfo);
119                            currentSpellCard = null;
120                            gameUI.endTurnButton.SetEnabled(true);
121                        };
122                        targetingArrow.Begin(boardSpell.transform.localPosition);
123                    }
124                    else
125                    //そうでなければそのまま処理
126                    {
127                        PlaySpellCard(card.card);
128                        effectSolver.MoveCard(netId, card.card, "Hand", "Board");
129                        currentSpellCard = null;
130                        gameUI.endTurnButton.SetEnabled(true);
131                    }
132                });
133            }
134        }
135        else
136        {
137            card.GetComponent<HandCard>().ResetToInitialPosition();
138        }
139    }

上記メソッドの引数となっているCarViewクラスは、GUIでマウス左クリック時にぶつかったobjectを判定することによって値を取得してきているため、GUI描画のない、デッキやハンドの外からトークンBを選択することは出来ません。

投稿2018/04/30 12:13

編集2018/04/30 12:28

imohori708

総合スコア10

続き②です。

CardViewクラスは以下に記載します。

C#
1using UnityEngine;
2using UnityEngine.Assertions;
3
4using TMPro;
5
6using CCGKit;
7
8/// <summary>
9/// カードの描画情報
10/// RuntimeCardクラスも持ってる。各スタッツ、使用可能の光とか
11/// </summary>
12public class CardView : MonoBehaviour
13{
14public RuntimeCard card { get; private set; }
15
16//使用可能の青い光
17[SerializeField]
18protected SpriteRenderer glowSprite;
19
20//イラスト
21[SerializeField]
22protected SpriteRenderer pictureSprite;
23
24[SerializeField]
25protected TextMeshPro costText;
26
27[SerializeField]
28protected TextMeshPro nameText;
29
30[SerializeField]
31protected TextMeshPro bodyText;
32
33protected GameObject previewCard;
34
35public int manaCost { get; protected set; }
36
37[HideInInspector]
38public bool isPreview;
39
40protected virtual void Awake()
41{
42Assert.IsNotNull(glowSprite);
43Assert.IsNotNull(pictureSprite);
44Assert.IsNotNull(costText);
45Assert.IsNotNull(nameText);
46Assert.IsNotNull(bodyText);
47}
48
49/// <summary>
50/// カードの情報を取り込む
51/// </summary>
52/// <param name="card"></param>
53public virtual void PopulateWithInfo(RuntimeCard card)
54{
55this.card = card;
56
57var gameConfig = GameManager.Instance.config;
58/*
59
60var cardType = gameConfig.cardTypes.Find(x => x.id == card.cardId);
61Assert.IsNotNull(cardType);
62pictureSprite.sprite = Resources.Load<Sprite>(cardType.GetStringProperty("Picture"));
63
64*/
65
66var libraryCard = gameConfig.GetCard(card.cardId);
67Assert.IsNotNull(libraryCard);
68nameText.text = libraryCard.name;
69bodyText.text = libraryCard.GetStringProperty("Text");
70
71var cost = libraryCard.costs.Find(x => x is PayResourceCost);
72if (cost != null)
73{
74var payResourceCost = cost as PayResourceCost;
75manaCost = payResourceCost.value;
76costText.text = manaCost.ToString();
77}
78
79pictureSprite.sprite = Resources.Load<Sprite>(string.Format("Images/{0}", libraryCard.GetStringProperty("Picture")));
80var material = libraryCard.GetStringProperty("Material");
81if (!string.IsNullOrEmpty(material))
82{
83pictureSprite.material = Resources.Load<Material>(string.Format("Materials/{0}", material));
84}
85}
86
87/// <summary>
88/// ライブラリーの情報を移行
89/// </summary>
90/// <param name="card"></param>
91public virtual void PopulateWithLibraryInfo(Card card)
92{
93nameText.text = card.name;
94bodyText.text = card.GetStringProperty("Text");
95
96var cost = card.costs.Find(x => x is PayResourceCost);
97if (cost != null)
98{
99var payResourceCost = cost as PayResourceCost;
100manaCost = payResourceCost.value;
101costText.text = manaCost.ToString();
102}
103
104pictureSprite.sprite = Resources.Load<Sprite>(string.Format("Images/{0}", card.GetStringProperty("Picture")));
105var material = card.GetStringProperty("Material");
106if (!string.IsNullOrEmpty(material))
107{
108pictureSprite.material = Resources.Load<Material>(string.Format("Materials/{0}", material));
109}
110}
111
112/// <summary>
113/// プレイできるか
114/// </summary>
115/// <param name="owner"></param>
116/// <returns></returns>
117public virtual bool CanBePlayed(DemoHumanPlayer owner)
118{
119return owner.isActivePlayer && owner.manaStat.effectiveValue >= manaCost;
120}
121
122/// <summary>
123/// ハイライト付いてるか判定
124/// </summary>
125/// <returns></returns>
126public bool IsHighlighted()
127{
128return glowSprite.enabled;
129}
130
131/// <summary>
132/// ハイライトをセット
133/// </summary>
134/// <param name="enabled"></param>
135public void SetHighlightingEnabled(bool enabled)
136{
137glowSprite.enabled = enabled;
138}
139}
140

聞きたいこと

RuntimeCard、あるいはCardViewクラスに、上記JSONファイルから値を持ってきてPlayCardクラスに渡しトークンBを召喚するにはどのようなコードを組めば良いでしょうか。
慣れない質問で要領を得ない書き方になっているかもしれませんが、何卒よろしくお願い致します。
不足している情報があればコメントお願いします。

投稿2018/04/30 11:22

編集2018/04/30 12:29

imohori708

総合スコア10