四消水果
2022-1-26
(0)
程序简介
四消水果，四个（以上）连一起的一样的图案会消除。这个游戏讲究移动和布局，属于是在运动中消灭图案，时刻要保持道路的通畅，还要合理的运用新出现的图案。
玩法：选择一个棋子，再选择一个可以抵达的空格，棋子会移动到空格，若移动后满足消除条件则消除。每一步后都会生成新棋子。棋盘满格则结束退出。参考资料附上网页版，玩法来源。
如果新生成的水果和原水果组成四个连一起是不会消除的。程序内可以改变消除数量，比如最少五个才能消除，还能改变格子数量，改变移动后每次生成的数量，都是很方便可以更改的。
这里面有一个能否移动的检测，上一次遇到还是困住小猫，然而困住小猫不是标准的六边形和矩形，当时有个遗憾是必须将小猫周围六个格子全部填充才能结束，现在看来可以解决了。这个能否移动是先将选中格能移动到的所有格子存储，再判断第二次点击的格子是否在其中。还有一种办法是把连连看的判断方法中的拐弯次数设到很大，其实设到足够大就是第一种方法了，只不过是储存的格子少了。
第一次更新：
- 图片更新，减小边框
- 代码更新，现在兼容 vc2010，不兼容 vc6.0
vc2010：_stscanf_s，vc6.0：_stscanf
vc2010：_stprintf_s，vc6.0：_stprintf - 修复结束时错误闪烁的 bug
程序执行效果
完整源代码
////////////////////////////////////////
// 程序：四消水果
// 作者：Gary
// 编译环境：Visual C++ 2010，EasyX_20211109
// 编写日期：2020-10-5
////////////////////////////// 游戏进程头文件 //////////////////////////////
# include <math.h>
# include <graphics.h>
# include <string>
# include <time.h>
# include <stdlib.h>
// 头文件
// 头文件编译开始
#ifndef CIRCLE_H
#define CIRCLE_H
// 定义变量
static HWND hOut; // 画布
// 定义一个结构体，格子
struct Node1
{
int i, j, k; // 矩形格子二维坐标，六边形格子三维坐标
int boxnum; // 格子编号
int posx, posy; // 物理坐标
int type; // 格子上棋子类型
};
// 定义一个结构体，临时存放格子
struct Node2
{
int num; // 编号
int boxnum; // 存放正式格子编号
};
// 定义一个结构体，按钮
struct Node3
{
int posx1, posy1, posx2, posy2; // 坐标
double r; // 圆按钮半径
LPTSTR text; // 按钮文本
int type; // 按钮激活状态
};
// 定义一个类，game
class game
{
public:
// 函数
// 游戏进程源文件
int carry_main (); // 游戏进程主循函数
void draw_button (); // 按钮绘制函数
void draw_piece (int posx, int posy, int type); // 棋子绘制函数
void draw_word (double size, int posx, int posy, LPTSTR text); // 标题绘制函数
int check_hexagon (int x, int y); // 六边形判断函数
int check_square (int x, int y); // 矩形判断函数
void creact_piece (int boxnum); // 生成棋子函数
void carry_prepare (); // 准备进程主循函数
void initialization_prepare (); // 准备进程初始化函数
void draw_scene_prepare (); // 准备进程绘制函数
void carry_start (); // 开始进程主循函数
void initialization_start (); // 开始进程初始化函数
void draw_scene_start (); // 开始进程绘制函数
Node1 box[1000]; // 格子，预制
Node2 eat[500]; // 临时存放格子
Node3 boxm[20]; // 按钮，预制二十个
int num_button; // 按钮数量
int exit_carry; // 主进程主循函数控制参数
int exit_start; // 开始进程主循函数控制参数
int mod_shape; // 棋盘模式参数，两种
int mod_start; // 游戏模式参数，三种
int size_shape; // 棋盘尺寸
int flag; // 临时存放格子数量参数
int selected_boxnum; // 选择格子参数
int selected_or_not; // 是否选择参数
int start_endtime; // 结束时间
int start_point; // 分数
wchar_t c[8]; // 绘制棋子参数
COLORREF color1[8], color2[8]; // 绘制棋子参数
};
// 头文件编译结束
#endif
////////////////////////////// 主程序源文件 //////////////////////////////
// 窗口初始化
void initialization ()
{
// 窗口定义，整个程序仅定义一次
hOut = initgraph (601, 501);
// 窗口标题
SetWindowText (hOut, _T ("消消乐"));
}
// 总进程主循函数
void carry ()
{
// 总进程参数初始化
int exit_carry = 0;
// 进程控制
BeginBatchDraw ();
// 创建游戏类对象
game G;
// 游戏进程
while (exit_carry == 0)
{
// 执行游戏总进程，并接收游戏进程结束时返回值
// 准备进程时，点击退出按钮结束返回 1
// 开始进程时，点击返回按钮结束返回 0
exit_carry = G.carry_main ();
}
EndBatchDraw ();
// 关闭窗口
closegraph ();
}
// 主函数
int main (void)
{
// 初始化
initialization ();
// 总进程主循函数
carry ();
return 0;
}
////////////////////////////// 游戏进程源文件 //////////////////////////////
// 游戏进程主循函数
int game::carry_main ()
{
// 游戏进程参数初始化
exit_carry = 0;
// 随机种子初始化
srand ((unsigned)time (NULL));
// 准备进程初始化函数
initialization_prepare ();
// 准备进程主循函数
carry_prepare ();
// 准备进程结束
// 准备进程时，点击退出按钮结束，游戏进程参数为 1
// 准备进程时，正常进入游戏，游戏进程参数为 0
if (exit_carry == 0)
{
// 开始进程初始化函数
initialization_start ();
// 开始进程主循函数
carry_start ();
}
// 开始进程结束
// 点击返回按钮结束，或者正常游戏结束，游戏进程参数不变
return exit_carry;
}
// 按钮绘制函数
void game::draw_button ()
{
// 根据颜色结构体设置参数
setlinecolor (RGB (125, 125, 125));
setfillcolor (RGB (88, 88, 88));
setbkcolor (RGB (88, 88, 88));
settextcolor (RGB (250, 250, 250));
settextstyle (30, 15, _T ("Consolas"));
setlinestyle (PS_SOLID, 10);
// 根据按钮数量参数绘制
for (int i = 0; i < num_button; i++)
{
if (boxm[i].type == 0)
{
// 边框
fillroundrect (boxm[i].posx1, boxm[i].posy1, boxm[i].posx2, boxm[i].posy2, 25, 25);
// 文字
outtextxy (boxm[i].posx1 + (boxm[i].posx2 - boxm[i].posx1) / 2 - textwidth (boxm[i].text) / 2, boxm[i].posy1 + 15, boxm[i].text);
}
}
FlushBatchDraw ();
}
// 生成新棋子函数
void game::creact_piece (int boxnum)
{
box[boxnum].type = rand () % 7 + 1;
}
// 棋子绘制函数
void game::draw_piece (int posx, int posy, int type)
{
int i;
setlinestyle (PS_SOLID, 1);
setlinecolor (RGB (238, 224, 253));
setfillcolor (RGB (217, 200, 248));
// 根据棋盘模式，画不同的格子
if (mod_shape == 0) { fillrectangle (posx, posy, posx + 50, posy + 50); }
else if (mod_shape == 1) { fillcircle (posx + 25, posy + 25, 25); }
if (type > 0)
{
// 绘制参数
settextstyle (60, 50, _T ("Wingdings"));
setbkmode (TRANSPARENT);
// 阴影
settextcolor (RGB (106, 93, 118));
for (i = 0; i < 3; i++) { outtextxy (posx, posy - i, c[type]); }
// 侧面
settextcolor (color1[type]);
for (i = 3; i < 6; i++) { outtextxy (posx, posy - i, c[type]); }
// 正面
settextcolor (color2[type]);
for (i = 6; i < 7; i++) { outtextxy (posx, posy - i, c[type]); }
// 恢复填充
setbkmode (OPAQUE);
}
}
// 矩形判断函数
int game::check_square (int x, int y)
{
int j, flag1, flag2;
flag1 = 0; flag2 = 0;
// 左右记录参数
flag1 = 0;
// 向左
j = x;
while (j % 10 > 0)
{
j--;
// 移动后格子上的棋子与被分析格子上的棋子类型一致，则记录
if (box[j].type == y) { eat[flag + flag1].boxnum = j; flag1++; }
// 否则直接退出
else { break; }
}
// 向右
j = x;
while (j % 10 < size_shape)
{
j++;
// 移动后格子上的棋子与被分析格子上的棋子类型一致，则记录
if (box[j].type == y) { eat[flag + flag1].boxnum = j; flag1++; }
// 否则直接退出
else { break; }
}
if (flag1 >= 2 || mod_start == 1) {}
// 左右判断少于两个，则无法消除，清空临时存储
else { flag1 = 0; }
// 上下记录参数
flag2 = 0;
// 向上
j = x;
while (j / 10 > 0)
{
j -= 10;
// 移动后格子上的棋子与被分析格子上的棋子类型一致，则记录
if (box[j].type == y) { eat[flag + flag1 + flag2].boxnum = j; flag2++; }
// 否则直接退出
else { break; }
}
// 向下
j = x;
while (j / 10 < size_shape)
{
j += 10;
// 移动后格子上的棋子与被分析格子上的棋子类型一致，则记录
if (box[j].type == y) { eat[flag + flag1 + flag2].boxnum = j; flag2++; }
// 否则直接退出
else { break; }
}
if (flag2 >= 2 || mod_start == 1) {}
// 上下判断少于两个，则无法消除，清空临时存储
else { flag2 = 0; }
flag += (flag1 + flag2);
return flag1 + flag2;
}
// 六边形判断函数
int game::check_hexagon (int x, int y)
{
int i, j, k, t, flag1, flag2, flag3;
flag1 = 0; flag2 = 0; flag3 = 0;
// 正上正下记录参数
flag1 = 0;
// 向正上
i = box[x].boxnum % 10; j = (box[x].boxnum / 10) % 10; k = box[x].boxnum / 100;
while (i < size_shape)
{
// 向正上移动
if (j > 0 && k > 0) { j--; k--; }
else { i++; }t = i + j * 10 + k * 100;
// 移动后格子上的棋子与被分析格子上的棋子类型一致，则记录
if (box[t].type == y) { eat[flag + flag1].boxnum = t; flag1++; }
// 否则直接退出
else { break; }
}
// 向正下
i = box[x].boxnum % 10; j = (box[x].boxnum / 10) % 10; k = box[x].boxnum / 100;
while ((j < size_shape && k < size_shape) || i != 0)
{
// 向正下移动
if (i > 0) { i--; }
else { j++; k++; }t = i + j * 10 + k * 100;
// 移动后格子上的棋子与被分析格子上的棋子类型一致，则记录
if (box[t].type == y) { eat[flag + flag1].boxnum = t; flag1++; }
// 否则直接退出
else { break; }
}
if (flag1 >= 2 || mod_start == 1) {}
// 正上正下判断少于两个，则无法消除，清空临时存储
else { flag1 = 0; }
// 左上右下记录参数
flag2 = 0;
// 向左上
i = box[x].boxnum % 10; j = (box[x].boxnum / 10) % 10; k = box[x].boxnum / 100;
while ((i < size_shape && k < size_shape) || j != 0)
{
// 向左上移动
if (j > 0) { j--; }
else { i++; k++; }t = i + j * 10 + k * 100;
// 移动后格子上的棋子与被分析格子上的棋子类型一致，则记录
if (box[t].type == y) { eat[flag + flag1 + flag2].boxnum = t; flag2++; }
// 否则直接退出
else { break; }
}
// 向右下
i = box[x].boxnum % 10; j = (box[x].boxnum / 10) % 10; k = box[x].boxnum / 100;
while (j < size_shape)
{
// 向右下移动
if (i > 0 && k > 0) { i--; k--; }
else { j++; }t = i + j * 10 + k * 100;
// 移动后格子上的棋子与被分析格子上的棋子类型一致，则记录
if (box[t].type == y) { eat[flag + flag1 + flag2].boxnum = t; flag2++; }
// 否则直接退出
else { break; }
}
if (flag2 >= 2 || mod_start == 1) {}
// 左上右下判断少于两个，则无法消除，清空临时存储
else { flag2 = 0; }
// 右上左下记录参数
flag3 = 0;
// 向右上
i = box[x].boxnum % 10; j = (box[x].boxnum / 10) % 10; k = box[x].boxnum / 100;
while ((i < size_shape && j < size_shape) || k != 0)
{
// 向右上移动
if (k > 0) { k--; }
else { i++; j++; }t = i + j * 10 + k * 100;
// 移动后格子上的棋子与被分析格子上的棋子类型一致，则记录
if (box[t].type == y) { eat[flag + flag1 + flag2 + flag3].boxnum = t; flag3++; }
// 否则直接退出
else { break; }
}
// 向左下
i = box[x].boxnum % 10; j = (box[x].boxnum / 10) % 10; k = box[x].boxnum / 100;
while (k < size_shape)
{
// 向左下移动
if (i > 0 && j > 0) { i--; j--; }
else { k++; }t = i + j * 10 + k * 100;
// 移动后格子上的棋子与被分析格子上的棋子类型一致，则记录
if (box[t].type == y) { eat[flag + flag1 + flag2 + flag3].boxnum = t; flag3++; }
// 否则直接退出
else { break; }
}
if (flag3 >= 2 || mod_start == 1) {}
// 右上左下判断少于两个，则无法消除，清空临时存储
else { flag3 = 0; }
flag += (flag1 + flag2 + flag3);
return flag1 + flag2 + flag3;
}
////////////////////////////// 准备进程源文件 //////////////////////////////
// 准备进程主循函数
void game::carry_prepare ()
{
int i;
// 鼠标定义
ExMessage m;
// 准备进程控制参数初始化
int exit_prepare = 0;
// 绘制界面
draw_scene_prepare ();
// 主循开始
while (exit_prepare == 0)
{
if (peekmessage (&m, EM_MOUSE | EM_KEY))
{
// 左键单击判断
if (m.message == WM_LBUTTONDOWN)
{
// 判断是否点击了按钮，按钮状态是否为激活
for (i = 0; i < num_button; i++)
{
if (m.x > boxm[i].posx1 && m.y > boxm[i].posy1 && m.x < boxm[i].posx2 && m.y < boxm[i].posy2 && boxm[i].type == 0)
{
break;
}
}
// 游戏类型按钮
if (i == 0 || i == 1 || i == 2)
{
// 进入选择游戏模式界面
// 按钮激活状态变更
boxm[0].type = 1;
boxm[1].type = 1;
boxm[2].type = 1;
boxm[3].type = 1;
boxm[4].type = 0;
boxm[5].type = 0;
boxm[6].type = 0;
// 开始进程控制参数为 0，进入普通模式
exit_start = 0;
// 游戏类型参数更新
// 0 是宝石迷阵，1 是四消水果，2 是推拉英雄
mod_start = i;
}
// 退出按钮
else if (i == 3)
{
// 总进程控制参数置一，跳过开始进程
exit_carry = 1;
// 准备进程控制参数置一，结束主循
exit_prepare = 1;
}
// 棋盘类型按钮
else if (i == 4 || i == 5)
{
// 棋盘类型参数更新
// 0 是矩形，1 是六边形
mod_shape = i - 4;
// 棋盘尺寸默认为：矩形 6，六边形 5
if (i == 4) { size_shape = 6; }
else if (i == 5) { size_shape = 4; }
// 准备进程控制参数置一，结束主循，开始游戏
exit_prepare = 1;
}
// 后退按钮
else if (i == 6)
{
// 从主题选择界面返回
// 按钮激活状态变更
boxm[0].type = 1;
boxm[1].type = 0;
boxm[2].type = 1;
boxm[3].type = 0;
boxm[4].type = 1;
boxm[5].type = 1;
boxm[6].type = 1;
}
if (i < 10 && exit_prepare == 0)
{
// 点击按钮后，根据按钮激活参数，重新绘制界面
draw_scene_prepare ();
FlushBatchDraw ();
}
}
}
}
}
// 准备进程初始化函数
void game::initialization_prepare ()
{
// 按钮设置初始化
// 按钮数量参数初始化
num_button = 7;
// 按钮结构体参数初始化
boxm[0].posx1 = 200; boxm[0].posy1 = 120; boxm[0].posx2 = 400; boxm[0].posy2 = 180; boxm[0].text = _T ("宝石迷阵"); boxm[0].type = 1;
boxm[1].posx1 = 200; boxm[1].posy1 = 120; boxm[1].posx2 = 400; boxm[1].posy2 = 180; boxm[1].text = _T ("四消水果"); boxm[1].type = 0;
boxm[2].posx1 = 200; boxm[2].posy1 = 320; boxm[2].posx2 = 400; boxm[2].posy2 = 380; boxm[2].text = _T ("推拉消除"); boxm[2].type = 1;
boxm[3].posx1 = 200; boxm[3].posy1 = 420; boxm[3].posx2 = 400; boxm[3].posy2 = 480; boxm[3].text = _T ("退出"); boxm[3].type = 0;
boxm[4].posx1 = 200; boxm[4].posy1 = 120; boxm[4].posx2 = 400; boxm[4].posy2 = 180; boxm[4].text = _T ("矩形"); boxm[4].type = 1;
boxm[5].posx1 = 200; boxm[5].posy1 = 220; boxm[5].posx2 = 400; boxm[5].posy2 = 280; boxm[5].text = _T ("六边形"); boxm[5].type = 1;
boxm[6].posx1 = 200; boxm[6].posy1 = 420; boxm[6].posx2 = 400; boxm[6].posy2 = 480; boxm[6].text = _T ("后退"); boxm[6].type = 1;
// 棋子初始化
c[1] = 0xA3; // 空心圆
c[2] = 0xAA; // 四角星
c[3] = 0xAB; // 五角星
c[4] = 0xAC; // 六角星
c[5] = 0xAD; // 八角星
c[6] = 0xA9; // 三角星
c[7] = 0xAE; // 星星
color1[1] = RGB (57, 130, 206);
color1[2] = RGB (210, 71, 38);
color1[3] = RGB (79, 161, 52);
color1[4] = RGB (225, 149, 52);
color1[5] = RGB (180, 46, 134);
color1[6] = RGB (151, 30, 19);
color1[7] = RGB (152, 39, 196);
color2[1] = RGB (102, 189, 244);
color2[2] = RGB (239, 151, 63);
color2[3] = RGB (120, 228, 80);
color2[4] = RGB (248, 220, 80);
color2[5] = RGB (236, 139, 209);
color2[6] = RGB (236, 109, 53);
color2[7] = RGB (235, 103, 244);
// 得分
start_point = 0;
}
// 准备进程绘制函数
void game::draw_scene_prepare ()
{
// 画布绘制
setbkcolor (WHITE);
cleardevice ();
// 按钮绘制
draw_button ();
// 标题绘制
draw_word (50, 230, 20, _T ("四消水果"));
FlushBatchDraw ();
}
// 文字绘制函数
void game::draw_word (double size, int posx, int posy, LPTSTR text)
{
int i, j;
// 参数设置，填充透明
setbkmode (TRANSPARENT);
settextstyle (int (size), int (size / 5 * 2), _T ("Consolas"));
// 背景色的反色
settextcolor (BLACK);
// 范围绘制，构造阴影
for (i = posx - 3; i <= posx + 3; i++)
{
for (j = posy - 3; j <= posy + 3; j++)
{
outtextxy (i, j, text);
}
}
// 背景色
settextcolor (WHITE);
// 在阴影中绘制
outtextxy (posx, posy, text);
// 恢复填充
setbkmode (OPAQUE);
FlushBatchDraw ();
}
////////////////////////////// 开始进程源文件 //////////////////////////////
// 开始进程主循函数
void game::carry_start ()
{
// 鼠标定义
ExMessage m;
int i, j, k, t, x[10];
// 绘制
draw_scene_start ();
// 普通模式
while (exit_start == 0)
{
if (peekmessage (&m, EM_MOUSE | EM_KEY))
{
// 左键单击判断
if (m.message == WM_LBUTTONDOWN)
{
// 单击在棋盘范围
if (m.x < 500 && m.x > 0 && m.y > 0 && m.y < 500)
{
// 判断是否点击了格子，有效的格子
for (i = 0; i < 1000; i++)
{
// 矩形
if (box[i].type != -1 && m.x > box[i].posx && m.y > box[i].posy && m.x < box[i].posx + 50 && m.y < box[i].posy + 50 && mod_shape == 0)
{
break;
}
// 六边形
else if (box[i].type != -1 && pow (double (m.x - box[i].posx - 25), 2) + pow (double (m.y - box[i].posy - 25), 2) < 626 && mod_shape == 1)
{
break;
}
}
// 选择参数为 0，则表示选择
if (selected_or_not == 0 && i < 1000 && box[i].type != 0)
{
selected_or_not = 1;
selected_boxnum = i;
}
// 选择参数为 1，则根据不同模式的规则进行下一步
else if (selected_or_not == 1)
{
selected_or_not = 0;
// 四消水果
if (mod_start == 1)
{
// 点击同一个格子，表示取消选择
if (selected_boxnum == i) {}
// 点击空位格子，判断可否移动
else if (box[i].type == 0)
{
// 先对之前选定的格子进行可抵达分析
flag = 1;
eat[0].boxnum = selected_boxnum;
for (j = 0; j < flag; j++)
{
// 矩形
if (mod_shape == 0) { k = check_square (eat[j].boxnum, 0); }
// 六边形
else if (mod_shape == 1) { k = check_hexagon (eat[j].boxnum, 0); }
// 重复性删减
for (k = 0; k < flag - 1; k++)
{
for (t = k + 1; t < flag; t++)
{
// 如有相同，t 后面的全部向前
if (eat[t].boxnum == eat[k].boxnum)
{
for (x[0] = t; x[0] < flag; x[0]++)
{
eat[x[0]].boxnum = eat[x[0] + 1].boxnum;
}
flag--;
}
}
}
}
// 结束后判断
for (j = 0; j < flag; j++)
{
if (i == eat[j].boxnum) { break; }
}
// 可达，先交换参数，后进行消除判断
if (i == eat[j].boxnum)
{
// 交换参数
box[i].type = box[selected_boxnum].type;
box[selected_boxnum].type = 0;
// 绘制
draw_scene_start ();
// 进行消除判断
flag = 1;
eat[0].boxnum = i;
for (j = 0; j < flag; j++)
{
// 矩形
if (mod_shape == 0) { k = check_square (eat[j].boxnum, box[eat[j].boxnum].type); }
// 六边形
else if (mod_shape == 1) { k = check_hexagon (eat[j].boxnum, box[eat[j].boxnum].type); }
// 重复性删减
for (k = 0; k < flag - 1; k++)
{
for (t = k + 1; t < flag; t++)
{
// 如有相同，t 后面的全部向前
if (eat[t].boxnum == eat[k].boxnum)
{
for (x[0] = t; x[0] < flag; x[0]++)
{
eat[x[0]].boxnum = eat[x[0] + 1].boxnum;
}
flag--;
}
}
}
}
// 结束后判断
if (flag >= 4)
{
// 得分奖励
start_point += flag;
// 闪烁显示
for (k = 0; k < 3; k++)
{
Sleep (350);
for (j = 0; j < flag; j++) { draw_piece (box[eat[j].boxnum].posx, box[eat[j].boxnum].posy, 0); }
FlushBatchDraw ();
Sleep (200);
for (j = 0; j < flag; j++) { draw_piece (box[eat[j].boxnum].posx, box[eat[j].boxnum].posy, box[eat[j].boxnum].type); }
FlushBatchDraw ();
}
// 消除
for (j = 0; j < flag; j++)
{
box[eat[j].boxnum].type = 0;
}
// 绘制
draw_scene_start ();
}
// 最后判断是否结束
t = 0;
for (k = 0; k < 1000; k++)
{
if (box[k].type == 0) { t++; }
}
// 结束
if ((t <= 2 && mod_shape == 0) || (t <= 4 && mod_shape == 1))
{
for (k = 0; k < 1000; k++)
{
if (box[k].type == 0) { box[k].type = 1; }
}
// 闪烁显示
for (t = 0; t < 4; t++)
{
Sleep (350);
for (k = 0; k < 1000; k++)
{
draw_piece (box[k].posx, box[k].posy, 0);
}
FlushBatchDraw ();
Sleep (200);
for (k = 0; k < 1000; k++)
{
draw_piece (box[k].posx, box[k].posy, box[k].type);
}
FlushBatchDraw ();
}
// 游戏结束
exit_start = 1;
// 退出提示
MessageBox (hOut, _T ("记录下得分，结束啦"), _T ("来自小豆子的提醒"), MB_OK);
}
// 矩形新生成两个，六边形新生成四个
else
{
for (t = 0; t < 2 + mod_shape * 2; t++)
{
do
{
k = rand () % 1000;
} while (box[k].type != 0);
creact_piece (k);
x[t] = k;
}
// 闪烁显示
for (t = 0; t < 2; t++)
{
for (k = 0; k < 2 + mod_shape * 2; k++)
{
draw_piece (box[x[k]].posx, box[x[k]].posy, box[x[k]].type);
}
FlushBatchDraw ();
Sleep (350);
for (k = 0; k < 2 + mod_shape * 2; k++)
{
draw_piece (box[x[k]].posx, box[x[k]].posy, 0);
}
FlushBatchDraw ();
Sleep (200);
}
}
}
// 不可达，则无效，保持原本选择
else
{
selected_or_not = 1;
}
}
// 点击其他非空位格子，表示换选择
else if (box[i].type != 0)
{
selected_or_not = 1;
selected_boxnum = i;
}
}
}
// 绘制
draw_scene_start ();
flushmessage (EM_MOUSE);
}
else
{
// 判断是否点击了按钮
for (i = 0; i < num_button; i++)
{
if (m.x > boxm[i].posx1 && m.y > boxm[i].posy1 && m.x < boxm[i].posx2 && m.y < boxm[i].posy2 && boxm[i].type == 0)
{
break;
}
}
// 刷新按钮
if (i == 0)
{
// 开始进程初始化函数，主要是格子参数的初始化
initialization_start ();
}
// 返回按钮
else if (i == 1)
{
exit_start = 1;
}
}
// 绘制
draw_scene_start ();
}
}
}
}
// 开始进程初始化函数
void game::initialization_start ()
{
int i, j, k, t;
// 画布初始化
setbkcolor (WHITE);
cleardevice ();
// 格子初始化
for (i = 0; i < 1000; i++)
{
box[i].type = -1;
box[i].posx = -800;
box[i].posy = -800;
}
// 矩形
if (mod_shape == 0)
{
// 二维参数定义
for (i = 0; i < size_shape; i++)
{
for (j = 0; j < size_shape; j++)
{
k = i * 10 + j;
box[k].boxnum = k;
box[k].posx = j * 50 + 250 - size_shape * 25;
box[k].posy = i * 50 + 250 - size_shape * 25;
box[k].type = 0;
if (mod_start == 0 || mod_start == 2)
{
creact_piece (k);
}
}
}
// 随机生成两个棋子
for (i = 0; i < 2; i++)
{
do
{
k = rand () % 1000;
} while (box[k].type < 0);
creact_piece (k);
}
}
// 六边形
else if (mod_shape == 1)
{
// 三维参数定义
for (i = 0; i <= size_shape; i++)
{
for (j = 0; j <= size_shape; j++)
{
for (k = 0; k <= size_shape; k++)
{
if (i == 0 || j == 0 || k == 0)
{
t = i + j * 10 + k * 100;
box[t].boxnum = t;
box[t].posx = 200 + 43 * (j - k);
box[t].posy = 230 - 50 * i + 25 * (j + k);
box[t].i = i;
box[t].j = j;
box[t].k = k;
box[t].type = 0;
if (mod_start == 0 || mod_start == 2)
{
creact_piece (t);
}
}
}
}
}
// 随机生成两个棋子
for (i = 0; i < 2; i++)
{
do
{
k = rand () % 1000;
} while (box[k].type < 0);
creact_piece (k);
}
}
// 按钮设置初始化
num_button = 2;
boxm[0].posx1 = 500; boxm[0].posy1 = 20; boxm[0].posx2 = 580; boxm[0].posy2 = 80; boxm[0].text = _T ("刷新"); boxm[0].type = 0;
boxm[1].posx1 = 500; boxm[1].posy1 = 420; boxm[1].posx2 = 580; boxm[1].posy2 = 480; boxm[1].text = _T ("返回"); boxm[1].type = 0;
// 是否选择参数初始化
selected_or_not = 0;
// 绘制
draw_scene_start ();
}
// 开始进程绘制函数
void game::draw_scene_start ()
{
int i, j, k, t;
// 绘制主背景
setbkcolor (WHITE);
cleardevice ();
// 画格子
// 矩形
if (mod_shape == 0)
{
// 二维参数
for (i = 0; i < size_shape; i++)
{
for (j = 0; j < size_shape; j++)
{
k = i * 10 + j;
// 普通状态
draw_piece (box[k].posx, box[k].posy, box[k].type);
// 选中状态
if (selected_or_not == 1 && k == selected_boxnum)
{
setfillstyle (BS_NULL);
setlinestyle (PS_SOLID, 2);
setlinecolor (LIGHTRED);
fillrectangle (box[k].posx + 1, box[k].posy + 1, box[k].posx + 49, box[k].posy + 49);
setfillstyle (BS_SOLID);
}
}
}
}
// 六边形
else if (mod_shape == 1)
{
// 三维参数
for (i = 0; i <= size_shape; i++)
{
for (j = 0; j <= size_shape; j++)
{
for (k = 0; k <= size_shape; k++)
{
if (i == 0 || j == 0 || k == 0)
{
t = i + j * 10 + k * 100;
// 普通状态
draw_piece (box[t].posx, box[t].posy, box[t].type);
// 选中状态
if (selected_or_not == 1 && t == selected_boxnum)
{
setfillstyle (BS_NULL);
setlinestyle (PS_SOLID, 2);
setlinecolor (LIGHTRED);
fillcircle (box[t].posx + 25, box[t].posy + 25, 23);
setfillstyle (BS_SOLID);
}
}
}
}
}
}
// 绘制按钮
draw_button ();
// 绘制得分
TCHAR s[25];
// 得分
draw_word (30, 510, 220, _T ("得分："));
_stprintf_s (s, _T ("%0.1d"), start_point);
draw_word (30, 510, 260, s);
FlushBatchDraw ();
}
添加评论
取消回复