{

class Card

{

///variables

/*type will store one of three values: 'M', 'S' or 'T'

*defining the card as type monster, spell or trap respectively.*/

static char type;

/*model will store the data pertaining to the display of the monster

* on the marker representing this paricular Card.*/

MarkerNode model;

//TransformNode sprite;

static int baseAtk;

int lastAtk;

int attackPower;

int health;

int defaultHealth;

bool ko;

string name;

string effect;

/*

* contructor: initializes Card data structure.

* parameters:

* marker (int) - marker number that displays card

* type (char) - type of monster, can be 'M', 'S', or 'T'

* model (TransformNode) - TransformNode displayed on read marker

* atk (int) - attack power of monster

* health (int) - health of monster

*

* */

public Card(char ntype, MarkerNode nmodel, int atk, int nhealth, string nname, string neffect)

{

type = ntype;

model = nmodel;

//sprite = nsprite; --> add sprite parameter?

attackPower = atk;

baseAtk = atk;

lastAtk = atk;

health = nhealth;

defaultHealth = health;

ko = false;

name = nname;

effect = neffect;

}

//getType fetches type and returns it.

public char getType()

{

return type;

}

//getModel fetches model and returns it

public MarkerNode getModel()

{

return model;

}

/* DEBATABLE METHOD:

* In the case that the model of the monster would have to be changed somehow

* (i.e color of monster needs to be changed),

* this method exists to change the model in its entirety.

* parameter: newModel (TransformNode)

*

*

public void setSprite(TransformNode newSprite)

{

sprite = newSprite;

}*/

/* isAttackingMonster exists to update damage given to another monster

* parameter: target (Card data structure)

* NOTE: no need for an isBeingAttacked method since this method will

* always be called by the attacking monster to edit values in the target monster.

* */

public void attacking(Card target)

{

target.takeDamage(attackPower);

}

/* takeDamage is used to register damage taken and subtract from the health pool of a given monster.

* parameter: amount (int)

* return: int value holding amount of damage done to owner of destroyed card.

* */

public void takeDamage(int amount)

{

health -= amount;

if (health <= 0)

{

destroy();

}

}

public void setHealth(int amount)

{

health += amount;

if (health > defaultHealth)

health = defaultHealth;

}

public int getDefaultHealth()

{

return defaultHealth;

}

public int getAttackPower()

{

return attackPower;

}

public void buff(int amount)

{

lastAtk = attackPower;

attackPower += amount;

}

public void debuff(int amount)

{

lastAtk = attackPower;

attackPower -= amount;

if (attackPower < 0)

attackPower = 0;

}

public void setDefault()

{

attackPower = baseAtk;

}

public void setLast()

{

attackPower = lastAtk;

lastAtk = baseAtk;

}

public string getName()

{

return name;

}

public string getEffect()

{

return effect;

}

public int getHealth()

{

return health;

}

public void destroy()

{

ko = true;

}

public bool isKO()

{

return ko;

}

}

/// <summary>

/// This tutorial demonstrates how to use both the ALVAR and ARTag optical marker tracker

/// library with our Goblin XNA framework. Please read the README.pdf included with this

/// project before running this tutorial. If you're using ARTag, please remove calib.xml

/// from the solution explorer so that you can successfully build the project.

/// </summary>

public class Tutorial8 : Microsoft.Xna.Framework.Game

{

GraphicsDeviceManager graphics;

Scene scene;

MarkerNode cylinderMarkerNode100,

cylinderMarkerNode101, cylinderMarkerNode102, cylinderMarkerNode103, cylinderMarkerNode104,

cylinderMarkerNode105, cylinderMarkerNode106, cylinderMarkerNode107, cylinderMarkerNode108,

cylinderMarkerNode109, cylinderMarkerNode110, cylinderMarkerNode111, cylinderMarkerNode112,

cylinderMarkerNode113, cylinderMarkerNode114;

MarkerNode cylinderMarkerNode115, cylinderMarkerNode116, cylinderMarkerNode117,

cylinderMarkerNode118, cylinderMarkerNode119, cylinderMarkerNode120, cylinderMarkerNode121,

cylinderMarkerNode122, cylinderMarkerNode123, cylinderMarkerNode124, cylinderMarkerNode125,

cylinderMarkerNode126, cylinderMarkerNode127, cylinderMarkerNode128, cylinderMarkerNode129;

MarkerNode cylinderMarkerNode130, cylinderMarkerNode131;

MarkerNode cylinderMarkerNode132, cylinderMarkerNode133, cylinderMarkerNode134,

cylinderMarkerNode135,cylinderMarkerNode136, cylinderMarkerNode137, cylinderMarkerNode138,

cylinderMarkerNode139, cylinderMarkerNode140, cylinderMarkerNode141;

bool useStaticImage = false;

SpriteFont uiFont;

Card p1Monster1;

Card p1Monster2;

Card p1Monster3;

Card p2Monster1;

Card p2Monster2;

Card p2Monster3;

Card p1Spell;

Card p1Trap;

Card p2Spell;

Card p2Trap;

bool p1Turn = true;

bool p1NoTrap = false;

bool p2NoTrap = false;

bool p1NoMagic = false;

bool p2NoMagic = false;

bool p1NoAttack = false;

bool p2NoAttack = false;

int p1TrapEffectCnt = 0;

int p2TrapEffectCnt = 0;

int p1life = 50, p2life = 50;

string text = "";

bool p1Winner = false;

public Tutorial8()

{

graphics = new GraphicsDeviceManager(this);

Content.RootDirectory = "Content";

}

Card[] cards = new Card[30];

string p1TrapFlag = "none";

string p2TrapFlag = "none";

string p1SpellFlag = "none";

string p2SpellFlag = "none";

/*state machine creation:

* * 0 = start splash page

* * 1 = turn in progress (game on!)

* * 2 = end phase

* * 3 = cleanup phase

* * 4 = end game

*/

int state = 1;

G2DPanel p1Frame, p2Frame;

G2DLabel p1LifeLab, p1m1LifeLab, p1m2LifeLab, p1m3LifeLab;

G2DLabel p2LifeLab, p2m1LifeLab, p2m2LifeLab, p2m3LifeLab;

/// <summary>

/// Allows the game to perform any initialization it needs to before starting to run.

/// This is where it can query for any required services and load any non-graphic

/// related content. Calling base.Initialize will enumerate through any components

/// and initialize them as well.

/// </summary>

protected override void Initialize()

{

base.Initialize();

// Initialize the GoblinXNA framework

State.InitGoblin(graphics, Content, "");

// Initialize the scene graph

scene = new Scene(this);

// Use the newton physics engine to perform collision detection

scene.PhysicsEngine = new NewtonPhysics();

// Multi-thread the marker tracking process

State.ThreadOption = (ushort)ThreadOptions.MarkerTracking;

// Set up optical marker tracking

// Note that we don't create our own camera when we use optical marker

// tracking. It'll be created automatically

SetupMarkerTracking();

// Set up the lights used in the scene

CreateLights();

// Create 3D objects

CreateObjects();

// Create the ground that represents the physical ground marker array

CreateGround();

Create2DGUI();

// Use per pixel lighting for better quality (If you using non NVidia graphics card,

// setting this to true may reduce the performance significantly)

scene.PreferPerPixelLighting = true;

// Enable shadow mapping

// NOTE: In order to use shadow mapping, you will need to add 'PostScreenShadowBlur.fx'

// and 'ShadowMap.fx' shader files as well as 'ShadowDistanceFadeoutMap.dds' texture file

// to your 'Content' directory

scene.EnableShadowMapping = true;

// Show Frames-Per-Second on the screen for debugging

State.ShowFPS = true;

}

private void CreateLights()

{

// Create a directional light source

LightSource lightSource = new LightSource();

lightSource.Direction = new Vector3(1, -1, -1);

lightSource.Diffuse = Color.White.ToVector4();

lightSource.Specular = new Vector4(0.6f, 0.6f, 0.6f, 1);

// Create a light node to hold the light source

LightNode lightNode = new LightNode();

lightNode.LightSource = lightSource;

scene.RootNode.AddChild(lightNode);

}

private void SetupMarkerTracking()

{

IVideoCapture captureDevice = null;

if (useStaticImage)

{

captureDevice = new NullCapture();

captureDevice.InitVideoCapture(0, FrameRate._30Hz, Resolution._800x600,

ImageFormat.R8G8B8_24, false);

((NullCapture)captureDevice).StaticImageFile = "testImage800x600.jpg";

}

else

{

// Create our video capture device that uses DirectShow library. Note that

// the combinations of resolution and frame rate that are allowed depend on

// the particular video capture device. Thus, setting incorrect resolution

// and frame rate values may cause exceptions or simply be ignored, depending

// on the device driver. The values set here will work for a Microsoft VX 6000,

// and many other webcams.

captureDevice = new DirectShowCapture2();

captureDevice.InitVideoCapture(0, FrameRate._60Hz, Resolution._640x480,

ImageFormat.R8G8B8_24, false);

}

// Add this video capture device to the scene so that it can be used for

// the marker tracker

scene.AddVideoCaptureDevice(captureDevice);

// Create an optical marker tracker that uses ALVAR library

ALVARMarkerTracker tracker = new ALVARMarkerTracker();

tracker.MaxMarkerError = 0.02f;

tracker.InitTracker(captureDevice.Width, captureDevice.Height, "calib.xml", 9.0);

// Set the marker tracker to use for our scene

scene.MarkerTracker = tracker;

// Display the camera image in the background. Note that this parameter should

// be set after adding at least one video capture device to the Scene class.

scene.ShowCameraImage = true;

}

private void CreateGround()

{

GeometryNode groundNode = new GeometryNode("Ground");

groundNode.Model = new Box(95, 59, 0.1f);

// Set this ground model to act as an occluder so that it appears transparent

groundNode.IsOccluder = true;

// Make the ground model to receive shadow casted by other objects with

// CastShadows set to true

groundNode.Model.ReceiveShadows = true;

Material groundMaterial = new Material();

groundMaterial.Diffuse = Color.Gray.ToVector4();

groundMaterial.Specular = Color.White.ToVector4();

groundMaterial.SpecularPower = 20;

}

private void Create2DGUI()

{

p1Frame = new G2DPanel();

p1Frame.Bounds = new Rectangle(0, 0, 150, 80);

p1Frame.Border = GoblinEnums.BorderFactory.LineBorder;

p1Frame.Transparency = 1.0f;

p1Frame.BackgroundColor = Color.CornflowerBlue;

//Generic Label: P1

G2DLabel p1Label = new G2DLabel("P1: ");

p1Label.Bounds = new Rectangle(10, 10, 10, 10);

p1Label.TextFont = uiFont;

//Life Point Label: P1

p1LifeLab = new G2DLabel();

p1LifeLab.Bounds = new Rectangle(25, 10, 20, 40);

p1LifeLab.Text = p1life.ToString() + " LP";

p1LifeLab.TextFont = uiFont;

//Generic Label: P1M1

G2DLabel p1m1StatLab = new G2DLabel("M1: ");

p1m1StatLab.Bounds = new Rectangle(10, 25, 10, 10);

p1m1StatLab.TextFont = uiFont;

//Status Label: P1M1

p1m1LifeLab = new G2DLabel();

p1m1LifeLab.Bounds = new Rectangle(25, 25, 20, 40);

p1m1LifeLab.TextFont = uiFont;

//Generic Label: P1M2

G2DLabel p1m2StatLab = new G2DLabel("M2: ");

p1m2StatLab.Bounds = new Rectangle(10, 40, 10, 10);

p1m2StatLab.TextFont = uiFont;

//Status Label: P1M2

p1m2LifeLab = new G2DLabel();

p1m2LifeLab.Bounds = new Rectangle(25, 40, 20, 40);

p1m2LifeLab.TextFont = uiFont;

//Generic Label: P1M3

G2DLabel p1m3StatLab = new G2DLabel("M3: ");

p1m3StatLab.Bounds = new Rectangle(10, 55, 10, 10);

p1m3StatLab.TextFont = uiFont;

//Status Label: P1M3

p1m3LifeLab = new G2DLabel();

p1m3LifeLab.Bounds = new Rectangle(25, 55, 20, 40);

p1m3LifeLab.TextFont = uiFont;

p1Frame.AddChild(p1Label);

p1Frame.AddChild(p1LifeLab);

p1Frame.AddChild(p1m1StatLab);

p1Frame.AddChild(p1m1LifeLab);

p1Frame.AddChild(p1m2StatLab);

p1Frame.AddChild(p1m2LifeLab);

p1Frame.AddChild(p1m3StatLab);

p1Frame.AddChild(p1m3LifeLab);

scene.UIRenderer.Add2DComponent(p1Frame);

p2Frame = new G2DPanel();

p2Frame.Bounds = new Rectangle(650, 0, 150, 80);

p2Frame.Border = GoblinEnums.BorderFactory.LineBorder;

p2Frame.Transparency = 1.0f;

p2Frame.BackgroundColor = Color.CornflowerBlue;

//Generic Label: P2

G2DLabel p2Label = new G2DLabel("P2: ");

p2Label.Bounds = new Rectangle(15, 10, 10, 10);

p2Label.TextFont = uiFont;

//Life Point Label: P2

p2LifeLab = new G2DLabel();

p2LifeLab.Bounds = new Rectangle(35, 10, 40, 40);

p2LifeLab.Text = p2life.ToString() + " LP";

p2LifeLab.TextFont = uiFont;

//Generic Label: P2M1

G2DLabel p2m1StatLab = new G2DLabel("M1: ");

p2m1StatLab.Bounds = new Rectangle(15, 25, 10, 10);

p2m1StatLab.TextFont = uiFont;

//Status Label: P2M1

p2m1LifeLab = new G2DLabel();

p2m1LifeLab.Bounds = new Rectangle(35, 25, 20, 40);

p2m1LifeLab.TextFont = uiFont;

//Generic Label: P2M2

G2DLabel p2m2StatLab = new G2DLabel("M2: ");

p2m2StatLab.Bounds = new Rectangle(15, 40, 10, 10);

p2m2StatLab.TextFont = uiFont;

//Status Label: P2M2

p2m2LifeLab = new G2DLabel();

p2m2LifeLab.Bounds = new Rectangle(35, 40, 20, 40);

p2m2LifeLab.TextFont = uiFont;

//Generic Label: P2M3

G2DLabel p2m3StatLab = new G2DLabel("M3: ");

p2m3StatLab.Bounds = new Rectangle(15, 55, 10, 10);

p2m3StatLab.TextFont = uiFont;

//Status Label: P2M3

p2m3LifeLab = new G2DLabel();

p2m3LifeLab.Bounds = new Rectangle(35, 55, 20, 40);

p2m3LifeLab.TextFont = uiFont;

p2Frame.AddChild(p2Label);

p2Frame.AddChild(p2LifeLab);

p2Frame.AddChild(p2m1StatLab);

p2Frame.AddChild(p2m1LifeLab);

p2Frame.AddChild(p2m2StatLab);

p2Frame.AddChild(p2m2LifeLab);

p2Frame.AddChild(p2m3StatLab);

p2Frame.AddChild(p2m3LifeLab);

scene.UIRenderer.Add2DComponent(p2Frame);

}

private void CreateObjects()

{

// Create a material to apply to the sphere model

Material sphereMaterial = new Material();

sphereMaterial.Diffuse = new Vector4(0, 0.5f, 0, 1);

sphereMaterial.Specular = Color.Green.ToVector4();

sphereMaterial.SpecularPower = 10;

Material sphereMaterial2 = new Material();

sphereMaterial2.Diffuse = new Vector4(0, 0, 0.5f, 1);

sphereMaterial2.Specular = Color.Blue.ToVector4();

sphereMaterial2.SpecularPower = 10;

Material sphereMaterial3 = new Material();

sphereMaterial3.Diffuse = new Vector4(0.5f, 0, 0, 1);

sphereMaterial3.Specular = Color.Red.ToVector4();

sphereMaterial3.SpecularPower = 10;

Material sphereMaterial4 = new Material();

sphereMaterial4.Diffuse = new Vector4(0.5f, 0, 0, 1);

sphereMaterial4.Specular = Color.Cyan.ToVector4();

sphereMaterial4.SpecularPower = 10;

Material sphereMaterial5 = new Material();

sphereMaterial5.Diffuse = new Vector4(0.5f, 0, 0, 1);

sphereMaterial5.Specular = Color.Magenta.ToVector4();

sphereMaterial5.SpecularPower = 10;

Material sphereMaterial6 = new Material();

sphereMaterial6.Diffuse = new Vector4(0.5f, 0, 0, 1);

sphereMaterial6.Specular = Color.Yellow.ToVector4();

sphereMaterial6.SpecularPower = 10;

Material sphereMaterial7 = new Material();

sphereMaterial7.Diffuse = new Vector4(0.5f, 0, 0, 1);

sphereMaterial7.Specular = Color.DarkGray.ToVector4();

sphereMaterial7.SpecularPower = 10;

Material sphereMaterial8 = new Material();

sphereMaterial8.Diffuse = new Vector4(0.5f, 0, 0, 1);

sphereMaterial8.Specular = Color.Orange.ToVector4();

sphereMaterial8.SpecularPower = 10;

Material sphereMaterial9 = new Material();

sphereMaterial9.Diffuse = new Vector4(0.5f, 0, 0, 1);

sphereMaterial9.Specular = Color.Purple.ToVector4();

sphereMaterial9.SpecularPower = 10;

Material sphereMaterial10 = new Material();

sphereMaterial10.Diffuse = new Vector4(0.5f, 0, 0, 1);

sphereMaterial10.Specular = Color.Pink.ToVector4();

sphereMaterial10.SpecularPower = 10;

int[] zero = new int[1];

int[] first = new int[1];

int[] two = new int[1];

int[] three = new int[1];

int[] four = new int[1];

int[] five = new int[1];

int[] six = new int[1];

int[] seven = new int[1];

int[] eight = new int[1];

int[] nine = new int[1];

int[] ten = new int[1];

int[] eleven = new int[1];

int[] twelve = new int[1];

int[] thirteen = new int[1];

int[] fourteen = new int[1];

int[] fifteen = new int[1];

int[] sixteen = new int[1];

int[] seventeen = new int[1];

int[] eighteen = new int[1];

int[] nineteen = new int[1];

int[] twenty = new int[1];

int[] twentyone = new int[1];

int[] twentytwo = new int[1];

int[] twentythree = new int[1];

int[] twentyfour = new int[1];

int[] twentyfive = new int[1];

int[] twentysix = new int[1];

int[] twentyseven = new int[1];

int[] twentyeight = new int[1];

int[] twentynine = new int[1];

int[] thirty = new int[1];

int[] thirtyone = new int[1];

int[] thirtytwo = new int[1];

int[] thirtythree = new int[1]{133};

int[] thirtyfour = new int[1]{134};

int[] thirtyfive = new int[1]{135};

int[] thirtysix = new int[1]{136};

int[] thirtyseven = new int[1]{137};

int[] thirtyeight = new int[1] { 138 };

int[] thirtynine = new int[1] { 139 };

int[] forty = new int[1] { 140 };

int[] fortyone = new int[1] { 141 };

zero[0] = 100;

first[0] = 101;

two[0] = 102;

three[0] = 103;

four[0] = 104;

five[0] = 105;

six[0] = 106;

seven[0] = 107;

eight[0] = 108;

nine[0] = 100;

ten[0] = 110;

eleven[0] = 111;

twelve[0] = 112;

thirteen[0] = 113;

fourteen[0] = 114;

fifteen[0] = 115;

sixteen[0] = 116;

seventeen[0] = 117;

eighteen[0] = 118;

nineteen[0] = 119;

twenty[0] = 120;

twentyone[0] = 121;

twentytwo[0] = 122;

twentythree[0] = 123;

twentyfour[0] = 124;

twentyfive[0] = 125;

twentysix[0] = 126;

twentyseven[0] = 127;

twentyeight[0] = 128;

twentynine[0] = 129;

thirty[0] = 130;

thirtyone[0] = 131;

thirtytwo[0] = 132;

ModelLoader loader = new ModelLoader();

Model trapModel0 = (Model)loader.Load("", "Boxwhite");

Model trapModel1 = (Model)loader.Load("", "Boxwhite");

Model trapModel2 = (Model)loader.Load("", "Boxwhite");

Model trapModel3 = (Model)loader.Load("", "Boxwhite");

Model trapModel4 = (Model)loader.Load("", "Boxwhite");

Model trapModel5 = (Model)loader.Load("", "Boxwhite");

Model trapModel6 = (Model)loader.Load("", "Boxwhite");

Model trapModel7 = (Model)loader.Load("", "Boxwhite");

Model trapModel8 = (Model)loader.Load("", "Boxwhite");

Model trapModel9 = (Model)loader.Load("", "Boxwhite");

Model spellModel0 = (Model)loader.Load("", "MagicHat");

Model spellModel1 = (Model)loader.Load("", "MagicHat");

Model spellModel2 = (Model)loader.Load("", "MagicHat");

Model spellModel3 = (Model)loader.Load("", "MagicHat");

Model spellModel4 = (Model)loader.Load("", "MagicHat");

Model spellModel5 = (Model)loader.Load("", "MagicHat");

Model spellModel6 = (Model)loader.Load("", "MagicHat");

Model spellModel7 = (Model)loader.Load("", "MagicHat");

Model spellModel8 = (Model)loader.Load("", "MagicHat");

Model spellModel9 = (Model)loader.Load("", "MagicHat");

Model monsterModel0 = (Model)loader.Load("", "Slime");

Model monsterModel1 = (Model)loader.Load("", "Slime");

Model monsterModel2 = (Model)loader.Load("", "Slime");

Model monsterModel3 = (Model)loader.Load("", "Slime");

Model monsterModel4 = (Model)loader.Load("", "Slime");

Model monsterModel5 = (Model)loader.Load("", "Slime");

Model monsterModel6 = (Model)loader.Load("", "Slime");

Model monsterModel7 = (Model)loader.Load("", "Slime");

Model monsterModel8 = (Model)loader.Load("", "Slime");

Model monsterModel9 = (Model)loader.Load("", "Slime");

//Marker 100

cylinderMarkerNode100 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML100.xml", zero);

GeometryNode cylinderNode0 = new GeometryNode("Cylinder");

cylinderNode0.Model = monsterModel0;

((Model)cylinderNode0.Model).UseInternalMaterials = false;

cylinderNode0.Material = sphereMaterial;

TransformNode cylinderTransNode0 = new TransformNode();

cylinderTransNode0.Scale = new Vector3(5, 5, 5);

cylinderTransNode0.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode100.AddChild(cylinderTransNode0);

cylinderTransNode0.AddChild(cylinderNode0);

//add to Card array here: generic monster card here

cards[0] = new Card('M', cylinderMarkerNode100, 90, 125, "Tethys, Goddess of Light", "Attack");

//Marker 101

cylinderMarkerNode101 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML101.xml", first);

GeometryNode cylinderNode1 = new GeometryNode("Cylinder");

cylinderNode1.Model = monsterModel1;

((Model)cylinderNode1.Model).UseInternalMaterials = false;

cylinderNode1.Material = sphereMaterial2;

TransformNode cylinderTransNode1 = new TransformNode();

cylinderTransNode1.Scale = new Vector3(5, 5, 5);

cylinderTransNode1.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode101.AddChild(cylinderTransNode1);

cylinderTransNode1.AddChild(cylinderNode1);

//add to Card array here: generic monster card here

cards[1] = new Card('M', cylinderMarkerNode101, 120, 150, "Athena", "Attack");

//Marker 102

cylinderMarkerNode102 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML102.xml", two);

GeometryNode cylinderNode2 = new GeometryNode("Cylinder");

cylinderNode2.Model = monsterModel2;

((Model)cylinderNode2.Model).UseInternalMaterials = false;

cylinderNode2.Material = sphereMaterial3;

TransformNode cylinderTransNode2 = new TransformNode();

cylinderTransNode2.Scale = new Vector3(5, 5, 5);

cylinderTransNode2.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode102.AddChild(cylinderTransNode2);

cylinderTransNode2.AddChild(cylinderNode2);

//add to Card array here: generic monster card here

cards[2] = new Card('M', cylinderMarkerNode102, 105, 120, "Victoria", "Attack");

//Marker 103

cylinderMarkerNode103 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML103.xml", three);

GeometryNode cylinderNode3 = new GeometryNode("Cylinder");

cylinderNode3.Model = monsterModel3;

((Model)cylinderNode3.Model).UseInternalMaterials = false;

cylinderNode3.Material = sphereMaterial4;

TransformNode cylinderTransNode3 = new TransformNode();

cylinderTransNode3.Scale = new Vector3(5, 5, 5);

cylinderTransNode3.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode103.AddChild(cylinderTransNode3);

cylinderTransNode3.AddChild(cylinderNode3);

//add to Card array here: generic monster card here

cards[3] = new Card('M', cylinderMarkerNode103, 130, 160, "The Agent of Force - Mars", "Attack");

//Marker 104

cylinderMarkerNode104 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML104.xml", four);

GeometryNode cylinderNode4 = new GeometryNode("Cylinder");

cylinderNode4.Model = monsterModel4;

((Model)cylinderNode4.Model).UseInternalMaterials = false;

cylinderNode4.Material = sphereMaterial5;

TransformNode cylinderTransNode4 = new TransformNode();

cylinderTransNode4.Scale = new Vector3(5, 5, 5);

cylinderTransNode4.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode104.AddChild(cylinderTransNode4);

cylinderTransNode4.AddChild(cylinderNode4);

//add to Card array here: generic monster card here

cards[4] = new Card('M', cylinderMarkerNode104, 115, 155, "The Agent of Wisdom - Mercury", "Attack");

//Marker 105

cylinderMarkerNode105 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML105.xml", five);

GeometryNode cylinderNode5 = new GeometryNode("Cylinder");

cylinderNode5.Model = monsterModel5;

((Model)cylinderNode5.Model).UseInternalMaterials = false;

cylinderNode5.Material = sphereMaterial6;

TransformNode cylinderTransNode5 = new TransformNode();

cylinderTransNode5.Scale = new Vector3(5, 5, 5);

cylinderTransNode5.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode105.AddChild(cylinderTransNode5);

cylinderTransNode5.AddChild(cylinderNode5);

//add to Card array here: generic monster card here

cards[5] = new Card('M', cylinderMarkerNode105, 95, 145, "The Agent of Mystery - Earth", "Attack");

//Marker 106

cylinderMarkerNode106 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML106.xml", six);

GeometryNode cylinderNode6 = new GeometryNode("Cylinder");

cylinderNode6.Model = monsterModel6;

((Model)cylinderNode6.Model).UseInternalMaterials = false;

cylinderNode6.Material = sphereMaterial7;

TransformNode cylinderTransNode6 = new TransformNode();

cylinderTransNode6.Scale = new Vector3(5, 5, 5);

cylinderTransNode6.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode106.AddChild(cylinderTransNode6);

cylinderTransNode6.AddChild(cylinderNode6);

//add to Card array here: generic monster card here

cards[6] = new Card('M', cylinderMarkerNode106, 130, 175, "The Agent of Miracles - Jupiter", "Attack");

//Marker 107

cylinderMarkerNode107 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML107.xml", seven);

GeometryNode cylinderNode7 = new GeometryNode("Cylinder");

cylinderNode7.Model = monsterModel7;

((Model)cylinderNode7.Model).UseInternalMaterials = false;

cylinderNode7.Material = sphereMaterial8;

TransformNode cylinderTransNode7 = new TransformNode();

cylinderTransNode7.Scale = new Vector3(5, 5, 5);

cylinderTransNode7.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode107.AddChild(cylinderTransNode7);

cylinderTransNode7.AddChild(cylinderNode7);

//add to Card array here: generic monster card here

cards[7] = new Card('M', cylinderMarkerNode107, 80, 120, "The Agent of Judgment - Saturn", "Attack");

//Marker 108

cylinderMarkerNode108 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML108.xml", eight);

GeometryNode cylinderNode8 = new GeometryNode("Cylinder");

cylinderNode8.Model = monsterModel8;

((Model)cylinderNode8.Model).UseInternalMaterials = false;

cylinderNode8.Material = sphereMaterial9;

TransformNode cylinderTransNode8 = new TransformNode();

cylinderTransNode8.Scale = new Vector3(5, 5, 5);

cylinderTransNode8.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode108.AddChild(cylinderTransNode8);

cylinderTransNode8.AddChild(cylinderNode8);

//add to Card array here: generic monster card here

cards[8] = new Card('M', cylinderMarkerNode108, 75, 140, "The Agent of Creation - Venus", "Attack");

//Marker 109

cylinderMarkerNode109 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML109.xml", nine);

GeometryNode cylinderNode9 = new GeometryNode("Cylinder");

cylinderNode9.Model = monsterModel9;

((Model)cylinderNode9.Model).UseInternalMaterials = false;

cylinderNode9.Material = sphereMaterial10;

TransformNode cylinderTransNode9 = new TransformNode();

cylinderTransNode9.Scale = new Vector3(5, 5, 5);

cylinderTransNode9.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode109.AddChild(cylinderTransNode9);

cylinderTransNode9.AddChild(cylinderNode9);

//add to Card array here: generic monster card here

cards[9] = new Card('M', cylinderMarkerNode109, 150, 200, "Master Hyperion", "Attack");

//Marker 110

cylinderMarkerNode110 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML110.xml", ten);

GeometryNode cylinderNode10 = new GeometryNode("Cylinder");

cylinderNode10.Model = spellModel0;

((Model)cylinderNode10.Model).UseInternalMaterials = false;

cylinderNode10.Material = sphereMaterial;

TransformNode cylinderTransNode10 = new TransformNode();

cylinderTransNode10.Scale = new Vector3(5, 5, 5);

cylinderTransNode10.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode110.AddChild(cylinderTransNode10);

cylinderTransNode10.AddChild(cylinderNode10);

//add to Card array here: generic spell card here

cards[10] = new Card('S', cylinderMarkerNode110, 100, 100, "Cards from the Sky", "All of your monsters are healed for 100 hp.");

//Marker 111

cylinderMarkerNode111 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML111.xml", eleven);

GeometryNode cylinderNode11 = new GeometryNode("Cylinder");

cylinderNode11.Model = spellModel1;

((Model)cylinderNode11.Model).UseInternalMaterials = false;

cylinderNode11.Material = sphereMaterial2;

TransformNode cylinderTransNode11 = new TransformNode();

cylinderTransNode11.Scale = new Vector3(5, 5, 5);

cylinderTransNode11.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode111.AddChild(cylinderTransNode11);

cylinderTransNode11.AddChild(cylinderNode11);

//add to Card array here: generic spell card here

cards[11] = new Card('S', cylinderMarkerNode111, 100, 100, "Valhalla, Hall of the Fallen", "All of your monsters are completly healed.");

//Marker 112

cylinderMarkerNode112 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML112.xml", twelve);

GeometryNode cylinderNode12 = new GeometryNode("Cylinder");

cylinderNode12.Model = spellModel2;

((Model)cylinderNode12.Model).UseInternalMaterials = false;

cylinderNode12.Material = sphereMaterial3;

TransformNode cylinderTransNode12 = new TransformNode();

cylinderTransNode12.Scale = new Vector3(5, 5, 5);

cylinderTransNode12.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode112.AddChild(cylinderTransNode12);

cylinderTransNode12.AddChild(cylinderNode12);

//add to Card array here: generic spell card here

cards[12] = new Card('S', cylinderMarkerNode112, 100, 100, "Terraforming", "All of your monsters are healed for 1 hp.");

//Marker 113

cylinderMarkerNode113 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML113.xml", thirteen);

GeometryNode cylinderNode13 = new GeometryNode("Cylinder");

cylinderNode13.Model = spellModel3;

((Model)cylinderNode13.Model).UseInternalMaterials = false;

cylinderNode13.Material = sphereMaterial4;

TransformNode cylinderTransNode13 = new TransformNode();

cylinderTransNode13.Scale = new Vector3(5, 5, 5);

cylinderTransNode13.Rotation = Quaternion.CreateFromYawPitchRoll(0, 1.5f, 0);

cylinderMarkerNode113.AddChild(cylinderTransNode13);

cylinderTransNode13.AddChild(cylinderNode13);

//add to Card array here: generic spell card here

cards[13] = new Card('S', cylinderMarkerNode113, 100, 100, "Smashing Ground", "All of your monsters are healed for 20 hp.");

//Marker 114

cylinderMarkerNode114 = new MarkerNode(scene.MarkerTracker, "ALVARConfigFromXML114.xml", fourteen);

GeometryNode cylinderNode14 = new GeometryNode("Cylinder");

cylinderNode14.Model = spellModel4;

((Model)cylinderNode14.Model).UseInternalMaterials = false;

cylinderNode14.Material = sphereMaterial5;

TransformNode cylinderTransNode14 = new TransformNode();