public AttackCreatureResponse(CharacterEnum caller, CharacterEnum target, CreatureCard attacker, CreatureCard attackedCreature)
{
this.Caller = caller;
this.Target = target;
this.Attacker = attacker;
this.AttackedCreature = attackedCreature;
}
/// <summary>
/// Block attacking card using selected card(def)
/// </summary>
/// <param name="def"></param>
public bool BlockCard(CreatureCard def)
{
Debug.LogFormat("Block Card With {0}", def);
bool ret = true;
CreatureCard atkCard = null;
PhysicalAttribute attackInst = null;
if (def.UseCard() == false) //If defend card can't be used, can't be blocked
{
return(false);
}
else
{
attackInst = Setting.RayCastCard(def.PhysicalCondition);
}
if (attackInst != null)
{
atkCard = (CreatureCard)attackInst.OriginCard;
if (!error.CheckAttackingCard(def, atkCard))
{
ret = false;
}
Debug.LogFormat("AttackingCard: {0}, DefendingCard: {1}", atkCard.GetCardData.Name, def.GetCardData.Name);
}
return(ret);
}
public override int Visit(DamageDependingOnCPAbility ability)
{
//Log(OwnerCard.Name + " used KillIfPDAbility");
List <CreatureCard> modCards = new List <CreatureCard>();
foreach (CardTarget t in CardTargets)
{
CreatureCard targetCard = (CreatureCard)(GameManager.UserDict[t.Character].Player.GetCardFromId(t.CardId, Place.INNER) ?? GameManager.UserDict[t.Character].Player.GetCardFromId(t.CardId, Place.OUTER));
//Log("Target is " + (deadCard.Name ?? "null") + " of " + t.Character.ToString());
targetCard.Health -= (int)Math.Ceiling((double)Caller.Mana / 2);
modCards.Add(targetCard);
}
foreach (CharacterEnum c in GameManager.UserDict.Keys)
{
if (modCards.Any())
{
AddResponse(c, new CardsModifiedResponse(modCards));
}
}
// Case target is Player
foreach (PlayerTarget t in PlayerTargets)
{
Player targetPlayer = GameManager.UserDict[t.Character].Player;
targetPlayer.Health -= Caller.Mana;
foreach (CharacterEnum c in GameManager.UserDict.Keys.ToList())
{
AddResponse(c, new PlayerModifiedResponse(targetPlayer.Character, targetPlayer.Mana, targetPlayer.Health));
}
}
return(0);
}
public override int Visit(SalazarAttack attack)
{
int attackPower = 2;
foreach (User u in GameManager.UserDict.Values)
{
foreach (CreatureCard c in u.Player.Inner)
{
attackPower += c.PoisonDamage;
}
foreach (CreatureCard c in u.Player.Outer)
{
attackPower += c.PoisonDamage;
}
}
if (CardTarget != null)
{
CreatureCard targetCard = (CreatureCard)(GameManager.UserDict[CardTarget.Character].Player.GetCardFromId(CardTarget.CardId, Place.INNER) ?? GameManager.UserDict[CardTarget.Character].Player.GetCardFromId(CardTarget.CardId, Place.OUTER));
if (targetCard.Health - attackPower > 0)
{
targetCard.PoisonDamage += attackPower;
foreach (CharacterEnum c in GameManager.UserDict.Keys.ToList())
{
AddResponse(c, new CardsModifiedResponse(targetCard));
}
}
}
return(attackPower);
}
public override int Visit(ReturnToHandAbility ability)
{
foreach (CardTarget target in CardTargets)
{
if (Caller.Hand.Count >= AmaruConstants.HAND_MAX_SIZE)
{
return(0);
}
Place origin = GameManager.UserDict[target.Character].Player.GetCardFromId(target.CardId, Place.INNER) == null ? Place.OUTER : Place.INNER;
CreatureCard oldCard = ((CreatureCard)GameManager.GetPlayer(target.Character).GetCardFromId(target.CardId, origin));
CreatureCard moved = (CreatureCard)oldCard.Original;
// TODO: gestire se l'area è piena
if (origin == Place.OUTER)
{
Caller.Outer.Remove(oldCard);
}
else if (origin == Place.INNER)
{
Caller.Inner.Remove(oldCard);
}
else//*/
{
return(0);
}
Caller.Hand.Add(moved);
foreach (CharacterEnum c in GameManager.UserDict.Keys)
{
AddResponse(c, new EvocationResponse(Owner, oldCard, moved, Place.HAND, deleteOriginal: true));
}
}
return(0);
}
public void CardPlayDrop(CreatureCard c, Area a)
{
Debug.Log("CardPlayDrop");
tmp.Add(1, a);
photonView.RPC("RPC_DropCard", PhotonTargets.All,
c.GetCardData.UniqueId, 1);
}
private void RPC_BlockClient(int defendId, int attackId, int defendUser, int attackUser, int count)
{
CreatureCard defendCard = GetCard(defendId, defendUser);
CreatureCard attackCard = GetCard(attackId, attackUser);
MoveCardInstance.SetCardsForBlock(defendCard, attackCard, count);
}
public void CreateHandCard(Card card, Player player)
{
GameObject cardInHand = null;
if (card.cardType == CardType.Creature)
{
Debug.Log("Am a Creature");
CreatureCard cCard = (CreatureCard)card;
cardInHand = CreateHandCreature(cCard);
}
else if (card.cardType == CardType.Spell)
{
Debug.Log("Am a Spell");
SpellCard sCard = (SpellCard)card;
cardInHand = CreateHandSpell(sCard);
}
Debug.Log(cardInHand.name);
if (player.isPlayer1)
{
cardInHand.transform.SetParent(p1HandContents, false);
}
if (!player.isPlayer1)
{
cardInHand.transform.SetParent(p2HandContents, false);
}
}
public void updatePreview(HistoryObjectHandler obj)
{
Card c = obj.card;
if (c is CreatureCard)
{
CreatureCard cc = (CreatureCard)c;
if (obj.owner == CARD_OWN.FRIENDLY)
{
previewImage.sprite = AssetManager.getSprite("friendly" + c.name);
}
else if (obj.owner == CARD_OWN.ENEMY)
{
previewImage.sprite = AssetManager.getSprite("enemy" + c.name);
}
previewAttack.text = cc.stats.attack.ToString();
previewHealth.text = cc.stats.health.ToString();
previewSpeed.text = cc.stats.speed.ToString();
previewRange.text = cc.stats.range.ToString();
previewDescription.text = buildDescription(cc);
}
else
{
previewImage.sprite = AssetManager.getSprite(c.name);
previewAttack.text = "";
previewHealth.text = "";
previewSpeed.text = "";
previewRange.text = "";
previewDescription.text = buildDescription(c);
}
}
public void Update()
{
deckSizeText.text = cards.ToString() + "/30";
if (hoveredId != 0)
{
Card c = GameEngine.getCardById(hoveredId);
previewPanel.SetActive(true);
if (c is CreatureCard)
{
CreatureCard cc = (CreatureCard)c;
previewImage.sprite = AssetManager.getSprite("friendly" + c.name);
previewAttack.text = cc.stats.attack.ToString();
previewHealth.text = cc.stats.health.ToString();
previewSpeed.text = cc.stats.speed.ToString();
previewRange.text = cc.stats.range.ToString();
previewDescription.text = buildDescription(cc);
}
else
{
previewImage.sprite = AssetManager.getSprite(c.name);
previewAttack.text = "";
previewHealth.text = "";
previewSpeed.text = "";
previewRange.text = "";
previewDescription.text = buildDescription(c);
}
}
else
{
previewPanel.SetActive(false);
}
}
/// <summary>
/// Add attacking and defending card instances in dictionary.
/// This data is used in 'BattlePhaseResolve' phase
/// </summary>
/// <param name="attk">Attacking card</param>
/// <param name="def">Defending card</param>
/// <param name="count">Number of 'def' card instances for 'attk' </param>
public void AddBlockInstance(CreatureCard attk, CreatureCard def, ref int count)
{
BlockInstance b = null;
//Check if there is same attacking card instance
//If 'attk' is new attacking card instance, make new 'BlockInstance' for this card.
b = SearchBlockInstanceOfAttacker(attk);
if (b == null)
{
b = new BlockInstance();
b.attacker = attk;
BlockInstDict.Add(attk, b);
Debug.Log("BlockInstDic added in dictionary.");
}
else
{
Debug.LogWarningFormat("BlockInst For Attacker, {0} AlreadyExist", attk.GetCardData.Name);
}
//If 'def' isn't in the 'defenders' of the BlockInstance 'b', add it in list
if (!b.defenders.Contains(def))
{
b.defenders.Add(def);
}
count = b.defenders.Count;
Debug.LogErrorFormat("Current Blocking Card Count for {0} is {1}", b.attacker.GetCardData.Name, count);
}
public GameCreature(Card card) : base(card)
{
CreatureCard gc = (CreatureCard)card;
currentAttack = gc.attack;
currentHealth = gc.health;
}
public GameObject CreateHandCreature (CreatureCard card) {
GameObject go = Instantiate(allStatsCard);
go.transform.SetParent(GameObject.FindGameObjectWithTag("Canvas").transform, false);
HandCreature hc = go.GetComponent<HandCreature>() as HandCreature;
hc.Initialise(card);
return go;
}
public IEnumerator HeroAttackPhase()
{
turnPhase = phase.CombatPhase; //sets state of combat phase
for (int i = 0; i < equippedCreaturesObj.Count; i++) //loop repeats for each creature fighting the hero
{
CreatureCard attackCreature = equippedCreaturesObj[i].GetComponent <CreatureCard>();
StartCoroutine(animationController.AttackMove(equippedCreaturesObj[i], equippedHeroObj[0])); //starts coroutine for moving attacking card
attackCreature.PlaySound(); //plays sound effect
if (attackCreature.creatureData.dmg > currentArmour.armourData.hp) //checks if creature attack is strong enough to pierce armour
{
defHero.heroData.hp -= attackCreature.creatureData.dmg - currentArmour.armourData.hp; //creature deals damage
}
HeroHPUpdate(); //updates UI text
float combatDelay = 1.3f;
yield return(new WaitForSeconds(combatDelay));
//if (i!=equippedCreaturesObj.Count-1)
//{
// yield return new WaitForSeconds(combatDelay);
//}
//else if (i == equippedCreaturesObj.Count - 1)
//{
// yield return null;
//}
}
if (defHero.heroData.hp <= 0) //checks if hero is dead
{
GameOver();
CancelInvoke();
}
Invoke("EndTurn", endTurnDelay);
}
public override int Visit(DamageDependingOnCreatureNumberAbility ability)
{
//Log(OwnerCard.Name + " used DamageDependingOnCreatureNumberAbility");
int attackPower = ability.myZone == Place.INNER ? GameManager.UserDict[Owner].Player.Inner.Count : GameManager.UserDict[Owner].Player.Outer.Count;
// Case target is Creature
if (Targets[0] is CardTarget)
{
CardTarget t = (CardTarget)Targets[0];
CreatureCard targetCard = (CreatureCard)(GameManager.UserDict[t.Character].Player.GetCardFromId(t.CardId, Place.INNER) ?? GameManager.UserDict[t.Character].Player.GetCardFromId(t.CardId, Place.OUTER));
targetCard.Health -= attackPower + ability.bonusDmg;
foreach (CharacterEnum c in GameManager.UserDict.Keys.ToList())
{
AddResponse(c, new CardsModifiedResponse(targetCard));
}
}
// Case target is Player
else
{
Player targetPlayer = GameManager.UserDict[Targets[0].Character].Player;
targetPlayer.Health -= attackPower + ability.bonusDmg;
foreach (CharacterEnum c in GameManager.UserDict.Keys.ToList())
{
AddResponse(c, new PlayerModifiedResponse(targetPlayer.Character, targetPlayer.Mana, targetPlayer.Health));
}
}
return(0);
}
public override void Visit(AttackCreatureAction action)
{
Player caller = this.GameManager.GetPlayer(action.Caller);
// Check caller player is alive and it is its main turn
if (!caller.IsAlive || GameManager.ActiveCharacter != action.Caller || !GameManager.IsMainTurn)
{
throw new CallerCannotPlayException();
}
// Check playedCard can attack and has enough EP
if (caller.GetCardFromId(action.PlayedCardId, Place.OUTER) == null &&
(caller.GetCardFromId(action.PlayedCardId, Place.INNER) == null && caller.InnerAttackAllowed))
{
throw new InvalidCardLocationException();
}
CreatureCard card = (CreatureCard)(caller.GetCardFromId(action.PlayedCardId, Place.OUTER) ?? caller.GetCardFromId(action.PlayedCardId, Place.INNER));
if (card.Energy < card.Attack.Cost)
{
throw new NotEnoughEPAvailableException();
}
// Looking that the creature is not protected
foreach (User p in GameManager.UserDict.Values)
{
if (p.Player.GetCardFromId(action.Target.CardId, Place.INNER) != null)
{
if (p.Player.IsShieldMaidenProtected)
{
throw new InvalidCardLocationException();
}
}
}
}
void Start()
{
CreatureCard c0 = new CreatureCard(3, 2, "Knight", 3, CardType.Creature, CardEffectName.Effect1, 0);
SpellCard c1 = new SpellCard("Horse", 3, CardType.Spell, CardEffectName.Effect1, 1);
SpellCard c2 = new SpellCard("Spearman", 1, CardType.Spell, CardEffectName.Effect1, 1);
CreatureCard c3 = new CreatureCard(2, 1, "Bishop", 2, CardType.Creature, CardEffectName.Effect1, 0);
CreatureCard c4 = new CreatureCard(2, 5, "King", 4, CardType.Creature, CardEffectName.Effect1, 0);
Game game = new Game(p1, p2);
p1.deck.Add(c1);
p1.deck.Add(c0);
p1.deck.Add(c2);
p1.deck.Add(c3);
p1.deck.Add(c4);
p1.deck.Add(c1);
p1.deck.Add(c0);
p1.deck.Add(c2);
p1.deck.Add(c3);
p2.deck.Add(c1);
p2.deck.Add(c0);
p2.deck.Add(c2);
p2.deck.Add(c3);
p2.deck.Add(c4);
p2.deck.Add(c1);
p2.deck.Add(c0);
p2.deck.Add(c2);
p2.deck.Add(c3);
ShuffleDeck(p1);
ShuffleDeck(p2);
}
public override int Visit(DealTotDamageToTotTargetsSpellAbility spell)
{
// Handle player targets
List <PlayerMod> modPlayers = new List <PlayerMod>();
foreach (PlayerTarget t in PlayerTargets)
{
GameManager.UserDict[t.Character].Player.Health -= spell.DamageToDeal;
modPlayers.Add(new PlayerMod(GameManager.UserDict[t.Character].Player));
}
// Handle Card targets
List <CreatureCard> modCards = new List <CreatureCard>();
foreach (CardTarget t in CardTargets)
{
CreatureCard card = (CreatureCard)(GameManager.UserDict[t.Character].Player.GetCardFromId(t.CardId, Place.INNER) ?? (GameManager.UserDict[t.Character].Player.GetCardFromId(t.CardId, Place.OUTER)));
card.Health -= spell.DamageToDeal;
modCards.Add(card);
}
// Prepare responses
foreach (CharacterEnum ch in GameManager.UserDict.Keys.ToList())
{
if (modCards.Any())
{
AddResponse(ch, new CardsModifiedResponse(modCards));
}
if (modPlayers.Any())
{
AddResponse(ch, new PlayerModifiedResponse(modPlayers));
}
}
return(0);
}
void Start () {
CreatureCard c0 = new CreatureCard(3, 2, "Knight", 3, CardType.Creature, CardEffectName.Effect1, 0);
SpellCard c1 = new SpellCard("Horse", 3, CardType.Spell, CardEffectName.Effect1, 1);
SpellCard c2 = new SpellCard("Spearman", 1, CardType.Spell, CardEffectName.Effect1, 1);
CreatureCard c3 = new CreatureCard(2, 1, "Bishop", 2, CardType.Creature, CardEffectName.Effect1, 0);
CreatureCard c4 = new CreatureCard(2, 5, "King", 4, CardType.Creature, CardEffectName.Effect1, 0);
Game game = new Game(p1, p2);
p1.deck.Add(c1);
p1.deck.Add(c0);
p1.deck.Add(c2);
p1.deck.Add(c3);
p1.deck.Add(c4);
p1.deck.Add(c1);
p1.deck.Add(c0);
p1.deck.Add(c2);
p1.deck.Add(c3);
p2.deck.Add(c1);
p2.deck.Add(c0);
p2.deck.Add(c2);
p2.deck.Add(c3);
p2.deck.Add(c4);
p2.deck.Add(c1);
p2.deck.Add(c0);
p2.deck.Add(c2);
p2.deck.Add(c3);
ShuffleDeck(p1);
ShuffleDeck(p2);
}
public override int Visit(PDDamageToCreatureSpellAbility spell)
{
// Handle Card targets
List <CreatureCard> modCards = new List <CreatureCard>();
foreach (CardTarget t in CardTargets)
{
CreatureCard card = (CreatureCard)(GameManager.UserDict[t.Character].Player.GetCardFromId(t.CardId, Place.INNER) ?? (GameManager.UserDict[t.Character].Player.GetCardFromId(t.CardId, Place.OUTER)));
card.Health -= spell.PDDamage;
if (card.Health > 0)
{
card.PoisonDamage += spell.PDDamage;
}
modCards.Add(card);
}
// Prepare responses
foreach (CharacterEnum ch in GameManager.UserDict.Keys.ToList())
{
if (modCards.Any())
{
AddResponse(ch, new CardsModifiedResponse(modCards));
}
}
return(0);
}
public override int Visit(ResurrectOrReturnToHandSpellAbility resurrectOrReturnToHandSpellAbility)
{
Random rnd = new Random();
CreatureCard resurrect = GameManager.Graveyard[rnd.Next(GameManager.Graveyard.Count)];
GameManager.Graveyard.Remove(resurrect);
CreatureCard evoked = (CreatureCard)resurrect.Original;
Log(OwnerCard.Name + " used ResurrectOrReturn, resurrected " + evoked.Name);
Place place;
if (GameManager.GetPlayer(Owner).Outer.Count < AmaruConstants.OUTER_MAX_SIZE)
{
place = Place.OUTER;
GameManager.GetPlayer(Owner).Outer.Add(evoked);
}
else if (GameManager.GetPlayer(Owner).Inner.Count < AmaruConstants.INNER_MAX_SIZE)
{
place = Place.INNER;
GameManager.GetPlayer(Owner).Inner.Add(evoked);
}
else
{
return(0);
}
foreach (CharacterEnum c in GameManager.UserDict.Keys)
{
AddResponse(c, new ResurrectResponse(Owner, evoked, place));
}
return(0);
}
public CardsModifiedResponse(CreatureCard card)
{
this.Cards = new List <CreatureCard>()
{
card
};
}
public override int Visit(AddEPAndDrawSpellAbility spell)
{
// Draw card and prepare response
AddResponse(Owner, new DrawCardResponse(Owner, GameManager.UserDict[Owner].Player.Draw()));
foreach (CharacterEnum ch in CharacterManager.Instance.Others(Owner))
{
AddResponse(ch, new DrawCardResponse(Owner, null));
}
// Handle Card targets
List <CreatureCard> modCards = new List <CreatureCard>();
foreach (CardTarget t in CardTargets)
{
CreatureCard card = (CreatureCard)(GameManager.UserDict[t.Character].Player.GetCardFromId(t.CardId, Place.INNER) ?? (GameManager.UserDict[t.Character].Player.GetCardFromId(t.CardId, Place.OUTER)));
card.Energy += spell.EpNumber;
modCards.Add(card);
}
// Prepare responses
foreach (CharacterEnum ch in GameManager.UserDict.Keys.ToList())
{
AddResponse(ch, new CardsModifiedResponse(modCards));
}
return(0);
}
public void WeaponAttack(GameObject creature, CreatureData creatureData, WeaponCard weaponCard)
{
if ((equippedCreaturesObj.IndexOf(creature) + 1) > tempRange) //checks if clicked creature is in range
{
WarningPopup("Target out of range");
}
else
{
ammo -= tempWeaponData.ap; //updates AP remaining
AmmoUpdate(); //updates UI text
creatureData.hp -= tempWeaponData.dmg; //weapon deals dmg to creature
weaponCard.PlaySound1(); //plays sound
CreatureCard defCreature = creature.GetComponent <CreatureCard>(); //creatures a reference to the creature
defCreature.hpText.text = defCreature.creatureData.hp.ToString(); //updates UI text
if (creatureData.hp <= 0) //checks if creature is dead
{
CreatureCard deadCreature = creature.GetComponent <CreatureCard>();
Destroy(deadCreature.gameObject); //destroys the creature
equippedCreaturesObj.Remove(deadCreature.gameObject); //removes destroyed creature from attackers list
MonstersUpdate(); //updates UI text
}
for (int i = 0; i < equippedCreaturesObj.Count; i++) //loop repeats for each creature on the board
{
CreatureCard attacker = equippedCreaturesObj[i].GetComponent <CreatureCard>();
attacker.buttonObject.SetActive(false); //disables buttons on all creature cards
}
tempRangeIndicator.SetActive(false); //disables range indicator
}
}
public override void Visit(AttackPlayerAction action)
{
Player target = GameManager.GetPlayer(action.Target.Character);
Player caller = GameManager.GetPlayer(action.Caller);
CreatureCard playedCard = (CreatureCard)(caller.GetCardFromId(action.PlayedCardId, Place.INNER) ?? caller.GetCardFromId(action.PlayedCardId, Place.OUTER));
playedCard.Energy -= playedCard.Attack.Cost;
AttacksVisitor attackVisitor = new AttacksVisitor(GameManager, caller, action.Target, playedCard);
int attackPower = playedCard.Attack.Visit(attackVisitor);
target.Health -= attackPower;
foreach (CharacterEnum dest in GameManager.UserDict.Keys.ToList())
{
GameManager.UserDict[dest].Write(new ResponseMessage(new AttackPlayerResponse(action.Caller, action.Target.Character, playedCard, target.Health)));
}
foreach (KeyValuePair <CharacterEnum, Response> kvp in attackVisitor.SuccessiveResponse)
{
GameManager.UserDict[kvp.Key].Write(new ResponseMessage(kvp.Value));
}
if (!target.IsAlive)
{
GameManager.KillPlayer(caller.Character, target.Character);
}
}
public MoveCreatureResponse(CharacterEnum caller, CreatureCard creature, Place place, int tablePos)
{
this.Caller = caller;
this.Creature = creature;
this.Place = place;
this.TablePos = tablePos;
}
public void TestBattlePhaseWithoutBonuses()
{
Player DummyPlayer1 = new Player("Player 1", "Human", true, false, 0, new Card[0]);
Player DummyPlayer2 = new Player("Player 2", "Human", true, false, 0, new Card[0]);
CreatureCard DummyInvaderCard = new CreatureCard(40, 20);
CreatureCard DummyDefenderCard = new CreatureCard(40, 20);
SorcererStreetMap DummyMap = CreateDummyMap();
TerrainSorcererStreet DummyTerrain = DummyMap.GetTerrain(DummyPlayer2.GamePiece);
DummyTerrain.DefendingCreature = DummyDefenderCard;
DummyTerrain.Owner = DummyPlayer2;
ActionPanelBattleStartPhase BattleStartPhase = new ActionPanelBattleStartPhase(DummyMap, DummyPlayer1, DummyInvaderCard);
BattleStartPhase.Load();
ActionPanelBattleAttackPhase BattleAttackPhase = new ActionPanelBattleAttackPhase(DummyMap.ListActionMenuChoice, DummyMap);
BattleAttackPhase.OnSelect();
Assert.AreEqual(DummyInvaderCard, BattleAttackPhase.FirstAttacker);
Assert.AreEqual(DummyDefenderCard, BattleAttackPhase.SecondAttacker);
BattleAttackPhase.ExecuteFirstAttack();
Assert.AreEqual(40, BattleAttackPhase.FirstAttacker.CurrentHP);
Assert.AreEqual(20, BattleAttackPhase.SecondAttacker.CurrentHP);
BattleAttackPhase.ExecuteSecondAttack();
Assert.AreEqual(20, BattleAttackPhase.FirstAttacker.CurrentHP);
Assert.AreEqual(20, BattleAttackPhase.SecondAttacker.CurrentHP);
}
public void TestBattlePhaseLoad()
{
Player DummyPlayer1 = new Player("Player 1", "Human", true, false, 0, new Card[0]);
Player DummyPlayer2 = new Player("Player 2", "Human", true, false, 0, new Card[0]);
CreatureCard DummyInvaderCard = new CreatureCard(40, 20);
CreatureCard DummyDefenderCard = new CreatureCard(40, 20);
SorcererStreetMap DummyMap = CreateDummyMap();
TerrainSorcererStreet DummyTerrain = DummyMap.GetTerrain(DummyPlayer2.GamePiece);
DummyTerrain.DefendingCreature = DummyDefenderCard;
DummyTerrain.Owner = DummyPlayer2;
ActionPanelBattleStartPhase BattleStartPhase = new ActionPanelBattleStartPhase(DummyMap, DummyPlayer1, DummyInvaderCard);
BattleStartPhase.Load();
Assert.AreEqual(DummyInvaderCard, DummyMap.GlobalSorcererStreetBattleContext.Invader);
Assert.AreEqual(DummyDefenderCard, DummyMap.GlobalSorcererStreetBattleContext.Defender);
Assert.AreEqual(DummyInvaderCard.CurrentHP, DummyMap.GlobalSorcererStreetBattleContext.InvaderFinalHP);
Assert.AreEqual(DummyDefenderCard.CurrentHP, DummyMap.GlobalSorcererStreetBattleContext.DefenderFinalHP);
Assert.AreEqual(DummyInvaderCard.CurrentST, DummyMap.GlobalSorcererStreetBattleContext.InvaderFinalST);
Assert.AreEqual(DummyDefenderCard.CurrentST, DummyMap.GlobalSorcererStreetBattleContext.DefenderFinalST);
}
public AttackPlayerResponse(CharacterEnum caller, CharacterEnum target, CreatureCard attacker, int targetHealthAfter)
{
this.Caller = caller;
this.Target = target;
this.Attacker = attacker;
this.TargetHealthAfter = targetHealthAfter;
}
public void Init(CreatureCard m_Card)
{
anim = GetComponent <Animator>();
ownerCard = m_Card;
sleepyFX = GetComponentInChildren <ParticleSystem>();
atkTxt.text = ownerCard.attack.text;
hlthTxt.text = ownerCard.health.text;
}
public void SetToAttack(CreatureCard attackCard)
{
if (!error.CheckCanAttack(attackCard))
{
return;
}
cardPlayManager.CardPlayAttack(attackCard);
}
public EvocationResponse(CharacterEnum caller, CreatureCard original, CreatureCard evoked, Place destination, bool deleteOriginal = false)
{
this.Caller = caller;
this.Original = original;
this.Evoked = evoked;
this.Destination = destination;
this.DeleteOriginal = deleteOriginal;
}
public void Initialise (CreatureCard card) {
SetCard(card);
this.cCard = card;
SetCurrentCooldown(card.cooldown);
GoOnCooldown();
SetCurrentManaCost(card.manaCost);
this.currentAttack = cCard.attack;
this.currentHealth = cCard.health;
}
public HandCreature (CreatureCard card): base (card) {
this.cCard = card;
this.currentAttack = cCard.attack;
this.currentHealth = cCard.health;
}
