/JTacticalSim.Console/Render/ConsoleRenderer.cs

using System;

using System.Collections.Generic;

using System.Collections.Concurrent;

using System.Configuration;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using JTacticalSim.API;

using JTacticalSim.API.Component;

using JTacticalSim.API.DTO;

using JTacticalSim.API.Game;

using JTacticalSim.Utility;



namespace JTacticalSim.Console

{

	public class ConsoleRenderer : BaseRenderer

	{

		protected const int ROWSPACING = 8;												// Total number of rows per board row

		protected const int COLUMNSPACING = 20;											// Total spaces per column

		protected const int TILEOFFSET = (COLUMNSPACING - COLUMNOFFSET);

		protected const int COLUMNHEADEROFFSET = 3;										// Number of spaces in a column or row header [R-1 e.g.]

		protected const int COLUMNOFFSET = 4;											// Number of spaces from the end of the base geog area to the next column

		protected const int FLAGWIDTH = 2;												// Number of spaces from the beginning of the column to base geog area (where the flag goes)

		protected const int BASEGEOGWIDTH = COLUMNSPACING - (COLUMNOFFSET + FLAGWIDTH);	// Width of the base geog area to be filled with color - MUST BE EVEN NUMBER

		protected const int TILEWIDTH = TILEOFFSET - COLUMNHEADEROFFSET;

		protected const int WESTMARGINOFFSET = COLUMNHEADEROFFSET + 2;

		protected const int WESTMARGIN = 2;



		protected ConsoleColor NodeSelectedColor = ConsoleColor.White;

		protected ConsoleColor NodeAvailableForMoveColor = ConsoleColor.Yellow;

		protected ConsoleColor UnitSelectedColor = ConsoleColor.White;

		protected ConsoleColor BoardBoundaryBGColor = ConsoleColor.DarkGray;

		protected ConsoleColor BoardBoundaryFGColor = ConsoleColor.Black;

		protected ConsoleColor WestFactionColor = ConsoleColor.DarkYellow;

		protected ConsoleColor EastFactionColor = ConsoleColor.Red;

		protected ConsoleColor LandBGColor = ConsoleColor.DarkGreen;

		protected ConsoleColor WaterBGColor = ConsoleColor.Cyan;



		private IGame _theGame { get; set; }



		public ConsoleRenderer(IGame theGame)

		{

			_theGame = theGame;

		}



		public override void LoadContent()

		{

			// Do nothing - no graphics content for console

		}



		public override void UnloadContent()

		{

			// Do nothing - no graphics content for console

		}



		// Handle errors



		public override void HandleErrorUI(string Message, Exception ex)

		{

			var display = new StringBuilder("{0} : ".F(Message));



			if (ex != null)

				display.AppendLine(ex.Message);



			DisplayError(display.ToString());

		}



		public void DisplayError(string error)

		{

			System.Console.ForegroundColor = ConsoleColor.Red;

			System.Console.Write(error);

			System.Console.WriteLine();

			System.Console.ResetColor();

		}





		// Screens



		public override void RenderBoard()

		{

			System.Console.Clear();

			CreateTitleRow("Main Board");

			CreateHeaderRow(2, false);

			CreateRows();

			CreateFooterRow(false);

			CreatePlayerSummaryRow();

			CreateFooterRow(true);

			System.Console.WriteLine("\n");

		}



		public override void RenderReinforcementScreen()

		{

			System.Console.Clear();

			CreateTitleRow("Reinforcements");

			CreateHeaderRow(0, true);

			System.Console.Write("\n");

			CreateUnitInfoRows();

			CreateFooterRow(true);

			CreatePlayerSummaryRow();

			CreateFooterRow(true);

			System.Console.WriteLine("\n");

		}



		public override void RenderTitleScreen()

		{

			System.Console.Clear();

			CreateHeaderRow(0, true);

			System.Console.Write("\n");

			ListScenarios();

			System.Console.Write("\n");

			ListSavedGames();

			CreateFooterRow(true);

			System.Console.Write("\n");

		}





		// Board



		public override void RenderNode(INode node)

		{

			if (node.IsWestOuterBoundary)

			{

				CreateWestVertBoundFiller();

				MoveCursor(WESTMARGIN);

			}



			node.GetTopTile().Render();



			if (node.IsEastOuterBoundary)

			{

				CreateEastVertBoundFiller();

			}

		}



		public override void RenderTile(ITile tile)

		{

			// Here in the console renderer, we have to kinda fudge this.

			// The data has to be rendered line by line so there's no real concept of 

			// 'rendering a node or tile'

			RenderTileDemographics(tile);

		}



