flex麻将和牌源代码

最简单的和牌方式 AA AAA AAA AAA AAA

思路，找出14张牌中是否有一对，有的话，查看其他剩余的能否组合成4*3（4对）

 判断和牌类

 0-9万

 10-19条

 20-29 饼

 30-37 风（7个）

可以这样测试

var all:Array=new Array(0,1,2,2,3,4,14,14,18,19,20,27,27,27);

WithCard.checkWith(all);//初始化
    
    Alert.show(WithCard.isSuccess()+"::::");//是否和了

package cn.isvi.util
{
	import com.carlcalderon.arthropod.Debug;
	
	import flash.geom.Point;
	
	import mx.collections.ArrayCollection;
	
	public class SerachSame
	{
		public var sameArray:Array=[];//相同的对的数组
		private var arr:Array;//被搜索的数组
		private var temp:Array=[];//临时数组
		public function SerachSame()
		{
		}
		
		public function filerSame(){
			Debug.log("arr.length"+arr.length,Debug.GREEN);
			for(var i:int;i<arr.length;i++){
				//类似map
				if(temp[i]==undefined){
					//throw new Error;
					temp[i]=[];
					temp[i]={index:i,num:0,data:arr[i],previous:arr[i],preIndex:i};//data当前值，previous上一个值
				}else{
					var nums:int=temp[i].num+1;
					var previous:Point=temp[i].previous;
					var preIndex:int=temp[i].preIndex;//上一个值的索引下标
					
					//if(!(nums>=3)){
						throw new Error;
						temp[i]={index:i,num:nums,data:arr[i],previous:previous,preIndex:preIndex};
						com.carlcalderon.arthropod.Debug.log("samess"+arr[i],Debug.GREEN);
				//	}
					
				}
			}
		}
		public function filterSameData(){
			for(var i:int=0;i<arr.length;i++){
				for(var j:int=0;j<arr.length-i-1;j++){
				
					if(arr[j].y==arr[j+1].y){
						var tem=arr[j];
						arr[j]=arr[j+1];
						arr[j+1]=tem;
						Debug.log("same number is"+arr[j].y);
						Debug.log("index::"+j);
						//throw new Error;
						//throw new Error;
						sameArray[i]={index:j+1,num:0,data:arr[i],previous:arr[i],preIndex:j}
					}
				}
			}
		
		}
		
		public function get getSameArray():Array{
			
			this.filterSameData();//过滤不相同
			Debug.log("templength"+temp.length);
			for(var i:int=0;i<temp.length;i++){
				if(temp[i].num==2){
					sameArray.push(temp[i]);
				}
			}
			Debug.log(sameArray.length+"same dui",Debug.BLUE);
			return this.sameArray;
		}
		
	
		public function set arrs(arr:Array):void{
			this.arr=new ArrayCollection(arr).toArray();
		}

	}
}

 

