public ChangeZoneEventArg(CardInstance _source, CardGroupEnum _origine, CardGroupEnum _destination)
{
Type = MagicEventType.ChangeZone;
Source = _source;
Origine = _origine;
Destination = _destination;
}
public override void Execute(float d)
{
if (Input.GetMouseButtonDown(0))
{
List <RaycastResult> results = Settings.GetUIObjects();
foreach (RaycastResult result in results)
{
CardInstance cardInst = result.gameObject.GetComponentInParent <CardInstance>();
PlayerHolder player = Settings.gameManager.currentPlayer;
if (player.cardsOnTable.Contains(cardInst))
{
if (cardInst.CanAttack())
{
player.attackingCards.Add(cardInst);
player.currentHolders.SetCardOnBattleLine(cardInst);
}
}
else
{
return;
}
}
}
}
public override void OnCick(CardInstance inst)
{
//Debug.Log("click card");
currentCard.Set(inst);
Settings.gameManager.SetState(hodlingWithCard);
onCurrentCardSelected.Raise();
}
public LifeEventArg(Player _player, CardInstance _source, int _oldValue, int _newValue)
{
this.Player = _player;
this.Source = _source;
this.OldValue = _oldValue;
this.NewValue = _newValue;
}
public override void OnMouseLeftClick(CardInstance inst)
{
Debug.Log("This is my hand card");
currentCard.Set(inst);
Settings.gameManager.SetState(holdingCard);
onCurrentCardSelected.Raise();
}
public CardDrawedViewSample()
{
int baseId = 123;
Clan clan = Clan.GetClanById(ClanId.Raptors);
string cardName = "Tester";
Skill ability = new Skill(SkillPrefix.Courage, SkillSuffix.DecreasePillzXMinY, 2, 3);
int minLevel = 2;
int maxLevel = 4;
List <CardLevel> cardLevels = new List <CardLevel>
{
new CardLevel(2, 2, 3),
new CardLevel(3, 3, 4),
new CardLevel(4, 6, 5),
};
int abilityUnlockLevel = 3;
CardRarity rarity = CardRarity.Legendary;
int currentLevel = 4;
int instanceId = 222;
CardBase cardBase = new CardBase(baseId, cardName, clan, minLevel, maxLevel, cardLevels, ability, abilityUnlockLevel, rarity);
CardInstance cardInstance = new CardInstance(cardBase, instanceId, currentLevel);
card = new CardDrawed(cardInstance);
}
/// <summary>
/// Retorna uma instância da carta a partir de seu id.
/// </summary>
public Card getCardById(int id)
{
Card card = CardInstance.createCard(id);
card.setPlayerId(player_id);
return(card);
}
internal void AddCard(CardInstance value, int qty)
{
if (value == null)
{
return;
}
foreach (var ci in CardsCollection.Where(ci => ci.BorderBrush != null))
{
ci.BorderBrush = null;
}
var card = CardsCollection.Where(ci => ci.CardId == value.CardId).FirstOrDefault();
if (card != null)
{
card.Quantity += qty; //if already in deck, inc qty
card.BorderBrush = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromArgb(255, 255, 100, 15));
}
else
{
card = value;
card.BorderBrush = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromArgb(255, 255, 100, 15));
card.Quantity = qty;
CardsCollection.Add(card);
}
if (LimitCardCount)
{
trackerFactory.GetService <IDeckService>().EnforceCardLimit(card);
}
NewCard = null;
}
internal NotifyCardEvent(Game game, string notification, CardInstance card, string message)
: base(game, notification)
{
Debug.Assert(card != null);
Card = card;
Message = message;
}
public override Cost Pay(ref CardInstance ci, CardInstance source)
{
Costs tmp = new Costs();
int i = 0;
while (i < CostList.Count)
{
Cost res = CostList [i].Pay(ref ci, source);
i++;
if (res != null)
{
tmp.CostList.Add(res);
}
if (ci == null)
{
break;
}
}
while (i < CostList.Count)
{
tmp.CostList.Add(CostList [i].Clone());
i++;
}
return(tmp.CostList.Count == 0 ? null : tmp.CostList.Count == 1 ? tmp.CostList [0] : tmp);
}
public void DrawCard(CardInstance cardInstance)
{
if (owner == currentPlayer.Get())
{
cardInitializer.SpawnCard(cardInstance);
}
}
/// <summary>
/// Cria uma instância de uma carta nova, e adiciona-a a mão.
/// </summary>
public void addCardToHand(int id)
{
Card card = CardInstance.createCard(id);
card.setPlayerId(this.player_id);
hand.addCard(card);
}
public override void OnClick(CardInstance instance)
{
currentCard.Set(instance);
onCurrentCardSelected.Raise();
Settings.gameManager.SetState(holdingCard);
Debug.Log("This card is in my hand - clicked");
}
public Bataille()
{
YACE.YACEParameters parameters = new YACEParameters();
CardDefinition battailDefinition = new CardDefinition()
{
Name = "BatailleCard",
};
parameters.ResourceDefinitions = new ResourceDefinition[]
{
new ResourceDefinition
{
Name = "Multiplier",
BaseValue = 1,
IsPlayerBound = true,
MinValue = 1,
},
new ResourceDefinition
{
Name = "Score",
BaseValue = 0,
IsPlayerBound = true,
}
};
parameters.ZoneDefinitions = new ZoneDefinition[]
{
new ZoneDefinition
{
Name = "MainDeck",
IsPlayerBound = false,
IsOrdered = false,
},
new ZoneDefinition
{
Name = "PlayerHand",
IsPlayerBound = true,
IsOrdered = false,
},
new ZoneDefinition
{
Name = "DiscardPile",
},
};
yace = new YACE.YACE(parameters);
CardInstance lastCard = null;
for (int i = 0; i < 10; ++i)
{
CardInstance card = new CardInstance(battailDefinition);
card.AddTag("Value", i + 1);
yace.SetCardToZone(card, "MainDeck");
lastCard = card;
}
yace.ShuffleZone("MainDeck");
}
private Deck InitializaDeck()
{
Deck deck = new Deck("Test Deck");
Card card = deck.AddCard();
card.SideA = "sideA - 你好";
card.SideB = "sideB - 你好";
card.Notes = "notes - 你好";
card.Tags = "tags";
CardInstance sideAToB = card.GetInstanceSideAToB();
CardPlan sideAToBPlan = sideAToB.Plan;
sideAToBPlan.LastDays = 1;
CardReview sideAToBValue = sideAToB.AddReview();
sideAToBValue.DateTime = DateTimeOffset.Now;
sideAToBValue.Value = ReviewValues.Values.VALUE_1;
CardInstance sideBToA = card.GetInstanceSideBToA();
CardPlan sideBToAPlan = sideBToA.Plan;
sideBToAPlan.LastDays = 1;
CardReview sideBToAValue = sideBToA.AddReview();
sideBToAValue.DateTime = DateTimeOffset.Now;
sideBToAValue.Value = ReviewValues.Values.VALUE_1;
return(deck);
}
public override void OnClick(CardInstance cardInstance)
{
Debug.Log("This card is on hand and it was clicked");
currentCard.Set(cardInstance);
Settings.gameManager.SetState(holdingCard);
onSelectCard.Raise();
}
public bool UpgradeCards(List <ICardInstance> cardTargets)
{
foreach (var cardTarget in cardTargets)
{
if (cardTarget.BaseCard.UpgradeTarget != null)
{
//Then, upgrade it
var newCard = (Activator.CreateInstance(cardTarget.BaseCard.UpgradeTarget) as BaseCard);
var newCardInstance = new CardInstance(newCard, _gameWorldManager);
//Then, replace the original one
if (_gameWorldManager.CardManager.Hand.Contains(cardTarget))
{
_gameWorldManager.CardManager.Hand[_gameWorldManager.CardManager.Hand.FindIndex(ind => ind.Equals(cardTarget))] = newCardInstance;
Logger.Log($"Upgrading card {cardTarget.Name} into {newCard.Name} in Hand");
}
else if (_gameWorldManager.CardManager.DeckPile.Contains(cardTarget))
{
_gameWorldManager.CardManager.DeckPile[_gameWorldManager.CardManager.Hand.FindIndex(ind => ind.Equals(cardTarget))] = newCardInstance;
Logger.Log($"Upgrading card {cardTarget.Name} into {newCard.Name} in Deck");
}
else if (_gameWorldManager.CardManager.DiscardPile.Contains(cardTarget))
{
_gameWorldManager.CardManager.DiscardPile[_gameWorldManager.CardManager.Hand.FindIndex(ind => ind.Equals(cardTarget))] = newCardInstance;
Logger.Log($"Upgrading card {cardTarget.Name} into {newCard.Name} in Discord");
}
_gameWorldManager.EventManager.CardUpgraded(cardTarget, newCard, newCardInstance);
}
}
return(true);
}
private static bool PlayBombCard(BotMain bot, CardInstance card)
{
var allBombableEnemyTerritories = bot.Standing.Territories.Values
.Where(o => o.OwnerPlayerID == bot.PlayerID)
.SelectMany(o => bot.Map.Territories[o.ID].ConnectedTo.Keys)
.Distinct()
.Select(o => bot.Standing.Territories[o])
.Where(o => bot.IsOpponent(o.OwnerPlayerID) && o.NumArmies.Fogged == false)
.ToList();
var minArmies = !bot.UseRandomness ? bot.BaseIncome.Total * 2 : SharedUtility.Round(bot.BaseIncome.Total * RandomUtility.BellRandom(1, 3));
var weights = allBombableEnemyTerritories.Where(o => o.NumArmies.NumArmies > minArmies).ToDictionary(o => o.ID, o => o.NumArmies.NumArmies - minArmies);
if (weights.Count == 0)
{
return(false);
}
var bomb = bot.UseRandomness ? RandomUtility.WeightedRandom(weights.Keys, o => weights[o]) : weights.OrderByDescending(o => o.Value).First().Key;
AILog.Log("PlayCards", "Bombing " + bot.TerrString(bomb));
bot.Orders.AddOrder(GameOrderPlayCardBomb.Create(card.ID, bot.PlayerID, bomb));
return(true);
}
public void CloneTest001()
{
CardInstance ci = new CardInstance();
PopulateObject(ci, StartProp);
ci.PropertyChanged += (s, e) => { };
CardInstance clone = ci.Clone() as CardInstance;
foreach (PropertyInfo p in typeof(CardInstance).GetProperties())
{
if (p.CanWrite)
{
TestContext.WriteLine("Checking prop:{0}.{1};{2}", p.Name, p.GetValue(ci), p.GetValue(clone));
if ((p.Name == nameof(CardInstance.Card)) ||//skip do not clone as this will never change anyway! (read from DB)
(p.Name == nameof(CardInstance.BorderBrush))) //brush wont be modified
{
continue;
}
Assert.IsFalse(Object.ReferenceEquals(p.GetValue(ci), p.GetValue(clone)));
}
}
foreach (EventInfo ev in typeof(CardInstance).GetEvents())
{
FieldInfo fieldTheEvent = GetAllFields(typeof(CardInstance)).Where(f => f.Name == ev.Name).First();
Assert.IsNull(fieldTheEvent.GetValue(clone));
}
}
public void SaveDeckTest001_OverwriteCurrent()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
Mock <ITracker> tracker = new Mock <ITracker>();
ObservableCollection <Deck> deckList = new ObservableCollection <Deck>();
tracker.Setup(t => t.Decks).Returns(deckList);
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
CardInstance card = new CardInstance(new Card(trackerFactory.Object));
Deck deck = Deck.CreateNewDeck(trackerFactory.Object, "test deck");
deck.SelectedVersion.Cards.Add(card);
// List<CardInstance> modifiedCollection = new List<CardInstance>()
{
// card, //include this and ensure it has been cloned
deck.SelectedVersion.Cards.Add(new CardInstance(Card.Unknown));
deck.SelectedVersion.Cards.Add(new CardInstance(new Card(trackerFactory.Object)));
};
DeckEditViewModel model = new DeckEditViewModel();
model.Deck = deck;
model.SaveDeck(tracker.Object, new SerializableVersion(0, 0), deck.SelectedVersion.Cards);
Assert.AreEqual(3, model.Deck.SelectedVersion.Cards.Count);
Assert.AreEqual(1, model.Deck.History.Count);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown("space"))
{
if (desc == null)
{
ICardGenerator cardGenerator = new ProceduralCardGenerator(model, images, creatureModels, nameModel);
if (providedSeed == 0)
{
generatedSeed = Random.Range(0, 10000);
}
else
{
generatedSeed = providedSeed;
}
instance = new CardInstance(cardGenerator.GenerateCard(generatedSeed, flags));
}
else
{
display.SetCard(new CardInstance(desc));
}
display.SetCard(instance);
}
else if (Input.GetKeyDown("q"))
{
if (instance != null)
{
double power = instance.baseCard.PowerLevel();
double mana = PowerBudget.PowerLevelToMana(power);
}
}
}
private async Task <JsonResult> buildJsonResult(int deckId)
{
if (deckId == 0)
{
return(GetEmptyJson());
}
CardInstance cardInstance = null;
using (var cardDao = new CardDao(DbContext))
{
cardInstance = await cardDao.GetNextCardInstanceToReview(deckId);
}
if (cardInstance == null)
{
return(GetEmptyJson());
}
var card = cardInstance.Card;
var result = new
{
cardId = card.Id,
sideA = card.SideA,
sideB = card.SideB,
notes = card.Notes,
tags = card.Tags,
cardInstanceId = cardInstance.Id,
sideAToB = cardInstance.SideAToB
};
return(Json(result));
}
public void ImportFromTextProcess(string importData)
{
var importLines = importData.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
this.DeckName = importLines[0].Replace("###", String.Empty).Trim();
foreach (string cardLine in importLines.Skip(1))
{
if (String.IsNullOrWhiteSpace(cardLine))
{
continue;
}
var cardData = RemoveTextInCurlyBraces(cardLine);
string[] splitedLine = cardData.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
int cardCount = GetCardQty(splitedLine);
string cardName = GetCardName(splitedLine);
Card card = this.cardsDatabase.FindCardByName(cardName);
CardInstance cardInstance = new CardInstance(card, trackerFactory);
cardInstance.Quantity = cardCount;
Cards.Add(cardInstance);
}
}
public void SaveDeckTest003_SaveMinor()
{
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
Mock <ITracker> tracker = new Mock <ITracker>();
ObservableCollection <Deck> deckList = new ObservableCollection <Deck>();
tracker.Setup(t => t.Decks).Returns(deckList);
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
CardInstance card = new CardInstance(new Card(trackerFactory.Object));
Deck deck = Deck.CreateNewDeck(trackerFactory.Object, "test deck");
deck.Class = DataModel.Enums.DeckClass.Assassin; //any
deck.SelectedVersion.Cards.Add(card);
DeckEditViewModel model = new DeckEditViewModel();
model.Deck = deck;
model.BeginEdit();
deck.SelectedVersion.Cards.Add(new CardInstance(Card.Unknown));
deck.SelectedVersion.Cards.Add(new CardInstance(new Card(trackerFactory.Object)));
model.SaveDeck(tracker.Object, new SerializableVersion(0, 1), deck.SelectedVersion.Cards);
Assert.AreEqual(3, model.Deck.SelectedVersion.Cards.Count);
Assert.AreEqual(new SerializableVersion(1, 1), model.Deck.SelectedVersion.Version);
Assert.AreEqual(1, model.Deck.History[0].Cards.Count);
Assert.AreEqual(2, model.Deck.History.Count);
//endsure inial card has ebeen cloned
Assert.IsFalse(model.Deck.SelectedVersion.Cards.Contains(card));
}
/// <summary>
/// 将手牌移动到弃牌堆
/// </summary>
/// <param name="cardInstance"></param>
internal void MoveHandCardToUsed(CardInstance cardInstance)
{
_lstHand.Remove(cardInstance);
_lstUsed.Add(cardInstance);
SendEvent(BattleEvent.MOVE_HAND_TO_USED, cardInstance);
SendEvent(BattleEvent.USED_NUM_UPDATE);
}
private IEnumerator DrawCardUntilNotAttack()
{
CardInstance drawCardInst = null;
while (true)
{
if (!BattleTool.IsDeckHasCard()) //如果没卡了
{
if (!BattleTool.IsUsedHasCard())
{
yield break;
}
float shuffleTime = BattleTool.ShuffleDeckFromUsed();
yield return(new WaitForSeconds(shuffleTime));
}
if (BattleTool.IsHandCardFull())// 如果手牌满了
{
yield break;
}
drawCardInst = _battleModel.DrawOneCard(false);
if (null == drawCardInst || drawCardInst.cardType != CardType.ATTACK)
{
yield break;
}
yield return(new WaitForSeconds(0.2f));
}
}
//处理卡牌效果
private void HandleCardEffect(CardInstance cardInstance, uint effectId, int targetInstId = 0)
{
CardEffectTemplate effectTemplate = CardEffectTemplateData.GetData(effectId);
if (effectTemplate == null)
{
return;
}
CardEffectBase cardEffect = CardEffectFactory.GetCardEffect(effectTemplate.nType);
if (cardEffect == null)
{
return;
}
if (cardEffect.CanTriggerCardEffect(effectTemplate))
{
cardEffect.DoEffect(this, cardInstance, effectTemplate, targetInstId);
}
if (effectTemplate.nLinkId != 0)
{
HandleCardEffect(cardInstance, effectTemplate.nLinkId, targetInstId);
}
}
public override bool IsComplete()
{
PlayerHolder playerHolder = Settings.gameManager.currentPlayer;
PlayerHolder enemyPlayerHolder = Settings.gameManager.GetEnemyOf(playerHolder);
if (playerHolder.attackingCards.Count == 0)
{
return(true);
}
for (int i = 0; i < playerHolder.attackingCards.Count; i++)
{
CardInstance cardInst = playerHolder.attackingCards[i];
Card card = cardInst.viz.card;
CardProperties attackProperty = card.GetProperty(attackElement);
if (attackProperty == null)
{
Debug.LogError("You are attacking with a card that cant attack");
continue;
}
playerHolder.DropCard(cardInst, false);
playerHolder.currentHolders.SetCardDown(cardInst);
cardInst.SetFlatfooted(true);
enemyPlayerHolder.DoDamage(attackProperty.intVal);
}
playerHolder.attackingCards.Clear();
return(true);
}
public virtual void AddCard(CardInstance c, bool anim = true)
{
if (c == null)
{
return;
}
c.CurrentGroup = this;
float hSpace = HorizontalSpacing;
if (HorizontalSpacing * (Cards.Count + 1) > MaxHorizontalSpace)
{
hSpace = MaxHorizontalSpace / (Cards.Count + 1);
}
Animation.StartAnimation(new FloatAnimation(c, "x", this.x + hSpace / 2 * Cards.Count, 0.2f));
float halfWidth = hSpace * (Cards.Count) / 2;
foreach (CardInstance i in Cards)
{
Animation.StartAnimation(new FloatAnimation(i, "x", this.x - halfWidth + hSpace * Cards.IndexOf(i), 0.2f));
Animation.StartAnimation(new FloatAnimation(i, "z", this.z + VerticalSpacing * Cards.IndexOf(i), 0.2f));
}
Animation.StartAnimation(new FloatAnimation(c, "y", this.y, 0.2f));
Animation.StartAnimation(new FloatAnimation(c, "z", this.z + VerticalSpacing * (Cards.Count + 1), 0.2f));
Animation.StartAnimation(new AngleAnimation(c, "yAngle", this.yAngle, MathHelper.Pi * 0.1f));
Animation.StartAnimation(new AngleAnimation(c, "xAngle", this.xAngle, MathHelper.Pi * 0.03f));
Cards.Add(c);
UpdateLayout(anim);
}
public override void Execute(float d)
{
if (Input.GetMouseButtonDown(0))
{
List <RaycastResult> results = Settings.GetUIObjs();
foreach (RaycastResult r in results)
{
CardInstance c = r.gameObject.GetComponentInParent <CardInstance>();
if (c != null)
{
GameManager gm = Settings.gameManager;
PlayerHolder enemy = gm.GetEnemyOf(gm.currentPlayer);
if (c.owner != enemy)
{
if (gm.currentPlayer.downCards.Contains(c))
{
if (!c.isFlatfooted)
{
Debug.Log(c.name);
currentCard.value = c;
gm.SetState(holdingCard);
onCurrentCardSelected.Raise();
}
}
}
return;
}
}
}
}
public override void OnClick(CardInstance inst)
{
// Debug.Log("this card is on my hand");
currentCard.Set(inst);
Settings.gameManager.SetState(holdingCard);
onCurrentCardSelected.Raise();
}
public static CardInstance[] MapToCards(this List<int> cardGuidArray, IIndexable<CardInstance> candidates)
{
var cardArray = new CardInstance[cardGuidArray.Count];
for (int i = 0; i < cardGuidArray.Count; ++i)
{
cardArray[i] = candidates.Find(cardGuidArray[i]);
}
return cardArray;
}
public DeactivateAssist(CardInstance cardToDeactivate)
{
if (cardToDeactivate == null)
{
throw new ArgumentNullException("cardToDeactivate");
}
CardToDeactivate = cardToDeactivate;
}
public ResetCard(CardInstance cardToReset, ICause cause)
: base(cause)
{
if (cardToReset == null)
{
throw new ArgumentNullException("cardToReset");
}
CardToReset = cardToReset;
}
protected void Validate(CardInstance card)
{
if (card == null)
{
FailValidation("Card can't be null.");
}
else
{
Validate(card.Owner);
}
}
public DealDamageToCard(CardInstance target, int damageToDeal, ICause cause)
: base(cause)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
Target = target;
DamageToDeal = damageToDeal;
}
public HealCard(CardInstance target, int lifeToHeal, ICause cause)
: base(cause)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
Target = target;
LifeToHeal = lifeToHeal;
}
public MoveCard(CardInstance subject, int toZone, ICause cause)
: base(cause)
{
if (subject == null)
{
throw new ArgumentNullException("subject");
}
m_fromZone = subject.Owner.m_zones.GetZone(subject.Zone);
m_toZone = subject.Owner.m_zones.GetZone(toZone);
Subject = subject;
}
public AddBehavior(CardInstance target, Behaviors.IBehavior behavior)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
else if (behavior == null)
{
throw new ArgumentNullException("behavior");
}
Target = target;
Behavior = behavior;
}
public Transform(CardInstance cardToTransform, ICardModel newModel)
{
if (cardToTransform == null)
{
throw new ArgumentNullException("cardToTransform");
}
else if (newModel == null)
{
throw new ArgumentNullException("newModel");
}
else if (newModel == cardToTransform.Model)
{
throw new ArgumentException("Card will not be transformed.");
}
CardToTransform = cardToTransform;
NewCardModel = newModel;
}
public AddCounter(CardInstance target, Behaviors.ICounter counter, int numToAdd)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
else if (counter == null)
{
throw new ArgumentNullException("behavior");
}
else if (numToAdd <= 0)
{
throw new ArgumentOutOfRangeException("numToAdd", "NumToAdd must be greater than zero.");
}
Target = target;
Counter = counter;
NumToAdd = numToAdd;
}
public InternalCardData(CardInstance card, int zonePosition)
{
Guid = card.Guid;
Zone = card.Zone;
ZonePosition = zonePosition;
OwnerPlayerIndex = card.Owner.Index;
Model = card.Model;
var manaCost = card.Behaviors.Get<Behaviors.ManaCost>();
SummonCost = manaCost != null ? manaCost.Cost : -1;
var warrior = card.Warrior;
IsWarrior = warrior != null;
AttackAndInitialAttack = new Tuple<int, int>(warrior != null ? warrior.Attack : -1, warrior != null ? warrior.InitialAttack : -1);
LifeAndInitialLife = new Tuple<int, int>(warrior != null ? warrior.Life : -1, warrior != null ? warrior.InitialLife : -1);
IsWarriorCoolingDown = warrior != null && warrior.State == Behaviors.WarriorState.CoolingDown;
IsAssist = card.Behaviors.Has<Behaviors.Assist>();
IsAssistActivated = card.IsActivatedAssist;
IsInstant = card.Behaviors.Has<Behaviors.Instant>();
IsTrap = card.Behaviors.Has<Behaviors.Trap>();
var counters = card.Counters;
var statusEffects = card.Behaviors.OfType<Behaviors.IStatusEffect>();
var counterArray = new InternalCounterData[counters.Count() + statusEffects.Count()];
int i = 0;
foreach (var counter in counters)
{
counterArray[i++] = new InternalCounterData(counter.Text, counter.IconUri, card.GetCounterCount(counter.GetType()));
}
foreach (var statusEffect in statusEffects)
{
counterArray[i++] = new InternalCounterData(statusEffect.Text, statusEffect.IconUri, 0);
}
Counters = counterArray.ToIndexable();
}
public override void OnSelectCards(Interactions.SelectCards io)
{
var respond = m_playingBack.ReadLine().Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (respond[0] == "se")
{
if (respond[1] == "null")
{
io.Respond(null);
}
else
{
CardInstance[] cards = new CardInstance[respond.Length - 1];
for (int i = 1; i < respond.Length; ++i)
{
cards[i - 1] = io.Candidates.First(c => c.Guid == Int32.Parse(respond[i]));
}
io.Respond(cards.ToIndexable());
}
}
else
{
throw new NotSupportedException(String.Format("Unrecognized verb {0}", respond[0]));
}
}
public CompiledPlayCard(CardInstance card)
{
m_cardGuid = card.Guid;
}
public void RespondAttackPlayer(CardInstance attacker, Player player)
{
if (attacker == null)
{
throw new ArgumentNullException("attacker");
}
else if (player == null)
{
throw new ArgumentNullException("player");
}
var result = new Result
{
ActionType = Interactions.BaseInteraction.PlayerAction.AttackPlayer,
Data = new object[] { attacker, player }
};
Validate(result);
RespondBack(result);
}
public void RespondAttackCard(CardInstance attacker, CardInstance defender)
{
if (attacker == null)
{
throw new ArgumentNullException("attacker");
}
else if (defender == null)
{
throw new ArgumentNullException("defender");
}
var result = new Result
{
ActionType = Interactions.BaseInteraction.PlayerAction.AttackCard,
Data = new CardInstance[] { attacker, defender }
};
Validate(result);
RespondBack(result);
}
public void RespondRedeem(CardInstance selectedCard)
{
if (selectedCard == null)
{
throw new ArgumentNullException("selectedCard");
}
var result = new Result
{
ActionType = Interactions.BaseInteraction.PlayerAction.Redeem,
Data = selectedCard
};
Validate(result);
RespondBack(result);
}
public AddCounter(CardInstance target, Behaviors.ICounter counter)
: this(target, counter, 1)
{ }
public InitiativeMoveCard(CardInstance subject, int toZone, ICause cause)
: base(subject, toZone, cause)
{ }
public CompiledResponse CompiledRespondRedeem(CardInstance selectedCard)
{
if (selectedCard == null)
{
throw new ArgumentNullException("selectedCard");
}
Validate(new Result
{
ActionType = Interactions.BaseInteraction.PlayerAction.Redeem,
Data = selectedCard
});
return new CompiledRedeem(selectedCard);
}
public CompiledSacrifice(CardInstance card)
{
m_cardGuid = card.Guid;
}
public CompiledRedeem(CardInstance card)
{
m_cardGuid = card.Guid;
}
public CompiledAttackCard(CardInstance attacker, CardInstance defender)
{
m_attackerGuid = attacker.Guid;
m_defenderGuid = defender.Guid;
}
public MoveCard(CardInstance subject, int toZone)
: this(subject, toZone, null)
{ }
public PlayCard(CardInstance subject, int toZone, Game cause)
: base(subject, toZone, cause)
{
if (subject == null)
{
throw new ArgumentNullException("subject");
}
else if (cause == null)
{
throw new ArgumentNullException("cause");
}
else if (FromZone != SystemZone.Hand
|| ToZoneType != ZoneType.OnBattlefield)
{
throw new InvalidOperationException("Invalid card to be played.");
}
}
public CompiledResponse CompiledRespondAttackPlayer(CardInstance attacker, Player player)
{
if (attacker == null)
{
throw new ArgumentNullException("attacker");
}
else if (player == null)
{
throw new ArgumentNullException("player");
}
Validate(new Result
{
ActionType = Interactions.BaseInteraction.PlayerAction.AttackPlayer,
Data = new object[] { attacker, player }
});
return new CompiledAttackPlayer(attacker, player);
}
internal override void RunMain()
{
var index = m_fromZone.CardModels.IndexOf(CardToRevive);
m_fromZone.CardModels.RemoveAt(index);
Subject = new CardInstance(CardToRevive, Player);
m_toZone.CardInstances.Add(Subject);
Subject.Zone = ToZone;
if (m_toZone.Type == ZoneType.OnBattlefield)
{
Context.Game.SubscribeCardToCommands(Subject);
}
}
public CompiledAttackPlayer(CardInstance attacker, Player player)
{
m_attackerGuid = attacker.Guid;
m_playerIndex = player.Index;
}
public CompiledResponse CompiledRespondAttackCard(CardInstance attacker, CardInstance defender)
{
if (attacker == null)
{
throw new ArgumentNullException("attacker");
}
else if (defender == null)
{
throw new ArgumentNullException("defender");
}
Validate(new Result
{
ActionType = Interactions.BaseInteraction.PlayerAction.AttackCard,
Data = new CardInstance[] { attacker, defender }
});
return new CompiledAttackCard(attacker, defender);
}
public CompiledActivateAssist(CardInstance card)
{
m_cardGuid = card.Guid;
}