		/// <summary>

		/// Only pertinent to console rendering

		/// </summary>

		/// <param name="tile"></param>

		private void RenderTileDemographics(ITile tile)

		{

			System.Console.Write("  "); // Flag area...

			// For tracking spacers. Start with the 2 spaces for the flag area above^

			int i = 2;



			// ~~~~~~~~~~ Geography/Terrain



			if (tile.ConsoleRenderHelper.hasMountains)

			{

				var drawMe = tile.AllGeography.Where(d => d.IsDemographicClass("Mountains")).Select(d => d.DemographicClass.TextDisplay).Single();

				DrawDemographics(drawMe, ConsoleColor.DarkYellow, ConsoleColor.Black);

				i += drawMe.Length;

			}

			if (tile.ConsoleRenderHelper.hasHills)

			{

				var drawMe = tile.AllGeography.Where(d => d.IsDemographicClass("Hills")).Select(d => d.DemographicClass.TextDisplay).Single();

				DrawDemographics(drawMe, ConsoleColor.DarkYellow, ConsoleColor.Black);

				i += drawMe.Length;

			}

			if (tile.ConsoleRenderHelper.hasLakes)

			{

				var drawMe = tile.AllGeography.Where(d => d.IsDemographicClass("Lake")).Select(d => d.DemographicClass.TextDisplay).Single();

				DrawDemographics(drawMe, ConsoleColor.Blue, ConsoleColor.Black);

				i += drawMe.Length;

			}



			DrawDemographics(" ", ConsoleColor.Black, ConsoleColor.Black);

			i++;



			// ~~~~~~~~~~~ Flora



			if (tile.ConsoleRenderHelper.hasForests)

			{

				var drawMe = tile.Flora.Where(d => d.IsDemographicClass("Forested")).Select(d => d.DemographicClass.TextDisplay).Single();

				DrawDemographics(drawMe, ConsoleColor.Green, ConsoleColor.Black);

				i += drawMe.Length;

			}

			if (tile.ConsoleRenderHelper.hasTrees)

			{

				var drawMe = tile.Flora.Where(d => d.IsDemographicClass("Trees")).Select(d => d.DemographicClass.TextDisplay).Single();

				DrawDemographics(drawMe, ConsoleColor.Green, ConsoleColor.Black);

				i += drawMe.Length;

			}

			if (tile.ConsoleRenderHelper.hasMarsh)

			{

				var drawMe = tile.Flora.Where(d => d.IsDemographicClass("Marsh")).Select(d => d.DemographicClass.TextDisplay).Single();

				DrawDemographics(drawMe, ConsoleColor.Green, ConsoleColor.Black);

				i += drawMe.Length;

			}



			DrawDemographics(" ", ConsoleColor.Black, ConsoleColor.Black);

			i++;



			// ~~~~~~~~~~ Infrastructure





			if (tile.ConsoleRenderHelper.hasCities)

			{

				var drawMe = tile.Infrastructure.Where(d => d.IsDemographicClass("Urban")).Select(d => d.DemographicClass.TextDisplay).Single();

				DrawDemographics(drawMe, ConsoleColor.DarkGray, ConsoleColor.Black);

				i += drawMe.Length;

			}



			if (tile.ConsoleRenderHelper.hasRoad)

			{

				var drawMe = tile.Infrastructure.Where(d => d.IsDemographicClass("Road")).Select(d => d.DemographicClass.TextDisplay).Single();

				DrawDemographics(drawMe, ConsoleColor.DarkGray, ConsoleColor.Black);

				i += drawMe.Length;

			}



			if (tile.ConsoleRenderHelper.hasBridge)

			{

				var drawMe = tile.Infrastructure.Where(d => d.IsDemographicClass("Bridge")).Select(d => d.DemographicClass.TextDisplay).Single();

				DrawDemographics(drawMe, ConsoleColor.DarkGray, ConsoleColor.Black);

				i += drawMe.Length;

			}



			if (tile.ConsoleRenderHelper.hasTracks)

			{

				var drawMe = tile.Infrastructure.Where(d => d.IsDemographicClass("TrainTrack")).Select(d => d.DemographicClass.TextDisplay).Single();

				DrawDemographics(drawMe, ConsoleColor.DarkGray, ConsoleColor.Black);

				i += drawMe.Length;

			}





			// Make the tiles uniform length

			for (int count = 0; count < COLUMNSPACING - i; count++)

			{

				System.Console.Write(" ");

			}



			System.Console.ResetColor();

		}



		/// <summary>

