//Constructor------------------------------------------------------------------------
/// <summary>
/// Construct a pack with an Object3D leader
/// </summary>
/// <param name="theStage"> the scene </param>
/// <param name="label"> name of pack </param>
/// <param name="meshFile"> model of a pack instance</param>
/// <param name="xPos, zPos"> approximate position of the pack </param>
/// <param name="aLeader"> alpha dog can be used for flock center and alignment </param>
public Pack(Stage theStage, string label, string meshFile, int nDogs, int xPos, int zPos, Object3D theLeader, bool isCollidable = true)
: base(theStage, label, meshFile)
{
this.isCollidable = isCollidable;
this.random = new Random();
this.leader = theLeader;
//Local Variables
UInt32 spacing = (UInt32)stage.Spacing;
Int32 x, z;
float scale;
//Initial vertex offset of dogs around (xPos, zPos)
Int32[,] position = { { 0, 0 }, { 7, -4 }, { -5, -2 }, { -7, 4 }, { 5, 2 } };
for (int i = 0; i < position.GetLength(0); i++)
{
//Position the dogs
x = xPos + position[i, 0];
z = zPos + position[i, 1];
//Scale the dogs
scale = (float)(0.5 + random.NextDouble());
//Add the pack member to the instance list
addObject(new Vector3(x * spacing, stage.surfaceHeight(x, z), z * spacing),
new Vector3(0, 1, 0),
0.0f,
new Vector3(scale, scale, scale));
}
}
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
using (Stage stage = new Stage())
{
stage.Run();
}
}
//Variables---------------------------------------------------------------------------------------------
//Void
//Constructor-------------------------------------------------------------------------------------------
public Wall(Stage theStage, string label, string meshFile, bool isCollidable = true)
: base(theStage, label, meshFile, isCollidable)
{
//Local Variables
UInt32 spacing = (UInt32)stage.Terrain.Spacing;
Terrain terrain = stage.Terrain;
// brick[x,z] vertex positions on terrain
UInt32[,] brick = { // "just another brick in the wall", Pink Floyd
{450, 450}, {451, 450}, {452, 450}, {453, 450}, {454, 450}, {455, 450}, {456, 450}, // 7 right
{457, 443}, {457, 444}, {457, 445}, {457, 446}, {457, 447}, {457, 448}, {457, 449}, {457, 450}, {457, 451},
{457, 452}, {457, 453}, {457, 454}, {457, 455}, {457, 456}, {457, 457}, {457, 458}, {457, 459}, {457, 460}, // 18 down
{451, 460}, {451, 459}, {451, 458}, {451, 457}, // 4 up
{451, 456}, {450, 456}, {449, 456}, {448, 456}, {447, 456}, {446, 456}, {445, 456}, {444, 456}, // 8 left
{444, 455}, {444, 454}, {444, 453}, {444, 452}, {444, 451}, {444, 450}, {444, 449}, {444, 448}, {444, 447},
{444, 446}, {444, 445}, {444, 444}, // 12 up
{444, 444}, {445, 444}, {446, 444}, {447, 444}, {448, 444}, {449, 444}, {450, 444}, {451, 444}, // 8 right
{451, 444}, {451, 443} // 2 up
};
//Add the bricks to the stage
for (UInt32 i = 0; i < brick.GetLength(0); i++)
{
UInt32 xPos = brick[i, 0];
UInt32 zPos = brick[i, 1];
addObject(new Vector3(xPos * spacing, terrain.surfaceHeight((int)xPos, (int)zPos), zPos * spacing), Vector3.Up, 0.0f, Vector3.One);
}
}
public Camera(Stage aScene, CameraEnum cameraType)
{
name = "Whole stage";
scene = aScene;
cameraCase = cameraType;
terrainCenter = scene.TerrainSize / 2;
updateViewMatrix();
}
/// <summary>
/// Create a path
/// </summary>
/// <param name="theStage"> "world's stage" </param>
/// <param name="apath"> collection of nodes in path</param>
/// <param name="aPathType"> SINGLE, REVERSE, or LOOP path traversal</param>
public Path(Stage theStage, List<NavNode> aPath, PathType aPathType)
: base(theStage)
{
node = aPath;
nextNode = 0;
pathType = aPathType;
stage = theStage;
done = false;
}
//Variables---------------------------------------------------------------------------------------------
//Void
//Constructor-------------------------------------------------------------------------------------------
public EyeCandy_Rocket(Stage theStage, string label, string meshFile, bool isCollidable = true)
: base(theStage, label, meshFile, isCollidable)
{
//Local Variables
UInt32 spacing = (UInt32)stage.Terrain.Spacing;
Terrain terrain = stage.Terrain;
UInt32[,] location = { { 450, 325 } };
//Add the bricks to the stage
for (UInt32 i = 0; i < location.GetLength(0); i++)
{
UInt32 xPos = location[i, 0];
UInt32 zPos = location[i, 1];
addObject(new Vector3(xPos * spacing, terrain.surfaceHeight((int)xPos, (int)zPos), zPos * spacing), Vector3.Up, (float)Math.PI, new Vector3(30, 30, 30));
}
}
// Constructor
public Cloud(Stage stage, string label, string meshFile, int nClouds)
: base(stage, label, meshFile)
{
random = new Random();
//Add nClouds random cloud instances
for (UInt32 i = 0; i < nClouds; i++)
{
UInt32 x = (UInt32)((128 + random.Next(256)) * stage.Spacing);
UInt32 z = (UInt32)((128 + random.Next(256)) * stage.Spacing);
addObject(
new Vector3(x, stage.surfaceHeight(x, z) + 15000, z),
new Vector3(0, 1, 0), 4.0f,
new Vector3(15, 4, 15));
}
}
//Constructor------------------------------------------------------------------------
public Player(Stage theStage, string label, Vector3 pos, Vector3 orientAxis, float radians, string meshFile, TreasureList tl, bool isCollidable = true)
: base(theStage, label, pos, orientAxis, radians, meshFile)
{
//Camera Name ID's
first.Name = "First";
follow.Name = "Follow";
above.Name = "Above";
//Set if this object is collidable
this.IsCollidable = isCollidable;
if(this.isCollidable)
stage.Collidable.Add(agentObject);
this.treasreList = tl;
this.treasureCount = 0;
//Set initial orientation of player
this.rotate = 0;
this.angle = 0.01f;
initialOrientation = agentObject.Orientation;
}
public TreasureList(Stage theStage, string label, string meshFile, bool isCollidable = false)
: base(theStage, label, meshFile)
{
this.isCollidable = isCollidable;
//The following represents a list of treausre locations..
int[,] treasure = {
{393,400},
{509,493},
{320,460},
{447,453},
{320,493}
};
this.treasuresRemaining = treasure.Length;
//Create a list of treasures
this.treasureNode = new TreasureNode[treasure.GetLength(0)];
int x, z;
for (int i = 0; i < treasure.GetLength(0); i++)
{
//Positions
x = treasure[i, 0];
z = treasure[i, 1];
//Keep a list of these locations
this.treasureNode[i].x = x;
this.treasureNode[i].z = z;
this.treasureNode[i].isTagged = false;
//Add the treasure
addObject(new Vector3(x * stage.Spacing, stage.Terrain.surfaceHeight(x, z), z * stage.Spacing),
new Vector3(0, 1, 0),
0.0f,
new Vector3(1, 1, 1));
}
}
/// <summary>
/// Create a path from XZ nodes defined in a pathFile.
/// The file must be accessible from the executable environment.
/// </summary>
/// <param name="theStage"> "world's stage" </param>
/// <param name="aPathType"> SINGLE, REVERSE, or LOOP path traversal</param>
/// <param name="pathFile"> text file, each line a node of X Z values, separated by a single space </x></param>
public Path(Stage theStage, PathType aPathType, string pathFile)
: base(theStage)
{
node = new List<NavNode>();
stage = theStage;
nextNode = 0;
pathType = aPathType;
done = false;
// read file for WayPoint vertex (x,z) positions
int spacing = stage.Spacing;
int x, z;
string line;
string[] tokens;
using (System.IO.StreamReader fileIn = System.IO.File.OpenText(pathFile))
{
line = fileIn.ReadLine();
do
{
tokens = line.Split(new char[] { }); // use default separators
x = Int32.Parse(tokens[0]);
z = Int32.Parse(tokens[1]);
node.Add(new NavNode(new Vector3(x * spacing, stage.Terrain.surfaceHeight(x, z), z * spacing),
NavNode.NavNodeEnum.PATH));
line = fileIn.ReadLine();
} while (line != null);
}
}
//Constructors-----------------------------------------------------------------------------------
public Model3D(Stage stage, string name, string fileOfModel, bool isCollidable = false)
: base(stage)
{
this.name = name;
this.stage = stage;
this.isCollidable = isCollidable;
instance = new List<Object3D>();
model = stage.Content.Load<Model>(fileOfModel);
// compute the translation to the model's bounding sphere
// center and radius;
float minX, minY, minZ, maxX, maxY, maxZ;
minX = minY = minZ = Int32.MaxValue;
maxX = maxY = maxZ = Int32.MinValue;
for (int i = 0; i < model.Meshes.Count; i++)
{
// See if this mesh extends the bounding sphere.
BoundingSphere aBoundingSphere = model.Meshes[i].BoundingSphere;
boundingSphereRadius = aBoundingSphere.Radius;
// minimum value
if ((aBoundingSphere.Center.X - aBoundingSphere.Radius) < minX)
minX = aBoundingSphere.Center.X - aBoundingSphere.Radius;
if ((aBoundingSphere.Center.Y - aBoundingSphere.Radius) < minY)
minY = aBoundingSphere.Center.Y - aBoundingSphere.Radius;
if ((aBoundingSphere.Center.Z - aBoundingSphere.Radius) < minZ)
minZ = aBoundingSphere.Center.Z - aBoundingSphere.Radius;
// maximum value
if ((aBoundingSphere.Center.X + aBoundingSphere.Radius) > maxX)
maxX = aBoundingSphere.Center.X + aBoundingSphere.Radius;
if ((aBoundingSphere.Center.Y + aBoundingSphere.Radius) > maxY)
maxY = aBoundingSphere.Center.Y + aBoundingSphere.Radius;
if ((aBoundingSphere.Center.Z + aBoundingSphere.Radius) > maxZ)
maxZ = aBoundingSphere.Center.Z + aBoundingSphere.Radius;
}
// get the diameter of model's bounding sphere
// radius temporarily holds the largest diameter
if ((maxX - minX) > boundingSphereRadius) boundingSphereRadius = maxX - minX;
// Since a bounding cylinder is used for collision height values not needed
// if ((maxY - minY) > boundingSphereRadius) boundingSphereRadius = maxY - minY;
if ((maxZ - minZ) > boundingSphereRadius) boundingSphereRadius = maxZ - minZ;
// set boundingSphereRadius
boundingSphereRadius = boundingSphereRadius * 1.05f / 2.0f; // set the radius from largest diameter
// set the center of model's bounding sphere
boundingSphereCenter = new Vector3(minX + boundingSphereRadius, minY + boundingSphereRadius, minZ + boundingSphereRadius);
}
//Constructor----------------------------------------------------------------------
/// <summary>
/// Constructor is a "pass-through" for arguments to Model3D's constructor
/// </summary>
/// <param name="theStage"></param>
/// <param name="label"></param>
/// <param name="meshFile"></param>
public MovableModel3D(Stage theStage, string label, string meshFile)
: base(theStage, label, meshFile)
{
}
public IndexVertexBuffers(Stage theStage, string label)
: base(theStage)
{
stage = theStage;
name = label;
}
private Int16 step, stepSize; // values for stepping
#endregion Fields
#region Constructors
//Constructors --------------------------------------------------------------------------
/// <summary>
/// Object that places and orients itself.
/// </summary>
/// <param name="theStage"> the stage containing object </param>
/// <param name="aModel"> how the object looks </param>
/// <param name="label"> name of object </param>
/// <param name="position"> position in stage </param>
/// <param name="orientAxis"> axis to orient on </param>
/// <param name="radians"> orientation rotation </param>
public Object3D(Stage stage, Model3D model, string name, Vector3 position,
Vector3 orientAxis, float radiansRot, Vector3 scale,
Int16 step = 1, Int16 stepSize = 10, float boundingRadius = 0.0f)
{
this.scales = scale;
this.stage = stage;
this.model = model;
this.name = name;
this.step = step;
this.stepSize = stepSize;
this.objectBoundingSphereRadius = boundingRadius;
//Initialize rotating factors
pitch = yaw = roll = 0.0f;
//Configure resulting orientation
orientation = Matrix.Identity;
orientation *= Matrix.CreateScale(scales);
orientation *= Matrix.CreateFromAxisAngle(orientAxis, radiansRot);
orientation *= Matrix.CreateTranslation(position);
scaleObjectBoundingSphere();
}
public PathFindingNode(Stage theStage, Int32 x, Int32 z)
{
this.nodeColor = Color.Red.ToVector3();
this.x = x;
this.z = z;
this.y = (Int32)theStage.surfaceHeight((float)x, (float)z);
this.id = string.Format("{0}::{1}", x, z);
adjacent = new LinkedList<PathFindingNode>();
}
//Constructor------------------------------------------------------------------------------------
/// <summary>
/// Make a Terrain from 2 png texture files.
/// Must have __XNA4__ capabilities to read from png files.
/// </summary>
/// <param name="theStage"></param>
/// <param name="label"></param>
/// <param name="heightFile"></param>
/// <param name="colorFile"></param>
public Terrain(Stage theStage, string label, string heightFile, string colorFile)
: base(theStage, label)
{
//Local Variables
UInt32 i = 0;
UInt32 vertexHeight;
Vector4 vector4;
Texture2D heightTexture;
Texture2D colorTexture;
Microsoft.Xna.Framework.Color[] heightMap;
Microsoft.Xna.Framework.Color[] colorMap;
//Initialization of most base class variables (IndexVertexBuffers)
constructorInit();
//Load in height map file and load up height texture
heightTexture = stage.Content.Load<Texture2D>(heightFile);
heightMap = new Microsoft.Xna.Framework.Color[width * height];
heightTexture.GetData<Microsoft.Xna.Framework.Color>(heightMap);
//Load in color map file and load up color texture
colorTexture = stage.Content.Load<Texture2D>(colorFile);
colorMap = new Microsoft.Xna.Framework.Color[width * height];
colorTexture.GetData<Microsoft.Xna.Framework.Color>(colorMap);
//Create vertices for the plain
for (UInt32 z = 0; z < height; z++)
{
for (UInt32 x = 0; x < width; x++)
{
//Convert the images RBGA values into a vec4
vector4 = heightMap[i].ToVector4();
//Scale these value into a height value (Remember, R = G = B = A)
vertexHeight = (UInt32)(vector4.X * 255);
//To make things a bit more interesting, mulitply the height by a const value
vertexHeight *= multiplier;
//Save this height for navigation
terrainHeight[x, z] = vertexHeight;
//Back up the color of the vertex with its coordinance
vertex[i] = new VertexPositionColor(new Vector3(x * spacing, vertexHeight, z * spacing),
new Color(colorMap[i].ToVector4()));
i++;
}
}
//Free up the now uneeded maps
colorMap = null;
heightMap = null;
//Fill in our indices, which make up our triangulated mesh pieces
makeIndicesSetData();
}
public Camera(Stage aScene, Object3D anAgentObject, CameraEnum cameraType)
{
scene = aScene;
agent = anAgentObject;
cameraCase = cameraType;
}
/// <summary>
/// Create a path from array
/// </summary>
/// <param name="theStage"> "world's stage" </param>
/// <param name="apath"> collection of nodes in path</param>
/// <param name="pathNode"> int[x,z] array of WayPoint positions for path</param>
/// <param name="aPathType"> SINGLE, REVERSE, or LOOP path traversal</param>
public Path(Stage theStage, int[,] pathNode, PathType aPathType)
: base(theStage)
{
nextNode = 0;
pathType = aPathType;
stage = theStage;
done = false;
int spacing = stage.Spacing;
int x, z;
// make a simple path, show how to set the type of the NavNode outside of construction.
node = new List<NavNode>();
for (int i = 0; i < pathNode.Length / 2; i++)
{
x = pathNode[i, 0];
z = pathNode[i, 1];
node.Add(new NavNode(new Vector3(x * spacing, stage.Terrain.surfaceHeight(x, z), z * spacing),
NavNode.NavNodeEnum.WAYPOINT));
}
}
public jwfPath(Stage theStage, Int32 startX, Int32 startZ, Int32 dist)
: base(theStage)
{
this.stage = theStage;
setUpNavigationGraph(startX, startZ, dist);
}
public Wall(Stage theStage, string label, string meshFile, int xOffset, int zOffset)
: base(theStage, label, meshFile)
{
initWall(xOffset, zOffset);
}
//Constructor------------------------------------------------------------------------------------
/// <summary>
/// Create a NPC.
/// AGXNASK distribution has npAgent move following a Path.
/// </summary>
/// <param name="theStage"> the world</param>
/// <param name="label"> name of </param>
/// <param name="pos"> initial position </param>
/// <param name="orientAxis"> initial rotation axis</param>
/// <param name="radians"> initial rotation</param>
/// <param name="meshFile"> Direct X *.x Model in Contents directory </param>
public NPAgent(Stage theStage, string label, Vector3 pos, Vector3 orientAxis, float radians, string meshFile, TreasureList tl, bool isCollidable = false)
: base(theStage, label, pos, orientAxis, radians, meshFile)
{
//Set variables
this.isCollidable = isCollidable;
this.treasureList = tl;
this.treasureCount = 0;
this.treasurePath = false;
//Change names for on-screen display of current camera
first.Name = "npFirst";
follow.Name = "npFollow";
above.Name = "npAbove";
// path is built to work on specific terrain, made from int[x,z] array pathNode
path = new Path(stage, pathNode, Path.PathType.LOOP); // continuous search path
stage.Components.Add(path);
//Get the first path goal
nextGoal = path.NextNode;
//Orient to face the first goal
agentObject.turnToFace(nextGoal.Translation);
//Set snapDistance to be a little larger than step * stepSize
snapDistance = (UInt32)(1.5 * (agentObject.Step * agentObject.StepSize));
}
public Wall(Stage theStage, string label, string meshFile)
: base(theStage, label, meshFile)
{
initWall(400, 400); // origin of wall on terrain
}
