Isometric 3d Game part 1

In this post I am going to talk about implementing a self playing isometric tank game client. First of all lets focus on what is isometric means?. In the context of gaming, isometric refers to some sort of parallel projection. View point of the game will be rotated and will show a side view of the game. This technique can be used to create a 3d game using 2d game programming features. Following is an image of an isometric view. In an isometric view, camera is angled from 60 degrees to all three xy,yz,zx planes.

This game is a multilayer game. Game has a server which will send game initialization, ending and update messages.

In this post I am describing how to implement  game client. Game client will play the game itself by deciding on messages received by the game server.

                                                       

 A screenshot of game UI. 

                                                         

Network Layer

Layers of my game

In communication layer there is a server that is sending messages and in my game client, there is communicator class which communicates with the server according to a protocol. Follwoing is the protocol specification for the network layer.

Game Protocol

 Joining the game

 The client will have to send a request to the Server saying  JOIN#

The server will reply with one of the following replies

• Join accept message (explained in the next slide)
• PLAYERS_FULL# - The maximum number of players are already added 
• ALREADY_ADDED# - The player is already added 
• GAME_ALREADY_STARTED# - The player tries to join an already started game

 Joining the game – Acceptance

        If the client’s request can be honoured, the server replies with a message in the following format.  S:P: < player location  x>,< player location  y>:#

          For an example the first player to register in a game instance may get a message like,     

          S:P1: 1,1:0#

Game Initiation

• A timer gets initiated when the first player resister for a game.
• When the 5th player joins the game or in the event of the timer expiring, the server will issue the game starting message to all the players that are already registered with the server.
• As discussed before, any join request by a client hereafter until the end of the game instance will be rejected.
• The game will be played in a 20x20 grid.
•   All other map details vary with each game instance and will be sent in the following format
  I:P1; < player location  x>,< player location  y>;: ...: P5< player location  x>,< player location  y>;: < x>,;< x>,;< x>,…..< x>,: < x>,;< x>,;< x>,…..< x>,: < x>,;< x>,;< x>,…..< x>,#
  Moving and Shooting
  
  
  Once per second the server will broadcast a global update to all the clients documenting its internal variables about the clients
  G:P1;< player location  x>,< player location  y>;;< whether shot>;;< coins>;< points>: …. P5;< player location  x>,< player location  y>;;< whether shot>;;< coins>;< points>: < x>,,;< x>,,;< x>,,;< x>,,…..< x>,,

Acquiring coins

The server will send the following message to signal the appearing event of a pile of coins.

C:,::#

• x - <int>
• y - <int>
• LT -<int> the time that the pile of coins will be on the map before it automatically disappears
• Val – value of the coins

Life Packs

 The server will send the following message to signal the appearing event of a Life Pack.

L:,:#

• x - <int>
• y - <int>
• LT -<int> the time that the life pack will be on the map before it automatically disappears

Isometric 3d Game part 2

Communicator Class


For communicator class i have used a TCPListner class in .net framework. This class has two methods. Read() and sendData().  Read will call in a separate thread which will be called from main thread in main class of the game. 

	using System;
	using System.Collections.Generic;
	using System.Text;
	using System.Net;
	using System.Net.Sockets;
	using System.IO;
	using System.Threading;
	namespace TileMap
	{
	class Communicator
	{
	#region "Variables"
	private NetworkStream clientStream; //Stream - outgoing
	private TcpClient client; //To talk back to the client
	private BinaryWriter writer; //To write to the clients
	private NetworkStream serverStream; //Stream - incoming
	private TcpListener listener; //To listen to the clinets
	public string reply = ""; //The message to be written
	private static Communicator comm = new Communicator();
	#endregion
	public void Prepare()
	{
	try
	{
	//Creating listening Socket
	IPAddress address = IPAddress.Parse(Constants.CLIENT_IP);
	this.listener = new TcpListener(address, Constants.CLIENT_PORT);
	//Starts listening
	this.listener.Start();
	//Establish connection upon client request
	}
	catch (Exception e)
	{
	Console.WriteLine("Communication (RECEIVING) Failed! \n " + e.Message);
	}
	}
	public string Read()
	{
	Socket connection = null;
	//connection is connected socket
	connection = listener.AcceptSocket();
	if (connection.Connected)
	{
	//To read from socket create NetworkStream object associated with socket
	this.serverStream = new NetworkStream(connection);
	SocketAddress sockAdd = connection.RemoteEndPoint.Serialize();
	string s = connection.RemoteEndPoint.ToString();
	List inputStr = new List();
	int asw = 0;
	while (asw != -1)
	{
	asw = this.serverStream.ReadByte();
	inputStr.Add((Byte)asw);
	}
	reply = Encoding.UTF8.GetString(inputStr.ToArray());
	//Console.WriteLine(reply);
	this.serverStream.Close();
	return reply;
	}
	else
	{
	return "nothing";
	}
	}
	public void SendData(String message)
	{
	//Opening the connection
	this.client = new TcpClient();
	try
	{
	this.client.Connect(Constants.SERVER_IP, Constants.SERVER_PORT);
	if (this.client.Connected)
	{
	//To write to the socket
	this.clientStream = client.GetStream();
	//Create objects for writing across stream
	this.writer = new BinaryWriter(clientStream);
	Byte[] tempStr = Encoding.ASCII.GetBytes(message);
	//writing to the port
	this.writer.Write(tempStr);
	this.writer.Close();
	this.clientStream.Close();
	}
	}
	catch (Exception e)
	{
	Console.WriteLine(e);
	}
	finally
	{
	this.client.Close();
	}
	}
	}
	}

