Isometric 3d Game part 5

Handling tiles according to the results from AI.

When considering the XNA game studio architecture, there are two methods called Run() and Update(). Run method is used to initialize the game and start processing events of the game. Game.Update method is where we used to determining the game logic.  This method will be called by the XNA engine itself with a high rate to make sure that there will not be a lagging. 

Following is my game class which is the controlling class of the game.

	using System;
	using System.Collections;
	using System.Linq;
	using Microsoft.Xna.Framework;
	using Microsoft.Xna.Framework.Audio;
	using Microsoft.Xna.Framework.Content;
	using Microsoft.Xna.Framework.GamerServices;
	using Microsoft.Xna.Framework.Graphics;
	using Microsoft.Xna.Framework.Input;
	using Microsoft.Xna.Framework.Media;
	using Microsoft.Xna.Framework.Net;
	using Microsoft.Xna.Framework.Storage;
	using System.Threading;
	using System.ComponentModel;
	using System.Data;
	using System.Text;
	namespace TileMap
	{
	///
	/// This is the main type for your game
	///
	public class Game1 : Microsoft.Xna.Framework.Game
	{
	GraphicsDeviceManager graphics;
	SpriteBatch spriteBatch;
	Communicator comm = new Communicator();
	String line;
	Map Map;
	bool tankinit=true;
	Stack path = new Stack();
	bool domove =false;
	bool gotFirst = false;
	GridSquare tmp=null;
	SoundEffect jumping, turning, coinGrab, lifepackGrab;
	float maingametime;
	float previousshoot=0;
	float previousmove = 0;
	Coins[] coins=new Coins[160];
	lifepack[] lifepacks=new lifepack[85];
	Bullet[] bullets = new Bullet[100];
	Tank mytank = new Tank();
	int activecoinscount=0;
	int activelifepackscount=0;
	int activebulletscount=0;
	char[] firstdelimeters = { ':', '#' };
	char[] seconddelimeters = {',',';'};
	char[] alldelimeters = {':',',',';','#'};
	char[] coindelimeters = {':',',','#'};
	char[] lifepackdelimeter = {':',',','#'};
	char[] singlesemicolon = { ';' };
	char[] singlecomma = { ',' };
	String[] mainparts;
	String[] bricks;
	String[] stones;
	String[] water;
	String[] coin;
	String[] lifepack;
	String[] tdata;
	int mainlength;
	int[] bricksvals;
	int[] stonesvals;
	int[] watervals;
	int myoffset=6;
	int enemyoffset = 10;
	Tank[] Tanks=new Tank[5];
	int tankscount;
	public Game1()
	{
	graphics = new GraphicsDeviceManager(this);
	Content.RootDirectory = "Content";
	}
	///
	/// 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.
	///
	protected override void Initialize()
	{
	// TODO: Add your initialization logic here
	comm.SendData("JOIN#");
	Thread thread = new Thread(new ThreadStart(WorkThreadFunction));
	thread.Start();
	base.Initialize();
	}
	///
	/// LoadContent will be called once per game and is the place to load
	/// all of your content.
	///
	protected override void LoadContent()
	{
	// Create a new SpriteBatch, which can be used to draw textures.
	jumping = Content.Load("audio/jumping");
	turning = Content.Load("audio/turning");
	coinGrab = Content.Load("audio/coinGrab");
	lifepackGrab = Content.Load("audio/lifepackGrab");
	spriteBatch = new SpriteBatch(GraphicsDevice);
	Map = new Map(Content, Constants.MAP_SIZE, Constants.MAP_SIZE);
	// TODO: use this.Content to load your game content here
	}
	///
	/// UnloadContent will be called once per game and is the place to unload
	/// all content.
	///
	protected override void UnloadContent()
	{
	// TODO: Unload any non ContentManager content here
	}
	///
	/// Allows the game to run logic such as updating the world,
	/// checking for collisions, gathering input, and playing audio.
	///
	/// Provides a snapshot of timing values.
	protected override void Update(GameTime gameTime)
	{
	// Allows the game to exit
	if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
	this.Exit();
	Map.Update();
	maingametime += (float)gameTime.ElapsedGameTime.TotalMilliseconds;
	for (int i = 0; i < activecoinscount; i++)
	{
	if (maingametime > coins[i].lt + coins[i].inittime)
	{
	Map.Blocks[coins[i].y, coins[i].x].Tile = 0;
	RemoveCoin(i);
	}
	}
	for (int k = 0; k < activelifepackscount; k++)
	{
	if (maingametime > lifepacks[k].lt + lifepacks[k].inittime)
	{
	Map.Blocks[lifepacks[k].y, lifepacks[k].x].Tile = 0;
	RemoveLifepack(k);
	}
	}
	if (maingametime > previousshoot + 250)
	{
	for (int i = 0; i < activebulletscount; i++)
	{
	if ((bullets[i].dir == 0) && (bullets[i].X>0)&&(Map.Blocks[bullets[i].Y, bullets[i].X - 1].Tile == 0))
	{
	Map.Blocks[bullets[i].Y, bullets[i].X].Tile = 0;
	bullets[i].X--;
	Map.Blocks[bullets[i].Y, bullets[i].X].Tile = 14;
	}
	else if ((bullets[i].dir == 1) && (bullets[i].Y < Map.Depth-1) && (Map.Blocks[bullets[i].Y + 1, bullets[i].X].Tile == 0))
	{
	Map.Blocks[bullets[i].Y, bullets[i].X].Tile = 0;
	bullets[i].Y++;
	Map.Blocks[bullets[i].Y, bullets[i].X].Tile = 14;
	}
	else if ((bullets[i].dir == 2) && (bullets[i].X < Map.Width-1) && (Map.Blocks[bullets[i].Y, bullets[i].X + 1].Tile == 0))
	{
	Map.Blocks[bullets[i].Y, bullets[i].X].Tile = 0;
	bullets[i].X++;
	Map.Blocks[bullets[i].Y, bullets[i].X].Tile = 14;
	}
	else if ((bullets[i].dir == 3) && (bullets[i].Y > 0) && (Map.Blocks[bullets[i].Y - 1, bullets[i].X].Tile == 0))
	{
	Map.Blocks[bullets[i].Y, bullets[i].X].Tile = 0;
	bullets[i].Y--;
	Map.Blocks[bullets[i].Y, bullets[i].X].Tile = 14;
	}
	else
	{
	Map.Blocks[bullets[i].Y, bullets[i].X].Tile = 0;
	for (int j = i; j < activebulletscount - 1; j++)
	{
	bullets[j] = bullets[j + 1];
	}
	activebulletscount--;
	}
	}
	previousshoot = maingametime;
	}
	//-------------------------------------------------------------------------------------------------routing starts----------------------------------------------------------------------------------------------
	if (gotFirst)
	{
	gotFirst = false;
	if(domove)
	{
	domove = false;
	if (tmp.dir == mytank.dir - myoffset)
	{
	Map.Blocks[mytank.Y, mytank.X].Tile = 0;
	mytank.X = tmp.x;
	mytank.Y = tmp.y;
	Map.Blocks[mytank.Y, mytank.X].Tile = (byte)mytank.dir;
	jumping.Play();
	}
	else
	{
	mytank.dir = tmp.dir + myoffset;
	Map.Blocks[mytank.Y, mytank.X].Tile = (byte)mytank.dir;
	turning.Play();
	}
	}
	previousmove = maingametime;
	Stack optimal =new Stack();
	optimal.Push("s");
	optimal.Pop();
	int precost = 100, nowcost=0;
	for (int n = 0; n < activecoinscount; n++)
	{
	AI ai = new AI();
	path = ai.generatePath(Map, mytank.X, mytank.Y, coins[n].x, coins[n].y);
	path.Pop();
	if (path.Count != 0)
	{
	nowcost = cost(path);
	if (nowcost < precost)
	{
	optimal.Clear();
	precost = nowcost;
	optimal = copy(path);
	}
	}
	else
	{
	coinGrab.Play();
	RemoveCoin(n);
	}
	}
	for (int n = 0; n < activelifepackscount; n++)
	{
	AI ai = new AI();
	path = ai.generatePath(Map, mytank.X, mytank.Y, lifepacks[n].x, lifepacks[n].y);
	path.Pop();
	if (path.Count != 0)
	{
	nowcost = cost(path);
	if (nowcost < precost)
	{
	optimal.Clear();
	precost = nowcost;
	optimal = copy(path);
	}
	}
	else
	{
	lifepackGrab.Play();
	RemoveLifepack(n);
	}
	}
	if (optimal.Count != 0)
	{
	domove = true;
	tmp = (GridSquare)optimal.Pop();
	if (tmp.dir == mytank.dir - myoffset)
	{
	if(tmp.x>mytank.X){
	comm.SendData("RIGHT#");
	}
	else if(tmp.x comm.SendData("LEFT#");
	}
	else if(tmp.y>mytank.Y){
	comm.SendData("DOWN#");
	}
	else if (tmp.y < mytank.Y)
	{
	comm.SendData("UP#");
	}
	}
	else
	{
	if (tmp.dir == 0)
	{
	comm.SendData("UP#");
	}
	else if (tmp.dir == 1)
	{
	comm.SendData("RIGHT#");
	}
	else if (tmp.dir == 2)
	{
	comm.SendData("DOWN#");
	}
	else if (tmp.dir == 3)
	{
	comm.SendData("LEFT#");
	}
	}
	}
	}
	//-------------------------------------------------------------------------------------------------routing ends----------------------------------------------------------------------------------------------
	Map.Blocks[0, 0].Tile = 15;
	// TODO: Add your update logic here
	base.Update(gameTime);
	}
	///
	/// This is called when the game should draw itself.
	///
	/// Provides a snapshot of timing values.
	protected override void Draw(GameTime gameTime)
	{
	GraphicsDevice.Clear(Color.Black);
	// TODO: Add your drawing code here
	spriteBatch.Begin();
	Map.Draw(spriteBatch);
	base.Draw(gameTime);
	spriteBatch.End();
	}
	public void WorkThreadFunction()
	{
	try
	{
	comm.Prepare();
	while (true)
	{
	line = comm.Read();
	Console.Out.Write(line);
	Console.Out.Write("\r\n");
	if (line.StartsWith("I"))
	{
	Mapinit(line);
	}
	if (line.StartsWith("C"))
	{
	CoinAssign(line);
	}
	if (line.StartsWith("L"))
	{
	LifepackAssign(line);
	}
	if (line.StartsWith("S"))
	{
	MyTank(line);
	}
	if (line.StartsWith("G"))
	{
	gotFirst = true;
	SetTanks(line);
	}
	}
	}
	catch (Exception ex)
	{
	// log errors
	}
	}
	public void Mapinit(String line)
	{
	mainparts = line.Split(firstdelimeters);
	mainlength = mainparts.Length;
	water = mainparts[mainlength - 2].Split(seconddelimeters);
	stones = mainparts[mainlength - 3].Split(seconddelimeters);
	bricks = mainparts[mainlength - 4].Split(seconddelimeters);
	watervals = water.Select(x => int.Parse(x)).ToArray();
	bricksvals = bricks.Select(x => int.Parse(x)).ToArray();
	stonesvals = stones.Select(x => int.Parse(x)).ToArray();
	for (int i = 0; i < watervals.Length; i++)
	{
	Map.Blocks[watervals[i + 1], watervals[i]].Tile = 3;
	i++;
	}
	for (int i = 0; i < bricksvals.Length; i++)
	{
	Map.Blocks[bricksvals[i + 1], bricksvals[i]].Tile = 1;
	i++;
	}
	for (int i = 0; i < stonesvals.Length; i++)
	{
	Map.Blocks[stonesvals[i + 1], stonesvals[i]].Tile = 2;
	i++;
	}
	}
	public void CoinAssign(String line)
	{
	coin = line.Split(coindelimeters);
	coins[activecoinscount] = new Coins();
	coins[activecoinscount].x = int.Parse(coin[1]);
	coins[activecoinscount].y = int.Parse(coin[2]);
	Map.Blocks[coins[activecoinscount].y, coins[activecoinscount].x].Tile = 4;
	coins[activecoinscount].lt = float.Parse(coin[3]);
	coins[activecoinscount].val=int.Parse(coin[4]);
	coins[activecoinscount].inittime = maingametime;
	activecoinscount++;
	}
	public void LifepackAssign(String line)
	{
	lifepack = line.Split(lifepackdelimeter);
	lifepacks[activelifepackscount] = new lifepack();
	lifepacks[activelifepackscount].x = int.Parse(lifepack[1]);
	lifepacks[activelifepackscount].y = int.Parse(lifepack[2]);
	Map.Blocks[lifepacks[activelifepackscount].y, lifepacks[activelifepackscount].x].Tile = 5;
	lifepacks[activelifepackscount].lt = float.Parse(lifepack[3]);
	lifepacks[activelifepackscount].inittime = maingametime;
	activelifepackscount++;
	}
	public void MyTank(String line)
	{
	mainparts = line.Split(alldelimeters);
	mainlength = mainparts.Length;
	mytank.X = int.Parse(mainparts[2]);
	mytank.Y = int.Parse(mainparts[3]);
	mytank.dir = int.Parse(mainparts[4]);
	mytank.dir += myoffset;
	Map.Blocks[mytank.Y, mytank.X].Tile = (byte)mytank.dir;
	}
	public void SetTanks(String line)
	{
	mainparts = line.Split(firstdelimeters);
	tankscount = mainparts.Length-3;
	if (tankinit)
	{
	tankinit = false;
	for (int i = 1; i < tankscount; i++)
	{
	Tanks[i] = new Tank();
	tdata = mainparts[i + 1].Split(singlesemicolon);
	Tanks[i].X = int.Parse(tdata[1].Split(singlecomma)[0]);
	Tanks[i].Y = int.Parse(tdata[1].Split(singlecomma)[1]);
	Tanks[i].dir = int.Parse(tdata[2]);
	Tanks[i].shot = int.Parse(tdata[3]);
	if (Tanks[i].shot == 1)
	{
	if (Tanks[i].dir == 0)
	{
	if ((Tanks[i].X > 0)&&(Map.Blocks[Tanks[i].Y,Tanks[i].X-1].Tile==0))
	{
	bullets[activebulletscount] = new Bullet();
	bullets[activebulletscount].dir = Tanks[i].dir;
	bullets[activebulletscount].X = Tanks[i].X - 1;
	bullets[activebulletscount].Y = Tanks[i].Y;
	activebulletscount++;
	}
	}
	else if (bullets[activebulletscount].dir == 1)
	{
	if ((Tanks[i].X < Map.Width - 1) && (Map.Blocks[Tanks[i].Y+1, Tanks[i].X].Tile == 0))
	{
	bullets[activebulletscount] = new Bullet();
	bullets[activebulletscount].dir = Tanks[i].dir;
	bullets[activebulletscount].X = Tanks[i].X;
	bullets[activebulletscount].Y = Tanks[i].Y+1;
	activebulletscount++;
	}
	}
	else if (bullets[activebulletscount].dir == 2)
	{
	if ((Tanks[i].X < Map.Depth - 1) && (Map.Blocks[Tanks[i].Y, Tanks[i].X + 1].Tile == 0))
	{
	bullets[activebulletscount] = new Bullet();
	bullets[activebulletscount].dir = Tanks[i].dir;
	bullets[activebulletscount].X = Tanks[i].X + 1;
	bullets[activebulletscount].Y = Tanks[i].Y;
	activebulletscount++;
	}
	}
	else if (bullets[activebulletscount].dir == 0)
	{
	if ((Tanks[i].X > 0) && (Map.Blocks[Tanks[i].Y-1, Tanks[i].X].Tile == 0))
	{
	bullets[activebulletscount] = new Bullet();
	bullets[activebulletscount].dir = Tanks[i].dir;
	bullets[activebulletscount].X = Tanks[i].X;
	bullets[activebulletscount].Y = Tanks[i].Y-1;
	activebulletscount++;
	}
	}
	if (activebulletscount > 0)
	{
	Map.Blocks[bullets[activebulletscount - 1].Y, bullets[activebulletscount - 1].X].Tile = 14;
	}
	}
	Tanks[i].health = int.Parse(tdata[4]);
	Tanks[i].coins = int.Parse(tdata[5]);
	Tanks[i].points = int.Parse(tdata[6]);
	Tanks[i].dir += enemyoffset;
	Map.Blocks[Tanks[i].Y, Tanks[i].X].Tile = (byte)Tanks[i].dir;
	}
	}
	else
	{
	for (int i = 1; i < tankscount; i++)
	{
	tdata = mainparts[i + 1].Split(singlesemicolon);
	Tanks[i].pX = Tanks[i].X;
	Tanks[i].pY = Tanks[i].Y;
	Tanks[i].X = int.Parse(tdata[1].Split(singlecomma)[0]);
	Tanks[i].Y = int.Parse(tdata[1].Split(singlecomma)[1]);
	for (int u = 0; u < activecoinscount;u++ )
	{
	if ((coins[u].x == Tanks[i].X) && (coins[u].y == Tanks[i].Y))
	{
	RemoveCoin(u);
	}
	}
	for (int u = 0; u < activelifepackscount; u++)
	{
	if ((lifepacks[u].x == Tanks[i].X) && (lifepacks[u].y == Tanks[i].Y))
	{
	RemoveLifepack(u);
	}
	}
	Tanks[i].dir = int.Parse(tdata[2]);
	Tanks[i].shot = int.Parse(tdata[3]);
	if (Tanks[i].shot == 1)
	{
	if (Tanks[i].dir == 0)
	{
	if ((Tanks[i].X > 0) && (Map.Blocks[Tanks[i].Y, Tanks[i].X - 1].Tile == 0))
	{
	bullets[activebulletscount] = new Bullet();
	bullets[activebulletscount].dir = Tanks[i].dir;
	bullets[activebulletscount].X = Tanks[i].X - 1;
	bullets[activebulletscount].Y = Tanks[i].Y;
	activebulletscount++;
	}
	}
	else if (bullets[activebulletscount].dir == 1)
	{
	if ((Tanks[i].X < Map.Width - 1) && (Map.Blocks[Tanks[i].Y + 1, Tanks[i].X].Tile == 0))
	{
	bullets[activebulletscount] = new Bullet();
	bullets[activebulletscount].dir = Tanks[i].dir;
	bullets[activebulletscount].X = Tanks[i].X;
	bullets[activebulletscount].Y = Tanks[i].Y + 1;
	activebulletscount++;
	}
	}
	else if (bullets[activebulletscount].dir == 2)
	{
	if ((Tanks[i].X < Map.Depth - 1) && (Map.Blocks[Tanks[i].Y, Tanks[i].X + 1].Tile == 0))
	{
	bullets[activebulletscount] = new Bullet();
	bullets[activebulletscount].dir = Tanks[i].dir;
	bullets[activebulletscount].X = Tanks[i].X + 1;
	bullets[activebulletscount].Y = Tanks[i].Y;
	activebulletscount++;
	}
	}
	else if (bullets[activebulletscount].dir == 0)
	{
	if ((Tanks[i].X > 0) && (Map.Blocks[Tanks[i].Y - 1, Tanks[i].X].Tile == 0))
	{
	bullets[activebulletscount] = new Bullet();
	bullets[activebulletscount].dir = Tanks[i].dir;
	bullets[activebulletscount].X = Tanks[i].X;
	bullets[activebulletscount].Y = Tanks[i].Y - 1;
	activebulletscount++;
	}
	}
	if (activebulletscount > 0)
	{
	Map.Blocks[bullets[activebulletscount - 1].Y, bullets[activebulletscount - 1].X].Tile = 14;
	}
	}
	Tanks[i].health = int.Parse(tdata[4]);
	Tanks[i].coins = int.Parse(tdata[5]);
	Tanks[i].points = int.Parse(tdata[6]);
	Tanks[i].dir += enemyoffset;
	Map.Blocks[Tanks[i].pY, Tanks[i].pX].Tile = 0;
	Map.Blocks[Tanks[i].Y, Tanks[i].X].Tile = (byte)Tanks[i].dir;
	}
	}
	}
	public int cost(Stack st)
	{
	Object[] gsq = st.ToArray();
	GridSquare temp=(GridSquare)gsq[st.Count-1];
	return temp.cost;
	}
	public Stack copy(Stack st)
	{
	Object[] obj = st.ToArray();
	Stack copy = new Stack();
	for (int i = obj.Length - 1; i >= 0; i--)
	{
	copy.Push(obj[i]);
	}
	return copy;
	}
	public void RemoveCoin(int n){
	for (int j = n; j < activecoinscount - 1; j++)
	{
	coins[j] = coins[j + 1];
	}
	activecoinscount--;
	}
	public void RemoveLifepack(int n)
	{
	for (int j = n; j < activelifepackscount - 1; j++)
	{
	lifepacks[j] = lifepacks[j + 1];
	}
	activelifepackscount--;
	}
	}
	}

view raw isogame5.java hosted with ❤ by GitHub