		///  Only pertinent to console rendering

		/// </summary>

		/// <param name="nodes"></param>

		private void RenderTopTileBaseGeog(IEnumerable<INode> nodes)

		{

			//	Render all the node items

			foreach (var n in nodes)

			{

				if (n.IsWestOuterBoundary)

				{

					System.Console.Write("\n");

					CreateRowHeader(n);

				}



				DrawTileBaseGeog(n.DefaultTile(), false);



				if (n.IsEastOuterBoundary)

				{

					MoveCursor(COLUMNSPACING - TILEOFFSET);

					CreateRowHeader(n);

				}

			}

		}



		/// <summary>

		/// Only pertinent to console rendering

		/// </summary>

		/// <param name="nodes"></param>

		private void RenderBottomTileBaseGeog(IEnumerable<INode> nodes)

		{

			//	Render all the node items

			foreach (var n in nodes)

			{

				if (n.IsWestOuterBoundary)

				{

					CreateWestVertBoundFiller();

				}



				//n.GetTopTile().Render();

				DrawTileBaseGeog(n.DefaultTile(), true);



				if (n.IsEastOuterBoundary)

				{

					MoveCursor(COLUMNSPACING - TILEOFFSET);

					CreateEastVertBoundFiller();

				}

			}

		}



		public override int RenderUnitStackInfo(IUnitStack stack)

		{

			var allVisibleUnits = stack.GetAllUnits();

			var allTransportedUnits = stack.GetAllUnits().Where(u => u.IsBeingTransported());



			var sb = new StringBuilder("({0})".F(allVisibleUnits.Count));



			if (allTransportedUnits.Any()) 

				sb.Append(" ({0} - trn)".F(allTransportedUnits.Count()));



			System.Console.ForegroundColor = (stack.Faction.ID == 0) ? WestFactionColor : EastFactionColor;

			System.Console.Write(sb.ToString());

			System.Console.ResetColor();



			return sb.Length;

		}



		public override void DisplayPlayerInfo(IPlayer player)

		{

			System.Console.WriteLine(player.TextInfo());



			if (player.UnplacedReinforcements.Any())

			{

				System.Console.WriteLine("Unplaced Reinforcement Units :");

				player.UnplacedReinforcements.ForEach(u => {u.DisplayName(); System.Console.WriteLine();});

			}

		}



		public override void DisplayNodeInfo(INode node)

		{

			System.Console.WriteLine(node.TextInfo());



			if (node.GetTopTile() != null)

			{

				node.GetTopTile().DisplayInfo();

			}

		}



		public override void DisplayTileInfo(ITile tile)

		{

			System.Console.WriteLine(tile.TextInfo());

		}



		public override void DisplayLegend()

		{

			StringBuilder sb = new StringBuilder();

			sb.AppendLine(string.Empty);



			var demoClasses = _theGame.JTSServices.GenericComponentService.GetAll<IDemographicClass, IDemographicClassDTO>()

							.Where(d => !String.IsNullOrWhiteSpace(d.TextDisplay)).ToList();

			var unitGroupTypes = _theGame.JTSServices.GenericComponentService.GetAll<IUnitGroupType, IUnitGroupTypeDTO>()

							.Where(ugt => !String.IsNullOrWhiteSpace(ugt.TextDisplay)).ToList();

			var unitTypes = _theGame.JTSServices.GenericComponentService.GetAll<IUnitType, IUnitTypeDTO>()

							.Where(ut => !String.IsNullOrWhiteSpace(ut.TextDisplay)).ToList();

			var unitClasses = _theGame.JTSServices.GenericComponentService.GetAll<IUnitClass, IUnitClassDTO>()

							.Where(uc => !String.IsNullOrWhiteSpace(uc.TextDisplay)).ToList();



			if (demoClasses.Any())

			{

				sb.AppendLine("Demographic Classes : ");

				sb.AppendLine(string.Empty);

				demoClasses.ForEach(d => sb.AppendLine("   {0} :  {1}".F(d.TextDisplay, d.Name)));

			}



			sb.AppendLine(string.Empty);



			if (unitGroupTypes.Any())

			{

				sb.AppendLine("Unit Group Types : ");

				sb.AppendLine(string.Empty);

				unitGroupTypes.ForEach(d => sb.AppendLine("   {0} :  {1}".F(d.TextDisplay, d.Name)));

			}



			sb.AppendLine(string.Empty);



			if (unitTypes.Any())

			{

				sb.AppendLine("Unit Types : ");

				sb.AppendLine(string.Empty);

				unitTypes.ForEach(d => sb.AppendLine("   {0} :  {1}".F(d.TextDisplay, d.Name)));

			}



			sb.AppendLine(string.Empty);



			if (unitClasses.Any())

			{

				sb.AppendLine("Unit Classes : ");

				sb.AppendLine(string.Empty);

				unitClasses.ForEach(d => sb.AppendLine("   {0} :  {1}".F(d.TextDisplay, d.Name)));

			}



			sb.AppendLine(string.Empty);



			System.Console.WriteLine(sb.ToString());

		}