package cn.isvi.util
{
	import cn.isvi.errors.SuccessErrors;
	
	import com.carlcalderon.arthropod.Debug;
	
	import flash.geom.*;
	
	import mx.collections.ArrayCollection;
	import mx.controls.Alert;
	import mx.utils.*;
	public class WithCard
	{
		private static var mah:Array=[];//34张麻将
		public static const SINGLECOUNT=9;//通过除以9跟求于得到指定的麻将
		
		static var wan:Array=[];
		static var tiao:Array=[];
		static var bing:Array=[];
		static var feng:Array=[];
		static var all:Array=new Array(4);//保存 wan bing tiao feng的数组
		static var fourCount:int=0;//AAA有几对
		public function WithCard()
		{
		}
		//查看是否和牌
		//先找 AA 一对，有的话，找剩余的是否能匹配4个 AAA AAA AAA
		public static function checkWith(gameData:Array):Boolean{
			//先把其中的万 饼 条，风分成四组
				var dui:int=0;//对的个数
				//这改了一下
                              wan=[];
				tiao=[];
				bing=[];
				feng=[];
				
				for(var j:int=0;j<gameData.length;j++){
					var point:Point=getAppoint(gameData[j]);
					initEveryArray(point);
					Debug.log(j);
				}
//				all[0]=wan;
//				all[1]=bing;
//				all[2]=tiao;
//				all[3]=feng;
				//依次便利万条饼feng中是否有对,有对的话，查看剩余的12张牌，能否匹配成 3*4
			return false;
		}
		public static function isSuccess():Boolean{
			var success:Boolean=false;
			try{
				checkIsDouble(0,wan);
				Debug.log("wan length"+wan.length,Debug.YELLOW);
				Debug.log("wan",Debug.RED);
				checkIsDouble(1,tiao);
				
				Debug.log("tiao length"+tiao.length,Debug.RED);
				checkIsDouble(2,bing);
				
				
				checkIsDouble(3,feng);
			}catch(err:SuccessErrors){
				success=true;
				Alert.show("和了");
			}
			return success;
		}
		
		public static function checkIsDouble(current:int,arrs:Array):Boolean
		{
			if(arrs==null){
				return false;
			}
			var arr:Array=getNewArray(arrs);
			
			arr.sortOn("y",Array.NUMERIC);
			//冒泡排序式的比较
			var serch:SerachSame=new SerachSame;
			serch.arrs=arr;
			var filterArray:Array=serch.getSameArray;
			out:for(var i:int;i<filterArray.length;i++)
			{
				var arrs:Array=getNewArray(arr);
				var pre:int=filterArray[i].preIndex;
				var now:int=filterArray[i].index;
				arrs.splice(pre,2);
				//arrs.splice(now,1);
				Debug.log("otherIndex"+pre+"_________"+now);
				Debug.log("other"+arrs.toString());
				
				Debug.log("check othr++++++++++++"+checkOtherArray(arrs));
				if(!checkOtherArray(arrs)){ //剩余的牌，除3的余数是否等于0，说明不能组合
//					throw new Error;
					if(i==filterArray.length-1){
						break out;
					}else{
						continue out;
					}
				}else{
//					throw new Error;
					if(checkLeverArray(current)){
						throw new SuccessErrors("糊了");
					} 
				}
				
			
			}
						
					
							
				return false;
			
		}
		//检查剩余的3个数组，是否有匹配的项  
		//current 0 wan
		//current 1 
		public static function checkLeverArray(current:int):Boolean{
			switch(current){
				case 0: return check(tiao)==check(bing)&&check(bing)==check(feng);break;
				case 1: return check(wan)==check(bing)&&check(bing)==check(feng);break;
				case 2: return check(wan)==check(tiao)&&check(tiao)==check(feng);break;
				case 3: return check(wan)==check(tiao)&&check(tiao)==check(bing);break;
			
			}	
			return false;
		}
		
		public static function check(arr:Array):Boolean{
			return checkOtherArray(arr);
		}
		
		public static function checkOtherArray(arr:Array):Boolean{
			var arrs:Array=new ArrayCollection(arr).toArray();
				
			if(arrs.length==0){
			
				return true;
			}
			if(arrs.length%3!=0){
				return false;
			}else{
				arrs.sortOn("y",Array.NUMERIC);//先排序
				
					switch(arrs.length){
						case 3: return checkIsAGroup(arrs);break;
						case 6: return checkIsTwoGroup(arrs);break;
						case 9: return checkIsThreeGroup(arrs);break;
						case 12: return checkIsFourGroup(arrs); break;
					}
				
			}
			return false;
		}
		//3查看这3个中是否有
		public static function checkIsAGroup(arrs:Array):Boolean{
			
			if(arrs[0].y==arrs[1].y&&arrs[1].y==arrs[2].y){
				return true;
			}else if(arrs[0].y+1==arrs[1].y&&arrs[1].y+1==arrs[2].y){
				return true;
			}else{
				//throw new Error;
				return false;
				
			}
		}
		//检查是否是两组
		public static function checkIsTwoGroup(arrs:Array):Boolean{
			//先猜想最简单的情况，想象就是 123 456这种方式
//			Debug.array(arrs.toString());
			//mx.controls.Alert.show(arrs.toString());
			if(checkIsAGroup(arrs)&&checkAroundMatch(arrs)){
				
					return true;
			
			}else{ //123 234(排序后是122334)013,245
			
					// 或者123 123(排序后是112233)024,135
					//122223
					//或者是 111222(排序后是121212)
					
				return checkNumberTwoThing(arrs);
			}
			return false;
			
		}
		//检查是否两组---第2中情况
		public static function checkNumberTwoThing(arrs:Array):Boolean{
			if(checkIsGroupUserIndex(0,1,3,arrs)&&checkIsGroupUserIndex(2,4,5,arrs)){
				return true;
			}else if(checkIsGroupUserIndex(0,2,4,arrs)&&checkIsGroupUserIndex(1,3,5,arrs)){
				return true;
			}else if(checkIndex(0,2,4,arrs)&&checkIndex(1,3,5,arrs)){
				return true;
			}else{
				return false;
			}
		}
		//检查是否是3组
		//错误想法：排序后肯定前3为是111或者123，要不是说明就不能组合成3组，因为还可能是下边说的情况1 情况2
		public static function checkIsThreeGroup(arrs:Array):Boolean{
			Debug.log("shengyu"+arrs.length);
			if(checkIsAGroup(arrs)){
				arrs.splice(0,3);//删除前3个
				return checkIsTwoGroup(arrs);
			 //判断是否 开头是不是AAA
			}else if(arrs[0].y==arrs[1].y){
				 var newArr:Array=getNewArray(arrs);
//				//如果是 AA开头，有可能是123123456或者是123123123(111,222,333)
				if(!checkThreeFirstThing(newArr[0].y,newArr)){
					//还有种情况是123123 456或者是123 123 234（排序后是112223334）反正2和3可定都有2个
					
					//情况1.112223334
					//情况2.112233345；
					//情况3. 11222233//这样不可能组成3组，排除
					//根据上边3组情况得出 假如能排成3组 2可定是数组下标2，数组下标5一定有个3
					//所以check 125是否是一组，然后查看剩余的是否是2组
					/***
					 * A
					 * 
					 * 这可能还有问题
					 * 
					 * */
					var six:Array=new Array(arrs[1],arrs[3],arrs[4],arrs[6],arrs[7],arrs[8]);
					var three:Array=new Array(arrs[0],arrs[2],arrs[5]);
					
					if(checkIsAGroup(three)&&checkIsTwoGroup(six)){
						return true;
					}
				}else{
					return true;
				}
			 //判断开头是否是123 abc
			}else if(arrs[0].y+1==arrs[1].y){
				var newArr:Array=getNewArray(arrs);
				if(!checkThreeFirstThing(newArr[1].y+1,newArr)){
					return false;
				}else{
					return true;
				}
			}else{
				return false;
			}
			return false;
			
		}
		//checkIsThreeGroup的第一种情况
		public static function checkThreeFirstThing(y:int,arrs:Array):Boolean{
			arrs.splice(0,2);//删除前2个元素，查看剩余的值，是否是2组
			var index:int=serachSpecify(y,arrs);//找到指定值的索引值
			if(index!=-1){
				Debug.log("index"+index);
				arrs.splice(index,1);
				Debug.log(arrs.toString(),Debug.BLUE);
				var bo:Boolean=checkIsTwoGroup(arrs);
			//	throw new Error;
				return bo;
				//throw new Error(arrs.toString()+"shengxiade shushi ");
			}else{
				return false;
			}
		}
		//如果是12张牌的话，查看是否是4组
		public static function checkIsFourGroup(arrs:Array):Boolean{
			//throw new Error;
			return checkIsFour(arrs);
		}
		
		public static function checkIsFour(arrs:Array):Boolean{
			//一样先开始看是否是 111 或者 123开头,然后判断剩余的9张牌
			Debug.log(arrs.toString()+"12");
			var nes:Array=getNewArray(arrs);
			nes.splice(0,3);
			if(checkIsAGroup(arrs)){
				//不能checkIsAGroup&&checkIsThreeGroup，否则else可能不对
				return checkIsThreeGroup(nes);
				
			}else{ //否则前两位是 11 ，肯定是相同的
				//剩下就是（123，123，234，234）112 222 333 344的那种方式（极端方式）
				
				var threeIndex:int=serachSpecify(arrs[2].y+1,arrs);//记得是.y
				
				var three:Array=new Array(arrs[0],arrs[2],arrs[threeIndex]);
				var newArray:Array=getNewArray(arrs);
				newArray.splice(threeIndex,1);
				newArray.splice(2,1);
				newArray.splice(0,1);
//				Alert.show("数组下标是"+threeIndex);
//				Alert.show("剩余的牌是"+newArray.toString());
				return checkIsAGroup(three)&&checkIsThreeGroup(newArray);
			}
			return false;
		}
		
		
		public static function filerDouble(in1:int,in2:int,arr:Array){
			
		}
		//初始化每个数组
		public static function initEveryArray(index:Point):void{
			switch(index.x){
						case 0:wan.push(index);Debug.log("ddddd")break;
						case 1:tiao.push(index);break;
						case 2:bing.push(index);break;
						case 3:feng.push(index);break;
			}
		}
		public static function initWan(index:Point):void{
			wan.push(index);
			
		}
		
		//通过数组下标得到指定的麻将是那个，属于什么万还是饼
		
		public static function getAppoint(mahIndex:int):Point{
			var index:int=mahIndex/SINGLECOUNT;
			var yu:int=mahIndex%SINGLECOUNT;
			return new Point(index,yu);
		}
		public static function checkAroundMatch(arr:Array):Boolean{
			if(arr[3].y+1==arr[4].y&&arr[4].y+1==arr[5].y){
//				fourCount+=2;
				return true;
			}else if(arr[3].y==arr[4].y&&arr[4].y==arr[5].y){
//				throw new Error;
				return true;
			}else{	
				// Debug.log(arr[3].y+":"+arr[4].y+":"+arr[5].y)
				 return false;
			}
		
		 }
		 //检查3个数是否连续的
		 public static function checkIsGroupUserIndex(x:int,y:int,z:int,arrs:Array):Boolean{
		 	if(arrs[x].y+1==arrs[y].y&&arrs[y].y+1==arrs[z].y){
		 		return true;
		 	}
		 	return false;
		 }
		 //检查3个数是否相同
		 public static function checkIsGroupSameIndex(x:int,y:int,z:int,arrs:Array):Boolean{
		 	if(arrs[x].y==arrs[y].y==arrs[z].y){
		 		return true;
		 	}
		 	return false;
		 }
		 public static function checkIndex(x:int,y:int,z:int,arrs:Array):Boolean{
		 	if(checkIsGroupUserIndex(x,y,z,arrs)||checkIsGroupSameIndex(x,y,z,arrs)){
		 		Debug.log("buxiangdeng");
		 		return true;
		 	}
		 	return false;
		 }
		 
		 public static function getPointY(i:int,arr:Array){
		 	return arr[i].y;
		 }
		 //查看指定的值在数组中的索引
		 public static function serachSpecify(y:int,arrs:Array):int{
		 	//去掉数组中前两位
//		 	Alert.show("现在的数组顺序是否排序"+arrs.toString());
		 	for(var i:int=0;i<arrs.length;i++){
		 		if(arrs[i].y==y){
		 			return i;
		 		}
		 	}
		 	return -1;
		 }
		 public static function getNewArray(arrs:Array):Array{
		 	return new ArrayCollection(arrs).toArray();
		 }
		 
	}
}

 

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" xmlns:single="cn.isvi.single.*"
	 creationComplete="init()">
	 <mx:VBox>
	 	
	
	<mx:Canvas height="100">
		<mx:HBox id="hb">
			
		</mx:HBox>
	</mx:Canvas>
	<mx:Script>
		<![CDATA[
			import cn.isvi.util.WithCard;
			import mx.controls.Alert;
			import cn.isvi.util.MahSprite;
			import mx.core.UIComponent;
			import flash.system.Security;
			private var dataArray:Array
			
			public function init():void{
				Security.allowDomain("*")
				this.dataArray=single.getDataArray;
				for(var i:int;i<dataArray.length-1;i++){
					for(var j:int=0;j<9;j++){
						var ui:UIComponent=new UIComponent;
						var sp:MahSprite=new MahSprite;
						sp.index=j;
						sp.bitmap=new Bitmap(dataArray[i][j]);
						sp.mahIndex=j+i*9;
						
						ui.x=i*j*30;
						ui.width=30;
						ui.height=50;
						sp.addChild(sp.bitmap);
						ui.addChild(sp);
						
						
						sp.addEventListener(MouseEvent.CLICK,onClick);
						hb.addChild(ui);
					}
				}
				for(var z:int=0;z<7;z++){
					
					var ui1:UIComponent=new UIComponent;
						var sps:MahSprite=new MahSprite;
						sps.index=z;
						
						sps.bitmap=new Bitmap(dataArray[3][z]);
						
						sps.mahIndex=z+3*9;
						
						ui1.x=3*z*30;
						
						ui1.width=30;
						ui1.height=50;
						
						sps.addChild(sps.bitmap);
						ui1.addChild(sps);
						
						
						sps.addEventListener(MouseEvent.CLICK,onClick);
						hb.addChild(ui1);
				}
			}
			private var checkArray:Array=[]
			private function onClick(e:MouseEvent){
				//mx.controls.Alert.show("click");
				var ui:UIComponent=new UIComponent;
				ui.width=30;
				var mahs:MahSprite=(e.target as MahSprite).clone();
				mahs.addChild(new Bitmap(mahs.bitmap.bitmapData));
				ui.addChild(mahs);
				vm.addChild(ui);
				mahs.addEventListener(MouseEvent.CLICK,onClickCheck);
				checkArray.push(mahs.mahIndex);
				
			}
			private function onClickCheck(e:MouseEvent){
					
			}
			import flash.utils.getTimer;
			private function isWith(){
				if(checkArray.length==14){
					cn.isvi.util.WithCard.checkWith(checkArray);
					checkArray.sortOn(Array.NUMERIC);
					Alert.show(checkArray.toString());
					var ti:Number=getTimer();
					if(WithCard.isSuccess()){
						
						mx.controls.Alert.show("糊了 哈哈用时"+(getTimer()-ti));
					}else{
						Alert.show("对不起，不能和");
					}
				}else{
					Alert.show("麻将个数不对");
				}
			}
			private function reset(){
				checkArray=[];
				vm.removeAllChildren();
			}
		]]>
	</mx:Script>
	<mx:Canvas height="100">
		<mx:HBox id="vm">
			
		</mx:HBox>
	</mx:Canvas>
		<mx:Button click="isWith()" label="是否和了">
			
		</mx:Button>
		<mx:Button click="reset()" label="重来">
			
		</mx:Button>
		<mx:LinkButton icon="@Embed('images/mah/1.png')">
			
		</mx:LinkButton>
	 </mx:VBox>
	<single:SingleMahJong id="single">
		
	</single:SingleMahJong>
</mx:Application>

 

评论

2 楼 fykyx521 2013-06-04  

ynduck 写道

如何来运行呢？

bu haoysi   wangji le

1 楼 ynduck 2013-06-03  

如何来运行呢？