public void GivePlayerACard(CardAsset cardAsset, int UniqueID)
{
GameObject card = CreateACardAtPosition(cardAsset, slots.Children[0].transform.localPosition);
foreach (Transform transform in card.GetComponentsInChildren <Transform>())
{
transform.tag = owner.ToString() + "Card";
}
AddCard(card);
WhereIsCard whereIsCard = card.GetComponent <WhereIsCard>();
IDHolder id = card.AddComponent <IDHolder>();
id.UniqueID = UniqueID;
Sequence sequence = DOTween.Sequence();
sequence.Append(card.transform.DOLocalMove(slots.Children[0].transform.localPosition, 0));
if (TakeCardsOpenly)
{
sequence.Insert(0f, card.transform.DORotate(Vector3.zero, 0));
}
sequence.OnComplete(() => ChangeLastCardStatusToInHand(card, whereIsCard));
}
// method to add a card to the table
public void AddCard(CardAsset cardAsset, Vector3 handPosition, int monsterIndex)
{
// create a new card from prefab
GameObject card;
card = GameObject.Instantiate(GameStateSync.Instance.SkillCardPrefab, handPosition, Quaternion.Euler(new Vector3(0f, -179f, 0f))) as GameObject;
// apply the look of the card based on the info from CardAsset
SkillCardManager manager = card.GetComponent <SkillCardManager>();
manager.cardAsset = cardAsset;
manager.ReadCardFromAsset();
// parent this card to our open slot
Transform openSlot = FindOpenSlot(monsterIndex);
card.transform.SetParent(openSlot);
// Bring card to front while it travels from draw spot to hand
WhereIsTheCardOrMonster w = card.GetComponent <WhereIsTheCardOrMonster>();
w.SendToBack();
w.Slot = monsterIndex;
// move card to the hand;
Sequence s = DOTween.Sequence();
s.Insert(0f, card.transform.DORotate(Vector3.zero, GameStateSync.Instance.CardTransitionTime));
s.Append(card.transform.DOMove(openSlot.position, GameStateSync.Instance.CardTransitionTime));
s.OnComplete(() => Command.CommandExecutionComplete());
}
GameObject CreateACardAtPosition(CardAsset c, Vector3 position, Vector3 eulerAngles)
{
GameObject card;
if (c.MaxHealth > 0)
{
card = GameObject.Instantiate(GlobalSettings.Instance.CreatureCardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
}
else
{
if (c.Targets == TargetingOptions.NoTarget)
{
card = GameObject.Instantiate(GlobalSettings.Instance.NoTargetSpellCardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
}
else
{
card = GameObject.Instantiate(GlobalSettings.Instance.TargetedSpellCardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
// передает список допустимых целей скрипту, отвечающему за проверку корректности цели
DragSpellOnTarget dragSpell = card.GetComponentInChildren <DragSpellOnTarget>();
dragSpell.Targets = c.Targets;
}
}
OneCardManager manager = card.GetComponent <OneCardManager>();
manager.cardAsset = c;
manager.ReadCardFromAsset();
return(card);
}
void InstantiateGameObject(CardAsset c)
{
cardSelectionPrefab.GetComponent <OneCardManager>().cardAsset = c;
GameObject inHand = Instantiate(cardSelectionPrefab, transform.position, Quaternion.identity) as GameObject;
SetSpace(inHand);
}
public void ApplyAsset(CardAsset ca, int quantity)
{
Asset = ca;
NameText.text = ca.ScriptName;
ManaCost.text = ca.ManaCost.ToString();
SetQuantity(quantity);
}
// CONSTRUCTOR
public CardLogic(CardAsset ca)
{
// ustaw referencje CardAsset
/// NA PRZYSZŁOŚć: this - odwołanie się klasy samej do siebie, Dlaczego tutaj tak? Bo parametrem funkcji jest ca więc odwołujemy się do niego
this.ca = ca;
//zdobądz unikalny int ID
// Do UniqueCardID przypisujemy wynik pobrany z funkcji GetUniqueID, która znajduje się w klasie IDFactory
UniqueCardID = IDFactory.GetUniqueID();
//UniqueCardID = IDFactory.GetUniqueID();
ResetManaCost(); // Wywołujemy funkcję ResetManaCost()
//Tworzymy instancję SpellEffect z nazwą z CardAsset i dołączamy ją
// Sprawdzamy czy zmienna SpellScriptName nie jest pusta i przechowuje jakąś nazwę skryptu
if (ca.SpellScriptName != null && ca.SpellScriptName != "")
{
// Tworzymy instancję aktywatora (pobiera typ(nazwę skryptu czaru)) nadaje mu typ spelleffect
/// NA przyszłosc: getType sprawdza również duże i małe litery
effect = System.Activator.CreateInstance(System.Type.GetType(ca.SpellScriptName)) as SpellEffect;
}
//Dodaj tę kartę do magazynu z identyfikatorem jako klucz
// Odwołuje się do tablicy CardsCreatedThisGame i dodaje kartę (add) z jej identyfikatorem i assetem, który przechowywany jest w ca (odwołanie this)
CardsCreatedThisGame.Add(UniqueCardID, this);
}
// Excès de rage
public override void WhenACreatureIsPlayed()
{
CardAsset[] allCards = Resources.LoadAll <CardAsset>("");
CardAsset creature = null;
foreach (CardAsset a in allCards)
{
if (a.Nom == specialName)
{
creature = a;
break;
}
}
if (owner.table.CreaturesOnTable.Count == 7)
{
return;
}
CardLogic creatureCard = new CardLogic(creature);
// add a creature to player`s table:
owner.PlayACreatureFromHand(creatureCard, tablePos: 0, causeBattlecry: false);
}
void CreateNewCard()
{
CardAsset cardAsset = CreateCardAssets.CreateSignleCard(type, cardName);
Selection.activeObject = cardAsset;
ApplyValues(cardAsset);
}
// gives player a new card from a given position
public void GivePlayerACard(CardAsset c, int index, bool canSee)
{
GameObject card;
card = CreateACardAtPosition(c, DeckTransform.position, new Vector3(0f, -179f, 0f));
// pass this card to HandVisual class
AddCard(card, index);
// Bring card to front while it travels from draw spot to hand
WhereIsTheCardOrMonster w = card.GetComponent <WhereIsTheCardOrMonster>();
w.BringToFront();
w.Slot = index;
// move card to the hand;
Sequence s = DOTween.Sequence();
// displace the card so that we can select it in the scene easier.
s.Append(card.transform.DOLocalMove(slots.Children[0].transform.localPosition, GameStateSync.Instance.CardTransitionTime));
if (canSee)
{
//s.Append(card.transform.DOMove(DrawPreviewSpot.position, GameStateSync.Instance.CardTransitionTime));
s.Insert(0f, card.transform.DORotate(Vector3.zero, GameStateSync.Instance.CardTransitionTime));
//s.AppendInterval(GameStateSync.Instance.CardPreviewTime);
}
else
{
HoverPreview preview = card.GetComponent <HoverPreview>();
Destroy(preview);
}
s.OnComplete(() => ChangeLastCardStatusToInHand(card, w));
}
public void ShowCraftingScreen(CardAsset cardToShow)
{
currentCard = cardToShow;
GameObject cardObject;
if (currentCard.TypeOfCard == TypesOfCards.Creature)
{
cardObject = CreatureCard;
CreatureCard.SetActive(true);
SpellCard.SetActive(false);
}
else
{
cardObject = SpellCard;
CreatureCard.SetActive(false);
SpellCard.SetActive(true);
}
OneCardManager manager = cardObject.GetComponent <OneCardManager>();
manager.CardAsset = cardToShow;
manager.ReadCardFromAsset();
CraftText.text = "Craft this card for " + TradingCosts[cardToShow.Rarity].CraftCost + " dust";
DisenchantText.text = "Disenchant to get " + TradingCosts[cardToShow.Rarity].DisenchantOutcome + " dust";
ShopManager.Instance.DustHUD.SetActive(true);
UpdateQuantityOfCurrentCard();
Content.SetActive(true);
}
public void ShowCardDetail(CardOutView vv)
{
Debug.Log(vv);
int idx = view.CardsViewList.IndexOf(vv);
if (idx == -1)
{
return;
}
CardInfo info = model.NowCardInfos[idx];
CardAsset ca = pCardMgr.GetCardInfo(info.CardId);
view.DetailDesp.text = ca.CardDesp;
view.DetailName.text = ca.CardName;
view.DetailEffectDesp.text = ca.CardEffectDesp;
if (preCardView != null)
{
preCardView.Hint.gameObject.SetActive(false);
}
view.DetailPanel.gameObject.SetActive(true);
vv.Hint.gameObject.SetActive(true);
preCardView = vv;
}
private void LoadCard()
{
List <CardInfo> infoList = mCardMdl.GetAllCards();
state.CardDeck.Clear();
foreach (CardInfo info in infoList)
{
string eid = info.CardId;
CardAsset ca = mCardMdl.GetCardInfo(eid);
CardInZhibo card = new CardInZhibo(eid, ca.UseTime);
card.ca = ca;
state.CardDeck.Add(card);
}
List <string> platformCards = pRoleMgr.GetNowPlatformInfo().PlatformCards;
for (int i = 0; i < platformCards.Count; i++)
{
string eid = platformCards[i];
CardAsset ca = mCardMdl.GetCardInfo(eid);
CardInZhibo card = new CardInZhibo(eid, ca.UseTime);
card.ca = ca;
state.CardDeck.Add(card);
}
shuffle <CardInZhibo>(state.CardDeck);
}
public void LoadFromNetworkPlayer(NetworkPlayer np)
{
this.np = np;
nickname = np.nickname;
nicknameField.text = nickname;
avatarAsset = np.avatar;
avatarSprite.sprite = avatarAsset.AvatarImage;
if (!np.cardsPlayed.Any() || np.cardsPlayed.Count < 2)
{
Debug.LogError("ERROR: Loading PlayedItem.cs from Player who didn't play any cards.");
}
else
{
card1Asset = np.cardsPlayed[0].ca;
card2Asset = np.cardsPlayed[1].ca;
OneCardManager card1Manager = card1.GetComponent <OneCardManager>();
card1Manager.cardAsset = card1Asset;
card1Manager.ReadCardFromAsset();
OneCardManager card2Manager = card2.GetComponent <OneCardManager>();
card2Manager.cardAsset = card2Asset;
card2Manager.ReadCardFromAsset();
}
}
//public int ID
//{
// get{ return UniqueCardID; }
//}
public CardLogic(CardAsset ca)
{
this.ca = ca;
//UniqueCardID = IDFactory.GetUniqueID();
//UniqueCardID = IDFactory.GetUniqueID();
//CardsCreatedThisGame.Add(UniqueCardID, this);
}
public void AddCardAtIndex(CardAsset cardAsset, int UniqueID, int index)
{
GameObject card = Instantiate(ViewManager.Instance.cardOnBoardPrefab, slots.Children[index].transform.position, Quaternion.identity) as GameObject;
CardOnBoardView cardView = card.GetComponent <CardOnBoardView>();
cardView.cardAsset = cardAsset;
cardView.displayCardOnBoardVisual();
foreach (Transform transform in card.GetComponentsInChildren <Transform>())
{
transform.tag = owner.ToString() + "CardOnFrontRow";
}
card.transform.SetParent(slots.transform);
cardsInRow.Insert(index, card);
WhereIsCard whereIsCard = card.GetComponent <WhereIsCard>();
whereIsCard.Slot = index;
whereIsCard.VisualState = VisualStates.LowBoardFrontRow;
IDHolder id = card.AddComponent <IDHolder>();
id.UniqueID = UniqueID;
ShiftSlotsGameObjectAccordingToNumberOfCardsOnBoard();
PlaceCardsOnNewSlots();
Command.CommandExecutionComplete();
}
public PlaySkillCardCommand(PlayerArea playerArea, CardAsset cardAsset, int handIndex, int monsterIndex)
{
this.playerArea = playerArea;
this.cardAsset = cardAsset;
this.handIndex = handIndex;
this.monsterIndex = monsterIndex;
}
public override void StartCommandExecution()
{
base.StartCommandExecution();
Deck deck = _player.deck;
if (deck.cards.Count == 0)
{
if (_player.discard.cards.Count == 0)
{
_player.HasLost = true;
Command.CommandQueue.Clear();
(new ChangeStateCommand(GameState.GameOverPhase)).AddToQueue();
}
else
{
// TODO animate
(new DrawCardCommand(ref _player)).InsertAtFront();
(new MoveDiscardToDeckCommand(ref _player)).InsertAtFront();
}
}
if (!_player.HasLost && deck.cards.Count > 0)
{
CardAsset drawnCard = deck.DrawCard();
if (drawnCard != null)
{
_player.CardInPlay = drawnCard;
GameManager.Instance.cardsAtStake.Add(_player.CardInPlay);
}
}
Command.CommandExecutionComplete();
}
// CARD DRAW METHODS
// creates a card and returns a new card as a GameObject
GameObject CreateACardAtPosition(CardAsset c, Vector3 position, Vector3 eulerAngles)
{
// Instantiate a card depending on its type
GameObject card;
if (c.VieMaximum > 0)
{
// this card is a creature card
card = GameObject.Instantiate(GlobalSettings.Instance.CreatureCardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
}
else
{
// this is a spell: checking for targeted or non-targeted spell
if (c.Cible == TargetingOptions.NoTarget)
{
card = GameObject.Instantiate(GlobalSettings.Instance.NoTargetSpellCardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
}
else
{
card = GameObject.Instantiate(GlobalSettings.Instance.TargetedSpellCardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
// pass targeting options to DraggingActions
DragSpellOnTarget dragSpell = card.GetComponentInChildren <DragSpellOnTarget>();
dragSpell.Targets = c.Cible;
}
}
// apply the look of the card based on the info from CardAsset
OneCardManager manager = card.GetComponent <OneCardManager>();
manager.cardAsset = c;
manager.ReadCardFromAsset();
return(card);
}
// method to create a new creature and add it to the table
public void AddCreatureAtIndex(CardAsset ca, int UniqueID, int index)
{
GameObject creature = GameObject.Instantiate(GlobalSettings.Instance.CreaturePrefab, this.transform.position, Quaternion.identity) as GameObject;
OneCreatureManager manager = creature.GetComponent <OneCreatureManager>();
manager.cardAsset = ca;
manager.LoadFromCardAsset();
foreach (Transform t in creature.GetComponentsInChildren <Transform>())
{
t.tag = owner.ToString() + "Creature";
}
creature.transform.SetParent(this.transform);
CreaturesOnTable.Insert(index, creature);
IDHolder id = creature.AddComponent <IDHolder>();
id.UniqueID = UniqueID;
CalculateCardPositions();
// end command execution
Command.CommandExecutionComplete();
}
GameObject CreateACardAtPosition(CardAsset cardAsset, Vector3 position, Vector3 eulerAngles)
{
GameObject card;
if (cardAsset.IsCreatureCard)
{
card = GameObject.Instantiate(GlobalSettings.Instance.CreatureCardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
}
else
{
if (cardAsset.Targets == TargetingOptions.NoTarget)
{
card = GameObject.Instantiate(GlobalSettings.Instance.NoTargetSpellCardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
}
else
{
card = GameObject.Instantiate(GlobalSettings.Instance.TargetedSpellCardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
// pass targeting options to DraggingActions
DragSpellOnTarget dragSpell = card.GetComponentInChildren <DragSpellOnTarget>();
dragSpell.Targets = cardAsset.Targets;
}
}
// apply the look of the card based on the info from CardAsset
OneCardManager manager = card.GetComponentInChildren <OneCardManager>();
manager.cardAsset = cardAsset;
manager.LoadFromCardAsset();
return(card);
}
public override void ActivateEffect(int specialAmount = 0, string specialName = "", ICharacter target = null)
{
int compteur;
for (compteur = 0; compteur < specialAmount; compteur++)
{
CardAsset[] allCards = Resources.LoadAll <CardAsset> ("");
CardAsset creature = null;
foreach (CardAsset a in allCards)
{
if (a.Nom == specialName)
{
creature = a;
break;
}
}
if (TurnManager.Instance.whoseTurn.table.CreaturesOnTable.Count == 7)
{
return;
}
CardLogic creatureCard = new CardLogic(creature);
// add a creature to player`s table:
TurnManager.Instance.whoseTurn.PlayACreatureFromHand(creatureCard, tablePos: 0, causeBattlecry: false);
}
}
private GameObject CardFromPack(RarityOptions rarity)
{
List <CardAsset> CardsOfThisRarity = CardCollection.Instance.GetCardsWithRarity(rarity);
CardAsset a = CardsOfThisRarity[Random.Range(0, CardsOfThisRarity.Count)];
CardCollection.Instance.QuantityOfEachCard[a]++;
GameObject card;
if (a.TypeOfCard == TypesOfCards.Creature)
{
card = Instantiate(CreatureCardFromPackPrefab) as GameObject;
}
else
{
card = Instantiate(SpellCardFromPackPrefab) as GameObject;
}
card.transform.rotation = Quaternion.Euler(0f, 180f, 0f);
OneCardManager manager = card.GetComponent <OneCardManager>();
manager.CardAsset = a;
manager.ReadCardFromAsset();
return(card);
}
public override void Initialize(CardAsset cardAsset)
{
base.Initialize(cardAsset);
revenue = cardAsset.revenue;
damageBoost = cardAsset.damageBoost;
}
private void LoadCardEffect(CardAsset cardAsset)
{
if (!string.IsNullOrEmpty(cardAsset.SpellScriptName))
{
_effect = Activator.CreateInstance(Type.GetType(cardAsset.SpellScriptName)) as SpellEffect;
}
}
public DrawACardCommand(PlayerArea playerArea, CardAsset cardAsset, int handPos, bool canSee)
{
this.playerArea = playerArea;
this.cardAsset = cardAsset;
this.handPos = handPos;
this.canSee = canSee;
}
public void ShowCraftingScreen(CardAsset cardToShow)
{
currentCard = cardToShow;
// select type of card to show on this screen - creature or spell
GameObject cardObject;
if (currentCard.TypeOfCard == TypesOfCards.Creature)
{
cardObject = CreatureCard;
CreatureCard.SetActive(true);
SpellCard.SetActive(false);
}
else
{
cardObject = SpellCard;
CreatureCard.SetActive(false);
SpellCard.SetActive(true);
}
// change the look of the card to the card that we selected
OneCardManager manager = cardObject.GetComponent <OneCardManager>();
manager.cardAsset = cardToShow;
manager.ReadCardFromAsset();
// change the text on buttons
CraftText.text = "Craft this card for " + TradingCosts[cardToShow.Rarity].CraftCost.ToString() + " dust";
DisenchantText.text = "Disenchant to get " + TradingCosts[cardToShow.Rarity].DisenchantOutcome.ToString() + " dust";
ShopManager.Instance.DustHUD.SetActive(true);
// make sure that correct amount of cards is shown
UpdateQuantityOfCurrentCard();
// show the content of this screen
Content.SetActive(true);
}
public CardInfo GainNewCard(string cid)
{
CardAsset aset = null;
CardDict.TryGetValue(cid, out aset);
if (aset == null)
{
aset = Load(cid);
}
if (aset != null)
{
aset.ReplaceWithAmountInEffect();
CardInfo info = new CardInfo(InstId, cid, Time.realtimeSinceStartup);
info.ca = aset;
cards.Add(info);
InstId += 1;
if (aset.HasTurnEffect || aset.TurnEffects.Count > 0)
{
CardsWithTurnEffect.Add(info);
}
return(info);
}
return(null);
}
// Excès de rage
public override void WhenACreatureIsPlayed()
{
List <CardAsset> allCreatureAssets = new List <CardAsset>();
CardAsset[] allCards = Resources.LoadAll <CardAsset>("");
// only select creatures
foreach (CardAsset a in allCards)
{
if (a.VieMaximum > 0)
{
allCreatureAssets.Add(a);
}
}
if (owner.table.CreaturesOnTable.Count == 7)
{
return;
}
// Select a random CardAsset:
int index = Random.Range(0, allCreatureAssets.Count);
CardAsset randomCreatureAsset = allCreatureAssets[index];
// make a CardLogic to call PlayACreatureFromHand():
CardLogic creatureCard = new CardLogic(randomCreatureAsset);
// add a creature to player`s table:
owner.PlayACreatureFromHand(creatureCard, tablePos: 0, causeBattlecry: false);
// or you can change it to: tablePos: 6 to place him on the other side.
}
public void AddCard(CardAsset asset)
{
//if we are browsing the collection
if (!InDeckBuildingMode)
{
return;
}
//if the deck is already full
if (deckList.Count == AmountOfCardsInDeck)
{
return;
}
int count = NumberOfThisCardInDeck(asset);
int limitOfThisCardInDeck = SameCardLimit;
//if something else if specified in the CardAsset, we use that
if (asset.OverrideLimitOfThisCardInDeck > 0)
{
limitOfThisCardInDeck = asset.OverrideLimitOfThisCardInDeck;
}
if (count < limitOfThisCardInDeck)
{
deckList.Add(asset);
//added one to count if we are adding this card
count++;
//add to card count
if (CardCount.Instance.count < 20)
{
CardCount.Instance.count++;
//CardCount.Instance.SetCountText ();
}
//do all the graphical stuff
if (ribbons.ContainsKey(asset))
{
//update quantity
ribbons [asset].SetQuantity(count);
}
else
{
// add card's name to the list
GameObject cardName = Instantiate(cardNamePrefab, content) as GameObject;
cardName.transform.SetAsLastSibling();
cardName.transform.localScale = Vector3.one;
CardNameRibbon ribbon = cardName.GetComponent <CardNameRibbon> ();
ribbon.ApplyAsset(asset, count);
ribbons.Add(asset, ribbon);
}
if (CardCount.Instance.count <= 20)
{
CardCount.Instance.SetCountText();
}
}
}
// gives player a new card from a given position
public void GivePlayerACard(CardAsset cardAsset, int UniqueID, bool fast = false, bool fromDeck = true)
{
var lastCardPosition = GetLastCardPosition();
var originPosition = fromDeck ? DeckTransform.position : OtherCardDrawSourceTransform.position;
var card = CreateACardAtPosition(cardAsset, originPosition, new Vector3(0f, -180f, 0f));
foreach (Transform t in card.GetComponentsInChildren <Transform>())
{
t.tag = owner.ToString() + "Card";
}
AddCard(card);
var whereIs = card.GetComponent <WhereIsTheCardOrCreature>();
if (whereIs == null)
{
whereIs = card.GetComponentInChildren <WhereIsTheCardOrCreature>();
}
whereIs.BringToFront();
whereIs.Slot = 0;
whereIs.VisualState = VisualStates.Transition;
// pass a unique ID to this card.
IDHolder id = card.AddComponent <IDHolder>();
id.UniqueID = UniqueID;
// move card to the hand;
Sequence s = DOTween.Sequence();
if (!fast)
{
s.Append(card.transform.DOMove(DrawPreviewSpot.position, GlobalSettings.Instance.CardTransitionTime));
if (TakeCardsOpenly)
{
s.Insert(0f, card.transform.DORotate(Vector3.zero, GlobalSettings.Instance.CardTransitionTime));
}
s.AppendInterval(GlobalSettings.Instance.CardPreviewTime);
s.Append(card.transform.DOLocalMove(lastCardPosition, GlobalSettings.Instance.CardTransitionTime));
}
else
{
s.Append(card.transform.DOLocalMove(lastCardPosition, GlobalSettings.Instance.CardTransitionTimeFast));
if (TakeCardsOpenly)
{
s.Insert(0f, card.transform.DORotate(Vector3.zero, GlobalSettings.Instance.CardTransitionTimeFast));
}
}
s.OnComplete(() => {
ChangeLastCardStatusToInHand(card, whereIs);
AdjustCardsInHand();
});
}