	// Units



		public override void DisplayUnits(List<IUnit> units)

		{

			if (!units.Any())

				return;



			System.Console.WriteLine("Units : ");

			foreach (IUnit u in units)

			{

				System.Console.WriteLine("----------------------------------------------- |");

				u.DisplayInfo();

			}

		}



		public override void DisplayUnitInfo(IUnit unit)

		{

			System.Console.WriteLine(unit.TextInfo());

		}



		public override void RenderUnit(IUnit unit)

		{

			RenderUnitName(unit);

		}



		public override void RenderUnitName(IUnit unit)

		{

			if (!unit.IsVisible())

				return;



			var IsSelectedUnit = (_theGame.GameBoard.SelectedUnits != null && _theGame.GameBoard.SelectedUnits.Any()) && 

									(_theGame.GameBoard.SelectedUnits.Any(m => m.Equals(unit)));



			System.Console.ForegroundColor = (unit.Faction.ID == 0) ? WestFactionColor : EastFactionColor;

			if (IsSelectedUnit) System.Console.ForegroundColor = UnitSelectedColor;



			if (!String.IsNullOrEmpty(unit.UnitInfo.UnitGroupType.TextDisplay))

			{

				System.Console.Write("{0} ", unit.UnitInfo.UnitGroupType.TextDisplay);

			}				

			

			System.Console.Write("{0}{1} {2}", 	unit.UnitInfo.UnitClass.TextDisplay, 

											unit.UnitInfo.UnitType.TextDisplay, 

											unit.Name);

			System.Console.ResetColor();

		}



	// Battle



		public override void RenderBattle(IBattle battle)

		{

			System.Console.Clear();

			System.Console.WriteLine(" ------------------------- COMBAT --------------------------");

			

			// Show the attackers and defenders....

			_theGame.CurrentBattle.Attackers.ForEach(u =>

				{

					System.Console.WriteLine();

					u.Render();

				});

			 

			System.Console.WriteLine(" ");

			System.Console.WriteLine(" ");

			System.Console.WriteLine(" - VS - ");



			_theGame.CurrentBattle.Defenders.ForEach(u =>

				{

					System.Console.WriteLine();

					u.Render();

				});



			System.Console.WriteLine(" ");

			System.Console.WriteLine(" ");

		}



		public override void RenderBattleRound(IRound round)

		{

			if (!round.Skirmishes.Any()) return;



			System.Console.WriteLine(" ");

			System.Console.WriteLine(" ----------------------------------------------- Start Round");

			System.Console.WriteLine(" ");



			round.Skirmishes.ForEach(sk =>

				{

					sk.Render();

				});



			System.Console.WriteLine(" ");

			System.Console.WriteLine(" ----------------------------------------------- End Round");

		}



		public override void RenderBattleSkirmish(ISkirmish skirmish)

		{

			System.Console.WriteLine("Combat Type : {0}".F(skirmish.Type.ToString()));

			System.Console.WriteLine(" ");

			

			if (skirmish.Type == SkirmishType.FULL)

			{

				// Full skirmish

				skirmish.Attacker.Render();

				System.Console.Write(" is attacking ");

				skirmish.Defender.Render();

			}

			else

			{

				// Special defence skirmish

				skirmish.Defender.Render();

				System.Console.Write(" is defending against ");

				skirmish.Attacker.Render();

			}



			System.Console.WriteLine(".............. {0}".F(skirmish.GetSkirmishResults().Message));

			System.Console.WriteLine(" ");

		}



		public override void RenderBattleOutcome(IBattle battle)

		{

			System.Console.WriteLine(" ");

			System.Console.WriteLine("Battle outcome is {0}.".F(_theGame.CurrentBattle.VictoryCondition.ToString()));

			System.Console.WriteLine(" ");

			System.Console.WriteLine(" ");

			System.Console.WriteLine("Hit Enter key to continue...");

			System.Console.ReadLine();

		}



		public override void RenderBattleRetreat(IBattle battle)

