flex 聯機游戲開發 - 四國軍棋游戲:(三) 核心類

通過前面的練習 flex 聯機游戲開發 - 四國軍棋游戲:(二)棋盤棋子我們已經成功地用不到200行的代碼繪制出了一個漂亮的棋盤，現在，我們開始進入游戲的核心類設計階段。四國軍棋的游戲邏輯還是比較復雜的，棋子在布局，游戲階段有不同的可移動位置，棋子的位置也有自己的可移動位置，工并可以到處飛，還有鐵道等，當然，設計者通過不同的渠道都可以達到相同的設計目標，主要看你設計的目標及對性能的要求。在開始設計之前，我先來說說flex的壞話

一）利用flex設計的利與弊

1.1）壞處

1）flex暫時還很難在沒有fms支持的情況下實現雙工通訊，這與silverlight成熟的雙工通訊機制比還是有點不足，當然，也并不全是壞事，在下棋的時候加上聊天，雙工通訊的開銷也是挺嚇人的。在沒有雙工通訊的基礎上，我們只能通過定時期不斷的獲得服務器端的數據進行更新

2) flex暫時還沒有比較完善的集合類，它僅提供了一個arraycollection及xmlcollection類供開發者使用，我們不得不使用一些第三方或自己開發的集合類來完善功能，比如hashmap,這總是應該有的一個集合類吧。當然，作為一個plug in ，adobe也是挺痛苦的，類庫太大方便了開發者，就苦了消費者。當年的java swing 直接將 java applet 送入了死亡通道,前車之鑒嘛，我估計最終仍舊是消費者戰勝開發者。

3）圖形繪制中沒有drawsting的功能，而且就算將來有，對中文字體的支持估計也夠嗆，所以，你只能自己寫一個類似于label的uid類或者直接用label類來顯示中文文本。這無疑增大系統的開銷。

1.2）好處

1）良好的ui設計，通過flex繪制出來的圖形本身已經比較漂亮，當你加入一些簡單的組件的效果，濾鏡時就更漂亮了，而所有這些，開銷并不算太大。在講究用戶體驗的今天，這些還是相當誘人的。

這是設計的一個全局位置圖。僅在棋盤中綁定一些label,label加上一些效果就行了，幾行代碼。 sg3_1

2）flex簡單易學，我從java,c#轉頭來做這個游戲似乎只看了一本書，書名叫“flex 4-一學就會”，所以，如果你是一位java,c#程序員，不要有太多的顧慮。另外，flex類似于silverlight的綁定機制，事件冒泡模式使設計開發變得更有想象力（當然，想象力太好也可能把事情越弄越復雜）s

3）所有好處好象最終只圍繞這個好處，那就是 flash player擁有全世界無人能敵的98%的裝機量，而且，直接延伸到android,iphone。還有什么比這更讓一個游戲開發者羨慕。。。

好了，聊完了上面的這些內容，讓我們來干些實事

二）全局設計考慮

1）你可以從任何一個方向來開始這個程序，對老練的程序員來算，只要你有頭腦，似乎并不需要太多的經驗，但是你首先得確定方向，本程序里，我開發的首先是一個聯機，然后才是游戲，對于聯機游戲，有必引入adobe的一種設計模式 cairngoarm,似乎可以將事情變得簡單一點。

2）作為聯機游戲，你得時時考慮服務器的開銷，在本程序里，服務器需要什么，他只需要一個數組標識三個內容（位置,玩家,棋子),算起來一共只要6個字節，加上129個位置，最多也不超過1k的傳輸內容，真是令人驚訝。沒開發的時候，我以為要傳輸的內容很多吶。所以，我決定從自頂向下的開發這個游戲。就是先設計與服務器交互的內容 GameEngine，然后再回頭來設計每個類。

3）需要設計什么類，首先是位置需要有個類 PositionVO,然后棋子應該是最主要的類QizhiVO,位置應該是棋子的成員，為什么棋子不是位置的成員？（原因：（有沒有沒有位置的棋子？當然沒有；有沒有沒有棋子的位置？當然有），還要設計一個玩家的類，玩家在一張桌子上有一個位置，我們就按順時針方向設計為（0，1，2，3）吧。這也是棋子的成員。似乎就沒什么要考慮了的吧。

