一、24点游戏玩法规则效果展示

1、初始化界面

2、开始游戏界面

3、游戏超时界面

4、查看答案界面

5、答对界面

6、答错界面

7、计算表达式的验证界面

8、一副牌算完开始新一副牌界面

到这里24点算法基本操作图就结束了,下面来看看示例代码吧。

二、完整代码演示

关于代码解释,为了方便读者浏览时更好理解代码的含义,我把注释都写在代码里面了。因为一开始我只考虑到功能上的实现并没有考虑代码的优化所以代码我就全写在一个页面了。至于那些生成扑克牌类、计算类等代码优化方面的内容就留给想要实现这个24点算法游戏的读者自己去完善吧。

 using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms; namespace XF_24Point
{
public partial class frnMain : Form
{
private int A, B, C, D;//牌面大小对应的数字大小也用于交换数字的位置
private int NumberA, NumberB, NumberC, NumberD;//牌面大小对应的数字大小
private int topCard;//显示在窗体四张牌中扑克牌的编号(1-52)
DateTime beginTime;//记录开始时间 #region 一副牌的生成
//结构: 值得一提的是,在C++中,struct的功能得到了强化,struct不仅可以添加成员变量,还可以添加成员函数,和class类似。
struct card
{
public int face;//牌面大小,数字大小
public int suit;//牌面花色,如梅花、黑桃、红心、方块,只能有四张
public int count;//牌面点数,牌面上的的图案点数
public bool faceup;//牌面是否向上
}
private card[] PlayingCards;//一副牌 //生成一副牌
private void GetPlayingCareds()
{
PlayingCards = new card[];
int i;//牌面大小
int j;//牌面花色
for (i = ; i < ; i++)
{
for (j = ; j <= ; j++)
{
PlayingCards[j + i * ].face = i + ;//PlayingCards[j + i * 4]:指的是:j + i * 4 =>获取文件图片扑克牌的序号
PlayingCards[j + i * ].suit = j;//牌面花色,如梅花、黑桃、红心、方块,只能有四张
if (i < )
{
PlayingCards[j + i * ].count = i + ;//牌面点数,牌面上的的图案点数
}
else
{
PlayingCards[j + i * ].count = ;
}
PlayingCards[j + i * ].faceup = false;
}
}
}
//洗牌 :Shuffle
private void Shuffle()
{
Random random = new Random((int)DateTime.Now.Ticks);
card middleCard;//作为临时交换牌顺序的变量
int j, k;
for (int i = ; i < ; i++)
{
j = (int)random.Next(, );
k = (int)random.Next(, );
//打乱牌的顺序(随机交换牌的顺序)
middleCard = PlayingCards[j];
PlayingCards[j] = PlayingCards[k];
PlayingCards[k] = middleCard;
}
}
//开始游戏的时候发四张牌
private void btnStart_Click(object sender, EventArgs e)
{
lblInput.Text = "";
GetPlayingCareds();//生成一副牌
Shuffle();//洗牌
topCard = ;//显示在窗体四张牌中扑克牌的编号(1-52)
int imageNum;//文件夹中扑克牌图片的编号(文件名)
string path;
//画第一张牌
topCard = topCard = ;
pictureBox1.Visible = true;
//获得文件中某张牌并且知道是什么花色对应的编号计算公式:
//牌面花色(1、2、3、4):要获得某张牌的的花色
//(牌面数字大小-1)*4:要获得的某张牌的前一个牌面大小如:要获得的牌是10,前一个牌面就是9
//牌面花色(1、2、3、4)+(牌面数字大小-1)*4
imageNum = PlayingCards[topCard].suit + (PlayingCards[topCard].face - ) * ;//文件图片编号
path = Directory.GetCurrentDirectory() + @"\images\" + imageNum.ToString() + ".bmp";
pictureBox1.Image = Image.FromFile(path);
NumberA = Convert.ToInt32(PlayingCards[topCard].face);//牌面大小对应的数字大小
btnNumber1.Text = NumberA.ToString();
//画第二张牌
topCard = topCard + ;
pictureBox2.Visible = true;
imageNum = PlayingCards[topCard].suit + (PlayingCards[topCard].face - ) * ;
path = Directory.GetCurrentDirectory() + @"\images\" + imageNum.ToString() + ".bmp";
pictureBox2.Image = Image.FromFile(path);
NumberB = Convert.ToInt32(PlayingCards[topCard].face);
btnNumber2.Text = NumberB.ToString();
//画第三张牌
topCard = topCard + ;
pictureBox3.Visible = true;
imageNum = PlayingCards[topCard].suit + (PlayingCards[topCard].face - ) * ;
path = Directory.GetCurrentDirectory() + @"\images\" + imageNum.ToString() + ".bmp";
pictureBox3.Image = Image.FromFile(path);
NumberC = Convert.ToInt32(PlayingCards[topCard].face);
btnNumber3.Text = NumberC.ToString();
//画第四张牌
topCard = topCard + ;
pictureBox4.Visible = true;
imageNum = PlayingCards[topCard].suit + (PlayingCards[topCard].face - ) * ;
path = Directory.GetCurrentDirectory() + @"\images\" + imageNum.ToString() + ".bmp";
pictureBox4.Image = Image.FromFile(path);
NumberD = Convert.ToInt32(PlayingCards[topCard].face);
btnNumber4.Text = NumberD.ToString();
//初始化界面控件
btnStart.Visible = false;//开始游戏
groupBox1.Visible = true;//计算表达式
groupBox2.Visible = true;//查看答案
groupBox3.Visible = true;//游戏规则
lblShowTime.Visible = true;//显示时间
timer1.Enabled = true;//启用时钟
beginTime = DateTime.Now;
}
#endregion public frnMain()
{
InitializeComponent();
Initialize();//初始化窗体上的控件的方法
} //初始化窗体上的控件的方法,一开始隐藏
private void Initialize()
{
pictureBox1.Visible = false;
pictureBox2.Visible = false;
pictureBox3.Visible = false;
pictureBox4.Visible = false;
groupBox1.Visible = false;
groupBox2.Visible = false;
groupBox3.Visible = false;
lblResult.Visible = false;
lblShowTime.Visible = false;
} #region 计算表达式的输入
//第一张牌
private void btnNumber1_Click(object sender, EventArgs e)
{
lblInput.Text = lblInput.Text + btnNumber1.Text.Trim();
}
//第二张牌
private void btnNumber2_Click(object sender, EventArgs e)
{
lblInput.Text = lblInput.Text + btnNumber2.Text.Trim();
}
//第三张牌
private void btnNumber3_Click(object sender, EventArgs e)
{
lblInput.Text = lblInput.Text + btnNumber3.Text.Trim();
}
//第四章牌
private void btnNumber4_Click(object sender, EventArgs e)
{
lblInput.Text = lblInput.Text + btnNumber4.Text.Trim();
}
//加号
private void btnAdd_Click(object sender, EventArgs e)
{
lblInput.Text = lblInput.Text + btnAdd.Text.Trim();
}
//减号
private void btnMinus_Click(object sender, EventArgs e)
{
lblInput.Text = lblInput.Text + btnMinus.Text.Trim();
}
//乘号
private void btnMulti_Click(object sender, EventArgs e)
{
lblInput.Text = lblInput.Text + btnMulti.Text.Trim();
}
//除号
private void btnDivide_Click(object sender, EventArgs e)
{
lblInput.Text = lblInput.Text + btnDivide.Text.Trim();
}
//左括号
private void btnLeft_Click(object sender, EventArgs e)
{
lblInput.Text = lblInput.Text + btnLeft.Text.Trim();
}
//右括号
private void btnRight_Click(object sender, EventArgs e)
{
lblInput.Text = lblInput.Text + btnRight.Text.Trim();
}
//删除最后一个字符
private void btnDelete_Click(object sender, EventArgs e)
{
string input = lblInput.Text.Trim();
lblInput.Text = input.Substring(, input.Length - );
}
//清除所有字符
private void btnClear_Click(object sender, EventArgs e)
{
lblInput.Text = "";
} #endregion //确定按钮
private void btnEnter_Click(object sender, EventArgs e)
{
if (lblInput.Text.Trim()== "")
{
MessageBox.Show("计算表达式不能为空!");
return;
}
if (CheckForNumber(lblInput.Text.Trim()))//检查输入表达式中输入的数字是否匹配
{
//计算表达式的结果第一层
int result = Deal(lblInput.Text.Trim());//调用Deal()处理方法,对用户输入的表达式做一系列判断计算,返回最终的结果
lblResult.Visible = true;
if (result == )
{
lblResult.Text = "<<---恭喜您,答对了!--->>";
timer1.Enabled = false;//暂停时钟
}
else
{
lblResult.Text = "<<--抱歉,您的回答有误!-->>";
}
}
} #region 验证确定按钮包含的一系列方法:检查计算用户输入表达式结果是否正确
//处理Deal谓词表达式中的括号
private int Deal(string InputExp)
{
int result = ;
while (InputExp.IndexOf(')') != -)//判断是否存在括号 input.IndexOf(')') !=-1,表明存在括号
{
//3*8÷(9-8)=24、(10+2)*(3-1)=24
int rightLoc = InputExp.IndexOf(')');//右括号的位置
string temp = InputExp.Substring(, rightLoc);//从0(开始位置)到右括号的位置,不包括右括号(10+2
int leftLoc = temp.LastIndexOf('(');//左括号的位置0
string first = InputExp.Substring(, leftLoc);//从0到左括号的位置,空
string middle = InputExp.Substring(leftLoc + , rightLoc - leftLoc - );//括号中间的部分10+2
string last = InputExp.Substring(rightLoc + );//右括号后面的部分*(3-1)
//计算表达式的结果第二层
InputExp = first + Formula(middle) + last; //""+10+2+*(3-1)注意:+表示连接,连接两个字符串
}
//计算表达式的结果第二层
result = Formula(InputExp);//调用用户输入表达式检查、计算方法,返回用户输入表达式的结果Formula:公式
return result;
} //最简式运算 Formula:公式
private int Formula(string InputExp)
{
int length = InputExp.Length;//验证表达式的长度
ArrayList OpeLoc = new ArrayList();//记录运算操作符位置
ArrayList Ope = new ArrayList();//记录运算操作符
ArrayList Value = new ArrayList();//记录数值内容 ,也就是记录输入表达式的数字的值
int i;//全局变量i,运用于方法体内每个循环
for (i = ; i < length; i++)
{
if (IsOperator(InputExp[i]))//检查获判断一个符号是否是基本算符
{
OpeLoc.Add(i);//记录并添加运算操作符位置x
Ope.Add(InputExp[i]);//记录并添加运算操作符
}
}
if (OpeLoc.Count == )
{
return int.Parse(InputExp);//处理无运算符的情况
}
//计算表达式的结果第三层
RebuildOperator(ref OpeLoc, ref Ope);//对运算符进行重新组合,把负号和减号区分开来
if (!CheckFunction(OpeLoc, length))
{
return ;//检查功能,判断运算符组是否合法 ,也就是运算符位置是否正确
}
int j = ;
for (i = ; i < OpeLoc.Count; i++)
{
Value.Add(int.Parse(InputExp.Substring(j, Convert.ToInt32(OpeLoc[i]) - j)));
j = Convert.ToInt32(OpeLoc[i]) + ;//最后一个数值的索引
}
//substring(开始索引,字符长度)
Value.Add(int.Parse(InputExp.Substring(j, length - j)));//处理最后一个数值的添加
//计算表达式的结果第四层
return Calculate(Ope, Value);//调用用户输入表达式的计算方法,参数1:运算符,参数2:数值
} //处理四则混合运算等基础运算(+-*/)
private int Calculate(ArrayList Ope, ArrayList Values)
{
int i;//全局变量i,运用于方法体内每个循环
for (i = ; i < Ope.Count; i++)//处理乘法、除法
{
switch (Convert.ToChar(Ope[i]))
{
case '*':
Values[i] = Convert.ToInt32(Values[i]) * Convert.ToInt32(Values[i + ]);
Values.RemoveAt(i + );
Ope.RemoveAt(i);
i--;
break;
case '/':
Values[i] = Convert.ToInt32(Values[i]) * Convert.ToInt32(Values[i + ]);
Values.RemoveAt(i + );
Ope.RemoveAt(i);
i--;
break;
}
}
for (i = ; i < Ope.Count; i++)//处理加法和减法
{
switch ((char)Ope[i])
{
case '+':
Values[i] = Convert.ToInt32(Values[i]) + Convert.ToInt32(Values[i + ]);
Values.RemoveAt(i + );
Ope.RemoveAt(i);
i--;
break;
case '-':
Values[i] = Convert.ToInt32(Values[i]) - Convert.ToInt32(Values[i + ]); ;
Values.RemoveAt(i + );
Ope.RemoveAt(i);
i--;
break;
}
}
return Convert.ToInt32(Values[].ToString());
} //判断运算符组是否合法
private bool CheckFunction(ArrayList OpeLoc, int length)
{
if (Convert.ToInt32(OpeLoc[]) == )//判断第一个运算符的的索引是否为0,也就是运算符排在表达式第一个
return false;
int i;
for (i = ; i < OpeLoc.Count; i++)
{
if (Convert.ToInt32(OpeLoc[i]) - Convert.ToInt32(OpeLoc[i - ]) == )//检查判断两个运算符是否连续
return false;
}
//判断最后一个运算符的的索引是否等于表达式索引的,也就是该运算符排在表达式末尾
if (Convert.ToInt32(OpeLoc[OpeLoc.Count - ]) == length - )
return false;
return true;
}
//对负号的处理和重构
private void RebuildOperator(ref ArrayList OpeLoc, ref ArrayList Ope)
{
ArrayList DelItem = new ArrayList();
if (Convert.ToInt32(OpeLoc[].ToString()) == && Convert.ToChar(Ope[]) == '-')//判断第一个符号是否是负号 ,索引为0的符号
{
DelItem.Add();
}
int i;
for (i = ; i < OpeLoc.Count; i++)
{
//判断是否有相邻的算符且后一个是负号,且后一个运算符-前一个运算符==1
if (Convert.ToChar(Ope[i]) == '-' && Convert.ToChar(Ope[i - ]) != '-' && (Convert.ToInt32(OpeLoc[i]) - Convert.ToInt32(OpeLoc[i - ])) != )
{
DelItem.Add(i);
}
}
for (i = DelItem.Count - ; i > ; i--)//将负号和减号分开处理
{
//移除运算符和所在运算符所在位置
Ope.RemoveAt(Convert.ToInt32(DelItem[i]));
OpeLoc.RemoveAt(Convert.ToInt32(DelItem[i]));
}
}
//判断一个符号是否是基本算符
private bool IsOperator(char c)
{
if (c == '+' || c == '-' || c == '*' || c == '/')
return true;//判断是否是四则混合运算算符
else
return false;
}
//检查输入的计算公式是否有错误,牌是否有重复或则输入有误或输入的牌超过四张
private bool CheckForNumber(string InputExp)//InputExp:用户输入的表达式如:(6*2)*(6/3)
{
bool result = true;
//先找出分隔符,再返回用户输入以这些分隔符分隔的的string类型数字数组
string[] str = InputExp.Split(new char[] { '+', '-', '*', '/', '(', ')' }, StringSplitOptions.RemoveEmptyEntries);
if (str.Length != )
{
MessageBox.Show("抱歉,输入有误!请重新输入");
result = false;
return result;
}
int[] InputNums = new int[];//用户输入计算表达式的数字
int[] CreatNums = { NumberA, NumberB, NumberC, NumberD };//生成的四张牌对应的数字,在生成牌时已经赋值
Array.Sort(CreatNums);//排序:升序
for (int i = ; i < ; i++)
{
InputNums[i] = Convert.ToInt32(str[i]);//用户输入的数字
}
Array.Sort(InputNums);//排序:升序
for (int i = ; i < ; i++)
{
if (InputNums[i] != CreatNums[i])//判断生成的牌对应的数字与用户输入的数字是否一一匹配,如果不匹配则表明牌有重复
{
result = false;
MessageBox.Show("抱歉,每张牌只能使用一次!");
return result;
}
}
return result;
} #endregion //查看答案按钮
private void btnAnswer_Click(object sender, EventArgs e)
{ int index = ;//记录答案个数
#region 点击查看答案按钮,输入按钮禁用,时钟停止,清空答案栏
btnAdd.Enabled = false;
btnMinus.Enabled = false;
btnDivide.Enabled = false;
btnMulti.Enabled = false;
btnNumber1.Enabled = false;
btnNumber2.Enabled = false;
btnNumber3.Enabled = false;
btnNumber4.Enabled = false;
btnDelete.Enabled = false;
btnClear.Enabled = false;
btnLeft.Enabled = false;
btnRight.Enabled = false;
btnEnter.Enabled = false;
timer1.Enabled = false;//停止时钟
txtAnswer.Text = "";//清空答案栏
#endregion
#region 首先:(ABCD位置)24种情况的遍历,然后:计算24点的方法,接着:把字符表达式转为数值表达式
for (int i = ; i <= ; i++)
{
ChangeOfPosition24(i);//24种情况的位置转换的方法
ArrayList first = new ArrayList();//数字集合对象
ArrayList firstStr = new ArrayList();//字符集合对象
first.Add(A.ToString());
firstStr.Add("A");
//此方法的核心思路:本来一开始是有ABCD四张牌,第一次对A、B进行加减乘除,再把得到的结果result返回去,第二次调用对result、C重复第一次操作
//第三次也是重复,不过这次返回去的结果就是计算出来的结果
cal(ref first, ref firstStr, B, 'B');
cal(ref first, ref firstStr, C, 'C');
cal(ref first, ref firstStr, D, 'D'); for (int j = ; j < first.Count; j++)
{
if (Convert.ToInt32(Convert.ToDouble(first[j].ToString())) == )
{
//replaceString参数(字符表达式,'字符',数值),此方法的核心思想是,一个一个字符替换为对应的数值
firstStr[j] = replaceString(firstStr[j].ToString(), 'A', A);
firstStr[j] = replaceString(firstStr[j].ToString(), 'B', B);
firstStr[j] = replaceString(firstStr[j].ToString(), 'C', C);
firstStr[j] = replaceString(firstStr[j].ToString(), 'D', D);
//追加文本答案
txtAnswer.AppendText("答案" + index + ": " + firstStr[j].ToString() + "=24;" + "\r\n");
index++;
}
}
}
if (txtAnswer.Text.Trim() == "")
{
txtAnswer.Text = "此题无解";
}
#endregion
} #region 点击查看答案按钮要做的一系列处理计算
//1、(ABCD)24种情况的位置转换
public void ChangeOfPosition24(int i)
{
//24种位置转换
//此方法的核心思想:要让A/B/C/D四个数两两算一次,如:+加号运算符
//(A+B) (A+C) (A+D) (B+C) (B+D) (C+D)一共有6种情况,以此类推减号也有6种情况,
//加减乘除四种运算符加起来总共就有24种情况
//补充:上面的意思是A在第一个位置有6种情况,同理
//B在第一个位置也有6种情况,C在第一个位置也有6种情况,D在第一个位置也有6种情况
switch (i)
{
case :
A = NumberA; B = NumberB; C = NumberC; D = NumberD;
break;
case :
A = NumberA; B = NumberB; D = NumberC; C = NumberD;
break;
case :
A = NumberA; C = NumberB; B = NumberC; D = NumberD;
break;
case :
A = NumberA; C = NumberB; D = NumberC; B = NumberD;
break;
case :
A = NumberA; D = NumberB; B = NumberC; C = NumberD;
break;
case :
A = NumberA; D = NumberB; C = NumberC; B = NumberD;
break;
case :
B = NumberA; A = NumberB; C = NumberC; D = NumberD;
break;
case :
B = NumberA; A = NumberB; D = NumberC; C = NumberD;
break;
case :
B = NumberA; C = NumberB; A = NumberC; D = NumberD;
break;
case :
B = NumberA; C = NumberB; D = NumberC; A = NumberD;
break;
case :
B = NumberA; D = NumberB; A = NumberC; C = NumberD;
break;
case :
B = NumberA; D = NumberB; C = NumberC; A = NumberD;
break;
case :
C = NumberA; A = NumberB; B = NumberC; D = NumberD;
break;
case :
C = NumberA; A = NumberB; D = NumberC; B = NumberD;
break;
case :
C = NumberA; B = NumberB; A = NumberC; D = NumberD;
break;
case :
C = NumberA; B = NumberB; D = NumberC; A = NumberD;
break;
case :
C = NumberA; D = NumberB; A = NumberC; B = NumberD;
break;
case :
C = NumberA; D = NumberB; B = NumberC; A = NumberD;
break;
case :
D = NumberA; A = NumberB; B = NumberC; C = NumberD;
break;
case :
D = NumberA; A = NumberB; C = NumberC; B = NumberD;
break;
case :
D = NumberA; B = NumberB; A = NumberC; C = NumberD;
break;
case :
D = NumberA; B = NumberB; C = NumberC; A = NumberD;
break;
case :
D = NumberA; C = NumberB; A = NumberC; B = NumberD;
break;
case :
D = NumberA; C = NumberB; B = NumberC; A = NumberD;
break;
}
} //2、24点计算方法(加减乘除)
//注意:ref:传入传出,out:传出
//此方法的核心思路:本来一开始是有ABCD四张牌,第一次对A、B进行加减乘除,再把得到的结果result返回去,第二次调用对result、C重复第一次操作
//第三次也是重复,不过这次返回去的结果就是计算出来的结果
private void cal(ref ArrayList num, ref ArrayList numStr, int num2, char num2Str)//传入参数A=6,"A",B=4,"B"
{
ArrayList newNum = new ArrayList();//数值集合对象
ArrayList newNumStr = new ArrayList();//字符集合对象
int temp;
for (int i = ; i < num.Count; i++)
{
int num1 = Convert.ToInt32(num[i].ToString()); #region 加法的情况
temp = num1 + num2;
newNum.Add(temp.ToString());//数字:6+4
newNumStr.Add(numStr[i].ToString() + "+" + num2Str);//字符A+B
#endregion #region 减法的情况
if (num1 > num2)
{
temp = num1 - num2;
newNum.Add(temp.ToString());//数字:6-4
newNumStr.Add(numStr[i].ToString() + "-" + num2Str);//字符A-B
}
else
{
temp = num2 - num1;
newNum.Add(temp.ToString());
//检查是否存在+-运算符,若查找返回索引的结果不等于-1,表示存在+-运算符
if (numStr[i].ToString().IndexOf('+') != - || numStr[i].ToString().IndexOf('-') != -)
{
newNumStr.Add(num2Str + "-" + "(" + numStr[i].ToString() + ")");//B-(A)
}
else
{
newNumStr.Add(num2Str + "-" + numStr[i].ToString());//B-A
}
}
#endregion #region 乘法的情况
temp = num1 * num2;
newNum.Add(temp.ToString());
//利用IndexOf()检查是否有+-运算符-1:指的是没有
if (numStr[i].ToString().IndexOf("+") == - && numStr[i].ToString().IndexOf("-") == -)
{
newNumStr.Add(numStr[i].ToString() + "*" + num2Str);//A*B
}
else
{
newNumStr.Add("(" + numStr[i].ToString() + ")" + "*" + num2Str);//(A+B)*C
}
#endregion #region 除法的情况
if (num1 > num2)
{
if (num2 != && num1 % num2 == )//除数不为0,而且两数相除余数要为0,也就是要能整除
{
temp = num1 / num2;
newNum.Add(temp.ToString());
if (numStr[i].ToString().IndexOf("+") == - && numStr[i].ToString().IndexOf("-") == -)
{
newNumStr.Add(numStr[i].ToString() + "/" + num2Str);//A/B
}
else
{
newNumStr.Add("(" + numStr[i].ToString() + ")" + "/" + num2Str);//(A+B)/C
}
}
}
else
{
if (num1 != && num2 % num1 == )
{
temp = num2 / num1;
newNum.Add(temp.ToString());
if (numStr[i].ToString().IndexOf("+") == - && numStr[i].ToString().IndexOf("-") == -)
{
newNumStr.Add(num2Str + "/" + numStr[i].ToString());
}
else
{
newNumStr.Add(num2Str + "/" + "(" + numStr[i].ToString() + ")");
}
}
}
#endregion
}
//要返回的集合结果
num = newNum;
numStr = newNumStr;
} //3、用数值表达式替换字符串表达式的方法,此方法的核心思想是,一个一个字符替换为对应的数值
private object replaceString(string ExpressionStr, char NumStr, int Num)
{
//参数(字符表达式=(A-B)*C+D,'字符'=A,数值=5)=>数值表达式=(13-12)*8+3
int loc = ExpressionStr.IndexOf(NumStr);
string first = ExpressionStr.Substring(, loc);
ExpressionStr = first + Convert.ToInt16(Num) + ExpressionStr.Substring(loc + );
return ExpressionStr;
} #endregion //点击下一轮按钮
private void btnNext_Click(object sender, EventArgs e)
{
#region 点击下一轮按钮更新初始化数据
btnAdd.Enabled = true;
btnMinus.Enabled = true;
btnDivide.Enabled = true;
btnMulti.Enabled = true;
btnNumber1.Enabled = true;
btnNumber2.Enabled = true;
btnNumber3.Enabled = true;
btnNumber4.Enabled = true;
btnDelete.Enabled = true;
btnClear.Enabled = true;
btnLeft.Enabled = true;
btnRight.Enabled = true;
btnEnter.Enabled = true;
lblInput.Text = "";
txtAnswer.Text = "";
lblResult.Visible = false;
lblShowTime.Text = "";
timer1.Enabled = true;
beginTime = DateTime.Now;
#endregion int imageNum;
string path;
//画第一张牌
if (topCard >= )
{
MessageBox.Show("恭喜你已算完整副牌,开始新的一副牌。");
topCard = ;
Shuffle();//洗牌
}
topCard = topCard + ;
imageNum = PlayingCards[topCard].suit + (PlayingCards[topCard].face - ) * ;
path = Directory.GetCurrentDirectory() + @"\images\" + imageNum.ToString() + ".bmp";
pictureBox1.Image = Image.FromFile(path);
NumberA = Convert.ToInt32(PlayingCards[topCard].face);
btnNumber1.Text = NumberA.ToString();
//画第二张牌
if (topCard >= )
{
MessageBox.Show("恭喜你已算完整副牌,开始新的一副牌。");
topCard = ;
Shuffle();
}
topCard = topCard + ;
imageNum = PlayingCards[topCard].suit + (PlayingCards[topCard].face - ) * ;
path = Directory.GetCurrentDirectory() + @"\images\" + imageNum.ToString() + ".bmp";
pictureBox2.Image = Image.FromFile(path);
NumberB = Convert.ToInt32(PlayingCards[topCard].face);
btnNumber2.Text = NumberB.ToString();
//画第三张牌
if (topCard >= )
{
MessageBox.Show("恭喜你已算完整副牌,开始新的一副牌。");
topCard = ;
Shuffle();
}
topCard = topCard + ;
imageNum = PlayingCards[topCard].suit + (PlayingCards[topCard].face - ) * ;
path = Directory.GetCurrentDirectory() + @"\images\" + imageNum.ToString() + ".bmp";
pictureBox3.Image = Image.FromFile(path);
NumberC = Convert.ToInt32(PlayingCards[topCard].face);
btnNumber3.Text = NumberC.ToString();
//画第四张牌
if (topCard >= )
{
MessageBox.Show("恭喜你已算完整副牌,开始新的一副牌。");
topCard = ;
Shuffle();
}
topCard = topCard + ;
imageNum = PlayingCards[topCard].suit + (PlayingCards[topCard].face - ) * ;
path = Directory.GetCurrentDirectory() + @"\images\" + imageNum.ToString() + ".bmp";
pictureBox4.Image = Image.FromFile(path);
NumberD = Convert.ToInt32(PlayingCards[topCard].face);
btnNumber4.Text = NumberD.ToString();
} //计时器
private void timer1_Tick(object sender, EventArgs e)
{
TimeSpan ts = DateTime.Now - beginTime;
lblShowTime.Text = "用时:" + ts.Minutes + "分" + ts.Seconds.ToString() + "秒";
if (ts.Seconds == |ts.Seconds==)
{
MessageBox.Show("我等到花儿都谢了,怎么还没算出来呀,需要帮助的话就点击查看答案哦!!!", "时间警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);
lblShowTime.ForeColor = Color.Red;
}
}
}
}

三、示例下载

GitHub:https://github.com/SeeYouBug2/twenty-four-Algorithm-Game.git

总结:“兴趣是你的最好老师,不管做任何事情,你都要寻找自己的兴趣点,跟着自己的兴趣走,你会学的更好,学的更深,学编程也不例外”。

【趣味分享】C#实现回味童年的24点算法游戏的更多相关文章

  1. 分享Kali Linux 2017年第24周镜像文件

     分享Kali Linux 2017年第24周镜像文件  Kali Linux官方于6月11日发布2017年的第24周镜像.这次维持了11个镜像文件的规模.默认的Gnome桌面的4个镜像,E17.KD ...

  2. 24点小游戏app宣传文案

    24点小游戏app宣传文案 游戏背景 24点小游戏是传统的扑克牌游戏,是通过扑克牌来完成的竞争性智力游戏,除了希望能够消磨我们的空闲时间,加强同学们的临机和速算能力,还能够促进我们每个人的大脑和逻辑性 ...

  3. C语言-纸牌计算24点小游戏

    C语言实现纸牌计算24点小游戏 利用系统时间设定随机种子生成4个随机数,并对4个数字之间的运算次序以及运算符号进行枚举,从而计算判断是否能得出24,以达到程序目的.程序主要功能已完成,目前还有部分细节 ...

  4. java 24点算法实现

    最近闲来无事,突然怀念起小时候和堂兄表姐们经常玩24点游戏,于是就琢磨着是不是开发一个安卓手机版本.然后上网上一搜,发现已经被别人给开发烂了啊.不过这只能说明这个小游戏要想赚广告费很难了,但是拿来锻炼 ...

  5. python实现算24的算法

    1.介绍 给定4个整数,数字范围在1-13之间,任意使用 + - * / ( ) ,构造出一个表达式,使得最终结果为24,这就是常见的算24的游戏.本文介绍用Python语言实现的两种方式.2.实现思 ...

  6. 数据结构和算法(Golang实现)(24)排序算法-优先队列及堆排序

    优先队列及堆排序 堆排序(Heap Sort)由威尔士-加拿大计算机科学家J. W. J. Williams在1964年发明,它利用了二叉堆(A binary heap)的性质实现了排序,并证明了二叉 ...

  7. 【模型推理】量化实现分享一:详解 min-max 对称量化算法实现

      欢迎关注我的公众号 [极智视界],回复001获取Google编程规范   O_o   >_<   o_O   O_o   ~_~   o_O   大家好,我是极智视界,本文剖析一下 m ...

  8. 【模型推理】量化实现分享二:详解 KL 对称量化算法实现

      欢迎关注我的公众号 [极智视界],回复001获取Google编程规范   O_o   >_<   o_O   O_o   ~_~   o_O   大家好,我是极智视界,本文剖析一下 K ...

  9. 【模型推理】量化实现分享三:详解 ACIQ 对称量化算法实现

      欢迎关注我的公众号 [极智视界],回复001获取Google编程规范   O_o   >_<   o_O   O_o   ~_~   o_O   大家好,我是极智视界,本文剖析一下AC ...

随机推荐

  1. 将DataTable中的某列转换成数组或者List

    string[] arrRate = dtRate.AsEnumerable().Select(d => d.Field<string>("arry")).ToA ...

  2. 原生JS实现-星级评分系统

    今天我又写了个很酷的实例:星级评分系统(可自定义星星个数.显示信息) sufuStar.star();使用默认值5个星星,默认信息 var msg = [........]; sufuStar.sta ...

  3. Oracle-BPM安装详解

    H3 BPM安装包括两个部分,基础工作包括安装IIS..net Freamwork基础框架.安装完成之后,主要配置安装包括数据库,H3 BPM 程序.下面详细介绍Oracle与H3 BPM对接安装的整 ...

  4. Android—简单的仿QQ聊天界面

    最近仿照QQ聊天做了一个类似界面,先看下界面组成(画面不太美凑合凑合呗,,,,):

  5. 第14章 Linux启动管理(2)_启动引导程序grub

    2. 启动引导程序grub 2.1 Grub配置文件 (1)grub中分区的表示 硬盘 分区 Linux设备文件名 Grub中设备文件名 第1块SCSI硬盘 第1个主分区 /dev/sda1 hd(0 ...

  6. angularJS(5)

    angularJS(5) 一,数据循环:特别要注意作用域 使用ng-repeat指令. <div ng-app="myApp" ng-controller="myC ...

  7. MemCache超详细解读

    MemCache是什么 MemCache是一个自由.源码开放.高性能.分布式的分布式内存对象缓存系统,用于动态Web应用以减轻数据库的负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高 ...

  8. 轻量级表达式树解析框架Faller

    有话说 之前我写了3篇关于表达式树解析的文章 干货!表达式树解析"框架"(1) 干货!表达式树解析"框架"(2) 干货!表达式树解析"框架" ...

  9. ABP源码分析三十七:ABP.Web.Api Script Proxy API

    ABP提供Script Proxy WebApi为所有的Dynamic WebApi生成访问这些WebApi的JQuery代理,AngularJs代理以及TypeScriptor代理.这些个代理就是j ...

  10. 相关query挖掘

    1.何为相关query 我通常也把相关query称为相似query,搜索日志中一个用户在短时间内的一系列搜索词被称为相关query.相关就是两个query间有一定的关系,反映了用户在当时的需求.本文就 ...