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 void OnPointerDown(PointerEventData eventData)
{
// OneCardManager c=this.GetComponent<OneCardManager>();
Debug.Log("ResolveCardByDiceRoll ");
OneCardManager c = this.GetComponent <OneCardManager>();
if (c.cardAsset.resolved == ResolvedType.resolved_lost |
c.cardAsset.resolved == ResolvedType.resolved_win)
{
return;
}
if (c.cardAsset.type == CardType.wrath)
{
return;
}
if (c.cardAsset.type == CardType.blessing)
{
return;
}
Game.instance.CurrentEnemyIndex = c.cardAsset.cardnumber;
if (c.cardAsset.rollResult > 0)
{
new GoToNextGamePhase(GamePhase.BattleEnd).AddToQueue();
}
else
{
new GoToNextGamePhase(GamePhase.Battle).AddToQueue();
}
// GameManager.instance.StartCoroutine(this.Draw3Cards());
}
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();
}
}
private void loadCardFromEvent(GameObject card, CardLogic cl)
{
OneCardManager cardManager = card.GetComponent <OneCardManager>();
cardManager.cardAsset = cl.ca;
cardManager.ReadCardFromAsset();
}
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);
}
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);
}
/// <summary>
/// Muestra los premios obtenidos en la partida para el jugador usuario.
/// </summary>
/// <param name="carta">Carta.</param>
/// <param name="items">Items.</param>
/// <param name="experiencia">Experiencia.</param>
public void MostrarPremioPartida(Carta carta, List <Item> items, int experiencia)
{
puntosExp.text = "ENHORABUENA, HAS OBTENIDO " + experiencia.ToString() + " PUNTOS DE EXP";
PremioPartidaPanel.SetActive(true);
if (carta != null)
{
CartaBase asset = carta.AssetCarta;
int progresoTrebol = carta.Progreso.Piedra;
int progresoPocion = carta.Progreso.Pocion;
GameObject cartaGobj = Instantiate(ObjetosGenerales.Instance.CardInventario, transform);
OneCardManager manager = cartaGobj.GetComponent <OneCardManager>();
ProgresoVisual progreso = cartaGobj.GetComponent <ProgresoVisual>();
manager.CartaAsset = asset;
progreso.PorcentajeProgresoPiedra = progresoTrebol;
progreso.PorcentajeProgresoPocion = progresoPocion;
manager.LeerDatos();
progreso.LeerProgreso();
cartaGobj.transform.SetParent(horizontalLayoutGroup.gameObject.transform);
}
GameObject itemGobj;
foreach (Item item in items)
{
itemGobj = Instantiate(ObjetosGenerales.Instance.ItemInventario, transform);
OneItemManager manager = itemGobj.GetComponent <OneItemManager>();
manager.Item = item;
manager.LeerDatosItem();
itemGobj.transform.SetParent(horizontalLayoutGroup.gameObject.transform);
}
}
private static void CorrectDeck2_AddItemToHand()
{
string cardname = "apollobow";
CardManager.Card chosenCard = null;
foreach (CardManager.Card card in Game.instance.currentDeck)
{
if (card.name.Equals(cardname))
{
chosenCard = card;
break;
}
}
foreach (CardManager.Card card in Game.instance.reserveDeck)
{
if (card.name.Equals(cardname))
{
chosenCard = card;
break;
}
}
if (chosenCard != null)
{
Game.instance.currentDeck.Remove(chosenCard);
SameDistanceChildren distance = Visual.instance.TreasureHand.GetComponent <SameDistanceChildren>();
int emptySlotIndex = distance.GetOccupiedSlotsNumber();
GameObject treasureslot = distance.slots[emptySlotIndex];
OneCardManager.CreateOneCardManager(chosenCard, treasureslot);
}
}
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);
}
private IEnumerator ActivateAegisOfZeusCoroutine()
{
Visual.instance.disableInput(true);
float timeMovement = Const.mediumCardTimeMovement;
HelmOfHadesTarget targetcomponent = target.GetComponent <HelmOfHadesTarget>();
HelmOfHadesTarget[] targetsarray = GameObject.FindObjectsOfType <HelmOfHadesTarget>();
foreach (var VARIABLE in targetsarray)
{
if (VARIABLE != targetcomponent)
{
GameObject.DestroyImmediate(VARIABLE);
}
}
HelmOfHadesActivated[] arractivated = GameObject.FindObjectsOfType <HelmOfHadesActivated>();
HelmOfHadesActivated activated = arractivated[0];
OneCardManager helmcm = activated.GetComponent <OneCardManager>();
VisualTool.DiscardCardToWinningPile(helmcm);
VisualTool.DiscardCardToDiscardPile(target);
GameLogicEvents.eventUpdateCurrentEncounter.Invoke();
GameLogicEvents.eventUpdateLossCounter.Invoke();
yield return(Const.mediumCardTimeMovement + EndTurn.SmallAmountOfTime);
VisualTool.SwitchAllControls(true);
Visual.instance.disableInput(false);
Command.CommandExecutionComplete();
}
public OneCardManager CreateCard(Point p, GameObject cardPrefab, GameObject initPosition, CardAsset cardAsset, float delay)
{
//card = Instantiate(cardPrefab);
//keep it bewtween 2 and 1
OneCardManager card = Instantiate(cardPrefab, initPosition.transform.position, Quaternion.Euler(0, 180, UnityEngine.Random.Range(-1, 1))).GetComponent <OneCardManager>();
RotateFieldCard(card);
AllCards.Add(card);
card.transform.SetParent(FieldCardParent.transform, false);
card.cardAsset = cardAsset;
card.ReadCardFromAsset();
card.point = p;
EmptyCardSlots.Remove(AllSlots[p.Y, p.X]); // cannot put it here sadly
card.transform.position = initPosition.transform.position;
//Debug.Log("R_"+card.transform.rotation);
//card.transform.Rotate(new Vector3(1, 2, -1));
Vector3 v = new Vector3(AllSlots[p.Y, p.X].transform.position.x + UnityEngine.Random.Range(-0.05f, 0.05f), AllSlots[p.Y, p.X].transform.position.y + UnityEngine.Random.Range(-0.05f, 0.05f), AllSlots[p.Y, p.X].transform.position.z);
if (card.cardAsset.Type == CardType.Player)
{
v.y = 0.35f;
}
card.transform.DOMove(v, delay); //AllSlots[p.Y, p.X].transform.position
return(card);
}
// Use this for initialization
void Awake()
{
isSelectable = false;
isSelected = false;
card = gameObject.GetComponent <OneCardManager>();
sm = UnityEngine.Object.FindObjectOfType <SelectionManager>().GetComponent <SelectionManager>();
}
// CARD DRAW METHODS
// creates a card and returns a new card as a GameObject
GameObject CreateACardAtPosition(Cards c, Vector3 position, Vector3 eulerAngles)
{
// Instantiate a card depending on its type
GameObject card;
/*if (c.MaxHealth > 0) //We don't have creature cards now
* {
* // 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.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 = c.targets;
}
//}
// apply the look of the card based on the info from CardAsset
OneCardManager manager = card.GetComponent <OneCardManager>();
manager.cardAsset = c;
manager.ReadCardFromAsset();
return(card);
}
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 void DeleteCard(OneCardManager card)
{
Debug.Log("DeletingCard");
ChatBot2.text = ChatBot2.text + "\n" + System.DateTime.Now.ToString("hh:mm:ss") + ": : DeleteCard()";
Debug.Log(card.point.X);
Debug.Log(card.point.Y);
AddEmptySlot(card.point);
StartCoroutine(card.DeleteThisCard());
}
// method to create a new card and add it to the table
public void AddSpellCardAtIndex(Cards ca, int UniqueID, int index, CardLogic cl, Player p, ICharacter target)
{
GameObject card;
// create a new creature from prefab
if (target == null)
{
card = GameObject.Instantiate(GlobalSettings.Instance.NoTargetSpellCardPrefab, slots.Children[index].transform.position, Quaternion.identity) as GameObject;
card.GetComponent <Draggable>().enabled = false;// just can't move when drag should somehow set "Candrag" in DraggingAction to false;
}
else
{
card = GameObject.Instantiate(GlobalSettings.Instance.TargetedSpellCardPrefab, slots.Children[index].transform.position, Quaternion.identity) as GameObject;
card.GetComponent <Draggable>().enabled = false;// just can't move when drag should somehow set "Candrag" in DraggingAction to false;
}
// apply the look from CardAsset
OneCardManager manager = card.GetComponent <OneCardManager>();
manager.cardAsset = ca;
manager.ReadCardFromAsset();
// add tag according to owner
foreach (Transform t in card.GetComponentsInChildren <Transform>())
{
t.tag = owner.ToString() + "Card";
}
// parent a new creature gameObject to table slots
card.transform.SetParent(slots.transform);
// add a new creature to the list
CardsOnTable.Insert(index, card);
// let this Card know about its position
WhereIsTheCardOrCreature w = card.GetComponent <WhereIsTheCardOrCreature>();
w.Slot = index;
w.VisualState = VisualStates.LowTable;
// add our unique ID to this Card
IDHolder id = card.AddComponent <IDHolder>();
id.UniqueID = UniqueID;
// after a new creature is added update placing of all the other creatures
ShiftSlotsGameObjectAccordingToNumberOfCards();
PlaceCardsOnNewSlots();
p.commandsWaitinglist.Add(new TriggerEffectCommand(cl, target, p, p.table));
// end command execution
Command.CommandExecutionComplete();
}
private void loadAdventurerCardsFromAsset(CardAsset ca)
{
OneCardManager smallManager = smallCard.GetComponent <OneCardManager>();
OneCardManager largeManager = largeCard.GetComponent <OneCardManager>();
smallManager.cardAsset = ca;
largeManager.cardAsset = ca;
smallManager.ReadCardFromAsset();
largeManager.ReadCardFromAsset();
}
private void Awake()
{
lr = GetComponentInChildren <LineRenderer>();
lr.sortingLayerName = "Above Everything";
triangle = transform.Find("Triangle");
triangleSR = triangle.GetComponent <SpriteRenderer>();
whereIsCard = GetComponentInParent <WhereIsTheCardOrCreature>();
manager = GetComponentInParent <OneCardManager>();
}
private void ShowCards(bool showingCardsPlayerDoesNotOwn = false, int pageIndex = 0, bool includeAllRarities = true, bool includeAllCharacters = true,
RarityOptions rarity = RarityOptions.Basic, CharacterAsset asset = null, string keyword = "", int manaCost = -1, bool includeTokenCards = false)
{
// saving the information about the cards that we are showing to players on this page
_showingCardsPlayerDoesNotOwn = showingCardsPlayerDoesNotOwn;
_pageIndex = pageIndex;
_includeAllRarities = includeAllRarities;
_includeAllCharacters = includeAllCharacters;
_rarity = rarity;
_asset = asset;
_keyword = keyword;
_manaCost = manaCost;
_includeTokenCards = includeTokenCards;
List <CardAsset> CardsOnThisPage = PageSelection(showingCardsPlayerDoesNotOwn, pageIndex, includeAllRarities, includeAllCharacters, rarity,
asset, keyword, manaCost, includeTokenCards);
// clear created cards list
ClearCreatedCards();
if (CardsOnThisPage.Count == 0)
{
return;
}
// Debug.Log(CardsOnThisPage.Count);
for (int i = 0; i < CardsOnThisPage.Count; i++)
{
GameObject newMenuCard;
if (CardsOnThisPage[i].TypeOfCard == TypesOfCards.Creature)
{
// it is a creature card
newMenuCard = Instantiate(CreatureMenuPrefab, Slots[i].position, Quaternion.identity) as GameObject;
}
else
{
// it is a spell card
newMenuCard = Instantiate(SpellMenuPrefab, Slots[i].position, Quaternion.identity) as GameObject;
}
newMenuCard.transform.SetParent(this.transform);
CreatedCards.Add(newMenuCard);
OneCardManager manager = newMenuCard.GetComponent <OneCardManager>();
manager.cardAsset = CardsOnThisPage[i];
manager.ReadCardFromAsset();
AddCardToDeck addCardComponent = newMenuCard.GetComponent <AddCardToDeck>();
addCardComponent.SetCardAsset(CardsOnThisPage[i]);
addCardComponent.UpdateQuantity();
}
}
public void Replace2(Point p1, Point p2)
{
OneCardManager c1 = FindFieldCardAtPoint(p1);
OneCardManager c2 = FindFieldCardAtPoint(p2);
DeleteCard(c1);
DeleteCard(c2);
CreateCard(p1, FieldCardPrefab, InitialFieldCardPos, fieldCardAssets[UnityEngine.Random.Range(0, fieldCardAssets.Count)], 0.5f); // should remove these from the deck tbh
CreateCard(p2, FieldCardPrefab, InitialFieldCardPos, fieldCardAssets[UnityEngine.Random.Range(0, fieldCardAssets.Count)], 1f);
}
public List <OneCardManager> GetValidMoves(OneCardManager card) // highlight arrows and save all player moves found
{
List <OneCardManager> nList = new List <OneCardManager>();
if (card != null)
{
nList.AddRange(GetValidMoves(card.point, card.arrows));
}
return(nList);
}
public void RemoveTouchComponentsExceptSelf(OneCardManager target, tempTouchComponent exceptionComponent)
{
tempTouchComponent[] arrTouchcomponent = target.GetComponents <tempTouchComponent>();
foreach (var VARIABLE in arrTouchcomponent)
{
if (VARIABLE == exceptionComponent)
{
continue;
}
GameObject.DestroyImmediate(VARIABLE);
}
}
public void HighlightPaths(OneCardManager card)
{
/*
* var allWays = new List<List<OneCardManager>>();
*
* List<OneCardManager> SelectableCards1 = new List<OneCardManager>();
* List<OneCardManager> SelectableCards2 = new List<OneCardManager>();
* List<OneCardManager> SelectableCards3 = new List<OneCardManager>();
* List<OneCardManager> SelectableCards4 = new List<OneCardManager>();
*
* SelectableCards1 = HighlightArrows(card); // 1 AP
* foreach (OneCardManager s in SelectableCards1)
* {
* allWays.Add(new List<OneCardManager> {card});
* }
*
* if (GameManager.Instance.CurrentPlayerTurn.ActionPoints >= 2)
* {
* foreach (OneCardManager ss in SelectableCards1) //2 AP
* {
* SelectableCards2 = HighlightArrows(ss);
* allWays.Add(new List<OneCardManager> { card, ss});
*
*
* if (GameManager.Instance.CurrentPlayerTurn.ActionPoints >= 3)
* {
* foreach (OneCardManager sss in SelectableCards2) //3 AP
* {
* SelectableCards3 = HighlightArrows(sss);
* allWays.Add(new List<OneCardManager> { card, ss, sss});
*
* if (GameManager.Instance.CurrentPlayerTurn.ActionPoints >= 3)
* {
* foreach (OneCardManager ssss in SelectableCards3) //4 AP
* {
* SelectableCards4 = HighlightArrows(ssss);
* allWays.Add(new List<OneCardManager> { card, ss, sss,ssss});
*
* }
* }
* }
* }
* }
* }
*
* Debug.Log(allWays);
* foreach (List<OneCardManager> l in allWays)
* {
* Debug.Log(l.Point.X);
* }
*/
}
public void showDetail()
{
print("showDetail");
GameObject canvas = GameObject.Find("DeckCanvas");
GameObject CardDetail = canvas.transform.Find("CardDetail").gameObject;
CardDetail.SetActive(true);
OneCardManager ocm = CardDetail.transform.Find("Card").GetComponent <OneCardManager>();
print(current.Description);
ocm.cardAsset = current;
ocm.ReadCardFromAsset();
}
private IEnumerator PrepareCardForNewGameCoroutine()
{
TestTools.DeckCorrection();
new WaitForSeconds(.01f);
foreach (CardManager.Card card in Game.instance.currentDeck)
{
GameObject cardPoint = Visual.instance.CardPointOutside;
GameObject cardObject = OneCardManager.CreateOneCardManager(card, cardPoint);
}
yield return(new WaitForSeconds(.01f));
Command.CommandExecutionComplete();
}
public void RotateArrows(Point p)
{
OneCardManager myCard = FindCardAtPoint(p);
// if (myCard.gameObject.tag == "Arrows")
// Arrow.gameObject.SetActive(false);
//arrowss = GameObject.FindGameObjectsWithTag("Arrows");
//foreach (GameObject r in arrowss)
// r.transform.Translate(Direction * movespeed * Time.deltaTime);
arrows t = arrows.None;
if ((myCard.arrows & arrows.Up) == arrows.Up)
{
t |= arrows.Down;
}
if ((myCard.arrows & arrows.Down) == arrows.Down)
{
t |= arrows.Up;
}
if ((myCard.arrows & arrows.Right) == arrows.Right)
{
t |= arrows.Left;
}
if ((myCard.arrows & arrows.Left) == arrows.Left)
{
t |= arrows.Right;
}
if (myCard.cardAsset.Type == CardType.Player)
{
foreach (PlayerManager pl in GameManager.Instance.players)
{
if (pl.myCardManager == myCard)
{
Debug.Log("rotateplayerArrows");
pl.arrows = t;
pl.point = myCard.point;
}
}
}
myCard.updateArrows(t);
}
private IEnumerator Draw3CardsCoroutine()
{
List <OneCardManager> drawlist = new List <OneCardManager>();
OneCardManager[] deckcards = Visual.instance.CardDeckFrame.GetComponentsInChildren <OneCardManager>();
SameDistanceChildren distance = Visual.instance.CurrentEncounter.GetComponent <SameDistanceChildren>();
int drawCardNumber = 3;
distance.CurrentEncounterSize = drawCardNumber;
for (int i = 1; i <= drawCardNumber; i++)
{
if (deckcards.Length < i)
{
break;
}
OneCardManager card = deckcards[deckcards.Length - (i)];
drawlist.Add(card);
}
float TimeMovement1 = .6f;
float TimeMovement2 = .4f;
float SmallAmountOfTime = .05f;
float DelayTime = .3f;
foreach (OneCardManager card in drawlist)
{
card.transform.SetParent(null);
Sequence sequence = DOTween.Sequence();
sequence.Append(card.transform.DOMove(Visual.instance.CardPoint.transform.position, TimeMovement1));
sequence.Insert(0f, card.transform.DORotate(Vector3.zero, TimeMovement1));
sequence.AppendInterval(DelayTime);
int index = drawlist.IndexOf(card);
GameObject slot = distance.slots[index];
sequence.Append(card.transform.DOLocalMove(slot.transform.position, TimeMovement2));
sequence.OnComplete(() => MoveCardToCurrentEncounterGroup(card, slot.transform));
sequence.Play();
yield return(new WaitForSeconds(DelayTime));
}
yield return(new WaitForSeconds(TimeMovement1 + TimeMovement2 + DelayTime));
Command.CommandExecutionComplete();
}
public void FillByCards(List <CardManager.Card> cards)
{
VisualTool.RemoveChildrensFromTransform(CardListContent.transform);
foreach (CardManager.Card VARIABLE in cards)
{
GameObject slot = Instantiate(Visual.instance.prefabBasicRect, CardListContent.transform);
RectTransform transform = slot.GetComponent <RectTransform>();
VisualTool.SetAnchorPreset(transform);
GameObject cmObject = OneCardManager.CreateOneCardManager(VARIABLE, slot);
VisualTool.SetAnchorPreset(cmObject.GetComponent <RectTransform>());
}
}
// 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;
card = GameObject.Instantiate(GlobalSettings.Instance.ItemCardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
// apply the look of the card based on the info from CardAsset
OneCardManager manager = card.GetComponent <OneCardManager>();
manager.cardAsset = c;
manager.ReadCardFromAsset();
return(card);
}
public int getAdjencyBonus(OneCardManager card)
{
ChatBot2.text = ChatBot2.text + "\n" + System.DateTime.Now.ToString("hh:mm:ss") + ": : getAdjencyBonus()";
List <OneCardManager> NeigborCards = GetNeighborCards(card);
int bonus = 0;
foreach (OneCardManager neigbor in NeigborCards)
{
if (neigbor.cardAsset.Type == CardType.Monster) // check if field card
{
bonus += 1;
}
}
return(bonus);
}