好了，現在我們來做四國軍棋游戲的邏輯部分，一些輕松的工作，設計自己的第一個類，常量助輔類 Enum,類里的元素相信你一看就明白;

package com.boyiju.game.siguo.util
{
	/**
	 * 四國軍模可能用到的常量值 
	 * @author Administrator
	 * 
	 */	
	public class Enum
	{
		//棋局狀態
		public static const GAME_LAYOUT:int=0;//布局
		public static const GAME_WAIT:int=1;//完成布局，等待棋它玩家
		public static const GAME_PLAYING:int=2;//游戲中
		public static const GAME_END:int=3;//游戲結束
		
		//玩家顏色
		public static const COLOR_PLAYER_BOTTOM:int=0X34699d;//下
		public static const COLOR_PLAYER_RIGHT:int=0Xd86c00;//右
		public static const COLOR_PLAYER_TOP:int=0X8f449f;//上
		public static const COLOR_PLAYER_LEFT:int=0X709c00;//左
		
		//棋子
		public static const QIZHI_SINING:int=40;//司令
		public static const QIZHI_JUNZHANG:int=39;
		public static const QIZHI_SHIZHANG:int=38;
		public static const QIZHI_LVZHANG:int=37;
		public static const QIZHI_TUANZHANG:int=36;
		public static const QIZHI_YINGZHANG:int=35;
		public static const QIZHI_LIANGZHANG:int=34;
		public static const QIZHI_PAIZHANG:int=33;
		public static const QIZHI_GONGBING:int=32;
		public static const QIZHI_DILEI:int=31;
		public static const QIZHI_JUQI:int=30; //最小為軍棋，誰都可以吃
		public static const QIZHI_ZHADAN:int=100;
		
		
		//可視
		public static const QIZHI_STATE_NONE:int=-1;//不可見
		public static const QIZHI_STATE_SELF:int=0; //自己可見
		public static const QIZHI_STATE_TEAM:int=1;//隊友可見
		public static const QIZHI_STATE_ALL:int=2;//全部可見
		
		//位置類型		
		public static const POSITION_NORAML:int=0;
		public static const POSITION_YING:int=1; //行營
		public static const POSITION_DABENYING:int=2; //大本營
		
		//布局移動
		public static const LAYOUT_MOVE_ALL:int=0;
		public static const LAYOUT_MOVE_LAST_TWO:int=1;//地雷只能在后兩排
		public static const LAYOUT_MOVE_NOT_FRONT:int=2;//炸彈不能在前排鐵道上
		public static const LAYOUT_MOVE_JUNQI:int=3;//軍棋只能在大本營內
		
		
		
	}
}

三，核心類設計

3.1 Position類

棋盤由4個layout與一個centerarea組成，每個layout有30個位置，包括25個棋子位置與5個行營位置，centerarea包括9個行棋位置，棋盤共129個位置。位置的標識如上圖所示，當用戶進入棋局時，他的布局的索引就是（30*玩家位置+具體位置）。這個邏輯就相當清楚了。

下面看類的具體內容，我將解釋直接寫到了類內部。

