/// <<inheritdoc />
public Card Build()
{
if (_card == null)
{
throw new NotProperlyInitializedException($"Card cannot be null. Call {nameof(AddBasicCardElements)} before {nameof(Build)}");
}
if (_pendulumMonsterCard != null)
{
CheckIfMonsterInitialized(_monsterCard);
_monsterCard.PendulumMonsterCard = _pendulumMonsterCard;
_pendulumMonsterCard.MonsterCard = _monsterCard;
}
if (_linkMonsterCard != null)
{
CheckIfMonsterInitialized(_monsterCard);
_monsterCard.LinkMonsterCard = _linkMonsterCard;
_linkMonsterCard.MonsterCard = _monsterCard;
}
if (_monsterCard != null)
{
_monsterCard.Card = _card;
_card.MonsterCard = _monsterCard;
}
_monsterCard = null;
_linkMonsterCard = null;
_pendulumMonsterCard = null;
return(_card);
}
private void CheckIfMonsterInitialized(MonsterCard monsterCard)
{
if (monsterCard == null)
{
throw new NotProperlyInitializedException($"Monster cannot be null when adding additional monster elements. Call {nameof(AddMonsterCardElements)}.");
}
}
void UpdatePartyStatus()
{
int i = 0;
foreach (GameObject slot in slots)
{
if (slot.transform.childCount > 0)
{
MonsterCard card = slot.transform.GetChild(0).GetComponent <MonsterCard>();
Entity mon = card.monster;
card.partyindex = -1;
card.index = i + offset * 6;
}
++i;
}
i = 0;
foreach (GameObject slot in partyslots)
{
if (slot.transform.childCount > 0)
{
MonsterCard card = slot.transform.GetChild(0).GetComponent <MonsterCard>();
Entity mon = card.monster;
card.partyindex = i;
card.index = -1;
}
++i;
}
}
public static void Apply(Player player, Field field, MonsterCard card, int index)
{
bool canSummon = true;
// Check for field space
if (field.monsterZone[index].sprite != null)
{
return;
}
// Order of application here is important.
// Apply to player
canSummon = player.Play(card);
if (!canSummon)
{
return;
}
if (card.stars > 4) // If monster was tribute summoned
{
player.sacrificed = new List <MonsterCard>(); // Use up the sacrifices
}
player.canNormalSummon = false;
// Apply to card BEFORE summoning to field.
card.mode = MonsterPosition.ATTACK;
card.canChangePosition = false;
// Apply to field
field.monsterZone[index] = card;
}
public void SingleTurnTest()
{
MTCGUser UserA = new MTCGUser("Tester A", 1, 20);
MTCGUser UserB = new MTCGUser("Tester B", 2, 20);
Card.Card Acard1 = new MonsterCard("Dragon", 2000, Element.Fire, MonsterTypes.Dragon);
Card.Card Acard2 = new MonsterCard("Dragon 2", 1200, Element.Water, MonsterTypes.Dragon);
Card.Card Acard3 = new MonsterCard("Dragon 3", 1900, Element.Normal, MonsterTypes.Dragon);
Card.Card Acard4 = new MonsterCard("Mega Goblin", 2500, Element.Fire, MonsterTypes.Goblin);
Card.Card Bcard1 = new MonsterCard("Goblin", 1000, Element.Normal, MonsterTypes.Goblin);
Card.Card Bcard2 = new MonsterCard("Elf", 2000, Element.Fire, MonsterTypes.FireElf);
Card.Card Bcard3 = new MonsterCard("Wizzard", 2000, Element.Water, MonsterTypes.Wizzard);
Card.Card Bcard4 = new MonsterCard("Mega Dragon", 2000, Element.Fire, MonsterTypes.Dragon);
Deck DeckA = new Deck(Acard1, Acard2, Acard3, Acard4);
Deck DeckB = new Deck(Bcard1, Bcard2, Bcard3, Bcard4);
Battle battle1 = new Battle(UserA, UserB, DeckA, DeckB);
battle1.battleTurnMonsterOnly(DeckA._card1, DeckB._card1);
Assert.AreEqual(battle1.turnWinner, UserA);
battle1.battleTurnMonsterOnly(DeckA._card3, DeckB._card3);
Assert.AreEqual(battle1.turnWinner, UserB);
}
public static void Apply(Player player, Field field, MonsterCard card, int index)
{
bool canSet = true;
// Check for field space
if (field.monsterZone[index].sprite != null)
{
return;
}
// Order of application here is important!!!!
// Apply to player
canSet = player.Play(card);
if (!canSet)
{
return;
}
// Apply to card BEFORE setting to field.
card.mode = MonsterPosition.FACE_DOWN_DEFENSE;
// Apply to field
field.monsterZone.RemoveAt(index);
field.monsterZone.Insert(index, card);
}
public void SetUp()
{
var asmbly = Assembly.GetExecutingAssembly();
var types = GetTypesWithMyAttribute(asmbly);
types.ToArray();
var hardShell = new HardShellCardAttribute(25);
var hardShell2 = new HardShellCardAttribute(50);
var sharper = new SharperCardAttribute();
var weightless = new WeightlessCardAttribute(0, 100);
var ironWill = new IronWillCardAttribute();
_attackerMonsterCard = new MountainRangerCard()
{
Atk = 25,
Hp = 50,
Def = 125
};
_defenderMonsterCard = new MountainRangerCard()
{
Atk = 25,
Hp = 50,
Def = 125
};
_attackerMonsterCard.Attributes.Add(hardShell);
_defenderMonsterCard.Attributes.Add(weightless);
_defenderMonsterCard.Attributes.Add(hardShell2);
_attackerMonsterCard.AddTypes(new PaperMonsterType(), new RockMonsterType());
_defenderMonsterCard.AddTypes(new ScissorsMonsterType());
_polymorpher = new Polymorpher();
_depolymorpher = new Depolymorpher();
_polymorphedMonster = _polymorpher.Polymorph(_attackerMonsterCard, _defenderMonsterCard);
}
public void Setup()
{
_kraken = new MonsterCard("sadf34s", 1, "Der Test Knight", elementTypes.Water, cardProperty.Kraken);
_waterSpell = new SpellCard("pouicyx23", 35, "Test Water Spell", elementTypes.Water);
_fireSpell = new SpellCard("pouicyx23", 35, "Test Fire Spell", elementTypes.Fire);
_normalSpell = new SpellCard("pouicyx23", 35, "Test Normal Spell", elementTypes.Normal);
}
public MonsterCard FlipNewActiveMonster()
{
if (cards.Count <= 0)
{
ResetDiscardedCards();
}
int drawnCard = cards[cards.Count - 1];
cards.RemoveAt(cards.Count - 1);
string stringToFlip = csvStrings[drawnCard + 1];
string[] parsedString = stringToFlip.Split(',');
MonsterCard flippedMonsterCard = new MonsterCard(System.Convert.ToInt32(parsedString[0]),
parsedString[1],
parsedString[2],
parsedString[3],
parsedString[4],
System.Convert.ToInt32(parsedString[5]),
System.Convert.ToInt32(parsedString[6]),
System.Convert.ToInt32(parsedString[7]),
System.Convert.ToInt32(parsedString[8]),
parsedString[9]);
activeMonsterScript.monsterCard = flippedMonsterCard;
return(flippedMonsterCard);
}
public void TestIsMonsterCard()
{
Card.Card card = new MonsterCard("Test", 1500, Element.Fire, MonsterTypes.Ork);
var actual = card.CardType;
Assert.AreEqual(CardType.Monster, actual);
}
static void ChooseMonster(GameObject chosenMonster)
{
TableDropZone.singleton.RetrieveBorrowedCards();
MonsterCard monsterCard = chosenMonster.GetComponent <MonsterCard>();
PlayerInGame.localPlayerInGame.UseStoredCardOnTarget(monsterCard.GetNetId());
}
protected override void Effect(BaseCard card)
{
MonsterCard monster = card as MonsterCard;
monster.Attack += buffAttack;
monster.HealthPoints += buffHealth;
}
public IEnumerator PlayerVsMonster(Hero player, MonsterCard monster)
{
var ogHP = player.healthPoint;
var monsterCardCopy = monster.GetCopy();
while (player.healthPoint >= 0.0f && monsterCardCopy.Health >= 0.0f)
{
monsterCardCopy.TakeDamage(player);
yield return(new WaitForSeconds(0.1f));
Debug.Log("Monster " + monsterCardCopy.Health);
player.TakeDamageFromMonster(monsterCardCopy);
yield return(new WaitForSeconds(0.1f));
UIManager.Instance.P1HpSlider.value = player.healthPoint;
Debug.Log("Player one " + player.healthPoint);
UIManager.Instance.P2HpSlider.value = monsterCardCopy.Health;
}
bool result = player.healthPoint > monsterCardCopy.Health;
UIManager.Instance.HidePrompts();
player.healthPoint = ogHP;
if (result)
{
LootCard rewardCardLooted = CardManager.Instance.GetRandomLoot();
UIManager.Instance.PromptReward(rewardCardLooted);
}
UIManager.Instance.ShowInventory();
NetworkManager.Instance.BroadcastUpdateTurn(); // Ends the turn
}
public static BaseCards MakeMonster(Random rand)
{
BaseCards tempCard = null;
//uid erstellen
string teststring = string.Format("{0:N}", Guid.NewGuid()); //erstellt eine unique Id
string uid = teststring.Substring(0, 9); //kürzt die ID auf 9 stellen
//entscheiden welchen typ also cardProperty
int randType = ChooseProperty(rand);
//entscheiden welche Eigenschaft also elementTypes
int randElement = ChooseElement(rand);
//entschieden wie viel damage
int damage = rand.Next(1, 51);
//irgwie da mit nem namen machen
string name = CreateNameMonster(rand);
//set the cardProperty
string card_Element = Enum.GetName(typeof(elementTypes), randElement);
elementTypes tempElement = ((elementTypes)Enum.Parse(typeof(elementTypes), card_Element));
string card_property = Enum.GetName(typeof(cardProperty), randType);
cardProperty tempProperty = ((cardProperty)Enum.Parse(typeof(cardProperty), card_property));
tempCard = new MonsterCard(uid, damage, name, tempElement, tempProperty);
return(tempCard);
}
public async Task DirectAttack(string uid, int index)
{
string playerID = Context.ConnectionId;
Game game = Games[uid];
Player Player1 = game.Player1.ID == playerID ? game.Player1 : game.Player2;
Player Player2 = game.Player1.ID == playerID ? game.Player2 : game.Player1;
MonsterCard card = Player1.Field.MonsterFields[index];
if (card == null)
{
return;
}
Player1.ProcessContinuousEffectWhenAttack(card.UID);
Player2.ProcessContinuousEffectWhenAttack(card.UID);
Player1.CheckTrapsWhenAttack();
if (Player2.EffectingCard != null)
{
await SendMessage(Player1, Player2, uid);
Thread.Sleep(500);
try
{
Player2.ProcessEffect(card.UID);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ex.StackTrace);
}
}
Player1.DirectAttack(index);
await SendMessage(Player1, Player2, uid);
}
public void summonMonster()
{
monster.transform.SetParent(zone.transform);
monster.transform.position = zone.transform.position;
monster.transform.eulerAngles = zone.transform.eulerAngles;
monster.GetComponent <ThisMonsterCard>().setSummoned(true);
monster.GetComponent <ThisMonsterCard>().setZoneSummoned(zone);
monster.GetComponent <ThisMonsterCard>().getZoneInHand().GetComponent <HandZone>().setCard(null);
monster.GetComponent <ThisMonsterCard>().setZoneInHand(null);
zone.GetComponent <FieldMonsterZone>().setMonster(monster);
MonsterCard monsterCard = monster.GetComponent <ThisMonsterCard>().getMonsterCard();
Mana manaCounter = monster.GetComponent <ThisMonsterCard>().getMyPlayer().getManaGameObject().GetComponent <Mana>();
MonsterHand hand = monster.GetComponent <ThisMonsterCard>().getMyPlayer().getMonsterHandGameObject().GetComponent <MonsterHand>();
// Pay the mana cost
manaCounter.setCurrentMana(manaCounter.getCurrentMana() - monsterCard.getCost());
// Set the correct number of cards in hand and Arrange them
hand.setNmbMonstersInHand(hand.getNmbMonstersInHand() - 1);
hand.arrangeCards();
FieldMonsters f = monster.GetComponent <ThisMonsterCard>().getMyPlayer().getFieldGameObject().GetComponent <FieldMonsters>();
f.setMonstersInPlay(f.getMonstersInPlay() + 1);
}
protected override bool AttackMonster(Card monster)
{
MonsterCard enemy = (MonsterCard)monster;
double battleDamage = Damage;
switch (enemy.MonsterType)
{
case MonsterType.Goblin:
break;
case MonsterType.Dragon:
break;
case MonsterType.Wizzard:
break;
case MonsterType.Ork:
return(true);
case MonsterType.Knight:
break;
case MonsterType.Kraken:
break;
case MonsterType.FireElf:
break;
}
return(battleDamage > enemy.Damage);
}
public static new void Apply(Player player, Field field, MonsterCard card, int index = 0)
{
// Apply to monster
if (card.canChangePosition) // Maybe this logic should be somewhere else?
{
card.mode = MonsterPosition.DEFENSE;
}
}
private void ActivatePanel(MonsterCard monster, CardZone targetZone = null)
{
gameObject.SetActive(true);
this.monster = monster;
this.targetZone = targetZone;
GetComponent <RectTransform>().position =
Input.mousePosition + new Vector3(-20, -20);
}
public MonsterCard getFromTheGrave()
{
graveCounter--;
MonsterCard m = monstersInGrave[graveCounter];
monstersInGrave.RemoveAt(graveCounter);
return(m);
}
public MonsterCard getFromTheGrave(int i)
{
MonsterCard m = monstersInGrave[i];
monstersInGrave.RemoveAt(i);
graveCounter--;
return(m);
}
public MonsterCard Create(MonsterCard card)
{
var cardRepository = new Repository <MonsterCard>();
var insertTask = cardRepository.InsertOne(card);
var cardResult = insertTask.Result;
Factory.Sender.publishStructureMessage("create", card);
return(cardResult);
}
internal void switchCanAttack(MonsterCard toSwitch)
{
List <MonsterCard> toSet = MeReadOnly.FaceUpMonsters;
int index = toSet.IndexOf(toSwitch);
toSwitch.CanAttack = false;
toSet[index] = toSwitch;
MeReadOnly.FaceUpMonsters = toSet;
}
/// <summary>
/// Create pendulum monster card.
/// </summary>
/// <param name="scale">Scale value.</param>
/// <param name="monsterCard"><see cref="DbModels.MonsterCard"/>.</param>
/// <returns>New instance of <see cref="PendulumMonsterCard"/>.</returns>
public static PendulumMonsterCard Create(
int scale,
MonsterCard monsterCard)
{
return(new PendulumMonsterCard(scale)
{
MonsterCard = monsterCard
});
}
private static CombatResult CalculateInCombatEffects(MonsterCard attacker, MonsterCard defender)
{
CombatResult combatResult = CalculateDamage(attacker, defender);
defender.Hp -= combatResult.DamageDealt;
CalculateEffects(attacker, defender, AttributeTriggers.DuringAttack, combatResult);
CalculateEffects(defender, attacker, AttributeTriggers.DuringAttack, combatResult);
return(combatResult);
}
/// <summary>
/// Trigger every EndTurn effects from Board
/// </summary>
public void TriggerEndPhaseEffects()
{
decks[DeckType.Board].ForEach(card =>
{
MonsterCard monster = card as MonsterCard;
GameManager.instance.actionStack.AddAction(monster.OnEndTurn, ActionStack.ActionType.EndTurn);
});
}
public IActionResult Edit(string id, [FromBody] MonsterCard card)
{
try {
cardService.Update(id, card);
} catch (Exception e) {
Console.WriteLine(e);
return(BadRequest(e.Message));
}
return(Ok());
}
private void SpawnMonster(Monster monster)
{
GameObject monsterInstance = Instantiate(_monsterCardPrefab, _uiSpawnArea);
monsterInstance.transform.localPosition = new Vector3(_currentHorizontalSpawnPosition, 0, 0);
MonsterCard monsterCard = monsterInstance.GetComponent <MonsterCard>();
monsterCard.Draw(monster);
CalculateHorizontalPostion();
}
public void Update(string id, MonsterCard cardIn)
{
var cardRepository = new Repository <MonsterCard>();
bool result = cardRepository.UpdateOne(id, cardIn).Result;
if (result)
{
Factory.Sender.publishStructureMessage("update", cardIn);
}
}
public void Delete(MonsterCard card)
{
var cardRepository = new Repository <MonsterCard>();
bool result = cardRepository.DeleteOne(card).Result;
if (result)
{
Factory.Sender.publishStructureMessage("delete", card);
}
}
public void UpdateFields(MonsterCard card)
{
CardAttack.enabled = true;
CardDefense.enabled = true;
CardName.text = card.cardName;
CardAttack.text = card.attack.ToString();
CardDefense.text = card.defense.ToString();
CardDesc.text = card.description;
}
public static MonsterCard NewCard(string name)
{
Uri baseUri = new Uri("ms-appx:///");
MonsterCard card = new MonsterCard();
card.Name = name;
switch (name)
{
case "Skull Servant":
card.Description = "A skeletal ghost that isn't strong but can mean trouble in large numbers.";
card.SetImage(baseUri, "Assets/Monster/SkullServant.jpg");
card.SetPower(300, 200);
break;
case "Harpie Girl":
card.Description = "A Harpie chick who aspires to flit about beautifully and gorgeously, but attack sharply.";
card.SetImage(baseUri, "Assets/Monster/HarpieGirl.jpg");
card.SetPower(500, 500);
break;
case "M-Warrior #2":
card.Description = "Specializing in combination attacks, this warrior is equipped with a tough, magnetically coated armor.";
card.SetImage(baseUri, "Assets/Monster/MWarrior2.jpg");
card.SetPower(500, 1000);
break;
case "Swordsman of Landstar":
card.Description = "An amateur with a sword, this fairy warrior relies on its mysterious powers.";
card.SetImage(baseUri, "Assets/Monster/SwordsmanOfLandstar.jpg");
card.SetPower(500, 1200);
break;
case "One-Eyed Shield Dragon":
card.Description = "This dragon wears a shield not only for its own protection, but also for ramming its enemies.";
card.SetImage(baseUri, "Assets/Monster/OneEyedShieldDragon.jpg");
card.SetPower(700, 1300);
break;
case "Kumootoko":
card.Description = "A massive, intelligent spider that traps enemies with webbing.";
card.SetImage(baseUri, "Assets/Monster/Kumootoko.jpg");
card.SetPower(700, 1400);
break;
case "Science Soldier":
card.Description = "Soldiers equipped with state-of-the-art weaponry to face unknown creatures.";
card.SetImage(baseUri, "Assets/Monster/ScienceSoldier.jpg");
card.SetPower(800, 800);
break;
case "Spirit of the Harp":
card.Description = "A spirit that soothes the soul with the music of its heavenly harp.";
card.SetImage(baseUri, "Assets/Monster/SpiritOfTheHarp.jpg");
card.SetPower(800, 2000);
break;
case "Flame Manipulator":
card.Description = "This Spellcaster attacks enemies with fire-related spells such as \"Sea of Flames\" and \"Wall of Fire\".";
card.SetImage(baseUri, "Assets/Monster/FlameManipulator.jpg");
card.SetPower(900, 1000);
break;
case "Dokuroyaiba":
card.Description = "A boomerang with brains that will pursue a target to the ends of the earth.";
card.SetImage(baseUri, "Assets/Monster/Dokuroyaiba.jpg");
card.SetPower(1000, 400);
break;
case "M-Warrior #1":
card.Description = "Specializing in combination attacks, this warrior uses magnetism to block an enemy's escape.";
card.SetImage(baseUri, "Assets/Monster/MWarrior1.jpg");
card.SetPower(1000, 500);
break;
case "Fairy Dragon":
card.Description = "This beautiful Dragon spirit harbors hidden strength.";
card.SetImage(baseUri, "Assets/Monster/FairyDragon.jpg");
card.SetPower(1100, 1200);
break;
case "Baby Dragon":
card.Description = "Much more than just a child, this dragon is gifted with untapped power.";
card.SetImage(baseUri, "Assets/Monster/BabyDragon.jpg");
card.SetPower(1200, 700);
break;
case "Silver Fang":
card.Description = "A snow wolf that's beautiful to the eye, but absolutely vicious in battle.";
card.SetImage(baseUri, "Assets/Monster/SilverFang.jpg");
card.SetPower(1200, 800);
break;
case "Terra the Terrible":
card.Description = "Known as a swamp dweller, this creature is a mission of the dark forces.";
card.SetImage(baseUri, "Assets/Monster/TerraTheTerrible.jpg");
card.SetPower(1200, 1300);
break;
case "Ogre of the Black Shadow":
card.Description = "An ogre possessed by the powers of the dark. Few can withstand its rapid charge.";
card.SetImage(baseUri, "Assets/Monster/OgreOfTheBlackShadow.jpg");
card.SetPower(1200, 1400);
break;
case "Aqua Madoor":
card.Description = "A wizard of the waters that conjures a liquid wall to crush any enemies that oppose him.";
card.SetImage(baseUri, "Assets/Monster/AquaMadoor.jpg");
card.SetPower(1200, 2000);
break;
case "Dark Titan of Terror":
card.Description = "A fiend said to dwell in the world of dreams, it attacks enemies in their sleep.";
card.SetImage(baseUri, "Assets/Monster/DarkTitanOfTerror.jpg");
card.SetPower(1300, 1100);
break;
case "D. Human":
card.Description = "Gifted with the power of dragons, this warrior wields a sword created from a dragon's fang.";
card.SetImage(baseUri, "Assets/Monster/DHuman.jpg");
card.SetPower(1300, 1100);
break;
case "Feral Imp":
card.Description = "A playful little fiend that lurks in the dark, waiting to attack an unwary enemy.";
card.SetImage(baseUri, "Assets/Monster/FeralImp.jpg");
card.SetPower(1300, 1400);
break;
case "Magical Ghost":
card.Description = "This creature casts a spell of terror and confusion just before attacking its enemies.";
card.SetImage(baseUri, "Assets/Monster/MagicalGhost.jpg");
card.SetPower(1300, 1400);
break;
case "Giant Soldier of Stone":
card.Description = "A giant warrior made of stone. A punch from this creature has earth-shaking results.";
card.SetImage(baseUri, "Assets/Monster/GiantSoldierOfStone.jpg");
card.SetPower(1300, 2000);
break;
case "Clown Zombie":
card.Description = "A clown revived by the powers of darkness. Its deadly dance has sent many monsters to their graves.";
card.SetImage(baseUri, "Assets/Monster/ClownZombie.jpg");
card.SetPower(1350, 0);
break;
case "Witty Phantom":
card.Description = "Dressed in a night-black tuxedo, this creature presides over death.";
card.SetImage(baseUri, "Assets/Monster/WittyPhantom.jpg");
card.SetPower(1400, 1300);
break;
case "Armored Lizard":
card.Description = "A lizard with a very tough hide and a vicious bite.";
card.SetImage(baseUri, "Assets/Monster/ArmoredLizard.jpg");
card.SetPower(1500, 1200);
break;
case "Gazelle the King of Mythical Beasts":
card.Description = "This monster moves so fast that it looks like an illusion to mortal eyes.";
card.SetImage(baseUri, "Assets/Monster/GazelleTheKingOfMythicalBeasts.jpg");
card.SetPower(1500, 1200);
break;
case "Rogue Doll":
card.Description = "A deadly doll gifted with mystical power, it is particularly powerful when attacking against dark forces.";
card.SetImage(baseUri, "Assets/Monster/RogueDoll.jpg");
card.SetPower(1600, 1000);
break;
case "Darkfire Soldier #1":
card.Description = "An explosive expert from a special elite force.";
card.SetImage(baseUri, "Assets/Monster/DarkfireSoldier1.jpg");
card.SetPower(1700, 1150);
break;
case "Ansatsu":
card.Description = "A silent and deadly warrior specializing in assassination.";
card.SetImage(baseUri, "Assets/Monster/Ansatsu.jpg");
card.SetPower(1700, 1200);
break;
case "Rude Kaiser":
card.Description = "With an axe in each hand, this monster delivers heavy damage.";
card.SetImage(baseUri, "Assets/Monster/RudeKaiser.jpg");
card.SetPower(1800, 1600);
break;
case "Gyakutenno Megami":
card.Description = "This fairy uses her mystical power to protect the weak and provide spiritual support.";
card.SetImage(baseUri, "Assets/Monster/GyakutennoMegami.jpg");
card.SetPower(1800, 2000);
break;
case "Curse of Dragon":
card.Description = "A wicked dragon that taps into dark forces to execute a powerful attack.";
card.SetImage(baseUri, "Assets/Monster/CurseOfDragon.jpg");
card.SetPower(2000, 1500);
break;
case "Judge Man":
card.Description = "This club-wielding warrior battles to the end and will never surrender.";
card.SetImage(baseUri, "Assets/Monster/JudgeMan.jpg");
card.SetPower(2200, 1500);
break;
case "Beast of Talwar":
card.Description = "Only the master of the sword among the Fiend-Type monsters is permitted to hold the Talwar.";
card.SetImage(baseUri, "Assets/Monster/BeastOfTalwar.jpg");
card.SetPower(2400, 2150);
break;
case "Dark Magician":
card.Description = "The ultimate wizard in terms of attack and defense.";
card.SetImage(baseUri, "Assets/Monster/DarkMagician.jpg");
card.SetPower(2500, 2100);
break;
case "Wingweaver":
card.Description = "A six-winged fairy who prays for peace and hope.";
card.SetImage(baseUri, "Assets/Monster/Wingweaver.jpg");
card.SetPower(2750, 2400);
break;
}
return card;
}
