public void EndCombat()
{
if (attacker != null)
{
attacker.battlefieldPos.position -= selectedPos;
attacker = null;
}
//TODO: End of Combat Events
if (defender != null)
{
defender.RPCTargetCard(PhotonTargets.All, false);
defender = null;
}
isInCombat = false;
selectingDefender = false;
if (lineDrawer.lineRenderer.enabled)
{
lineDrawer.RPCStopDrawing(PhotonTargets.All);
}
combatState = CombatState.ChoosingAttacker;
}
public void LaunchVFX(CreatureCardVisual damageDealer, CreatureCardVisual damageTaker)
{
GameObject atkVFX;
if (damageDealer.cardData.movingVFX)
{
atkVFX = PhotonNetwork.Instantiate(damageDealer.attackEffect, damageDealer.transform.position, Quaternion.identity, 0) as GameObject;
}
else
{
atkVFX = PhotonNetwork.Instantiate(damageDealer.attackEffect, damageTaker.transform.position, Quaternion.identity, 0) as GameObject;
}
CardVFX vfx = atkVFX.GetComponent <CardVFX>();
if (vfx.photonView.isMine)
{
vfx.Initialize(damageTaker, damageDealer.cardData.movingVFX);
if (damageDealer.cardData.movingVFX)
{
atkVFX.transform.SetParent(damageDealer.transform, false);
atkVFX.transform.localPosition = Vector3.zero;
//vfx.target = damageTaker.battleToken.incomingEffectLocation;
//vfx.beginMovement = true;
}
else
{
atkVFX.transform.SetParent(damageTaker.battleToken.incomingEffectLocation, false);
atkVFX.transform.localPosition = Vector3.zero;
}
}
vfx.RPCSetVFXAciveState(PhotonTargets.Others, true);
}
private void SelectAttacker()
{
CreatureCardVisual currentTarget = CardClicked() as CreatureCardVisual;
//CardCreatureData creatureData = currentTarget.cardData as CardCreatureData;
//Debug.Log("Selecting Attacker");
if (!ConfirmCardClicked(currentTarget, DeckType.Battlefield, true))
{
return;
}
if (!Finder.CardHasPrimaryType(currentTarget, CardType.Soul) && !Finder.CardHasPrimaryType(currentTarget, CardType.Player))
{
//Debug.LogError("That cannot attack");
return;
}
if (!currentTarget.CanAttack())
{
//Debug.LogError("That cannot attack");
return;
}
attacker = currentTarget;
isInCombat = true;
selectingDefender = true;
attacker.battlefieldPos.position += selectedPos;
currentInterceptors = SortInterceptors();
combatState = CombatState.ChoosingDefender;
}
private void SelectDefender()
{
CreatureCardVisual currentTarget = CardClicked() as CreatureCardVisual;
//CardCreatureData creatureData = currentTarget.cardData as CardCreatureData;
if (!ConfirmCardClicked(currentTarget, DeckType.Battlefield))
{
Debug.Log("Invalid Target");
return;
}
if (currentTarget.owner == owner)
{
Debug.Log("That Soul is yours");
return;
}
if (Finder.CardHasKeyword(currentTarget, Keywords.Invisible))
{
Debug.Log("That Soul is invisible");
return;
}
if (attacker.keywords.Contains(Keywords.Rush) && currentTarget.primaryCardType == CardType.Player)
{
Debug.Log("Rush Souls cannot attack Generals the turn they're played");
return;
}
if (currentTarget.keywords.Contains(Keywords.Flight) && !attacker.keywords.Contains(Keywords.Flight) && !attacker.keywords.Contains(Keywords.Reach))
{
Debug.Log("That target is flying");
return;
}
//List<CardVisual> potentialInterceptors = Finder.FindAllCardsInZone(DeckType.Battlefield, Keywords.Interceptor, OwnerConstraints.Theirs);
if (currentInterceptors.Count > 0)
{
if (!currentInterceptors.Contains(currentTarget))
{
Debug.Log("You must select an Interceptor");
return;
}
defender = currentTarget;
}
else
{
defender = currentTarget;
}
Debug.Log(defender.cardData.cardName + " is Defending");
combatState = CombatState.SendingCombatEvents;
}
public static List <CardVisual> FindAllDamagedOrUndamagedCreatures(bool damaged)
{
List <CardVisual> results = new List <CardVisual>();
List <CardVisual> allCards = FindAllCardsOfType(CardType.Soul);
for (int i = 0; i < allCards.Count; i++)
{
CreatureCardVisual soul = allCards[i] as CreatureCardVisual;
//CardCreatureData soulData = soul.cardData as CardCreatureData;
//Debug.Log("Checking to see if " + soul.cardData.cardName + " is damaged " + damaged);
//Debug.Log(soul.health + " is the heath of " + soul.cardData.cardName);
if (soul.health < soul.maxHealth && damaged)
{
results.Add(soul);
//Debug.Log(soul.cardData.cardName + " is damaged");
}
if (soul.health >= soul.maxHealth && !damaged)
{
results.Add(soul);
}
}
return(results);
}
public override void Initialize(CardData data, CardVisual card)
{
base.Initialize(data, card);
_creatureData = parentCardData as CardCreatureData;
_parentCard = parentCard as CreatureCardVisual;
SetUpTokenText();
}
private List <CardVisual> SortInterceptors()
{
currentInterceptors.Clear();
List <CardVisual> allInterceptors = Finder.FindAllCardsInZone(DeckType.Battlefield, Keywords.Interceptor, OwnerConstraints.Theirs);
for (int i = allInterceptors.Count - 1; i >= 0; i--)
{
CreatureCardVisual interceptor = allInterceptors[i] as CreatureCardVisual;
if (Finder.CardHasKeyword(attacker, Keywords.Invisible))
{
allInterceptors.Remove(interceptor);
//Debug.Log("attcker is invisable, removeing all interceptors");
continue;
}
if (Finder.CardHasKeyword(interceptor, Keywords.Invisible))
{
allInterceptors.Remove(interceptor);
//Debug.Log("Defender is invisable, removeing");
continue;
}
if (interceptor.size < attacker.size)
{
//Debug.Log(interceptor.cardData.cardName + " is smaller than " + attacker.cardData.cardName + ". Removeing");
allInterceptors.Remove(interceptor);
continue;
}
if (Finder.CardHasKeyword(attacker, Keywords.Flight) && !Finder.CardHasKeyword(interceptor, Keywords.Flight) && !Finder.CardHasKeyword(interceptor, Keywords.Reach))
{
//Debug.Log(interceptor.cardData.cardName + " does not have flight or reach and " + attacker.cardData.cardName + " does. Removeing");
allInterceptors.Remove(interceptor);
continue;
}
if (Finder.CardHasKeyword(interceptor, Keywords.Flight) && !Finder.CardHasKeyword(attacker, Keywords.Flight))
{
allInterceptors.Remove(interceptor);
continue;
}
}
//for (int i = 0; i < allInterceptors.Count; i++) {
// Debug.Log(allInterceptors[i].cardData.name + " is a valid interceptor");
//}
return(allInterceptors);
}
public CardVisual SpawnTokenWithCopiedStats(CardVisual target)
{
CardData tokenData = Resources.Load <CardData>("CardData/" + spawnableTokenDataName) as CardData;
CardVisual tokenCard = SpawnBaseToken(tokenData, GetCardPrefabName(spawnCardType));
if (target is CreatureCardVisual)
{
CreatureCardVisual soul = target as CreatureCardVisual;
tokenCard.RPCSetCardStats(PhotonTargets.All, soul.essenceCost, soul.attack, soul.size, soul.maxHealth);
}
return(tokenCard);
}
//Update all my stat adjustments with the selecte tagret's chosen stat.
private void SetAdjustmentValuesByTargetStat(CardVisual target)
{
if (!(target is CreatureCardVisual))
{
return;
}
CreatureCardVisual soul = target as CreatureCardVisual;
for (int i = 0; i < adjustments.Count; i++)
{
adjustments[i].value = SetValueBasedOnTarget(soul, invertValue);
source.RPCUpdateSpecialAbilityStatAdjustment(PhotonTargets.Others, adjustments[i], source, adjustments[i].value);
}
}
private void CombatHelper(CreatureCardVisual damageDealer, CreatureCardVisual damageTaker)
{
int tempAttackvalue = 0;
if (damageDealer.attack < 0)
{
tempAttackvalue = 0;
}
else
{
tempAttackvalue = -damageDealer.attack;
}
//Debug.Log("the attacker's attack value at the time of damage dealt is: " + damageDealer.attack.ToString());
SpecialAbility.StatAdjustment adj = new SpecialAbility.StatAdjustment(Constants.CardStats.Health, tempAttackvalue, false, false, damageDealer);
bool hasVFX = String.IsNullOrEmpty(damageDealer.attackEffect);
if (damageDealer == attacker)
{
if (damageDealer.keywords.Contains(Keywords.Cleave))
{
CardVisual rightOfTarget = damageTaker.owner.battleFieldManager.GetCardToTheRight(damageTaker);
CardVisual leftOfTarget = damageTaker.owner.battleFieldManager.GetCardToTheLeft(damageTaker);
if (rightOfTarget != null)
{
rightOfTarget.RPCApplyUntrackedStatAdjustment(PhotonTargets.All, adj, damageDealer, false);
}
if (leftOfTarget != null)
{
leftOfTarget.RPCApplyUntrackedStatAdjustment(PhotonTargets.All, adj, damageDealer, false);
}
}
}
damageTaker.RPCApplyUntrackedStatAdjustment(PhotonTargets.All, adj, damageDealer, !hasVFX);
if (!hasVFX)
{
LaunchVFX(damageDealer, damageTaker);
}
}
public void RefreshMySouls()
{
List <CardVisual> cardsOnField = Finder.FindAllCardsInZone(Constants.DeckType.Battlefield, Constants.OwnerConstraints.Mine);
//Deck._battlefield.RefreshAll(cardsOnField);
battlefield.RefreshAll(cardsOnField);
for (int i = 0; i < cardsOnField.Count; i++)
{
if (cardsOnField[i] is CreatureCardVisual)
{
CreatureCardVisual creature = cardsOnField[i] as CreatureCardVisual;
creature.hasAttacked = false;
}
}
gameState = GameStates.Upkeep;
}
//Determine which stat to derive a value from
private int SetValueBasedOnTarget(CreatureCardVisual target, bool inverse)
{
int value = 0;
if (target != null)
{
switch (targetStat)
{
case CardStats.Cost:
value = target.essenceCost;
break;
case CardStats.Attack:
value = target.attack;
break;
case CardStats.Size:
value = target.size;
break;
case CardStats.Health:
value = target.health;
break;
}
}
if (maxValue > 0 && value > maxValue)
{
value = maxValue;
}
if (inverse)
{
value = -value;
}
return(value);
}
//private IEnumerator RemoveCardVisualFromField(CardVisual card) {
// card.SetCardActiveState(false);
// yield return new WaitForSeconds(3f);
// if (card.photonView.isMine) {
// card.ChangeCardVisualState((int)CardVisual.CardVisualState.ShowFront);
// card.RPCChangeCardVisualState(PhotonTargets.Others, CardVisual.CardVisualState.ShowBack);
// }
// if (card is CreatureCardVisual) {
// CreatureCardVisual creature = card as CreatureCardVisual;
// creature.RPCToggleExhaust(PhotonTargets.All, false);
// }
// card.transform.localPosition = new Vector3(-40f, 20f, 20f);
//}
private void SendCardToVoid(CardVisual card)
{
if (card.photonView.isMine)
{
card.ChangeCardVisualState((int)CardVisual.CardVisualState.ShowFront);
card.RPCChangeCardVisualState(PhotonTargets.Others, CardVisual.CardVisualState.ShowBack);
}
if (card is CreatureCardVisual)
{
CreatureCardVisual creature = card as CreatureCardVisual;
creature.RPCToggleExhaust(PhotonTargets.All, false);
}
//card.ResetCardData();
//card.RPCSetUpCardData(PhotonTargets.All);
//card.SetupCardData();
if (card.photonView.isMine)
{
card.transform.localPosition = new Vector3(-80f, 20f, -40f);
}
}
public void RPCInitialize(int cardID, bool moving)
{
CardVisual target = Finder.FindCardByID(cardID);
if (target == null)
{
return;
}
if (lifetime > 0 && !moving)
{
Invoke("CleanUp", lifetime);
}
this.targetCard = target;
if (target is CreatureCardVisual)
{
CreatureCardVisual soul = target as CreatureCardVisual;
this.target = soul.battleToken.incomingEffectLocation;
}
}
private static Dictionary <int, int> StatCollector(CardStats stat, DeckType zone, OwnerConstraints owner)
{
Dictionary <int, int> results = new Dictionary <int, int>();
List <CardVisual> cardsToSearch = FindAllCardsInZone(zone, owner); //FindAllCardsOfType(CardType.Soul, zone, owner);
//foreach(CardVisual card in cardsToSearch) {
// Debug.Log(card.gameObject.name + " is " + card.cardData.cardName);
//}
switch (stat)
{
case CardStats.Cost:
for (int i = 0; i < cardsToSearch.Count; i++)
{
results.Add(cardsToSearch[i].photonView.viewID, cardsToSearch[i].essenceCost);
}
break;
case CardStats.Attack:
for (int i = 0; i < cardsToSearch.Count; i++)
{
if (cardsToSearch[i].primaryCardType != CardType.Soul)
{
continue;
}
CreatureCardVisual soul = cardsToSearch[i] as CreatureCardVisual;
results.Add(soul.photonView.viewID, soul.attack);
}
break;
case CardStats.Size:
for (int i = 0; i < cardsToSearch.Count; i++)
{
if (cardsToSearch[i].primaryCardType != CardType.Soul)
{
continue;
}
CreatureCardVisual soul = cardsToSearch[i] as CreatureCardVisual;
results.Add(soul.photonView.viewID, soul.size);
}
break;
case CardStats.Health:
for (int i = 0; i < cardsToSearch.Count; i++)
{
if (cardsToSearch[i].primaryCardType != CardType.Soul)
{
continue;
}
CreatureCardVisual soul = cardsToSearch[i] as CreatureCardVisual;
results.Add(soul.photonView.viewID, soul.health);
}
break;
}
return(results);
}