package com.boyiju.game.siguo.vo
{

	import com.boyiju.game.siguo.util.Enum;
	
	import mx.collections.ArrayCollection;
	/**
	 * 位置類，每個棋盤共129個位置，每個位置有不同的可移動目標，類型，編號等 
	 * 每個位置將對應一個棋子類
	 */	
	[Bindable]
	public class PositionVO
	{
		/**
		 *常量：可以直接移動的位置的集合，共30個 
		 */		
		public static const MOVE_ONE_STEP:Array=[new Array(1,6,7),new Array(0,2,7),new Array(1,3,7,8,9),new Array(2,4,9),new Array(3,5,9,10),new Array(4,11),new Array(0,12,7),new Array(0,1,2,6,8,12,13,14),new Array(2,7,9,14),new Array(2,3,4,8,10,14,15,16),new Array(4,9,11,16),null,new Array(6,7,13,18,19),new Array(7,12,14,19),new Array(7,8,9,13,15,19,20,21),new Array(9,14,16,21),new Array(9,10,15,17,21,22),new Array(11,16,23),new Array(12,19,24),new Array(12,13,14,18,20,24,25,26),new Array(14,19,21,26),new Array(14,15,16,20,22,26,27,28),new Array(16,21,23,28),null,new Array(18,19,25),new Array(19,24,26),new Array(19,20,21,25,27),new Array(21,26,28),new Array(21,22,27,29),new Array(23,28)];
		
		/**
		 *常量：鐵道線上的位置集合，橫7條，豎七條，外加拐彎的4條，共18條 
		 */		
		public static const MOVE_RAIL:Array=[new Array(118,112,106,100,94),new Array(114,108,102,96,90),new Array(4,3,2,1,0,122,121,120,84,85,86,87,88),new Array(12,125,124,123,72),new Array(28,27,26,25,24,128,127,126,60,61,62,63,64),new Array(30,36,42,48,54),new Array(34,40,46,52,58),new Array(28,22,16,10,4),new Array(24,18,12,6,0),new Array(34,33,32,31,30,128,125,122,114,115,116,117,118),new Array(42,127,124,121,102),new Array(2,7,9,14),new Array(58,57,56,55,54,126,123,120,90,91,92,93,94),new Array(4,9,11,16),new Array(60,66,72,78,84),new Array(64,70,76,82,88)];

		
		private var _index:int=-1;
		/**
		 *棋子位置的類型 如營或大本營 
		 */		
		public var type:int;
		
		/**
		 *棋子繪制的開始位置 
		 */		
		public var startX:int;
		public var startY:int;
		
		
		/**
		 *可移動位置的索引 
		 */		
		public var moveAC:ArrayCollection=new ArrayCollection();
		public var moveRailAC:ArrayCollection=new ArrayCollection();
		
		public function get index():int
		{
			return _index;
		}
		/**
		 *位置的索引，作為一個聯機游戲，用戶在桌子上的位置就是索引的，在進入游戲時，索引已經固定(0-129)。 
		 * 通過索引可以得到可以移動的全部目標子位，棋子的類型，布局的位置索引(0-30)
		 * @param value
		 * 
		 */
		public function set index(value:int):void
		{
			_index = value;
			var layoutindex:int = value%30;
			if (_index<120)
			{
				startX=Math.floor(layoutindex/6)*37.5+5;
				startY=Math.floor(layoutindex%6)*30+10;	
			}
			else
			{
				startX=Math.floor(layoutindex/3)*75+7.5;
				startY=Math.floor(layoutindex%3)*75+7.5;	
			}
			type=getType(layoutindex);
			initMoveAC(layoutindex);
			initMoveRoad(index);
		}
		/**
		 *可以直接移動的子位，不需要判斷中間是否有間隔 
		 * @param layoutindex
		 * 
		 */		
		private function initMoveAC(layoutindex:int):void
		{
			moveAC.removeAll();
			var tempAC:ArrayCollection=new ArrayCollection(MOVE_ONE_STEP[layoutindex]);
			moveAC.addAll(tempAC);
			var basecount:int=_index-layoutindex;
			if (moveAC.length>0)
			{
				for (var i2:int=0;i2<moveAC.length;i2++)
				{
					moveAC[i2]=moveAC[i2]+basecount;
				}
			}
			
		}
		/**
		 *鐵道線上的位置索引，如果該子包括在線路中，則將鐵路放到索引中。 
		 * @param index
		 * 
		 */		
		private function initMoveRoad(index:int):void{
			moveRailAC.removeAll();
			for (var i:int=0;i<MOVE_RAIL.length;i++)
			{
				if (MOVE_RAIL[i].indexOf(index)>=0)
				{
					var tempAC:ArrayCollection=new ArrayCollection(MOVE_RAIL[i]);
					if (tempAC.contains(_index))
					{
						moveRailAC.addItem(tempAC);
					}
				}
			}
		}
		/**
		 *獲得當前位置的類型，如棋，大本營，行營等。
		 * @param layoutindex
		 * @return 
		 * 
		 */
		private function getType(layoutindex:int):int{
			var type:int;
			if (layoutindex==7||layoutindex==9||layoutindex==14||layoutindex==19||layoutindex==21)
			{
				type=Enum.POSITION_YING;
			}
			else if (layoutindex==11||layoutindex==23)
			{
				type=Enum.POSITION_DABENYING;
			}
			else
			{
				type=Enum.POSITION_NORAML;
			}
			return type;
		}

	}
}

