public static int CalculateGainAttackerWouldGetIfPowerAndThoughnessWouldIncrease(Card attacker, IEnumerable<Card> blockers, int powerIncrease, int toughnessIncrease) { if ((blockers.None()) && powerIncrease > 0) { return CalculateDefendingPlayerLifeloss(attacker, blockers) > 0 ? 2 : 0; } if (toughnessIncrease < 1 && !attacker.Has().Charge) return 0; var p = new AttackerEvaluationParameters(attacker, blockers); var canBeDealtLeathalDamageWithoutBoost = CanAttackerBeDealtLeathalDamage(p); if (canBeDealtLeathalDamageWithoutBoost == false) return 0; p.AttackerPowerIncrease = powerIncrease; p.AttackerToughnessIncrease = toughnessIncrease; var canBeDealtLeathalDamageWithBoost = CanAttackerBeDealtLeathalDamage(p); return canBeDealtLeathalDamageWithBoost ? 0 : attacker.Score; }
public static int CalculatePermanentScore(Card permanent) { var score = 0; if (permanent.OverrideScore.Battlefield.HasValue) return permanent.OverrideScore.Battlefield.Value; if (permanent.Level > 0) score += 10 * permanent.Level.Value; if (permanent.ManaCost != null) { //score += CalculatePermanentScoreFromManaCost(permanent); if (permanent.Is().Creature) { score += (permanent.Power.Value * 10 + permanent.Toughness.Value * 3); if (permanent.HasSummoningSickness) score -= 1; } } else if (permanent.Is().Creature) { score += CalculatePermanentScoreFromPowerToughness(permanent.Power.Value, permanent.Toughness.Value); } else if (permanent.Is().Land) { score += GetLandOnBattlefieldScore(permanent); if (!permanent.Is().BasicLand) score += 10; } return score; }
public Attacker(Card card, Engine game) { Game = game; _card = card; _blockers.Initialize(ChangeTracker); _assignedDamage.Initialize(ChangeTracker); _isBlocked.Initialize(ChangeTracker); }
public Blocker(Card card, Attacker attacker, Engine game) { Card = card; Game = game; _attacker = new Trackable<Attacker>(attacker); _attacker.Initialize(ChangeTracker); _assignedDamage.Initialize(ChangeTracker); _damageAssignmentOrder.Initialize(ChangeTracker); }
public void PutOnTop(Card card) { if (card.Zone == Name) { MoveToFront(card); } else { AddToFront(card); } }
public void PutOnBottom(Card card) { if (card.Zone == Name) { MoveToEnd(card); } else { AddToEnd(card); } }
public static int CalculateDefendingPlayerLifeloss(Card attacker, IEnumerable<Card> blockers) { var total = 0; if (blockers.None()) { total = attacker.CalculateCombatDamageAmount(singleDamageStep: false); } //else if (attacker.Has().Trample) //{ // total = CalculateTrampleDamage(attacker, blockers); //} var prevented = attacker.Controller.Opponent.CalculatePreventedReceivedDamageAmount(total, attacker, isCombat: true); return total - prevented; }
public static bool CanAttackerBeDealtLeathalDamage(Card attacker, IEnumerable<Card> blockers) { return CanAttackerBeDealtLeathalDamage(new AttackerEvaluationParameters(attacker, blockers)); }
public ZoneChangedEvent(Card card, Zone @from, Zone to) { Card = card; From = @from; To = to; }
//public List<ActivationPrerequisites> CanActivateAbilities(bool ignoreManaAbilities = false) //{ // return _activatedAbilities.CanActivate(ignoreManaAbilities); //} public bool CanBeBlockedBy(Card card) { if (card.IsTapped) return false; if (Has().Immunity) return false; if (Has().SpellShield) return false; if (HasProtectionFrom(card)) return false; return true; }
public static int GetAmountOfDamageThatNeedsToBePreventedToSafeBlockerFromDying(Card blocker, Card attacker) { var evaluation = new BlockerEvaluation(new BlockerEvaluationParameters { Blocker = blocker, Attacker = attacker }); var results = evaluation.Evaluate(); if (results.ReceivesLeathalDamage) return results.DamageDealt; return 0; }
public static int GetAmountOfDamageCreature1WillDealToCreature2(Card creature1, Card creature2, int powerIncrease = 0) { var amountDealt = creature1.CalculateCombatDamageAmount(powerIncrease: powerIncrease); var preventedReceived = creature2.CalculatePreventedDamageAmount(amountDealt, creature1, isCombat: true); return amountDealt - preventedReceived; }
public CardViewModel(Card card) { Card = card; Colors = new CardColor[] { }; }
public SpellCastEvent(Card card, Targets targets) { Card = card; Targets = targets; }
public override void AfterRemove(Card card) { card.OnCardLeftBattlefield(); }
public override void AfterAdd(Card card) { card.OnCardJoinedBattlefield(); }
//public void ActivateAbility(int index, ActivationParameters activationParameters) //{ // _activatedAbilities.Activate(index, activationParameters); // IncreaseUsageScore(); //} //public void IncreaseUsageScore() //{ // // to avoid useless moves every move lowers the score a bit // // this factor increases linearily with elapsed turns // // AI will prefer playing spells as soon as possible // var increase = Turn.TurnCount; // if (Turn.Step < Step.SecondMain) // increase += 1; // UsageScore += increase; //} public bool HasProtectionFrom(Card card) { return false; //return HasProtectionFromTypes(card._type.Value); }
public bool HasAttachment(Card card) { return _attachments.Contains(card); }
public void Detach(Card card) { _attachments.Remove(card); card.AttachedTo = null; Publish(new AttachmentDetachedEvent(attachment: card, attachedTo: this)); }
public static bool CanAttackerKillAnyBlocker(Card attacker, IEnumerable<Card> blockers) { return blockers.Any(blocker => CanBlockerBeDealtLeathalCombatDamage(attacker, blocker)); }
//public static int CalculateTrampleDamage(Card attacker, Card blocker) //{ // return CalculateTrampleDamage(attacker, blocker.ToEnumerable()); //} public static bool CanBlockerBeDealtLeathalCombatDamage(Card attacker, Card blocker) { return CanBlockerBeDealtLeathalCombatDamage(new BlockerEvaluationParameters { Attacker = attacker, Blocker = blocker }); }
public bool OnMouseOver(Card card, Vector2 mousePosition) { int offSet = 20; int width = card.ImageTexture.Width * (int)card.Scale + offSet; int height = card.ImageTexture.Height * (int)card.Scale + offSet; int xOffSet = (int)card.Position.X;// -(int)(width / 2); int yOffSet = (int)card.Position.Y;// -(int)(height / 2); var sceneCoords = mousePosition / Resolution.ScreenScale; if (sceneCoords.X >= (xOffSet - offSet) && sceneCoords.X <= (xOffSet + width) && sceneCoords.Y >= (yOffSet - offSet) && sceneCoords.Y <= (yOffSet + height)) { return true; } else { return false; } }
public static int GetAmountOfDamageThatNeedsToBePreventedToSafeAttackerFromDying(Card attacker, IEnumerable<Card> blockers) { var p = new AttackerEvaluationParameters(attacker, blockers); var results = new AttackerEvaluation(p).Evaluate(); if (!results.ReceivesLeathalDamage) return 0; if (results.DeathTouchDamage > 0) return results.DeathTouchDamage; var prevented = results.TotalDamage - attacker.Life + 1; return prevented; }
public static int CalculateGainBlockerWouldGetIfPowerAndThougnessWouldIncrease(Card attacker, Card blocker, int powerIncrease, int toughnessIncrease) { if (attacker == null) return 0; var p = new BlockerEvaluationParameters { Attacker = attacker, Blocker = blocker, }; var canBeDealtLeathalDamageWithoutBoost = CanBlockerBeDealtLeathalCombatDamage(p); if (canBeDealtLeathalDamageWithoutBoost == false) return 0; p.BlockerPowerIncrease += powerIncrease; p.BlockerToughnessIncrease += toughnessIncrease; var canBeDealtLeathalDamageWithBoost = CanBlockerBeDealtLeathalCombatDamage(p); return canBeDealtLeathalDamageWithBoost == false ? blocker.Score : 1; }
public static Card GetBlockerThatDealsLeathalDamageToAttacker(Card attacker, IEnumerable<Card> blockers) { var p = new AttackerEvaluationParameters(attacker, blockers); var performance = new AttackerEvaluation(p); var results = performance.Evaluate(); return results.LeathalBlocker; }
//public bool HasProtectionFromTypes(IEnumerable<string> types) //{ // return _protections.HasProtectionFromAnyTypes() && // types.Any(x => _protections.HasProtectionFrom(x)); //} public void Attach(Card attachment) { if (attachment.IsAttached) { var controller = attachment.AttachedTo.Controller; attachment.AttachedTo.Detach(attachment); if (controller != Controller) { Controller.PutCardToBattlefield(attachment); } } attachment.AttachedTo = this; _attachments.Add(attachment); Publish(new AttachmentAttachedEvent(attachment)); }
public void ShuffleIntoLibrary(Card card) { PutOnBottomOfLibrary(card); _library.Shuffle(); }
public int CalculatePreventedDamageAmount(int totalAmount, Card source, bool isCombat = false) { if (HasProtectionFrom(source)) { return totalAmount; } var damage = new PreventDamageParameters { Amount = totalAmount, QueryOnly = true, Source = source, IsCombat = isCombat, Target = this, }; return Game.PreventDamage(damage); }
public void DrawCard(SpriteBatch spriteBatch, SpriteFont spriteFont, Card card) { Color color = new Color((byte)255, (byte)255, (byte)255, (byte)255); //Cost Vector2 costPosition = new Vector2(card.Source.Left - card.costPreview.Width / 2, card.Source.Top - card.costPreview.Height / 2); spriteBatch.Draw( card.costPreview, costPosition, null, color, 0.0f, Vector2.Zero, card.Scale, SpriteEffects.None, 0.0f); if (card.ManaCost.HasValue) { TextureContent.DrawText(spriteBatch, spriteFont, card.ManaCost.Value.ToString(), Color.Black, color, card.Scale, new Vector2(costPosition.X + card.costPreview.Width / 2, costPosition.Y + card.costPreview.Height / 2)); } //Name Vector2 borderPosition = new Vector2(card.Source.Left - card.ImageTexture.Width / 2, card.Source.Center.Y - card.ImageTexture.Height / 2); TextureContent.DrawText(spriteBatch, spriteFont, card.Name.ToString(), Color.Black, color, card.Scale / 2, new Vector2(borderPosition.X + card.ImageTexture.Width, card.Position.Y)); }
public bool CanBeBlockedBy(Card creature) { return _card.CanBeBlockedBy(creature); }