		{

			var round = battle.CurrentRound;

			round.Render();



			// Handle retreat

			// No retreat for forced engagements

			if (battle.VictoryCondition == BattleVictoryCondition.NO_VICTOR && battle.BattleType != BattleType.FORCED_ENGAGEMENT)

			{

				System.Console.WriteLine(" ");

				System.Console.WriteLine(" ");

				System.Console.Write("Retreat? ");



				if (CommandLineUtil.ConsoleUtils.GetYesNoInputAsBool())

				{

					battle.VictoryCondition = BattleVictoryCondition.RETREAT;

				}



				System.Console.WriteLine(" ");

			}

		}



	// Reinforcements





#region Event Handlers



		public override void On_BoardPostRender(EventArgs e)

		{

			//_theGameGameBoard.ClearSelectedItems();

		}



		public override void On_BoardPreRender(EventArgs e)

		{}



#endregion





#region DrawUtilities





	// Title



		private void ListScenarios()

		{

			var scenarios = _theGame.JTSServices.GenericComponentService.GetAll<IScenario, IScenarioDTO>();



			System.Console.Write("\n\t");

			DrawLine();



			System.Console.ForegroundColor = ConsoleColor.Cyan;

			System.Console.WriteLine("\n\n\tAvailable Scenarios : \n");

			System.Console.ResetColor();



			scenarios.ForEach(s =>

				{

					

					System.Console.Write("\t\t* {0}", s.Name);

					System.Console.Write("\n");

				});



			System.Console.Write("\n");

		}



		private void ListSavedGames()

		{

			System.Console.Write("\n");

			// Display the currently loaded game

			if (_theGame.SavedGame != null)

			{

				System.Console.ForegroundColor = ConsoleColor.Cyan;

				System.Console.Write("\tCurrent Game : ");

				System.Console.ResetColor();

				System.Console.Write(_theGame.SavedGame.Name);

			}

			else

			{

				System.Console.ForegroundColor = ConsoleColor.Cyan;

				System.Console.Write("\tNo game loaded. Select a game from below.");

				System.Console.ResetColor();

			}



			var savedGames = _theGame.JTSServices.GenericComponentService.GetAll<ISavedGame, ISavedGameDTO>();



			System.Console.Write("\n\t");

			DrawLine();



			System.Console.ForegroundColor = ConsoleColor.Cyan;

			System.Console.WriteLine("\n\n\tSaved Games : \n");

			System.Console.ResetColor();



			savedGames.ForEach(sg =>

				{

					

					System.Console.Write("\t\t* {0}", sg.Name);

					System.Console.Write("\n");

				});



			System.Console.Write("\n");

		}



	// Reinforcements



		private void CreateUnitInfoRows()

		{

			// Get unit types			

			var unitTypes = _theGame.JTSServices.GenericComponentService.GetAll<IUnitType, IUnitTypeDTO>();



			System.Console.Write("\n");



			unitTypes.ForEach(ut =>

				{

					System.Console.ForegroundColor = ConsoleColor.Cyan;

					System.Console.Write("\t{0}", ut.Name);

					System.Console.ResetColor();

					System.Console.WriteLine("  ({0})", ut.Description);

					CreateAvailableUnitClassRow(ut);

					System.Console.Write("\n");

				});



		}



		private void CreateAvailableUnitClassRow(IUnitType ut)

		{

			// Get available unit classes
			var ids = _theGame.JTSServices.DataService.LookupAllowableUnitClassesByUnitBaseType(ut.BaseType.ID);
			var unitClasses = _theGame.JTSServices.UnitService.GetUnitClassesByIDs(ids).Result;



			System.Console.Write("\t");



			foreach (var uc in unitClasses)

			{

				System.Console.ForegroundColor = ConsoleColor.DarkGray;

				var totalCost = _theGame.JTSServices.RulesService.CalculateTotalRPByUnitTypeUnitClass(ut, uc);

				System.Console.Write("{0}: {1}rp ".F(uc.Name, totalCost));

				System.Console.ForegroundColor = ConsoleColor.DarkYellow;

				System.Console.Write("| ");

				System.Console.ResetColor();

			}



			System.Console.Write("\n");

			System.Console.ResetColor();

		}



	// Board/Main



		private void CreateTitleRow(string screen)

		{

			System.Console.Write("\n");

			System.Console.ForegroundColor = ConsoleColor.DarkYellow;

			System.Console.Write("[[ JTacticalSim : {0} - {1} ]] {2} - {3}", 

											_theGame.SavedGame.Name, 

											_theGame.SavedGame.Scenario.Name,

											_theGame.GameBoard.DefaultAttributes.Title,

											screen);

			System.Console.ResetColor();

			System.Console.Write("\n");

		}



