private Card GetCard(CardInfo info)
{
Card card;
switch (info.TypeCard)
{
case CardType.Attack:
card = new AttackCard();
break;
case CardType.Healing:
card = new HealingCard();
break;
case CardType.Stun:
card = new StunCard();
break;
default:
card = new AttackCard();
break;
}
return(card);
}
private void GenerateCard()
{
// Empty list
// Add 2 random attack cards to list
// Add 1/2 counter card to list
// Add healing or no action card to list
_generatedCardList[0] = new AttackCard(id);
_generatedCardList[1] = new AttackCard(id);
_generatedCardList[2] = new CounterCard(id);
if (Utilities.IsLessThanPercentage(COUNTER_CHANCE))
{
_generatedCardList[3] = new CounterCard(id);
}
else
{
_generatedCardList[3] = new NoActionCard(id);
}
if (Utilities.IsLessThanPercentage(HEALING_CHANCE))
{
_generatedCardList[4] = new HealCard(id);
}
else
{
_generatedCardList[4] = new NoActionCard(id);
}
}
public virtual int UserDamageModifiers(int damage, AttackCard attack, UnitCard target, bool heal = false)
{
if (!heal)
{
if (attack.type == AttackType.PHYSICAL)
{
//aggresion
damage += aggression;
//berserk
if (currentHealth <= Defines.criticalHp && berserk)
{
damage *= Defines.criticalHpMultiplier;
}
}
else //type == AttackType.MAGICAL
{
//analytic
damage += analytic;
//overdrive
if (currentHealth <= Defines.criticalHp && overdrive)
{
damage *= Defines.criticalHpMultiplier;
}
}
if (infiltrate > 0 && Infiltrated())
{
damage += infiltrate;
}
}
return(damage);
}
protected void InsertCardsIntoZone(int n, Unit owner, Zone <Card> zone)
{
for (var i = 0; i < n; i++)
{
AttackCard.MakeCopy(owner).MoveTo(zone);
}
}
private Card RandomAttackCard()
{
int value = Random.Range(0, 100);
Card card = null;
List <Temp> list = new List <Temp>();
for (int i = 0; i < TBL_ATTACK_CARD.CountEntities; i++)
{
TBL_ATTACK_CARD data = TBL_ATTACK_CARD.GetEntity(i);
AttackCard c = new AttackCard(data);
list.Add(new Temp(c.percent, CardType.AttackCard, c));
}
float cumulative = 0f;
for (int i = 0; i < list.Count; i++)
{
cumulative += list[i].percent;
if (value <= cumulative)
{
card = list[i].card;
break;
}
}
return(card);
}
// 공격 카드 사용
private float UseAttackCard(AttackCard card)
{
guard = 0;
string randomAttackAnimationName = Random.Range(0, 2) == 0 ? "Attack1" : "Attack2";
var animationTime = m_SkeletonAnimation.Skeleton.Data.FindAnimation(randomAttackAnimationName).Duration;
int index = Random.Range(0, 7);
foreach (var posIndex in card.positions)
{
var tilePosition = GetPosition(posIndex);
TileManager.Instance.SetColor(tilePosition, animationTime * 1.2f);
TileManager.Instance.GetTile(tilePosition)?.PlayAttack(index, animationTime);
}
if (Energy - card.energyCost >= 0)
{
Invoke("SSS", 1f);
int i = Random.Range(1, 4);
string str = "Attack_Voice" + i.ToString();
SoundManager.Instance.PlaySFX(str);
m_SkeletonAnimation.AnimationState.SetAnimation(0, randomAttackAnimationName, false);
StartCoroutine(UseAttackCard_Coroutine(card, animationTime));
}
return(GameSetting.AttackCardTime);
}
public override int DamageModifiers(int damage, AttackCard attack, UnitCard user, UnitCard enemy, bool heal = false)
{
if (attack is HealAttackCard)
{
return(damage + 10);
}
return(damage);
}
public void CardIsMovedIntoHand()
{
var physicalCard = AttackCard.MakeCopy(Friend1);
physicalCard.MoveTo(Friend1.Hand);
Assert.IsTrue(Friend1.Hand.Contains(physicalCard));
}
public void Visit(AttackCard card)
{
var enemies = _player.GetNearbyEnemies();
_player.Movement.Attack(enemies);
HandledCard(card);
}
void testAttackCard(){
int[] attackVal = new int[4];
attackVal [0] = 30;
attackVal [1] = 1;
attackVal [2] = 2;
attackVal [3] = 3;
Card a = new AttackCard ("TestAttack", attackVal);
print(a);
}
public void CardIsMovedChangesZone()
{
var physicalCard = AttackCard.MakeCopy(Friend1);
physicalCard.MoveTo(Friend1.Hand);
physicalCard.MoveTo(Friend1.DiscardPile);
Assert.IsFalse(Friend1.Hand.Contains(physicalCard));
Assert.IsTrue(Friend1.DiscardPile.Contains(physicalCard));
}
void AddCardData()
{
cards = new Card[6];
cards[0] = new GoldCard();
cards[1] = new AttackCard();
cards[2] = new MovementCard();
cards[3] = new TeleportCard();
cards[4] = new VisionCard();
cards[5] = new WallBreakCard();
}
private void SetupCardsInHands()
{
AttackCard.MakeCopy(Enemy1).MoveTo(Enemy1.Hand);
AttackCard.MakeCopy(Enemy1).MoveTo(Enemy1.Hand);
CopyCard.MakeCopy(Enemy2).MoveTo(Enemy2.Hand);
AttackCard.MakeCopy(Friend1).MoveTo(Friend1.Hand);
HealCard.MakeCopy(Friend2).MoveTo(Friend2.Hand);
}
//改变卡的攻击面
public void attackAssignment(GameObject card1, AttackCard card2)
{
card1.GetComponent <CardManager>().attackCard.attackCardNo = card2.attackCardNo;
card1.GetComponent <CardManager>().attackCard.CardName = card2.CardName;
card1.GetComponent <CardManager>().attackCard.CardIntroduction = card2.CardIntroduction;
card1.GetComponent <CardManager>().attackCard.CardEffect = card2.CardEffect;
card1.GetComponent <CardManager>().attackCard.counterAttribute = card2.counterAttribute;
card1.GetComponent <CardManager>().attackCard.ActionPoint = card2.ActionPoint;
card1.GetComponent <CardManager>().attackCard.damageAttribute = card2.damageAttribute;
card1.GetComponent <CardManager>().attackCard.Damage = card2.Damage;
card1.GetComponent <CardManager>().attackCard.attackSprite = card2.attackSprite;
card1.GetComponent <CardManager>().attackCard.attackBallSprite = card2.attackBallSprite;
card1.GetComponent <CardManager>().attackCard.damageCubeSprite = card2.damageCubeSprite;
}
public void DrawAttackCard()
{
if (attackDeck.Count() <= 0)
{
ReshuffleAttackDeck();
}
AttackCard card = (AttackCard)attackDeck.DrawCard();
card.player = this;
attacksOnHand.Add(card);
playerHandController.AddCard(card);
}
public Sprite damageCubeSprite; //伤害方块
public AttackCard(AttackCard card)
{
attackCardNo = card.attackCardNo;
CardName = card.CardName;
CardIntroduction = card.CardIntroduction;
CardEffect = card.CardEffect;
counterAttribute = card.counterAttribute;
ActionPoint = card.ActionPoint;
damageAttribute = card.damageAttribute;
Damage = card.Damage;
attackSprite = card.attackSprite;
attackBallSprite = card.attackBallSprite;
damageCubeSprite = card.damageCubeSprite;
canCounter = card.canCounter;
}
//sets up hand, loads the virtual attack card, draws 4 cards
public void initHand(){
hand = new Card[6];
int[] attackVal = new int[4];
attackVal [0] = 0;
attackVal [1] = 1;
attackVal [2] = 1;
attackVal [3] = 1;
Card virtualattack = new AttackCard ("virtualattack", attackVal);
hand[0] = virtualattack;
for (int i=0; i<4; i++) {
drawCard();
}
}
public virtual int TargetDamageModifiers(int damage, AttackCard attack, UnitCard attacker, bool heal = false)
{
if (!heal)
{
if (attack.type == AttackType.PHYSICAL)
{
damage -= armor; //armor
}
else //type == AttackType.MAGICAL
{
damage -= endurance; //endurance
}
}
return(Mathf.Max(damage, 0));
}
private IEnumerator UseAttackCard_Coroutine(AttackCard card, float time)
{
yield return(new WaitForSeconds(time));
m_SkeletonAnimation.AnimationState.SetAnimation(0, "Idle", true);
Player target = isPlayer ? PlayerManager.Instance.Enemy : PlayerManager.Instance.Player;
if (InTarget(card.positions, target.tilePosition)) //명중하면 true, 빗나가면 false
{
target.AddHP(-card.damage);
target.TakeHitAnimation();
}
AddEnergy(-card.energyCost);
}
public override void OnAttackCardPlayed(AttackCard attack, UnitCard user, UnitCard enemy)
{
if (attack.modifyUserStrength > 0)
{
user.currentStrength++;
}
if (attack.modifyUserAgility > 0)
{
user.currentAgility++;
}
if (attack.modifyUserWisdom > 0)
{
user.currentWisdom++;
}
if (attack.modifyUserSpirit > 0)
{
user.currentSpirit++;
}
}
public void LoadCardData(AttackCardData card)
{
cardData = card;
LoadRegularCardData(card);
AttackCard attackCard = (AttackCard)GetComponent <AttackCard>();
attackCard.costText = costText;
attackCard.baseDamageText = baseDamageText;
attackCard.playableEffect = playableEffect;
attackCard.originalCost = card.cost;
attackCard.baseDamage = card.baseDamage;
attackCard.type = card.attackType;
attackCard.statTestStrength = card.statTestStrength;
attackCard.statTestAgility = card.statTestAgility;
attackCard.statTestWisdom = card.statTestWisdom;
attackCard.statTestSpirit = card.statTestSpirit;
attackCard.outStatStrength = card.outStatStrength;
attackCard.outStatAgility = card.outStatAgility;
attackCard.outStatWisdom = card.outStatWisdom;
attackCard.outStatSpirit = card.outStatSpirit;
attackCard.statFailStrength = card.statFailStrength;
attackCard.statFailAgility = card.statFailAgility;
attackCard.statFailWisdom = card.statFailWisdom;
attackCard.statFailSpirit = card.statFailSpirit;
attackCard.modifyUserStrength = card.modifyUserStrength;
attackCard.modifyUserAgility = card.modifyUserAgility;
attackCard.modifyUserWisdom = card.modifyUserWisdom;
attackCard.modifyUserSpirit = card.modifyUserSpirit;
attackCard.modifyEnemyStrength = card.modifyEnemyStrength;
attackCard.modifyEnemyAgility = card.modifyEnemyAgility;
attackCard.modifyEnemyWisdom = card.modifyEnemyWisdom;
attackCard.modifyEnemySpirit = card.modifyEnemySpirit;
}
// generates a new card from the internal list of prototypes
public BaseCard GetNewCard(int cid)
{
CardData c = cardPrototypes.Find((CardData cd) => cd.cid == cid);
if (c == null)
{
throw new CardException("Cannot find card with id = " + cid);
}
else
{
BaseCard newCard;
switch (c.type.ToLower())
{
case "attack":
newCard = new AttackCard(c);
newCard.SetCardType(CardType.Attack);
return(newCard);
case "defend":
case "defense":
newCard = new DefendCard(c);
newCard.SetCardType(CardType.Defend);
return(newCard);
case "counter":
case "effect":
newCard = new EffectCard(c);
newCard.SetCardType(CardType.Effect);
return(newCard);
case "serve":
newCard = new ServeCard(c);
newCard.SetCardType(CardType.Serve);
return(newCard);
default:
throw new CardException("Unknown card type with type = " + c.type);
}
}
}
public void ActionEffect(AttackCard aCard, CounterCard cCard, bool isMyAction)
{
print(aCard.CardName + " " + cCard.CardName);
int damage = aCard.Damage; //伤害
int backDamage = 0; //反击伤害
Attribute backAttribute = Attribute.Physical; //反击伤害类型
PlayerManager user; //进攻方
PlayerManager opposite; //反击方
Transform userHead; //进攻方动画播放位置
Transform oppositeHead; //反击方动画播放位置
float r_miss = 0; //闪避值，超过500闪避成功
if (isMyAction)
{
user = myPlayer;
opposite = enemyPlayer;
userHead = myHeadPosition;
oppositeHead = enemyHeadPosition;
}
else
{
user = enemyPlayer;
opposite = myPlayer;
userHead = enemyHeadPosition;
oppositeHead = myHeadPosition;
}
//反击牌效果
switch (cCard.counterCardNo)
{
case 5:
//暗器
backDamage = 1;
break;
case 6:
//幸运牌
if (isMyAction)
{
enemyHCurved.HCNumChange(2);
}
else
{
cardCurved.GetCards();
cardCurved.GetCards();
cardCurved.AddCardAnimations();
}
break;
case 7:
//停战号令
roundManager.AbandonmentRoundStart();
break;
case 8:
//气流吸纳
opposite.saveAp++;
break;
}
//进攻牌效果
switch (aCard.attackCardNo)
{
case 4:
//魔力引爆
opposite.burnDamage += 2;
break;
case 5:
//恢复魔法
user.HpChange(3, 0);
break;
case 7:
//正义审判
if (user.HP > opposite.HP)
{
damage++;
}
break;
case 8:
//结晶风暴
opposite.saveAp--;
break;
case 9:
//黑炎仪式
user.darkfire = true;
break;
}
//黑炎Buff生效
if (user.darkfire)
{
damage *= 2;
if (aCard.attackCardNo != 9)
{
user.darkfire = false;
}
}
//反击牌改变伤害效果
switch (cCard.counterCardNo)
{
case 1:
//钢盾
if (aCard.damageAttribute == Attribute.Physical)
{
damage = 1;
}
break;
case 2:
//图纹盾
damage -= 1;
break;
case 3:
//闪避
r_miss = Random.Range(0, 1000f);
if (r_miss > 500)
{
damage = 0;
}
break;
case 4:
//魔法反射
if (aCard.damageAttribute == Attribute.Magic)
{
backDamage = damage;
backAttribute = Attribute.Magic;
damage = 0;
}
break;
}
if (r_miss > 500)
{
//闪避
ShowEffect(effect_C[2], userHead);
}
else
{
//没有闪避，播放进攻牌动画
switch (aCard.attackCardNo)
{
case 1:
float r_color = Random.Range(0, 1000f);
if (r_color < 200)
{
ShowEffect(effect_A[0], oppositeHead);
}
else if (r_color < 400)
{
ShowEffect(effect_A[1], oppositeHead);
}
else if (r_color < 600)
{
ShowEffect(effect_A[2], oppositeHead);
}
else if (r_color < 800)
{
ShowEffect(effect_A[3], oppositeHead);
}
else
{
ShowEffect(effect_A[4], oppositeHead);
}
break;
case 2:
ShowEffect(effect_A[5], oppositeHead);
break;
case 3:
ShowEffect(effect_A[6], oppositeHead);
break;
case 4:
ShowEffect(effect_A[7], oppositeHead);
break;
case 5:
ShowEffect(effect_A[9], userHead);
break;
case 6:
ShowEffect(effect_A[10], oppositeHead);
break;
case 7:
ShowEffect(effect_A[11], oppositeHead);
break;
case 8:
ShowEffect(effect_A[12], oppositeHead);
break;
case 9:
ShowEffect(effect_A[13], userHead);
break;
case 10:
ShowEffect(effect_A[14], oppositeHead);
break;
}
attackJustOver = true;
effect_cCard = cCard.counterCardNo;
effect_isMyAction = isMyAction;
}
user.HpChange(-backDamage, 2);
opposite.HpChange(-damage, 2);
}
public void AddCard(AttackCard card)
{
card.SetParent(hand);
hand.ForceUpdateRectTransforms();
}
public void OnAttackCardPlayed(AttackCard card)
{
}
void SetCard()
{
int startCount = CardSetting.AttackCardStartCount;
while (startCount > 0)
{
int random = Random.Range(0, TBL_ATTACK_CARD.CountEntities);
AttackCard card = new AttackCard(TBL_ATTACK_CARD.GetEntity(random));
if (!CheckDuplicate(card))
{
cardList.Add(card);
startCount--;
}
}
startCount = CardSetting.EnergyCardStartCount;
while (startCount > 0)
{
int random = Random.Range(0, TBL_ENERGY_CARD.CountEntities);
EnergyCard card = new EnergyCard(TBL_ENERGY_CARD.GetEntity(random));
if (!CheckDuplicate(card))
{
cardList.Add(card);
startCount--;
}
}
startCount = CardSetting.GuardCardStartCount;
while (startCount > 0)
{
int random = Random.Range(0, TBL_GUARD_CARD.CountEntities);
GuardCard card = new GuardCard(TBL_GUARD_CARD.GetEntity(random));
if (!CheckDuplicate(card))
{
cardList.Add(card);
startCount--;
}
}
startCount = CardSetting.HealCardStartCount;
while (startCount > 0)
{
int random = Random.Range(0, TBL_HEAL_CARD.CountEntities);
HealCard card = new HealCard(TBL_HEAL_CARD.GetEntity(random));
if (!CheckDuplicate(card))
{
cardList.Add(card);
startCount--;
}
}
startCount = CardSetting.MoveCardStartCount;
while (startCount > 0)
{
int random = Random.Range(0, TBL_MOVE_CARD.CountEntities);
MoveCard card = new MoveCard(TBL_MOVE_CARD.GetEntity(random));
if (!CheckDuplicate(card))
{
cardList.Add(card);
startCount--;
}
}
Shuffle(cardList);
//for(int i=0; i<list.Count; i++)
//{
// cardPos[i].GetComponent<CardComponent>().SetCard(list[i]);
//}
UpdateCardPos();
}
/// <summary>
/// Function to Modify the Att and Def as per the Att Support and Def Support Cards
/// </summary>
/// <param name="supportCardLeft"></param>
/// <param name="supportCardRight"></param>
public void SupportModifiers(AttackCard supportCardLeft, AttackCard supportCardRight)
{
cardAttack = supportCardLeft.cardAttack / 2;
cardDefense = supportCardRight.cardDefense / 2;
}
public virtual void OnAttackCardTarget(AttackCard attack, UnitCard enemy)
{
}
public virtual void OnAttackCardPlayed(AttackCard attack, UnitCard enemy)
{
Reckless();
}
public virtual int DamageModifiers(int damage, AttackCard attack, UnitCard attacker, UnitCard defender, bool heal = false)
{
return(damage);
}
public virtual void OnAttackCardPlayed(AttackCard attack, UnitCard user, UnitCard enemy)
{
}
/// <summary>
/// Metodo que muestra las celdas de ataque de la carta del barco
/// </summary>
public void ShowAttackCells(int indexCard)
{
AttackCard card = this.Deck.AttackCards[indexCard];
GridManager.Instance.PaintCells(this.OwnerPlayer, GameManager.Instance.CurrentPhase, this.ShowCells(card.AttackCells));
}
//loads some cards in deck
public void initDeck(){
deck = new List<Card> ();
//here's just a starter deck--nothing special or significant about my choices, basically from all the previous art I've done/some intuition judgement--just to be consistent with the game
//add 3 portals
for (int i=0;i<3;i++){
Card p = new PortalCard ("teleport");
deck.Add (p);
}
//add attack cards (except virtual attack) and hidden passion (I believe it's too powerful/too much time to compute result of attack)
int[] attackVal = new int[4];
attackVal [0] = 30;
attackVal [1] = 0;
attackVal [2] = 0;
attackVal [3] = 0;
Card curveset = new AttackCard ("curveset", attackVal);
deck.Add (curveset);
//since no hidden passion and flowers is also rather too powerful, I'll add 2 more curvesets and just 1 more flowers
deck.Add (curveset);
deck.Add (curveset);
/* weird this is causing curveset to have flowers' attack val that is rather than 30, 20+HT+CF
attackVal [0] = 20;
attackVal [1] = 0;
attackVal [2] = 1;
attackVal [3] = 1;
*/
int[] attackVal2 = new int[4];
attackVal2 [0] = 20;
attackVal2 [1] = 0;
attackVal2 [2] = 1;
attackVal2 [3] = 1;
Card flowers = new AttackCard ("flowers", attackVal2);
deck.Add (flowers);
//add specials (2 sets)
Vector3 effect = new Vector3 (0, 0, 0);
for (int i=0;i<2;i++){
effect = new Vector3(5,0,0);
Card adderall = new SpecialCard ("adderall", effect, true);
deck.Add (adderall);
effect = new Vector3(5,0,0);
Card caffeinepill = new SpecialCard ("caffeinepill", effect, true);
deck.Add (caffeinepill);
effect = new Vector3(5,0,0);
Card drunk = new SpecialCard ("drunk", effect, false);
deck.Add (drunk);
effect = new Vector3(0,0,3);
Card hairdo = new SpecialCard ("hairdo", effect, true);
deck.Add (hairdo);
effect = new Vector3(0,0,5);
Card intimidate = new SpecialCard ("intimidate", effect, false);
deck.Add (intimidate);
effect = new Vector3(0,5,0);
Card steroids = new SpecialCard ("steroids", effect, true);
deck.Add (steroids);
effect = new Vector3(0,5,0);
Card trashtalk = new SpecialCard ("trashtalk", effect, false);
deck.Add (trashtalk);
effect = new Vector3(0,0,10);
Card wallflowerbloom = new SpecialCard ("wallflowerbloom", effect, true);
deck.Add (wallflowerbloom);
effect = new Vector3(0,3,3);
Card workout = new SpecialCard ("workout", effect, true);
deck.Add (workout);
}
}
