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);
}