		private void CreateColumnHeaders(bool blank)

		{

			System.Console.BackgroundColor = BoardBoundaryBGColor;

			System.Console.ForegroundColor = BoardBoundaryFGColor;



			// Draw to first header

			MoveCursor(WESTMARGINOFFSET);



			for (int i = 0; i < _theGame.GameBoard.DefaultAttributes.Width ; i++)

			{

				string headerText = (blank) ? "   " : "C-{0}".F(i);

				System.Console.Write(headerText);

				MoveCursor(COLUMNSPACING - COLUMNHEADEROFFSET);

			}



			//extend over east header column

			MoveCursor(COLUMNHEADEROFFSET);



			System.Console.ResetColor();

		}



		private void CreateRowHeader(INode node)

		{

			System.Console.BackgroundColor = BoardBoundaryBGColor;

			System.Console.ForegroundColor = BoardBoundaryFGColor;			

			System.Console.Write("R-{0}", node.Location.Y.ToString());

			System.Console.ResetColor();		

		}



		private void CreateHeaderRow(int vertBoundFiller = 2, bool blank = false)

		{

			System.Console.Write("\n");

			CreateColumnHeaders(blank);

			CreateVertBoundFiller(vertBoundFiller);

		}



		private void CreateFooterRow(bool blank = false)

		{

			System.Console.Write("\n");

			CreateColumnHeaders(blank);

		}



		private void CreatePlayerSummaryRow()

		{

			System.Console.Write("\n");



			System.Console.BackgroundColor = BoardBoundaryBGColor;

			System.Console.ForegroundColor = BoardBoundaryFGColor;



			// Draw to first header

			System.Console.Write("   ");

			

			System.Console.ResetColor();



			System.Console.Write(" ");



			System.Console.Write("Player: {0}\t\tCountry: {1} ".F(_theGame.CurrentTurn.Player.Name, _theGame.CurrentTurn.Player.Country.Name));

			DrawFlag(_theGame.CurrentTurn.Player.Country.Faction);

			System.Console.Write("\t\tReinforcement Points: {0}".F(_theGame.CurrentTurn.Player.ReinforcementPoints.ToString()));

			System.Console.ResetColor();

		}



		private void CreateRows()

		{

			var rowDict = new ConcurrentDictionary<int, List<INode>>();

			var allNodes = _theGame.JTSServices.NodeService.GetAllNodes();

			

			foreach (INode n in allNodes)

			{

			    if (!rowDict.ContainsKey(n.Location.Y))

			        rowDict.GetOrAdd(n.Location.Y, new List<INode>{n});

			    else

			        rowDict[n.Location.Y].Add(n);				

			}



			foreach(var kvp in rowDict)

			{

				//	We need to sort the row first to make sure it's in column order

				var sortedRow = kvp.Value.OrderBy(n => n.Location.X).ToList();

				CreateRow(sortedRow, kvp.Key);

			}

				

		}



		private void CreateRow(List<INode> nodes, int row)

		{

			// Holds the total stacks in the entire row

			// We only render the top unit for each stack

			var componentStacksInRow = new List<IUnitStack>();



			// Add in the stack info row for each stack

			int rowCount = (GetMaximumRowStackCount(nodes));

			

			// Make sure the stack orders are correct

			nodes.ForEach(n =>

				{

					var tile = n.DefaultTile();

					n.DefaultTile().ResetComponentStackDisplayOrder();

					componentStacksInRow.AddRange(tile.GetAllComponentStacks().Where(cs => (cs.DisplayOrder != 0 && cs.GetAllUnits().Any())));

				});



			// take care of displaying the concepts of hybrid demographics for the console renderer - kinda weird

			RenderTopTileBaseGeog(nodes);

			RenderBottomTileBaseGeog(nodes);

			

			nodes.ForEach(n =>

				{

					n.Render();

				});



			// Empty space before units

			CreateVertBoundFiller(1);



			//Render TileBaseDemographics by top and bottom rows

			//Render Unit Stacks with headers, unit row by unit row

			for (int i = 1; i < rowCount + 1; i++)

			{

				var stacks = componentStacksInRow.Where(cs => cs.DisplayOrder == i).ToList();

				CreateStackHeaderRow(stacks);

				CreateUnitRow(stacks);

			}



			//Keep the rows uniform size

			CreateVertBoundFiller(ROWSPACING - (rowCount + 2));

		}







		private void CreateStackHeaderRow(IEnumerable<IUnitStack> unitStacks)

