游戏类.ef

E语言飞扬版源码已修复了部分错误,需安装易语言飞扬才能运行.

引入 工具,用户界面;

公开 类 游戏类
{
	整数[] 坐标数组;
	逻辑 选中=假;//是否有球被选中
	整数 选中行,选中列;//记录被选中的行列坐标
	整数 编号1,编号2,编号3;//下三个球的编号
	逻辑 结束=假;//游戏是否结束
	逻辑 是否出球=假;

	公开 整数[] 初始化游戏(整数[] 格子数组)
	{
		数学运算.置随机数种子();
		坐标数组=格子数组;
		取随机编号();
		//计次循环(1)//测试用
		坐标数组=随机出球(坐标数组);
		选中=假;结束=假;
		选中行=0;选中列=0;
		是否出球=假;
		返回(坐标数组);
	}

	公开 整数[] 随机出球(整数[] 格子数组)
	{
		坐标数组=格子数组;
		出球(编号1);
		出球(编号2);
		出球(编号3);
		取随机编号();
		返回(坐标数组);
	}

	出球(整数 编号)//不能出球,表示游戏结束
	{
		整数 行,列,i,n;
		计次循环(100,i)
		{
			如果(坐标数组[i]==0) n++;//统计无球的格子数
		}
		如果(n>19)//数组自带19个空格子,大于19表示有空格子
		{
			(行,列)=取随机位置();
			坐标数组[行][列]=编号;
		}
		如果(n-1==19) 结束=真;
	}

	整数,整数 取随机位置()
	{
		整数 行,列;
		开始
		{
			行=数学运算.取随机数()%9+1;
			列=数学运算.取随机数()%9+1;
		}循环(坐标数组[行][列]!=0);
		返回(行,列);
	}

	公开 整数,整数,整数 取编号()
	{
		返回(编号1,编号2,编号3);
	}
	取随机编号()
	{
		编号1=数学运算.取随机数()%(6)+1;
		编号2=数学运算.取随机数()%(6)+1;
		编号3=数学运算.取随机数()%(6)+1;
	}

	公开 逻辑 是否结束()
	{
		返回(结束);
	}

	公开 整数,整数,整数 取选中值()
	{
		返回(选中行,选中列,坐标数组[选中行][选中列]);
	}

	公开 逻辑 取出球值()
	{
		返回(是否出球);
	}

	//游戏运行过程：
	//1格子有球:选中处理-->选中=真-->返回(ok)
	//2格子无球:1选中==假-->返回(ok)
	//			2选中==真-->1能否移动==假-->返回(ok)
	//			2选中==真-->2能否移动==真-->移动处理-->1能否消球==假----------------------->随机出球处理-->1能否消球==假->返回
	//			2选中==真-->2能否移动==真-->移动处理-->2能否消球==真-->消分处理------------------------------------------>返回
	公开 整数[],坐标点[],坐标点[],整数,整数 运行游戏(整数[] 格子数组,整数 行,整数 列)
	{
		坐标数组=格子数组;
		坐标点 访问点=创建 坐标点();
		访问点.置横纵坐标(行,列);
		坐标点[] 路径表=创建 坐标点[0];
		坐标点[] 消球表=创建 坐标点[0];
		路径表=(坐标点[])路径表.插入(0,访问点);
		整数 移动值,消球值;
		是否出球=假;
		{//格子有球
			如果(坐标数组[行][列]!=0)
			{
				//选中处理:记录选中行列,给选中格画标记,选中=真,返回
				选中行=行;选中列=列;
				选中=真;
			}
		}
		{//格子无球
			如果(坐标数组[行][列]==0)
			{
				如果(选中==真)//==假时直接返回
				{
					//能否移动？？？
					坐标点[] 遍历父表=创建 坐标点[0];//记录父点行列坐标
					坐标点[] 遍历子表=创建 坐标点[0];//记录父点行列坐标
					(遍历父表,遍历子表)=取遍历表();//取得选中球的遍历表
					逻辑 能否移动=是否重复访问点(遍历子表,访问点);//能移动返回真
					如果(能否移动==真)//==假时直接返回
					{
						//移动处理
						移动值=坐标数组[选中行][选中列];
						路径表=取移动路径(遍历父表,遍历子表,访问点);
						坐标数组[访问点.横坐标()][访问点.纵坐标()]=坐标数组[选中行][选中列];
						坐标数组[选中行][选中列]=0;
						选中行=0;选中列=0;
						选中=假;
						//能否消球？？？
						(消球表,消球值)=取消球坐标();//取得可以消的球的坐标表
						如果(消球表.长度()>=5)//>=5时表示有可消球
						{
							//消球处理
							整数 x;
							计次循环(消球表.长度(),x)
							{
								坐标数组[消球表[x].横坐标()][消球表[x].纵坐标()]=0;
							}
							是否出球=假;
						}
						否则 是否出球=真;//随机出球条件满足:不能消球时,随机出球
					}
				}
			}
		}
		返回(坐标数组,路径表,消球表,移动值,消球值);
	}

	公开 坐标点[],整数 取消球坐标()
	{
		整数 m,n,x,消球值=0;
		坐标点[] 消球数组=创建 坐标点[0];
		计次循环(9,m)
			计次循环(9,n)
		{
			消球值=坐标数组[m+1][n+1];
			如果(是否有相同色球(m+1,n+1,1))//[-]向判断
			{
				坐标点 坐标=创建 坐标点();
				坐标.置横纵坐标(m+1,n+1);
				消球数组=(坐标点[])消球数组.添加(坐标);
				计次循环(9-(n+1),x)
				{
					如果(坐标数组[m+1][n+1]==坐标数组[m+1][n+1+x+1])
					{
						坐标点 坐标=创建 坐标点();
						坐标.置横纵坐标(m+1,n+1+x+1);
						消球数组=(坐标点[])消球数组.添加(坐标);
					}
					否则 返回(消球数组,消球值);
				}
				返回(消球数组,消球值);
			}
			如果(是否有相同色球(m+1,n+1,2))//[\]向判断
			{
				坐标点 坐标=创建 坐标点();
				坐标.置横纵坐标(m+1,n+1);
				消球数组=(坐标点[])消球数组.添加(坐标);
				如果(m+1-(n+1)<0)//不同于其他方式的操作，可实际画图理解
				{
					计次循环(9-(n+1),x)
					{
						如果(坐标数组[m+1][n+1]==坐标数组[m+1+(x+1)][n+1+(x+1)])
						{
							坐标点 坐标=创建 坐标点();
							坐标.置横纵坐标(m+1+(x+1),n+1+(x+1));
							消球数组=(坐标点[])消球数组.添加(坐标);
						}
						否则 返回(消球数组,消球值);
					}
				}
				否则
				{
					计次循环(9-(m+1),x)
					{
						如果(坐标数组[m+1][n+1]==坐标数组[m+1+(x+1)][n+1+(x+1)])
						{
							坐标点 坐标=创建 坐标点();
							坐标.置横纵坐标(m+1+(x+1),n+1+(x+1));
							消球数组=(坐标点[])消球数组.添加(坐标);
						}
						否则 返回(消球数组,消球值);
					}
				}
				返回(消球数组,消球值);
			}
			如果(是否有相同色球(m+1,n+1,3))//[|]向判断
			{
				坐标点 坐标=创建 坐标点();
				坐标.置横纵坐标(m+1,n+1);
				消球数组=(坐标点[])消球数组.添加(坐标);
				计次循环(9-(m+1),x)
				{
					如果(坐标数组[m+1][n+1]==坐标数组[m+1+x+1][n+1])
					{
						坐标点 坐标=创建 坐标点();
						坐标.置横纵坐标(m+1+x+1,n+1);
						消球数组=(坐标点[])消球数组.添加(坐标);
					}
					否则 返回(消球数组,消球值);
				}
				返回(消球数组,消球值);
			}
			如果(是否有相同色球(m+1,n+1,4))//[/]向判断
			{
				坐标点 坐标=创建 坐标点();
				坐标.置横纵坐标(m+1,n+1);
				消球数组=(坐标点[])消球数组.添加(坐标);
				如果(m+1+n+1<10)//不同于其他方式的操作，可实际画图理解
				{
					计次循环((n+1)-1,x)
					{
						如果(坐标数组[m+1][n+1]==坐标数组[m+1+(x+1)][n+1-(x+1)])
						{
							坐标点 坐标=创建 坐标点();
							坐标.置横纵坐标(m+1+(x+1),n+1-(x+1));
							消球数组=(坐标点[])消球数组.添加(坐标);
						}
						否则 返回(消球数组,消球值);
					}
				}
				否则
				{
					计次循环(9-(m+1),x)
					{
						如果(坐标数组[m+1][n+1]==坐标数组[m+1+(x+1)][n+1-(x+1)])
						{
							坐标点 坐标=创建 坐标点();
							坐标.置横纵坐标(m+1+(x+1),n+1-(x+1));
							消球数组=(坐标点[])消球数组.添加(坐标);
						}
						否则 返回(消球数组,消球值);
					}
				}
				返回(消球数组,消球值);
			}
		}
		返回(消球数组,消球值);
	}
	逻辑 是否有相同色球(整数 行,整数 列,整数 方向)//判断当前球的有效范围,-向\向|向/向,四个方向
	{
		逻辑 值=假;
		假如(方向)//因从行1列1进行每个单元格判断，所以只用判断4个方向即可
		{
		为 1://[-]向判断
			{
				如果(列+4<=9 && 坐标数组[行][列]!=0 && 坐标数组[行][列]==坐标数组[行][列+1]==坐标数组[行][列+2] && 坐标数组[行][列+2]==坐标数组[行][列+3]==坐标数组[行][列+4]) 值=真;
			}
			为 2://[\]向判断
				{
					如果(行+4<=9 && 列+4<=9 && 坐标数组[行][列]!=0 && 坐标数组[行][列]==坐标数组[行+1][列+1]==坐标数组[行+2][列+2] && 坐标数组[行+2][列+2]==坐标数组[行+3][列+3]==坐标数组[行+4][列+4]) 值=真;
				}
				为 3://[|]向判断
					{
						如果(行+4<=9 && 坐标数组[行][列]!=0 && 坐标数组[行][列]==坐标数组[行+1][列]==坐标数组[行+2][列] && 坐标数组[行+2][列]==坐标数组[行+3][列]==坐标数组[行+4][列]) 值=真;
					}
					为 4://[/]向判断
						{
							如果(行+4<=9 && 列-4>=1 && 坐标数组[行][列]!=0 && 坐标数组[行][列]==坐标数组[行+1][列-1]==坐标数组[行+2][列-2] && 坐标数组[行+2][列-2]==坐标数组[行+3][列-3]==坐标数组[行+4][列-4]) 值=真;
						}
		}
		//如果(值) 界面程序.信息框("ok");//测试用,发现可以消球时提醒
		返回(值);
	}
	坐标点[] 取移动路径(坐标点[] 遍历父表,坐标点[] 遍历子表,坐标点 访问点)
	{
		整数 指针;
		坐标点[] 路径表=创建 坐标点[0];
		开始
		{
			指针=取指针(遍历子表,访问点);
			路径表=(坐标点[])路径表.插入(0,遍历子表[指针]);
			访问点=遍历父表[指针];
		}循环(访问点.横坐标()!=-1 && 访问点.纵坐标()!=-1);
		返回(路径表);
	}
	整数 取指针(坐标点[] 遍历表,坐标点 访问点)//指针==成员在数组中的位置
	{
		整数 指针,x;
		计次循环(遍历表.长度(),x)
		{
			如果(遍历表[x].横坐标()==访问点.横坐标() && 遍历表[x].纵坐标()==访问点.纵坐标)
			{
				指针=x;跳出();
			}
		}
		返回(指针);
	}
	坐标点[],坐标点[] 取遍历表()
	{
		整数 表指针=0;
		坐标点[] 遍历父表=创建 坐标点[0];//记录父点行列坐标
		坐标点[] 遍历子表=创建 坐标点[0];//记录父点行列坐标
		坐标点 父点=创建 坐标点();坐标点 访问点=创建 坐标点();//横纵==行列
		父点.置横纵坐标(-1,-1);访问点.置横纵坐标(选中行,选中列);
		遍历父表=(坐标点[])遍历父表.添加(父点);遍历子表=(坐标点[])遍历子表.添加(访问点);
		//取子[表指针]的未访问点X.加入遍历表中(X!==遍历子表中已访问点)
		//表指针++,至到表指针==数组.长度()结束遍历
		开始
		{
			(遍历父表,遍历子表)=取已访问点(遍历父表,遍历子表,表指针);
			表指针++;
		}循环(表指针<遍历子表.长度());
		//遍历表到遍历数组(遍历子表);//测试用,可显示所有可达到单元格
		返回(遍历父表,遍历子表);
	}

	坐标点[],坐标点[] 取已访问点(坐标点[] 遍历父表,坐标点[] 遍历子表,整数 表指针)
	{
		整数 行=遍历子表[表指针].横坐标(),列=遍历子表[表指针].纵坐标();
		如果(行<9 && 坐标数组[行+1][列]==0)
		{
			坐标点 访问点1=创建 坐标点();
			访问点1.置横纵坐标(行+1,列);
			如果(是否重复访问点(遍历子表,访问点1)==假)
			{
				遍历父表=(坐标点[])遍历父表.添加(遍历子表[表指针]);遍历子表=(坐标点[])遍历子表.添加(访问点1);
			}
		}
		如果(行>1 && 坐标数组[行-1][列]==0)
		{
			坐标点 访问点2=创建 坐标点();
			访问点2.置横纵坐标(行-1,列);
			如果(是否重复访问点(遍历子表,访问点2)==假)
			{
				遍历父表=(坐标点[])遍历父表.添加(遍历子表[表指针]);遍历子表=(坐标点[])遍历子表.添加(访问点2);
			}
		}
		如果(列<9 && 坐标数组[行][列+1]==0)
		{
			坐标点 访问点3=创建 坐标点();
			访问点3.置横纵坐标(行,列+1);
			如果(是否重复访问点(遍历子表,访问点3)==假)
			{
				遍历父表=(坐标点[])遍历父表.添加(遍历子表[表指针]);遍历子表=(坐标点[])遍历子表.添加(访问点3);
			}
		}
		如果(列>1 && 坐标数组[行][列-1]==0)
		{
			坐标点 访问点4=创建 坐标点();
			访问点4.置横纵坐标(行,列-1);
			如果(是否重复访问点(遍历子表,访问点4)==假)
			{
				遍历父表=(坐标点[])遍历父表.添加(遍历子表[表指针]);遍历子表=(坐标点[])遍历子表.添加(访问点4);
			}
		}
		返回(遍历父表,遍历子表);
	}
	逻辑 是否重复访问点(坐标点[] 遍历子表,坐标点 访问点)//重复返回真,示重复返回假
	{
		逻辑 值=假;
		整数 x;
		计次循环(遍历子表.长度(),x)
		{
			如果(遍历子表[x].横坐标()==访问点.横坐标() && 遍历子表[x].纵坐标()==访问点.纵坐标)
			{
				值=真;返回(值);
			}
		}
		返回(值);
	}
}