view raw isogame2.java hosted with ❤ by GitHub

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

Isometric 3d Game part 3

I have used an AI to generate the optimal path for movements of the tank. I have adopted A* algorithm for that. Cost of 1 second will be accounted for both turning the tank and moving the tank to a new block.  Path is generated after each movement of the tank. Then only tank can pickup newly appeared coins or life packs near to current position of the tank..

	using System;
	using System.Collections;
	using System.Linq;
	using System.Text;
	namespace TileMap
	{
	class AI
	{
	public Stack generatePath(Map map,int Sx,int Sy,int Dx,int Dy)
	{
	PriorityQueue working = new PriorityQueue();
	PriorityQueue finished=new PriorityQueue();
	Stack st = new Stack();
	working.enqueue(new GridSquare(0,Sx,Sy,-1,-1,0));
	GridSquare temp,tempworking;
	int tempcost;
	while (true)
	{
	temp = working.dequeue();
	finished.enqueue(temp);
	if ((temp.x == Dx) && (temp.y == Dy))
	{
	st.Push(temp);
	while ((temp.parX != -1) && (temp.parY != -1))
	{
	temp = finished.get(temp.parX,temp.parY);
	st.Push(temp);
	}
	break;
	}
	//north
	if ((temp.y - 1 >= 0) && ((map.Blocks[temp.y - 1, temp.x].Tile == 0) || (map.Blocks[temp.y - 1, temp.x].Tile == 4) || (map.Blocks[temp.y - 1, temp.x].Tile == 5)))
	{
	if (finished.get(temp.x, temp.y - 1) == null)
	{
	tempworking = working.get(temp.x, temp.y - 1);
	if (temp.dir == 0) tempcost = temp.cost + 1; else tempcost = temp.cost + 2;
	if (tempworking == null)
	{
	working.enqueue(new GridSquare(tempcost,temp.x,temp.y-1,temp.x,temp.y,0));
	}
	else if (tempworking.cost > tempcost)
	{
	working.remove(tempworking.x,tempworking.y);
	working.enqueue(new GridSquare(tempcost, temp.x, temp.y - 1, temp.x, temp.y, 0));
	}
	}
	}
	//east
	if ((temp.x + 1 < Constants.MAP_SIZE) && ((map.Blocks[temp.y, temp.x + 1].Tile == 0) || (map.Blocks[temp.y, temp.x + 1].Tile == 4) || (map.Blocks[temp.y, temp.x + 1].Tile == 5)))
	{
	if (finished.get(temp.x+1, temp.y) == null)
	{
	tempworking = working.get(temp.x+1, temp.y);
	if (temp.dir == 1) tempcost = temp.cost + 1; else tempcost = temp.cost + 2;
	if (tempworking == null)
	{
	working.enqueue(new GridSquare(tempcost, temp.x+1, temp.y, temp.x, temp.y, 1));
	}
	else if (tempworking.cost > tempcost)
	{
	working.remove(tempworking.x, tempworking.y);
	working.enqueue(new GridSquare(tempcost, temp.x+1, temp.y, temp.x, temp.y, 1));
	}
	}
	}
	//south
	if ((temp.y + 1 < Constants.MAP_SIZE) && ((map.Blocks[temp.y + 1, temp.x].Tile == 0) || (map.Blocks[temp.y + 1, temp.x].Tile == 4) || (map.Blocks[temp.y + 1, temp.x].Tile == 5)))
	{
	if (finished.get(temp.x, temp.y + 1) == null)
	{
	tempworking = working.get(temp.x, temp.y + 1);
	if (temp.dir == 2) tempcost = temp.cost + 1; else tempcost = temp.cost + 2;
	if (tempworking == null)
	{
	working.enqueue(new GridSquare(tempcost, temp.x, temp.y + 1, temp.x, temp.y, 2));
	}
	else if (tempworking.cost > tempcost)
	{
	working.remove(tempworking.x, tempworking.y);
	working.enqueue(new GridSquare(tempcost, temp.x, temp.y + 1, temp.x, temp.y, 2));
	}
	}
	}
	//west
	if ((temp.x - 1 >= 0) && ((map.Blocks[temp.y, temp.x - 1].Tile == 0) || (map.Blocks[temp.y, temp.x - 1].Tile == 4) || (map.Blocks[temp.y, temp.x - 1].Tile == 5)))
	{
	if (finished.get(temp.x-1, temp.y) == null)
	{
	tempworking = working.get(temp.x-1, temp.y);
	if (temp.dir == 0) tempcost = temp.cost + 1; else tempcost = temp.cost + 2;
	if (tempworking == null)
	{
	working.enqueue(new GridSquare(tempcost, temp.x-1, temp.y, temp.x, temp.y, 3));
	}
	else if (tempworking.cost > tempcost)
	{
	working.remove(tempworking.x, tempworking.y);
	working.enqueue(new GridSquare(tempcost, temp.x-1, temp.y, temp.x, temp.y, 3));
	}
	}
	}
	}
	return st;
	}
	}
	}

view raw isogame3.java hosted with ❤ by GitHub

Isometric 3d Game part 4

Tiles and tile placing

Ground Tiles

  Object Tiles

All of these are isometric tiles in 128 128. Following image describes how the real tile image is placed inside the 128x128 image.

 When placing tiles we must calculate the tile positions in proper way. Then it will appears as a 3d grid.
Suppose we placed a tile with the coordinates a,a for top left corner of the tile, the next tile must be placed down in (a+64,a-32) and up in (a+64,a+32). All the tiles will be represented as a 2d array.

 In the 5th post you will find the code for main game class which includes the algorithm for placing tiles.