layout.cs

classic tsp analysis method with c++ !

using System;
using System.Collections;

namespace HRD.Core
{
	public class Layout
	{
		private Mediator _mediator;
		private Chessman[] _chessmen = new Chessman[10];
		private Chessman[] sortedChessmen  = new Chessman[12];
		private bool _finished = false;
		private bool _gotTheAnswer = false;
		private int _current = 0, chessmanNum = 0;

		private BlankPosition _blankPosition;

		//===========================================================
		// 根据当前棋盘布局获取下一步可走的方案
		//===========================================================
		public void CheckAvailableSteps()
		{
			chessmanNum = 0;
			CallBackDelegate _callback = new CallBackDelegate(EncapsulateChessStep);

			for(_current = 0; _current<12; _current++)
			{
				if((sortedChessmen[_current].chessmanType != ChessmanType.Blank))
				{ 
					if(sortedChessmen[_current].chessmanType != ChessmanType.General)
						chessmanNum++;

					sortedChessmen[_current].CheckAvailableSteps(_blankPosition, _callback);
				}
			}
		}

		//===========================================================
		// 初始化棋盘布局数组
		//===========================================================
		public void InitLayoutMap()
		{
			int j;

			for(int i = 0; i<10; i++)
			{
				QuickSortArray.list[i].index = i;
				QuickSortArray.list[i].value = chessmen[i].position.y*10 + chessmen[i].position.x;
			}

			QuickSortArray.list[10].index = 10;
			QuickSortArray.list[10].value = blankPosition.Pos1.y*10 + blankPosition.Pos1.x;
			QuickSortArray.list[11].index = 11;
			QuickSortArray.list[11].value = blankPosition.Pos2.y*10 + blankPosition.Pos2.x;

			QuickSortArray.quickSort();

			for(int i=0; i<12; i++)
			{
				j = QuickSortArray.list[i].index;
				
				if(j < 10)
					sortedChessmen[i] = chessmen[j];
				else if(j == 11)
					sortedChessmen[i] = new BlankChessman(blankPosition.Pos2);
				else
					sortedChessmen[i] = new BlankChessman(blankPosition.Pos1);
			}
		}

		//===========================================================
		// 将当前棋局转换为一整数
		//===========================================================
		public int ToInt()
		{
			int result = 0;
			int a = 0;

			// 生成整数
			for(int i=0; i<12; i++)
			{
				if(sortedChessmen[i].chessmanType != ChessmanType.General)
				{
					result = result << 2;
					result += (int)(sortedChessmen[i].chessmanType);
				}
				else
				{
					a = i + 1;
					if(sortedChessmen[i].position.y == 3 && sortedChessmen[i].position.x == 1)
						this._finished = true;
				}
			}
			a = a<<22;
			result += a;

			return result;
		}

		//===========================================================
		// 获取移动棋子后，棋盘的布局
		//===========================================================
		private void EncapsulateChessStep(Position newPosition, BlankPosition newBlankPosition, MoveMethod mm)
		{
			if( _gotTheAnswer )
				return;

			Layout l = _mediator.AllocateLayout();
			
			// 生成新布局
			for(int i = 0; i<10; i++)
			{
				if(this.chessmen[i] == this.sortedChessmen[_current])
				{
					l.chessmen[i].position = newPosition;
					l.blankPosition = newBlankPosition;
				}
				else
				{
					l.chessmen[i].position = this.chessmen[i].position;
				}
			}

			l.InitLayoutMap();

			ChessStep cs = new ChessStep();
			cs.layout = l.ToInt();
			cs.moveMethod = mm;

			if(sortedChessmen[_current].chessmanType == ChessmanType.General)
				cs.chessmanNum = 99;
			else
				cs.chessmanNum = (short)chessmanNum;

			// 将封装好的ChessStep发送给mediator作进一步处理
			if(l.IsFinished)
			{
				_gotTheAnswer = true;
				_mediator.Finished(cs);
			}
			else
				_mediator.CheckStep(cs);
		}		

		#region Property Method

		public bool IsFinished
		{
			get
			{
				return _finished;
			}
		}

		public Chessman[] chessmen 
		{
			get 
			{
				return _chessmen;
			}
			set 
			{
				_chessmen = value;
			}
		}

		public BlankPosition blankPosition 
		{
			get 
			{
				return _blankPosition;
			}
			set 
			{
				_blankPosition = value;
			}
		}

		public Mediator mediator 
		{
			set 
			{
				_mediator = value;
			}
		}

		#endregion
	}
}