		{

			int lastStackColPosition = 0;

			int lastStackDisplayLength = 0;

			int i = 0;



			CreateWestVertBoundFiller();



			foreach (var us in unitStacks)

			{

				if (!us.HasVisibleComponents) continue;



				//Secret sauce

				var leftModifier = (i == 0) ? 1 : 0;

				var leftColOffset = (i == 0) ? (COLUMNSPACING - WESTMARGIN) : 0;



				//Determine spaces to move cursor

				MoveCursor((((us.Location.X + leftModifier) - lastStackColPosition) * COLUMNSPACING) - (lastStackDisplayLength + leftColOffset));



				lastStackDisplayLength = us.Render();

				lastStackColPosition = us.Location.X;



				i++;

			}

			

			// 2 * i allows for the moving of the unit names to line up after the flag

			MoveCursor(((_theGame.GameBoard.DefaultAttributes.Width - lastStackColPosition) * COLUMNSPACING) - lastStackDisplayLength);

			CreateEastVertBoundFiller();

		}



		private void CreateUnitRow(IEnumerable<IUnitStack> unitStacks)

		{

			int lastUnitColPosition = 0;

			int lastUnitDisplayLength = 0;

			int i = 0;



			CreateWestVertBoundFiller();



			foreach (var us in unitStacks)

			{

				// No visible units

				if (!us.HasVisibleComponents) continue;



				// The unit to render

				var unit = us.GetFirstVisibleUnit();



				//Secret sauce

				var leftModifier = (i == 0) ? 1 : 0;

				var leftColOffset = (i == 0) ? (COLUMNSPACING - WESTMARGIN) : 0;



				//Determine spaces to move cursor

				MoveCursor((((us.Location.X + leftModifier) - lastUnitColPosition) * COLUMNSPACING) - (lastUnitDisplayLength + leftColOffset));

				

				unit.Render();

				lastUnitColPosition = unit.Location.X;

				lastUnitDisplayLength = unit.TotalDisplayLength + 2; //Account for the dash and the space;

				i++;

			}	



			// 2 * i allows for the moving of the unit names to line up after the flag

			MoveCursor(((_theGame.GameBoard.DefaultAttributes.Width - lastUnitColPosition) * COLUMNSPACING) - lastUnitDisplayLength);

			CreateEastVertBoundFiller();

		}



		private void CreateVertBoundFiller(int rowCount)

		{

			for (int i = 0; i < rowCount ; i++)

			{				

				CreateWestVertBoundFiller();

				MoveCursor((_theGame.GameBoard.DefaultAttributes.Width * COLUMNSPACING) + WESTMARGIN);

				CreateEastVertBoundFiller();

			}		

		}



		private void CreateWestVertBoundFiller()

		{

			System.Console.BackgroundColor = BoardBoundaryBGColor;

			System.Console.Write("\n   ");

			System.Console.ResetColor();

		}



		private void CreateEastVertBoundFiller()

		{

			System.Console.BackgroundColor = BoardBoundaryBGColor;

			System.Console.Write("   ");

			System.Console.ResetColor();



		}



		private void DrawFlag(IFaction faction)

		{

			// Put a faction colored space before the tile draws (Flag)

			System.Console.BackgroundColor = (faction.ID == 0) ? WestFactionColor : EastFactionColor;			

			System.Console.Write(" ");

			System.Console.ResetColor();

			System.Console.Write(" ");

		}



		private void DrawVictoryPoints(string victoryPoints)

		{

			System.Console.BackgroundColor = ConsoleColor.Black;

			System.Console.ForegroundColor = ConsoleColor.Red;

			System.Console.Write(victoryPoints);

			System.Console.ResetColor();

			System.Console.Write(" ");

		}



		/// <summary>

		/// Used to offset the return value for the row-end

		/// </summary>

		/// <param name="nodes"></param>

		/// <returns></returns>

		private int GetMaximumRowStackCount(IEnumerable<INode> nodes)

		{

			return nodes.Aggregate(0, (current, n) => (n.DefaultTile().VisibleStackCount() > current) ? n.DefaultTile().VisibleStackCount() : current);

		}



		private void MoveCursor(int spaces)

		{

			for (var i = 0; i < spaces; i++)

			{

			    System.Console.Write(" ");

			}

		}



		private void DrawDemographics(string demographicDisplay, ConsoleColor itemColor, ConsoleColor tileColor)

		{

			System.Console.ForegroundColor = itemColor;

			System.Console.BackgroundColor = tileColor;

			System.Console.Write("{0}", demographicDisplay);

			System.Console.ResetColor();

		}