3.2 QizhiVO類

棋子是棋局的基本組成部分，在布局階段，我們會為用戶在除行營外的位置上放置一些默認的棋子作為初始值，一共25個，也就是說，一個棋局只可能有100個棋子，并且會慢慢減小。現在，我們就來描述具體的棋子類。棋子的核實屬性，也就是與服務器進行交互的只有3個，位置，值，與玩家，擴展顯示的有一些，如名稱，背景，位置的起始值等。棋子的方法包括與其它棋子比較大小，移動到目標位置，與目標位置的棋子碰撞等。現在，我們圍繞這個設計棋子類。

package com.boyiju.game.siguo.vo
{
	import asds.map.HashMap;
	
	import com.boyiju.game.siguo.components.Qizhi;
	import com.boyiju.game.siguo.util.Enum;
	
	import mx.collections.ArrayCollection;
	
	/**
	 *棋子類，每個棋子核心數值僅包括棋子的值，棋子的位置，棋子是否顯示與棋子的玩家，
	 * 其它的輔助值主要用于交互與顯示，將通過核心值獲得并可進行綁定顯示 
	 */	
	[Bindable]
	public class QizhiVO
	{
		private var _value:int=-1;
		private var _deskpos:int=-1;			
		private var _display:int=-1;
	
		public var positionVO:PositionVO;
		public var name:String;
		public var bgColor:int;
		public var layoutMoveType:int;
		
		
		public function get display():int
		{
			return _display;
		}
		
		public function set display(value:int):void
		{
			_display = value;
		}
		
		public function get deskpos():int
		{
			return _deskpos;
		}
		
		
		public function set deskpos(value:int):void
		{
			_deskpos = value;
			this.bgColor=getColor(value);
		}
		
		public function get value():int
		{
			return _value;
		}
		
		public function set value(value:int):void
		{
			_value = value;
			this.name=getQizhiName(value);
			this.layoutMoveType=getLayoutMoveType(value);
		}

		private function isTeam(deskpos:int):Boolean
		{
			var teamdeskpos:int=(this.deskpos+2)%4;
			return deskpos==teamdeskpos;
		}
		/**
		 *獲得棋子的顯示名稱，與棋子的顯示類進行綁定 
		 * @param value
		 * @return 
		 * 
		 */		
		private function getQizhiName(value:int):String{
			if (value==40) return "司令";
			if (value==39) return "軍長";
			if (value==38) return "師長";
			if (value==37) return "旅長";
			if (value==36) return "團長";
			if (value==35) return "營長";
			if (value==34) return "連長";
			if (value==33) return "排長";
			if (value==32) return "工兵";
			if (value==31) return "地雷";
			if (value==30) return "軍棋";
			if (value==100) return "炸彈";
			return "";
		}
		/**
		 *棋子的顏色，通過棋子的玩家獲得 
		 * @param player
		 * 玩家
		 * @return 
		 * 顏色值
		 * 
		 */		
		private function getColor(player:int):int{
			if (player==0) return Enum.COLOR_PLAYER_BOTTOM;
			else if(player==1) return Enum.COLOR_PLAYER_RIGHT;
			else if (player==2) return Enum.COLOR_PLAYER_TOP;
			else if (player==3) return Enum.COLOR_PLAYER_LEFT;
			return 0x000000;
		}
		/**
		 * 棋子本身在布局階段的移動限制 
		 * @param value 棋子的值
		 * @return 
		 * 
		 */		
		private function getLayoutMoveType(value:int):int{
			
			if (value==Enum.QIZHI_GONGBING) return Enum.LAYOUT_MOVE_LAST_TWO;
			if (value==Enum.QIZHI_ZHADAN) return Enum.LAYOUT_MOVE_NOT_FRONT;
			if (value==Enum.QIZHI_DILEI) return Enum.LAYOUT_MOVE_JUNQI;
			return Enum.LAYOUT_MOVE_ALL;
		}
		
		/**
		 * 與目標棋子比較大小 
		 * @param target
		 * @return 
		 * 
		 */		
		public function Compare(target:QizhiVO):int
		{
			if (this.value==Enum.QIZHI_ZHADAN||target.value==Enum.QIZHI_ZHADAN||this.value==target.value) 
			{
				trace("很壯烈，您的 "+this.name+" 與敵人的 "+target.name+" 同歸于盡");
				return 0;
			}
			if (target.value==Enum.QIZHI_DILEI&&this.value!=Enum.QIZHI_GONGBING||this.value<target.value)
			{
				trace("很悲劇，您的 "+this.name+" 被敵人的 "+target.name+" 吃掉了");
				
				return -1;
			}
			if (this.value>target.value) 
			{
				trace("很爽，您的 "+this.name+" 吃掉了敵人的 "+target.name);
				return 1;
			}
			return 1;
		}
		
		/**
		 *布局階段與目標棋子交換 
		 * @param target
		 * 
		 */		
		public function exchange(target:QizhiVO):void
		{
			if (target==null) return;
			if (target.value==-1) return;
			if (target.deskpos!=this.deskpos) return;
			
			//軍棋只能放大本營
			if (this.layoutMoveType==Enum.LAYOUT_MOVE_JUNQI)
			{
				if (target.positionVO.index==11)
				{
					
				}else if (target.positionVO.index==23)
				{
					
				}
				else
					return;
			}
			if (target.layoutMoveType==Enum.LAYOUT_MOVE_JUNQI)
			{
				if (this.positionVO.index==11)
				{
					
				}else if (this.positionVO.index==23)
				{
					
				}
				else
					return;
			}
			//地雷只能放在后兩排
			if (this.layoutMoveType==Enum.LAYOUT_MOVE_LAST_TWO)
			{
				if (target.positionVO.index%6<4) return;
			}
			if (target.layoutMoveType==Enum.LAYOUT_MOVE_LAST_TWO)
			{
				if (this.positionVO.index%6<4) return;
			}
			//炸彈不能放在第一排三個位置
			if (this.layoutMoveType==Enum.LAYOUT_MOVE_NOT_FRONT)
			{
				if (target.positionVO.index==0||target.positionVO.index==12||target.positionVO.index==24) return;
			}
			if (target.layoutMoveType==Enum.LAYOUT_MOVE_NOT_FRONT)
			{
				if (this.positionVO.index==0||this.positionVO.index==12||this.positionVO.index==24) return;
			}
			var temp:int=target.value;
			target.value=this.value;
			this.value=temp;
		}
		
		/**
		 * 可否移動到目標位置，主要包括棋子的可移動性，棋子的移動目標值，目標位置的內容等。
		 * @param targetPos
		 * @param qizhiMap
		 * @return 
		 * 
		 */		
		public function canMoveTo(targetPos:PositionVO,qizhiMap:HashMap):Boolean{
			
			//位置無法移動
			if (this.positionVO.moveAC.length==0||this.value==Enum.QIZHI_DILEI||this.value==Enum.QIZHI_JUQI) 
			{
				trace("該位置無法移動:"+this.positionVO.index);
				return false;
			}
			//目標位置不在可移動區內
			if (!this.positionVO.moveAC.contains(targetPos.index)) 
			{
				if (this.positionVO.moveRailAC.length==0){
					trace(targetPos.index+" 不在該位置的可移動路徑內:"+this.positionVO.index);
					return false;
					
				}
				for each (var railAC:ArrayCollection in this.positionVO.moveRailAC)
				{
						
						var targetindex:int=railAC.getItemIndex(targetPos.index);
						//目標棋子不在鐵路中
						if (targetindex==-1) continue;
						//目標棋子在鐵路中.再找原始棋子的位置
						var sourceindex:int=railAC.getItemIndex(this.positionVO.index);
						//從原始棋子到目標棋子的通路中沒有其它子
						
						if (sourceindex>targetindex)
						{
							for(var i:int=targetindex+1;i<sourceindex;i++)
							{
								//到達目標區的通路有其它的棋子
								var qizhiVO:QizhiVO=qizhiMap.get(railAC.getItemAt(i)) as QizhiVO;
								if (qizhiVO.value!=-1)
								{
									trace("路徑不通:"+qizhiVO.positionVO.index+" 有子 "+qizhiVO.name);					return false;
								}
								trace("經過:"+qizhiVO.positionVO.index);
								
								
							}
							
						}
						else
						{
							for(var j:int=sourceindex+1;j<targetindex;j++)
							{
								//到達目標區的通路有其它的棋子
								var qizhiVO2:QizhiVO=qizhiMap.get(railAC.getItemAt(j)) as QizhiVO;
								if (qizhiVO2.value!=-1)
								{
									trace("路徑不通:"+qizhiVO2.positionVO.index+" 有子 "+qizhiVO2.name);
									return false;
								}
								trace("經過:"+qizhiVO2.positionVO.index);
								
							}
							
						}
						trace(this.name+" 從 "+this.positionVO.index+ " 移動至:"+targetPos.index);
						return true;
						
				}
					
			}
			
			trace(this.name+" 從 "+this.positionVO.index+ " 移動至:"+targetPos.index);
			return true;
			
		}
		
		/**
		 * 與目標棋子碰撞 
		 * @param target
		 * @return 
		 * 
		 */		
		public function eat(target:QizhiVO,qizhiMap:HashMap):int{
			//不能吃自己的子
			if (target==null)
			{
				return -6;
			}
			if (target.value==-1)
			{
				trace( "目標位置無棋子");
				return -5;
			}
			if (target.deskpos==this.deskpos)
			{
				trace( "不能吃自己的子");
				
				return -4;
			}
			//不能吃隊友的子
			if (isTeam(target.deskpos))
			{
				trace( "位于"+target.positionVO.index+" 的棋子是您的隊友的 "+target.name);
				
				return -3;
			}
			if (!canMoveTo(target.positionVO,qizhiMap))
			{
				return -2;
			}
			//比較大小
			return this.Compare(target);
			
		}
		
	}
}

