public void SabotageEffect()
{
Debug.Log("sabotage");
ActiveCard selectedCard = GetCard(manager.currentPlayer.cards, ActiveCardType.SABOTAGE);
ActivateEffect(selectedCard);
}
public void FillActiveCard()
{
if (CardSet == null)
{
return;
}
if (ActiveCard.Count < ActiveCardCount)
{
for (int i = 1; i <= (ActiveCardCount - ActiveCard.Count + 1); i++)
{
bool updated = false;
while (!updated)
{
int idx = rnd.Next(CardSet.Count);
bool repeat = false;
for (int j = 0; j < ActiveCard.Count; j++)
{
if (CardSet[idx] == ActiveCard[j])
{
repeat = true;
}
}
if (!repeat)
{
ActiveCard.Add(CardSet[idx]);
updated = true;
}
}
}
}
}
public void AddCard(int cardId, int level, int modify)
{
ActiveCard card = new ActiveCard(cardId, (byte)level, 0);
card.CostModify = modify;
AddCard(card);
}
public void DoSpell(LiveMonster target, ActiveCard card, Point location)
{
if (!BeforeUseCard(card, location))
{
return;
}
try
{
Spell spell = new Spell(card.CardId);
spell.Addon = SpellEffectAddon;
spell.UpgradeToLevel(card.Level);
if (!card.IsHeroSkill)
{
BattleManager.Instance.StatisticData.GetPlayer(IsLeft).SpellAdd++;
}
SpellAssistant.CheckSpellEffect(spell, IsLeft, target, location);
if (SpikeManager.HasSpike("mirrorspell"))
{
Rival.AddCard(null, card.CardId, card.Level);
}
}
catch (Exception e)
{
NLog.Warn(e);
BattleManager.Instance.FlowWordQueue.Add(new FlowWord("未知错误", location, 0, "Red", 26, 0, 0, 2, 15), false);
return;
}
AfterUseCard(card);
CardManager.DeleteCardAt(SelectId);
}
protected void UniqueCopyCard(object parameter)
{
if (ActiveCard != null)
{
//create new card and move it to a place right after the one that was copied
ICardViewItem card = ActiveCard.CloneCard(ActiveCard.OwningSet);
ICardSetModel set = card.Parent as ICardSetModel;
set.SwitchCardOrder(card, ActiveCard, false);
//change name of the cloned card so that the
//user can easily identify that it is the cloned card
foreach (ITemplateElement <string> element in card.Template.Children.OfType <ITemplateElement <string> >())
{
if (element.Name.Equals(Card.ElementNameCardBinding))
{
element.Content = ActiveCard.Name + " (copy)";
}
}
NotifyPropertyChanged("ObservableSets");
double x = (canvasWorkspace.ActualWidth / 2) - (card.Template.Width / 2);
double y = (canvasWorkspace.ActualHeight / 2) - (card.Template.Height / 2);
card.Template.XPos = x;
card.Template.YPos = y;
}
NotifyPropertyChanged("ObservableSets");
}
public void UseSideKick(LiveMonster lm, ActiveCard card)
{
if (!BeforeUseCard(card, lm.Position))
{
return;
}
try
{
Monster mon = new Monster(card.CardId);
mon.UpgradeToLevel(card.Level);
if (!card.IsHeroSkill)
{
BattleManager.Instance.StatisticData.GetPlayer(IsLeft).MonsterAdd++;
}
var tWeapon = new SideKickWeapon(lm, card.Level, mon);
lm.AddWeapon(tWeapon);
}
catch (Exception e)
{
NLog.Warn(e);
BattleManager.Instance.FlowWordQueue.Add(new FlowWord("未知错误", lm.Position, 0, "Red", 26, 0, 0, 2, 15), false);
return;
}
AfterUseCard(card);
CardManager.DeleteCardAt(SelectId);
}
public void BushfireEffect()
{
Debug.Log("bushfire");
audioManager.PlaySound(Sounds.BUSHFIRE);
ActiveCard selectedCard = GetCard(manager.currentPlayer.cards, ActiveCardType.BUSHFIRE);
ActivateEffect(selectedCard);
}
public void SeedbombEffect()
{
Debug.Log("seedbomb");
audioManager.PlaySound(Sounds.SEEDBOMB);
ActiveCard selectedCard = GetCard(manager.currentPlayer.cards, ActiveCardType.SEEDBOMB);
ActivateEffect(selectedCard);
}
public override void SetData(ActiveCard card1)
{
card = card1.Card;
if (card1.Level > 1)
{
spell.UpgradeToLevel(card1.Level);
}
}
public void WeaponReturn()
{
if (Weapon is TrueWeapon)
{
ActiveCard card = new ActiveCard(new DeckCard(Weapon.CardId, (byte)Weapon.Level, 0));
OwnerPlayer.CardManager.AddCard(card);
DeleteWeapon();
}
}
private void panelBattle_MouseClick(object sender, MouseEventArgs e)
{
if (BattleManager.Instance.PlayerManager.LeftPlayer == null)
{
return;
}
if (isGamePaused)
{
return;
}
int cardSize = BattleManager.Instance.MemMap.CardSize;
if (e.Button == MouseButtons.Left)
{
if (leftSelectCard != null && (myCursor.Name == "summon" || myCursor.Name == "equip" || myCursor.Name == "cast" || myCursor.Name == "sidekick"))
{
int result;
if ((result = BattleManager.Instance.PlayerManager.LeftPlayer.CheckUseCard(leftSelectCard, BattleManager.Instance.PlayerManager.LeftPlayer, BattleManager.Instance.PlayerManager.RightPlayer)) != HSErrorTypes.OK)
{
BattleManager.Instance.FlowWordQueue.Add(new FlowErrInfo(result, new Point(mouseX, mouseY), 0, 0), false);
return;
}
LiveMonster lm = BattleLocationManager.GetPlaceMonster(mouseX, mouseY);
if (myCursor.Name == "summon" && lm == null)
{
var pos = new Point(mouseX / cardSize * cardSize, mouseY / cardSize * cardSize);
BattleManager.Instance.PlayerManager.LeftPlayer.UseMonster(leftSelectCard, pos);
}
else if (myCursor.Name == "equip" && lm != null)
{
BattleManager.Instance.PlayerManager.LeftPlayer.UseWeapon(lm, leftSelectCard);
}
else if (myCursor.Name == "sidekick" && lm != null)
{
BattleManager.Instance.PlayerManager.LeftPlayer.UseSideKick(lm, leftSelectCard);
}
else if (myCursor.Name == "cast")
{
BattleManager.Instance.PlayerManager.LeftPlayer.DoSpell(lm, leftSelectCard, e.Location);
}
var cardData = CardConfigManager.GetCardConfig(leftSelectCard.CardId);
UserProfile.Profile.OnUseCard(cardData.Star, 0, cardData.TypeSub);
cardsArray1.DisSelectCard();
}
}
else if (e.Button == MouseButtons.Right)
{
leftSelectCard = null;
cardsArray1.DisSelectCard();
}
}
public CardSelectMethodDiscover(int[] cardId, int lv, DiscoverCardActionType type)
{
discoverCard = new ActiveCard[cardId.Length];
cardLevel = lv;
for (int i = 0; i < discoverCard.Length; i++)
{
discoverCard[i] = new ActiveCard(cardId[i], (byte)cardLevel, 0);
}
discoverType = type;
}
private void OnVRegionClick(int id, int x, int y, MouseButtons button)
{
if (id > 0)
{
var key = vRegion.GetRegion(id).GetKeyValue();
HeroPowerConfig heroSkillConfig = ConfigData.GetHeroPowerConfig(key);
LevelExpConfig levelConfig = ConfigData.GetLevelExpConfig(UserProfile.Profile.InfoBasic.Level);
leftSelectCard = new ActiveCard(heroSkillConfig.CardId, (byte)levelConfig.HeroSkillLevel, 0);
leftSelectCard.IsHeroSkill = true;
OnSelectCardChange();
}
}
private Card canKill()
{
foreach (Card c in Enemy.Cards)
{
if (ActiveCard.CanKill(c))
{
return(c);
}
}
return(null);
}
private void cardsArray1_SelectionChange(object sender, EventArgs e)
{
leftSelectCard = cardsArray1.GetSelectCard();
if (leftSelectCard != null && leftSelectCard.CardType == CardTypes.Monster)
{
visualRegion.Update(leftSelectCard.CardId);
}
else
{
visualRegion.Update(0);
}
OnSelectCardChange();
}
private void SetCard(int id, ActiveCard card)
{
int count = GetCardNumber();
if (id < count)
{
cards[id] = card;
}
if (self.CardsDesk != null)
{
self.CardsDesk.UpdateSlot(cards);
}
}
public void CopyRandomCardFor(IPlayer p, int levelChange)
{
if (GetCardNumber() > 0)
{
int id = MathTool.GetRandom(GetCardNumber());
ActiveCard card = cards[id].GetCopy();
card.ChangeLevel((byte)(card.Level + levelChange));
Player player = p as Player;
if (player != null)
{
player.CardManager.AddCard(card);
}
}
}
public void GetNextCard()
{
if (GetCardNumber() < GameConstants.CardSlotMaxCount)
{
ActiveCard next = self.Cards.GetNextCard();
if (next != ActiveCards.NoneCard)
{
AddCard(next);
}
else
{
self.OnGetCardFail(true); //卡组抽完有惩罚
}
}
else
{
self.OnGetCardFail(false);//手牌满了有惩罚
}
}
public void AfterUseCard(ActiveCard selectCard)
{
var oldComboTime = comboTime;
comboTime = 1;
if (oldComboTime <= 0)
{
CardManager.UpdateCardCombo();
}
if (selectCard.IsHeroSkill) //成功使用英雄技能
{
CardManager.HeroSkillCd = 1;
if (HeroSkillChanged != null)
{
HeroSkillChanged(false);
}
}
}
private static bool UseFightItem(ItemConsumerConfig itemConfig)
{
var player = BattleManager.Instance.PlayerManager.LeftPlayer;
if (itemConfig.GainLp > 0)
{
player.AddLp(itemConfig.GainLp);
}
if (itemConfig.GainPp > 0)
{
player.AddPp(itemConfig.GainPp);
}
if (itemConfig.GainMp > 0)
{
player.AddMp(itemConfig.GainMp);
}
if (itemConfig.DirectDamage > 0)
{
player.DirectDamage += itemConfig.DirectDamage;
}
if (itemConfig.FightRandomCardType > 0)
{
int cardId = CardConfigManager.GetRandomTypeCard(itemConfig.FightRandomCardType);
var card = new ActiveCard(new DeckCard(cardId, 1, 0));
player.CardManager.AddCard(card);
}
if (!string.IsNullOrEmpty(itemConfig.HolyWord))
{
player.AddHolyWord(itemConfig.HolyWord);
}
if (itemConfig.AttrAddAfterSummon != null && itemConfig.AttrAddAfterSummon.Length > 0)
{
player.AddMonsterAddon(itemConfig.AttrAddAfterSummon);
}
if (itemConfig.AddTowerHp > 0)
{
player.AddTowerHp(itemConfig.AddTowerHp);
}
return(true);
}
public void UseMonster(ActiveCard card, Point location)
{
if (!BeforeUseCard(card, location))
{
return;
}
try
{
var mon = new Monster(card.CardId);
mon.UpgradeToLevel(card.Level);
if (!card.IsHeroSkill)
{
BattleManager.Instance.StatisticData.GetPlayer(IsLeft).MonsterAdd++;
}
LiveMonster newMon = new LiveMonster(card.Level, mon, location, IsLeft);
BattleManager.Instance.MonsterQueue.Add(newMon);
var addon = GetAllMonsterAddonAndClear();//这个属性目前可以来自药水
if (addon.Length > 0)
{
foreach (var add in addon)
{
if (add.Length > 1)
{
newMon.AddBasicData(add[0], add[1]);
}
}
}
var rival = Rival as Player;
rival.TrapHolder.CheckTrapOnSummon(newMon, rival);
}
catch (Exception e)
{
NLog.Warn(e);
BattleManager.Instance.FlowWordQueue.Add(new FlowWord("未知错误", location, 0, "Red", 26, 0, 0, 2, 15), false);
return;
}
AfterUseCard(card);
CardManager.DeleteCardAt(SelectId);
}
public void ActivateEffect(ActiveCard card)
{
if (!card.used)
{
switch (card.cardType)
{
case ActiveCardType.BUSHFIRE:
{
bushfire = true;
Debug.Log("We are in BUSHFIRE Card effect");
break;
}
case ActiveCardType.SEEDBOMB:
{
seedbomb = true;
break;
}
case ActiveCardType.SABOTAGE:
{
sabotage = true;
if (!manager.TrySabotage())
{
//card effect failed, undo the tile usage
sabotage = false;
card.used = false;
}
else
{
Debug.Log("it worked");
manager.PlayerTurn();
}
break;
}
default:
break;
}
card.used = true;
}
}
public bool CheckTrapOnUseCard(ActiveCard selectCard, Point location, IPlayer rival)
{
foreach (var trap in trapList)
{
var trapConfig = ConfigData.GetSpellTrapConfig(trap.Id);
if (trapConfig.EffectUse != null)
{
if (self.Mp >= trapConfig.ManaCost && trapConfig.EffectUse(self, rival, trap, selectCard.CardId, (int)selectCard.CardType))
{
RemoveTrap(trap, trapConfig);
NLog.Debug(string.Format("RemoveTrap UseCard id={0} cardId={1}", trap.Id, selectCard.CardId));
BattleManager.Instance.EffectQueue.Add(new ActiveEffect(EffectBook.GetEffect(trapConfig.UnitEffect), location, false));
return(true);
}
}
}
return(false);
}
public void DeleteCardAt(int index)
{
if (index <= 0)
{//使用英雄技能卡
return;
}
cards[index - 1] = ActiveCards.NoneCard;
for (int i = 0; i < GameConstants.CardSlotMaxCount - 1; i++)
{
if (cards[i].CardId == 0 && cards[i + 1].CardId > 0)
{
ActiveCard tempCard = cards[i];
cards[i] = cards[i + 1];
cards[i + 1] = tempCard;
}
}
if (self.CardsDesk != null)
{
self.CardsDesk.UpdateSlot(cards);
}
}
public bool BeforeUseCard(ActiveCard selectCard, Point location)
{
AddMp(-selectCard.Mp);
AddLp(-selectCard.Lp);
AddPp(-selectCard.Pp);
var rival = Rival as Player;
if (rival.TrapHolder.CheckTrapOnUseCard(selectCard, location, rival))
{
return(false);
}
SpikeManager.OnUseCard(selectCard.CardType);
BattleManager.Instance.MonsterQueue.OnPlayerUseCard(this, (int)selectCard.CardType, selectCard.Level);
if (OnUseCard != null)
{
OnUseCard(selectCard.CardId, selectCard.Level, IsLeft);
}
return(true);
}
public void AddCard(ActiveCard card)
{
var spikeManager = self.SpikeManager;
card.MpCostChange = spikeManager.MpCost;
card.LpCostChange = spikeManager.LpCost;
card.PpCostChange = spikeManager.PpCost;
card.Lp2Mp = spikeManager.HasSpike("lp2mp");
card.Combo = self.Combo;
int count = GetCardNumber();
if (count < GameConstants.CardSlotMaxCount)
{
cards[count] = card;
}
if (spikeManager.HasSpike("copycard") && count < GameConstants.CardSlotMaxCount - 1)
{
cards[count + 1] = card.GetCopy();
}
if (self.CardsDesk != null)
{
self.CardsDesk.UpdateSlot(cards);
}
}
public int CheckUseCard(ActiveCard selectCard, Player left, Player right)
{
if (Mp < selectCard.Mp)
{
return(HSErrorTypes.BattleLackMp);
}
if (Lp < selectCard.Lp)
{
return(HSErrorTypes.BattleLackLp);
}
if (Pp < selectCard.Pp)
{
return(HSErrorTypes.BattleLackPp);
}
if (selectCard.IsHeroSkill && CardManager.HeroSkillCd > 0)
{
return(HSErrorTypes.BattleHeroSkillInCd);
}
return(HSErrorTypes.OK);
}
/// <summary>
/// Decide which card is the winner.
/// </summary>
public bool SelectWinnerCard()
{
if (SelectedCardPropertyName == null || ChallengerCard == null)
{
return(false);
}
float ownCard = ActiveCard.PropertyFloatValue(SelectedCardPropertyName);
float opponentCard = ChallengerCard.PropertyFloatValue(SelectedCardPropertyName);
OwnValue = ownCard;
OpponentValue = opponentCard;
// Highest value wins, except when comparing the economy or acceleration
if (SelectedCardPropertyName == "Economy" ||
SelectedCardPropertyName == "Acceleration")
{
ownCard = -ownCard;
opponentCard = -opponentCard;
}
ActiveCard.IsWinner = Visibility.Collapsed;
ChallengerCard.IsWinner = Visibility.Collapsed;
if (ownCard > opponentCard)
{
// We won, enable the challenger's card
Results = ComparisonResult.EWeWon;
ChallengerCard.IsEnabled = true;
if (App.CardModel.CardLeft == Count - 1)
{
//show "game over" , ultimate winner
ShowUltimateWinner = Visibility.Visible;
}
else
{
ActiveCard.IsWinner = Visibility.Visible;
}
InitCardListing();
}
else if (ownCard < opponentCard)
{
// We lost, disable our active card
Results = ComparisonResult.EWeLost;
ActiveCard.IsEnabled = false;
if (App.CardModel.CardLeft == 1)
{
// Show "game over", ultimate looser
ShowUltimateLooser = Visibility.Visible;
}
else
{
ChallengerCard.IsWinner = Visibility.Visible;
}
InitCardListing();
}
else
{
// It's a tie
Results = ComparisonResult.ETie;
}
return(Results == ComparisonResult.EWeWon);
}
public ActiveCard[] GetCards()
{
ActiveCard[] cards = new ActiveCard[GameConstants.BattleInitialCardCount];
Array.Copy(cardList.GetAllCard(), 0, cards, 0, cards.Length);
return(cards);
}
internal static void AIProc(Player player)
{
if (player.CardNumber <= 0)
{
return;
}
if (MathTool.GetRandom(4) != 0)
{
return;
}
int row = BattleManager.Instance.MemMap.RowCount;
int size = BattleManager.Instance.MemMap.CardSize;
bool isLeft = player.IsLeft;
var rival = player == BattleManager.Instance.PlayerManager.LeftPlayer ?
BattleManager.Instance.PlayerManager.RightPlayer : BattleManager.Instance.PlayerManager.LeftPlayer;
player.CardsDesk.SetSelectId(MathTool.GetRandom(player.CardNumber) + 1);
if (player.SelectCardId != 0)
{
ActiveCard card = player.CardsDesk.GetSelectCard();
if (player.CheckUseCard(card, player, rival) != HSErrorTypes.OK)
{
return;
}
int tar = -1;
if (card.CardType == CardTypes.Weapon)
{
for (int i = 0; i < BattleManager.Instance.MonsterQueue.Count; i++)
{
LiveMonster monster = BattleManager.Instance.MonsterQueue[i];
if (!monster.IsGhost && monster.IsLeft == isLeft && monster.Weapon == null && monster.Life > monster.RealMaxHp / 2)
{
if (!monster.CanAddWeapon())//建筑无法使用武器
{
continue;
}
if (tar == -1 || monster.Avatar.MonsterConfig.Star > BattleManager.Instance.MonsterQueue[tar].Avatar.MonsterConfig.Star)
{
tar = i;
}
}
}
if (tar == -1)
{
return;
}
}
else if (card.CardType == CardTypes.Spell)
{
SpellConfig spellConfig = ConfigData.GetSpellConfig(card.CardId);
if (BattleTargetManager.IsSpellUnitTarget(spellConfig.Target))
{
var targetStar = -1;
if (tar >= 0)
{
targetStar = BattleManager.Instance.MonsterQueue[tar].Avatar.MonsterConfig.Star;
}
for (int i = 0; i < BattleManager.Instance.MonsterQueue.Count; i++)
{
LiveMonster monster = BattleManager.Instance.MonsterQueue[i];
if (monster.IsGhost)
{
continue;
}
if ((monster.IsLeft != isLeft && spellConfig.Target[1] != 'F') || (monster.IsLeft == isLeft && spellConfig.Target[1] != 'E'))
{
if (tar == -1 || monster.Avatar.MonsterConfig.Star > targetStar)
{
tar = i;
targetStar = monster.Avatar.MonsterConfig.Star;
}
}
}
if (tar == -1)
{
return;
}
}
}
if (card.CardType == CardTypes.Monster)
{
Point monPos = GetMonsterPoint(card.CardId, false);
player.UseMonster(card, monPos);
}
else if (card.CardType == CardTypes.Weapon)
{
var lm = BattleManager.Instance.MonsterQueue[tar];
player.UseWeapon(lm, card);
}
else if (card.CardType == CardTypes.Spell)
{
SpellConfig spellConfig = ConfigData.GetSpellConfig(card.CardId);
Point targetPos = Point.Empty;
LiveMonster targetMonster = null;
if (BattleTargetManager.IsSpellNullTarget(spellConfig.Target))
{
targetPos = new Point(isLeft ? MathTool.GetRandom(200, 300) : MathTool.GetRandom(600, 700), MathTool.GetRandom(size * 3 / 10, row * size - size * 3 / 10));
}
else if (BattleTargetManager.IsSpellUnitTarget(spellConfig.Target))
{
targetMonster = BattleManager.Instance.MonsterQueue[tar];
targetPos = targetMonster.CenterPosition;
}
player.DoSpell(targetMonster, card, targetPos);
}
}
}