		private void DrawTileBaseGeog(ITile tile, bool IsBottomRow)

		{

			INode node = _theGame.JTSServices.NodeService.GetNodeAt(tile.Location);



			var IsCurrentNode = (_theGame.GameBoard.SelectedNode == null) ? false : (_theGame.GameBoard.SelectedNode.Equals(node));

			var IsMovementAvailableNode = _theGame.GameBoard.AvailableMovementNodes.Any(n => n.Equals(node));



			// If this is the first node in the row, the offset is the size of the column (row header) otherwise the tile

			int offset = (node.IsWestOuterBoundary) ? WESTMARGIN : (COLUMNSPACING - TILEOFFSET);



			// Advance to next column

			MoveCursor(offset);



			if (IsBottomRow)

			{

				DrawVictoryPoints((tile.VictoryPoints > 0) ? tile.VictoryPoints.ToString() : " ");

			}

			else

			{

				DrawFlag(node.Faction);

			}

			



			if (tile.ConsoleRenderHelper.hasShoreLineNorth)

			{

				var geogBGColor = (IsBottomRow) ? WaterBGColor : LandBGColor;

				System.Console.BackgroundColor = (IsCurrentNode) ? NodeSelectedColor : geogBGColor;

				if (IsMovementAvailableNode) System.Console.BackgroundColor = NodeAvailableForMoveColor;

				MoveCursor(BASEGEOGWIDTH);

				System.Console.ResetColor();

				return;

			}

			if (tile.ConsoleRenderHelper.hasShoreLineSouth)

			{

				var geogBGColor = (IsBottomRow) ? WaterBGColor : LandBGColor;

				System.Console.BackgroundColor = (IsCurrentNode) ? NodeSelectedColor : geogBGColor;

				if (IsMovementAvailableNode) System.Console.BackgroundColor = NodeAvailableForMoveColor;

				MoveCursor(BASEGEOGWIDTH);

				System.Console.ResetColor();

				return;

			}

			if (tile.ConsoleRenderHelper.hasShoreLineWest)

			{

				var geogBGColor = LandBGColor;

				System.Console.BackgroundColor = (IsCurrentNode) ? NodeSelectedColor : geogBGColor;

				if (IsMovementAvailableNode) System.Console.BackgroundColor = NodeAvailableForMoveColor;

				MoveCursor(BASEGEOGWIDTH / 2);



				geogBGColor = LandBGColor;

				System.Console.BackgroundColor = (IsCurrentNode) ? NodeSelectedColor : geogBGColor;

				if (IsMovementAvailableNode) System.Console.BackgroundColor = NodeAvailableForMoveColor;

				MoveCursor(BASEGEOGWIDTH / 2);

				System.Console.ResetColor();

				return;

			}

			if (tile.ConsoleRenderHelper.hasShoreLineEast)

			{

				var geogBGColor = WaterBGColor;

				System.Console.BackgroundColor = (IsCurrentNode) ? NodeSelectedColor : geogBGColor;

				if (IsMovementAvailableNode) System.Console.BackgroundColor = NodeAvailableForMoveColor;

				MoveCursor(BASEGEOGWIDTH / 2);



				geogBGColor = LandBGColor;

				System.Console.BackgroundColor = (IsCurrentNode) ? NodeSelectedColor : geogBGColor;

				if (IsMovementAvailableNode) System.Console.BackgroundColor = NodeAvailableForMoveColor;

				MoveCursor(BASEGEOGWIDTH / 2);

				System.Console.ResetColor();

				return;

			}

			if (tile.ConsoleRenderHelper.IsRiver)

			{

				var geogBGColor = WaterBGColor;

				System.Console.BackgroundColor = (IsCurrentNode) ? NodeSelectedColor : geogBGColor;

				if (IsMovementAvailableNode) System.Console.BackgroundColor = NodeAvailableForMoveColor;

				MoveCursor(BASEGEOGWIDTH);

				System.Console.ResetColor();

				return;

			}

			if (!tile.ConsoleRenderHelper.IsRiver)

			{

				var geogBGColor = LandBGColor;

				System.Console.BackgroundColor = (IsCurrentNode) ? NodeSelectedColor : geogBGColor;

				if (IsMovementAvailableNode) System.Console.BackgroundColor = NodeAvailableForMoveColor;

				MoveCursor(BASEGEOGWIDTH);

				System.Console.ResetColor();

				return;

			}

		}



		private void DrawLine()
		{
			System.Console.Write("________________________________________________________");
		}



#endregion



	}

}