3.3 GameEngine 游戲控制類

游戲控制類用于對游戲進行調試，設計為一個全局類，包括了游戲進行必需的一些內容，如桌主，等待時間，游戲狀態，游戲棋子集合，當前玩家，當前布局，當前選中棋子等內容。充分利用flex的綁定機制，將顯示部分與控制部分結合。

 package com.boyiju.game.siguo.model
{

	import asds.map.HashMap;
	
	import com.adobe.cairngorm.model.IModelLocator;
	import com.boyiju.game.siguo.components.LayoutSelect;
	import com.boyiju.game.siguo.components.Qizhi;
	import com.boyiju.game.siguo.util.Enum;
	import com.boyiju.game.siguo.vo.LayoutVO;
	import com.boyiju.game.siguo.vo.PositionVO;
	import com.boyiju.game.siguo.vo.QizhiVO;
	import com.boyiju.game.siguo.vo.UserVO;
	
	import mx.collections.ArrayCollection;
	import mx.core.FlexGlobals;
	
	/**
	 *四國軍棋游戲的全局控制類，使用了cairngoarm類設計
	 */	
	
	[Bindable]
	public class GameEngine implements IModelLocator
	{
		private static var _model:GameEngine;
			
		
		
		public var gameOwner:int;//游戲桌主
				
		public var gameWaitTime:int=30;//等待時間 秒		
		
		public var gameStatus:int;//游戲狀態
		
		
		public var currentPlayer:UserVO;//當前玩家
		public var currentTurn:int;//當前回合玩家
		public var currentSelectedQZ:Qizhi; //選中的棋子
		
		
		public var sourceQZ:Qizhi;	 //源棋子，用于棋子之間產鮮紅用
		
		
		public var layoutAC:ArrayCollection;//布局文件組合
		public var currentLayout:LayoutVO;//當前布局文件
		
		public var playerAC:HashMap; //玩家組合
		
		
		public var qizhiMap:HashMap; //所有棋子有組合，與服務器交互的主要類
		
		
		
		/**
		 *初始化四國軍棋棋局 
		 * @param enforcer
		 * 
		 */		
		public function GameEngine(enforcer:SingletonEnforcer) {	
			
			gameStatus=Enum.GAME_LAYOUT;
			
			layoutAC=new ArrayCollection();
			layoutAC.addItem(new LayoutVO("守型",LayoutSelect.LAYOUT_COOL,"偏防守"));
			layoutAC.addItem(new LayoutVO("攻型",LayoutSelect.LAYOUT_HOT,"偏進攻"));
			layoutAC.addItem(new LayoutVO("基本",LayoutSelect.LAYOUT_NORMAL,"攻守平衡"));
			currentLayout=layoutAC.getItemAt(0) as LayoutVO;
			
			qizhiMap=new HashMap();
			playerAC =new HashMap();
			
			createAndInitUser();
			currentPlayer=playerAC.get(0) as UserVO;
		}
		/**
		 *將布局文件添加到全局布局列表中 
		 * @param layout
		 * 
		 */		
		public function addLayout(layout:LayoutVO,deskpos:int):void{
			
			for (var i:int=0;i<layout.lyAC.length;i++)
			{
				if (layout.lyAC[i]!=-1)
				{
					var positionVO:PositionVO=new PositionVO();
					positionVO.index=30*deskpos+i;
					var qizhiVO:QizhiVO=new QizhiVO();
					qizhiVO.value=(layout.lyAC[i]);
					qizhiVO.deskpos=deskpos;
					qizhiVO.positionVO=positionVO;
					qizhiMap.put(qizhiVO.positionVO.index,qizhiVO);
				}
			}
		}
		
		public static function get intance():GameEngine
		{
			if (_model ==null) {
				_model=new GameEngine(new SingletonEnforcer());
			}
			return _model;
		}
		/**
		 *測試用，加入一些用戶 
		 * 
		 */		
		private function createAndInitUser():void {
			var user:UserVO=new UserVO();
			user.name="張柏枝";
			user.picture="assets/images/zbz.jpg";
			user.score=0;
			user.win=0;
			user.lost=0;
			user.points=2100;
			user.deskpos=0;
			playerAC.put(user.deskpos,user);
			user=new UserVO();
			user.name="王菲";
			user.picture="assets/images/wf.jpg";
			user.score=0;
			user.win=0;
			user.lost=0;
			user.points=500;
			user.deskpos=1;
			playerAC.put(user.deskpos,user);
			user=new UserVO();
			user.name="林志玲";
			user.picture="assets/images/lzl.jpg";
			user.score=0;
			user.win=0;
			user.lost=0;
			user.points=2250;
			user.deskpos=2;
			playerAC.put(user.deskpos,user);
			user=new UserVO();
			user.name="阿嬌";
			user.picture="assets/images/aj.jpg";
			user.score=0;
			user.win=0;
			user.lost=0;
			user.points=350;
			user.deskpos=3;
			playerAC.put(user.deskpos,user);
		}
		/**
		 *獲得下一位玩家， 
		 * @param num
		 * @return 
		 * 
		 */		
		public function getNextUser(num:int):UserVO{
			var nextid:int=(currentPlayer.deskpos+num)%4;
			return playerAC.get(nextid) as UserVO;
		} 
		
	}
	
}
class SingletonEnforcer
{
	
}

