private IEnumerator PromoteMinion(Transform card, CardVisual cv) { yield return(new WaitForSeconds(1)); int cost = int.Parse(cv.cost.text); GameManager.Instance.ActiveHero(true).AdjustMana(cost, false); DelayCommand dc = new DelayCommand(GameManager.Instance.GetActiveHand(true), 1f); dc.AddToQueue(); yield return(new WaitForSeconds(1)); MoveCardCommand mc = new MoveCardCommand(card.gameObject, GameManager.Instance.GetActiveMinionZone(true)); mc.AddToQueue(); cv.AdjustHealth(2, true); cv.PromotedHealth = cv.CurrentHealth; if (cv.Md != null) { RemoveCardFromHand(cv.Md); } else { RemoveCardFromHand(cv.Sd); } card.Find("CardBack").gameObject.SetActive(false); }
private void RemoveCardFromGame(CardVisual card) { if (card.photonView.isMine) { card.transform.localPosition = new Vector3(-100f, 20f, -40f); } }
/** Create a new card, set its attributes, and return its transform */ public CardVisual CreateCard(CardData cardData, int cardID, bool faceUp) { if (m_cardPrefab == null) { Debug.LogError("Card Visual prefab not set"); } // Create the new card GameObject newCard = GameObject.Instantiate(m_cardPrefab); if (faceUp) { newCard.transform.localEulerAngles = new Vector3(0, 0, 0); } else { newCard.transform.localEulerAngles = new Vector3(0, 180, 0); } CardVisual cv = newCard.GetComponent <CardVisual>(); // cardData is null if the card is hidden (e.g. a card in the opponent's hand) if (cardData != null) { cv.SetCardData(cardData, cardID); } // Add the new card to the list by its ID m_cards.Add(cardID, cv); return(cv); }
public void BuildDistrict() { CardVisual selectedCard = gameManager.gameGUI.selectedCard; if (selectedCard != null) { //TODO: make sure district is not already built //TODO: check build district bug, kept card after building district if (coins >= selectedCard.card.cost) { districtstoBuild--; AdjustCoins(-selectedCard.card.cost); Card c = hand.RemoveCardWithID(selectedCard.card.id); gameManager.gameGUI.RemoveCard(c); builtDistricts.AddCard(c); gameManager.gameGUI.RecalculateCardPositions(); gameManager.gameGUI.AddDistrict(c, builtDistricts.collection.Count - 1); if (districtstoBuild == 0) { gameManager.gameGUI.turnButtons[0].interactable = false; } Hashtable table = new Hashtable(); table[(byte)1] = myID; table[(byte)2] = c.id; gameManager.gameClient.SendEvent(11, table, true, false); } } }
private void CheckAndActivateCard(CardVisual card) { if (!card.active) { card.RPCSetCardAciveState(PhotonTargets.All, true); } }
public void StartEvent() { bool hasMinion = false; Transform mz = GameManager.Instance.GetActiveMinionZone(false); foreach (Transform t in mz) { CardVisual cv = t.GetComponent <CardVisual>(); if (cv.Md != null) { hasMinion = true; } } //TODO: If Silence is one of the hero powers, then do a PostNotification for Hero Power Silence). if (GameManager.Instance.GetActiveMinionZone(false).childCount == 0 || !hasMinion) { EffectCommand.Instance.EffectQueue.Enqueue(EVENT_TYPE.POWER_SILENCE); //Call the Next Power in the Queue InvokeEventCommand.InvokeNextEvent(); } else { StartCoroutine(GameManager.Instance.SetInstructionsText("Select a Minion to Silence")); foreach (Transform t in mz) { CardVisual cv = t.GetComponent <CardVisual>(); if (cv.Md != null) { t.gameObject.AddComponent <SilenceListener>(); } } } }
public override void ExecuteCommand() { // Create the new card m_card = m_visualManager.CreateHiddenCard(); MoveToDeck(); }
public void OnPointerDown(PointerEventData eventData) { GameObject card = eventData.pointerCurrentRaycast.gameObject.transform.parent.gameObject; CardVisual cv = card.GetComponent <CardVisual>(); Transform minions = GameManager.Instance.GetActiveMinionZone(false); //Multiplayer int position = gameObject.transform.GetSiblingIndex(); object[] data = new object[] { position }; EffectCommandPun.Instance.SendData(ACTIVATE_SILENCE_SYNC_EVENT, data); cv.ActivateSilence(true); foreach (Transform t in minions) { SilenceListener sl = t.GetComponent <SilenceListener>(); if (sl) { Destroy(sl); } } EffectCommand.Instance.EffectQueue.Enqueue(EVENT_TYPE.POWER_SILENCE); InvokeEventCommand.InvokeNextEvent(); UIManager.Instance.RemoveEffectIcon = true; }
public void OnPointerDown(PointerEventData eventData) { GameObject card = eventData.pointerCurrentRaycast.gameObject.transform.parent.gameObject; CardVisual cv = card.GetComponent <CardVisual>(); Discard(cv, card); }
private void TapMinions(List <CardPhoton> cards) { foreach (CardPhoton card in cards) { foreach (Transform t in GameManager.Instance.GetActiveMinionZone(true)) { CardVisual cv = t.GetComponent <CardVisual>(); if (cv.Md != null && card is MinionDataPhoton) { MinionDataPhoton mdp = (MinionDataPhoton)card; if (mdp.MinionID == cv.Md.MinionID) { cv.IsTapped = true; cv.ChangeTappedAppearance(); } } else if (cv.Sd != null && card is StarterDataPhoton) { StarterDataPhoton sdp = (StarterDataPhoton)card; if (sdp.StarterID == cv.Sd.StarterID) { cv.IsTapped = true; cv.ChangeTappedAppearance(); } } } } }
private void AssignDamageToAttackers() { foreach (GameObject card in GameManager.Instance.MinionsAttacking) { CardVisual cv = card.GetComponent <CardVisual>(); ConditionListener cl = card.GetComponent <ConditionListener>(); if (cv.Md != null && cl != null) { if ((cl.ConditionEvent == EVENT_TYPE.BLEED || cl.ConditionEvent == EVENT_TYPE.MINION_DEFEATED) && (cv.CurrentHealth - 1) == 0) { minionsLeft.Add(cv); } else { cv.AdjustHealth(1, false); } } else { cv.AdjustHealth(1, false); } } if (minionsLeft.Count > 0) { attackAfter = true; } GameManager.Instance.MinionsAttacking.Clear(); }
public override void ExecuteCommand() { CGBasicZone playerFocusZone; CardVisual card = m_visualManager.GetCard(m_cardID); if (card != null) { if (m_casterID == m_visualManager.m_playerID) { playerFocusZone = m_visualManager.GetPlayerTargettingZone(); } else { playerFocusZone = m_visualManager.GetOpponentTargettingZone(); } Sequence seq = playerFocusZone.MoveCardToZone(card); seq.AppendInterval(1.0f); seq.AppendCallback(RunSpellAnimation); } else { Debug.LogError("CardVisual being cast not found"); FinishCommand(); } }
public CardVisual SpawnToken() { CardData tokenData = Resources.Load <CardData>("CardData/" + spawnableTokenDataName) as CardData; CardVisual tokenCard = SpawnBaseToken(tokenData, GetCardPrefabName(spawnCardType)); return(tokenCard); }
protected override void OnVFXLanded(EventData data) { base.OnVFXLanded(data); CardVisual card = data.GetMonoBehaviour("Card") as CardVisual; CardVFX vfx = data.GetMonoBehaviour("VFX") as CardVFX; if (card != this) { return; } switch (lastStatAdjustment.stat) { case Constants.CardStats.SupportValue: cardSupportValueText.text = supportValue.ToString(); supportToken.UpdateSupportText(lastStatAdjustment.stat, supportValue); TextTools.AlterTextColor(supportValue, _supportData.supportValue, cardSupportValueText); break; } Debug.Log(card.gameObject.name + " has been hit with a VFX: " + vfx.gameObject.name); Grid.EventManager.RemoveListener(Constants.GameEvent.VFXLanded, OnVFXLanded); }
//Remove all my adjustments from a target private void RemoveStatAdjustments(CardVisual card) { //bool hasVFX = String.IsNullOrEmpty(parentAbility.abilityVFX); List <StatAdjustment> targetAdjustments = new List <StatAdjustment>(); for (int i = 0; i < card.statAdjustments.Count; i++) { for (int j = 0; j < adjustments.Count; j++) { if (card.statAdjustments[i].uniqueID == adjustments[j].uniqueID) { //Debug.Log("Match Found"); targetAdjustments.Add(card.statAdjustments[i]); } //else { // Debug.Log(card.statAdjustments[i].uniqueID + " is the id I'm looking at and " + adjustments[j].uniqueID + " is my id"); //} } } for (int i = 0; i < targetAdjustments.Count; i++) { card.RPCRemoveSpecialAbilityStatAdjustment(PhotonTargets.All, targetAdjustments[i].uniqueID, source, false, setStatToValue); } }
public virtual void Initialize(CardData data, CardVisual card) { parentCard = card; parentCardData = data; image.sprite = parentCardData.cardImage; }
public override void Apply(CardVisual target) { switch (valueSetmethod) { case ValueSetMethod.Manual: ApplyStatAdjustment(target); break; case ValueSetMethod.DeriveValueFromTargetStat: DetermineSourceOfTargetStat(); ApplyStatAdjustment(target); break; case ValueSetMethod.DeriveValueFromCardsInZone: SetAdjustmentValuesByCardsInZone(); ApplyStatAdjustment(target); break; case ValueSetMethod.DeriveValueFromResource: SetAdjustmentValuesByResource(); ApplyStatAdjustment(target); break; case ValueSetMethod.SwapStats: SwapStats(target); break; } }
private void DoStuffOnTarget() { CardVisual currentTarget = CardClicked(); if (!ConfirmCardClicked(currentTarget, DeckType.Battlefield)) { return; } //TargetingHandler.CreateTargetInfoListing(sourceOfTargetingEffect, currentTarget); if (confirmedTargetCallback != null) { if (confirmedTargetCallback(currentTarget)) { //Debug.Log(currentTarget.cardData.cardName + " has been clicked"); //if (isChoosingTarget) // isChoosingTarget = false; selectionComplete = true; StartCoroutine(Reset()); //currentTarget. } } else { Debug.LogError("[Combat Manager - DoStuffOnTarget] Callback was null"); } }
public override void Apply(CardVisual target) { //Debug.Log(targetLocation.ToString()); bool hasVFX = String.IsNullOrEmpty(parentAbility.abilityVFX); switch (targetLocation) { case DeckType.SoulCrypt: if (target is CreatureCardVisual || target is SupportCardVisual) { target.RPCCheckDeath(PhotonTargets.All, source, true, !hasVFX); } else { target.RPCCheckDeath(PhotonTargets.All, source, true, !hasVFX); target.currentDeck.RPCTransferCard(PhotonTargets.All, target, GetDeckFromType(targetLocation, target)); } break; case DeckType.Void: target.currentDeck.RPCTransferCard(PhotonTargets.All, target, GetDeckFromType(targetLocation, target)); target.StartCoroutine(target.RemoveCardVisualFromField(target)); break; default: target.currentDeck.RPCTransferCard(PhotonTargets.All, target, GetDeckFromType(targetLocation, target)); break; } }
//public void RPCBroadcastInterceptor(PhotonTargets targets, CardVisual interceptor) { //} public void RPCBroadcastCombat(PhotonTargets targets, CardVisual attacker, CardVisual defender) { int attackerID = attacker.photonView.viewID; int defenderID = defender.photonView.viewID; owner.photonView.RPC("BroadcastCombat", targets, attackerID, defenderID); }
public void AssignDamageToAttackers() { foreach (Transform card in GameManager.Instance.GetActiveMinionZone(true)) { CardVisual cv = card.GetComponent <CardVisual>(); if (cv.IsTapped && !cv.TapEffect) { if (cv.Md != null) { if ((cv.Md.ConditionID == 1 && (cv.CurrentHealth - 1) == 0) || (cv.Md.ConditionID == 3 && (cv.CurrentHealth - 1) == 0)) { continue; } else { cv.AdjustHealth(1, false); } } else { cv.AdjustHealth(1, false); } } } }
public void Initialize(CardVisual target, bool moving, bool sendImpactEvent = true) { //if (lifetime > 0 && !moving) // Invoke("CleanUp", lifetime); if (target == null) { return; } photonView.RPC("RPCInitialize", PhotonTargets.All, target.photonView.viewID, moving); if (moving) { StartCoroutine(StartMovement()); } else { //RPCSendImpactEvent(PhotonTargets.Others); //StartCoroutine(SendImmediateEvent()); if (sendImpactEvent) { SendImmediateEvent(); } } //StartCoroutine(StartMovement()); //RPCInitialize(targetCard.photonView.viewID, moving); }
public void InitIalize(CardVisual myCard) { myDomainCard = myCard; domainImage.sprite = ((CardDomainData)myDomainCard.cardData).domainIcon; myDomainCard.domainTile = this; }
public void DropCard(CardVisual visual) { NetworkCardGameManager.sInstance.AddCardToDrop(visual.CardAsset, PhotonNetwork.player, LocalPlayerVisual.CardAnimationAim.Hand, false); NetworkCardGameManager.sInstance.RemoveCardFromHand(visual.CardAsset, PhotonNetwork.player); CardsManager.Instance.DropCard(visual); awaliableDrops--; }
private void SendCardToHand(CardVisual card) { //Debug.Log(card.gameObject.name + " is being sent to the hand"); if (owner.handManager.IsCollectionFull()) { Debug.LogWarning("Hand is Full"); //StartCoroutine(SendCardToSoulCrypt(card)); SendCardToSoulCrypt(card); return; } if (card.photonView.isMine) { card.RPCChangeCardVisualState(PhotonTargets.Others, CardVisual.CardVisualState.ShowBack); card.ChangeCardVisualState((int)CardVisual.CardVisualState.ShowFront); //Debug.Log(card.cardData.cardName + " is mine and is showing the card back to others"); } if (!Mulligan.choosingMulligan) { CheckAndActivateCard(card); card.handPos = owner.handManager.GetFirstEmptyCardPosition(card); } else { card.RPCSetCardAciveState(PhotonTargets.All, false); card.handPos = owner.mulliganManager.GetFirstEmptyCardPosition(card); } }
public Transform AssignSpecificPosition(Transform testlocation, CardVisual card) { for (int i = 0; i < cardPositions.Count; i++) { if (cardPositions[i].cardPosition == testlocation && cardPositions[i].filled) { Debug.LogWarning("[Card Position Manager] The position in question is alreay filled. Returning Null"); return(null); } if (cardPositions[i].cardPosition == testlocation && !cardPositions[i].filled) { cardPositions[i].filled = true; cardPositions[i].card = card; if (managerLocation == ManagerLocation.Battlefield) { RPCBroadcastcardPositionIndex(PhotonTargets.Others, i, card); } return(testlocation); } } return(null); }
/** Define the data of a blank card */ public CardVisual DefineCard(CardVisual card, CardData data, int cardID) { card.SetCardData(data, cardID); m_cards.Add(cardID, card); return(card); }
public override void ExecuteCommand() { // Create the new card m_card = m_visualManager.CreateCard(m_cardData, m_cardID, false); MoveToDeck(); }
private void RemoveKeywords(CardVisual target) { for (int i = 0; i < keywords.Count; i++) { target.RPCAddKeyword(PhotonTargets.All, keywords[i], false); } }
public override void ExecuteCommand() { GameObject castMenu = (GameObject)GameObject.Instantiate(Resources.Load("CardGame/Menus/SelectionMenu")); m_menu = castMenu.GetComponent <CGSelectionZone>(); if (m_menu == null) { Debug.LogError("Cast Menu prefab missing CGCastMenuZone"); } List <int> cardIDs = new List <int>(); foreach (CastableCard card in m_castableCards) { cardIDs.Add(card.cardID); CardVisual cv = m_visualManager.GetCard(card.cardID); // Move card to CastMenu m_menu.MoveCardToZone(cv); } // Highlight all playable cards // Make playable cards clickable m_visualManager.MakeClickable(cardIDs, OnCardClick); }