3.4 LayoutVO 類 布局文件類

布局文件類是個更簡單的類，他包括一個名稱，目錄，及30個棋子位置的子的集合，

    [Bindable]    
public class LayoutVO    
{        

public var name:String;        
public var lyAC:ArrayCollection;        
public var catalog:String;     
           
public function LayoutVO(name:String,lyAC:Array,catalog:String)        
{           
 this.name=name;            
this.lyAC=new ArrayCollection(lyAC);           
 this.catalog=catalog;        
 }  
}

一個典型的博命型的劃攻布局可以描述如下。夠簡單了吧，看看我們下QQ游戲的布局文件，幾個K,我汗。。

public static const LAYOUT_HOT:Array=[40,39,38,38,37,37,36,-1,100,-1,36,30,35,35,-1,34,34,34,33,-1,33,-1,33,32,32,32,31,31,31,100];

四）下一節可能做的工作

核心部分基本就包括在這四個類內，應該來講夠簡單吧，最終完成的效果如圖

sg3_2s

下一節我來設計顯示的部分及游戲進行中的邏輯部分，顯示的部分就是把控件拉來拉去，加上綁定機制。你會覺得更簡單的：），同時，下節打算做出第一個測試版本swf文件供大家測試一下。

posted @ 2010-12-31 14:22 博弈居閱讀(1908) 評論(0) 收藏舉報

刷新頁面返回頂部

博弈居

新浪微博:http://weibo.com/rainfuling

flex 聯機游戲開發 - 四國軍棋游戲:(三) 核心類

公告