鱼C论坛

 找回密码
 立即注册
查看: 11577|回复: 79

[技术交流] 扫雷

[复制链接]
发表于 2018-2-8 01:34:26 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能^_^

您需要 登录 才可以下载或查看,没有账号?立即注册

x
本帖最后由 人造人 于 2018-2-8 18:34 编辑

灵感来自 http://bbs.fishc.com/thread-104918-1-1.html

我目前不会写自动翻开的那部分
如果我点了一个,这个和这个周围没有雷,那就把这些翻开,这部分我目前不会写


GIF1.gif
GIF2.gif
GIF3.gif

GIF10.gif
GIF11.gif
GIF12.gif
GIF13.gif


源码
游客,如果您要查看本帖隐藏内容请回复



2018-02-08更新在13楼

评分

参与人数 1荣誉 +6 鱼币 +6 贡献 +6 收起 理由
小甲鱼 + 6 + 6 + 6 支持楼主!

查看全部评分

想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复

使用道具 举报

 楼主| 发表于 2018-2-8 01:38:34 | 显示全部楼层
最后一张图是亮点
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2018-2-8 01:39:06 | 显示全部楼层
@风过无痕丶
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2018-2-8 02:31:28 | 显示全部楼层
666
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复

使用道具 举报

发表于 2018-2-8 11:03:43 From FishC Mobile | 显示全部楼层
人造人 发表于 2018-2-8 01:39
@风过无痕丶

我觉得需要一个边框!
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2018-2-8 11:20:01 | 显示全部楼层
  我觉得自动翻开那部分 可以写个类似数组的自动增长因子的东西~
翻开那部分由翻的次数 来增长~
举例说:
    翻第一次, 检索周围 两步的范围有没雷, 如果有雷 就只开当前范围, 如果没雷就打开增长范围的未知区域。。。
    翻第二次   检索周围  两步的次方
   。。。。。
我大概的思维就是这样~
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2018-2-8 11:52:10 | 显示全部楼层
还有~昨晚的那个随机数我好像找到解决方法了。。
如果不要种子,就只有一个值~
把种子放在 主调函数就可以了。。。
QQ截图20180208115148.jpg
QQ截图20180208115222.jpg
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2018-2-8 13:43:33 | 显示全部楼层
  自动是自动开了~我怎么感觉我写成外挂了~ 把雷区就不开着 给我剩在那了~
QQ图片20180208134423.jpg
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2018-2-8 14:38:56 | 显示全部楼层
6
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复

使用道具 举报

 楼主| 发表于 2018-2-8 15:58:30 | 显示全部楼层
风过无痕丶 发表于 2018-2-8 11:03
我觉得需要一个边框!

确实需要一个边框
^_^
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2018-2-8 16:00:46 | 显示全部楼层
风过无痕丶 发表于 2018-2-8 11:20
我觉得自动翻开那部分 可以写个类似数组的自动增长因子的东西~
翻开那部分由翻的次数 来增长~ ...

还是不明白,这部分我不会写
^_^
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2018-2-8 16:29:16 | 显示全部楼层

  1.                         // 检测附近有没雷,如果没雷,打开n的位置
  2.                         //  如果有雷 打开当前位置
  3.                         void Prompt_arr(void){
  4.                                 // 先取得当前位置!
  5.                                 int x,y;
  6.                                 gps_saolei(&x,&y);

  7.                                 // 来吧!开始数雷!
  8.                                 int count_A = 0;
  9.                                 int count_B = 0;
  10.                                 int count_C = 0;
  11.                                 int count_D = 0;
  12.                                 int n = count_saolei;   // count_saolei 为全局变量,按下开格子之后会自增~ 检测到有雷,值会缩减~
  13.                                
  14.                                 // 总觉得还差点什么~
  15.                                 // 检测一下 是否在边界,如果是在边界的话,就不打开那么宽了
  16.                                 for (int i = 0; i < n--; i++){

  17.                                         if (x > 15){
  18.                                                 ;
  19.                                         }
  20.                                         else {
  21.                                                 if (juzhen_tnt[x+i][y] == 8){ // 8为雷标识符
  22.                                                         count_A++; // 有雷的话,就数一下有几个雷
  23.                                                         }
  24.                                                 else {
  25.                                                         juzhen[x+i][y] = 3; // 没雷的话,就打开格子
  26.                                                 }
  27.                                         }
  28.                                 }


  29.                                 n = count_saolei;
  30.                                 for (int i = 0; i < n--; i++){
  31.                                         if (x == 0){
  32.                                                 ;
  33.                                         }
  34.                                         else {
  35.                                                 if (juzhen_tnt[x-i][y] == 8){
  36.                                                         count_B++;
  37.                                                 }
  38.                                                 else {
  39.                                                         juzhen[x-i][y] = 3;
  40.                                                 }
  41.                                         }
  42.                                 }


  43.                                 n = count_saolei;
  44.                                 for (int i = 0; i < n--; i++){
  45.                                         if (y > 15){
  46.                                                 ;
  47.                                         }
  48.                                         else {
  49.                                                 if (juzhen_tnt[x][y+i] == 8){
  50.                                                         count_C++;
  51.                                                 }
  52.                                                 else {
  53.                                                         juzhen[x][y+i] = 3;
  54.                                                 }
  55.                                         }
  56.                                 }


  57.                                 n = count_saolei;
  58.                                 for (int i = 0; i < n--; i++){
  59.                                         if (y == 0){
  60.                                                 if (juzhen_tnt[x][y-i] == 8){
  61.                                                         count_D++;
  62.                                                 }
  63.                                                 else {
  64.                                                         juzhen[x][y-i] = 3;
  65.                                                 }
  66.                                         }
  67.                                 }
  68.                         }
  69. };

复制代码


功能是可以实现~但是有点毛病~遇到雷了 它会绕开~就剩个光秃秃的雷区~可能还要修改一下算法和全局变量的衰减力度
QQ图片20180208162917.jpg
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2018-2-8 16:55:04 | 显示全部楼层
风过无痕丶 发表于 2018-2-8 16:29
功能是可以实现~但是有点毛病~遇到雷了 它会绕开~就剩个光秃秃的雷区~可能还要修改一下算法和全局变量 ...

谢谢,我研究一下
^_^
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2018-2-8 18:31:17 | 显示全部楼层
本帖最后由 人造人 于 2018-2-8 18:36 编辑

2018-02-08 更新

就差自动翻开的部分了吧


GIF20.gif
GIF21.gif


  1. #include <iostream>
  2. #include <string>
  3. #include <ctime>
  4. #include <windows.h>
  5. #include <conio.h>

  6. struct MapElem
  7. {
  8.         bool status;
  9.         bool is_mine;
  10.         bool flag;
  11.         int  count;
  12. };

  13. const int MAP_X = 16;
  14. const int MAP_Y = 16;
  15. MapElem map[MAP_X][MAP_Y];

  16. void GlobalInit(void)
  17. {
  18.         for(int i = 0; i < MAP_X; ++i)
  19.         {
  20.                 for(int j = 0; j < MAP_Y; ++j)
  21.                 {
  22.                         map[i][j].is_mine = false;
  23.                         map[i][j].status = false;
  24.                         map[i][j].flag = false;
  25.                         map[i][j].count = 0;
  26.                 }
  27.         }
  28. }

  29. // 隐藏CMD窗口光标
  30. void HideCursor(void)
  31. {
  32.         CONSOLE_CURSOR_INFO cci;
  33.         cci.bVisible = FALSE;
  34.         cci.dwSize = sizeof(cci);
  35.         HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  36.         SetConsoleCursorInfo(handle, &cci);
  37. }

  38. static void GotoXY(int x, int y)
  39. {
  40.         COORD c;
  41.         c.X = x * 2;
  42.         c.Y = y;
  43.         SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), c);
  44. }

  45. static void DrawString(const char *str, int color)
  46. {
  47.         static const WORD attr[] = {
  48.                 FOREGROUND_RED | FOREGROUND_INTENSITY, //红色
  49.                 FOREGROUND_GREEN | FOREGROUND_INTENSITY, //绿色
  50.                 FOREGROUND_BLUE | FOREGROUND_INTENSITY, //蓝色
  51.                 FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY //白色
  52.         };
  53.         CONSOLE_SCREEN_BUFFER_INFO csbi;
  54.         DWORD NumberOfAttrsWritten;

  55.         GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
  56.         printf(str);
  57.         FillConsoleOutputAttribute(GetStdHandle(STD_OUTPUT_HANDLE), attr[color], strlen(str), csbi.dwCursorPosition, &NumberOfAttrsWritten);
  58. }

  59. void SetMine(int num)
  60. {
  61.         for(int i = 0; i < num; ++i)
  62.         {
  63.                 int x, y;

  64.                 do
  65.                 {
  66.                         x = rand() % MAP_X;
  67.                         y = rand() % MAP_Y;
  68.                 }
  69.                 while(map[x][y].is_mine);

  70.                 map[x][y].is_mine = true;
  71.         }
  72. }

  73. void ShowCount(int x, int y, int color)
  74. {
  75.         if(!map[x][y].count)
  76.         {
  77.                 DrawString("∷", color);
  78.                 return;
  79.         }

  80.         char buf[3] = "①";
  81.         buf[1] += map[x][y].count - 1;
  82.         DrawString(buf, color);
  83. }

  84. const int MAP_OFFSET_X = 20;
  85. const int MAP_OFFSET_Y = 10;
  86. void DrawMap(void)
  87. {
  88.         int color;

  89.         for(int i = 0; i < MAP_X; ++i)
  90.         {
  91.                 for(int j = 0; j < MAP_Y; ++j)
  92.                 {
  93.                         if(map[i][j].flag)
  94.                                 color = 1;
  95.                         else
  96.                                 color = 3;

  97.                         GotoXY(i + MAP_OFFSET_X, j + MAP_OFFSET_Y);

  98.                         if(map[i][j].flag)
  99.                         {
  100.                                 DrawString("◎", color);
  101.                                 continue;
  102.                         }

  103.                         if(map[i][j].status)
  104.                         {
  105.                                 if(map[i][j].is_mine)
  106.                                         DrawString("★", color);
  107.                                 else
  108.                                         ShowCount(i, j, color);
  109.                         }
  110.                         else
  111.                                 DrawString("■", color);
  112.                 }
  113.         }
  114. }

  115. void UpdateCursor(POINT po)
  116. {
  117.         DrawMap();

  118.         GotoXY(po.x + MAP_OFFSET_X, po.y + MAP_OFFSET_Y);
  119.         DrawString("□", 3);
  120. }

  121. bool SelectTarget(POINT cur)
  122. {
  123.         if(map[cur.x][cur.y].status)
  124.                 return false;

  125.         map[cur.x][cur.y].status = true;
  126.         DrawMap();

  127.         if(map[cur.x][cur.y].is_mine)
  128.         {
  129.                 GotoXY(cur.x + MAP_OFFSET_X, cur.y + MAP_OFFSET_Y);
  130.                 DrawString("★", 0);
  131.                 return true;
  132.         }

  133.         return false;
  134. }

  135. void ShowMap(void)
  136. {
  137.         int color;

  138.         for(int i = 0; i < MAP_X; ++i)
  139.         {
  140.                 for(int j = 0; j < MAP_Y; ++j)
  141.                 {
  142.                         if(!map[i][j].status)
  143.                         {
  144.                                 if(map[i][j].flag)
  145.                                         color = 1;
  146.                                 else
  147.                                         color = 3;

  148.                                 GotoXY(i + MAP_OFFSET_X, j + MAP_OFFSET_Y);
  149.                                 if(map[i][j].is_mine)
  150.                                         DrawString("★", color);
  151.                                 else
  152.                                         ShowCount(i, j, color);
  153.                         }
  154.                 }
  155.         }
  156. }

  157. int GetCount(int x, int y)
  158. {
  159.         int count = 0;

  160.         // 左上角 -> 右上角
  161.         for(int i = 0; i < 3; ++i)
  162.                 if((x - 1 + i >= 0) && (y - 1 >= 0))
  163.                         if(map[x - 1 + i][y - 1].is_mine)
  164.                                 ++count;

  165.         // 左下角 -> 右下角
  166.         for(int i = 0; i < 3; ++i)
  167.                 if((x - 1 + i >= 0) && (y + 1 < MAP_Y))
  168.                         if(map[x - 1 + i][y + 1].is_mine)
  169.                                 ++count;

  170.         // 左边
  171.         if(x - 1 >= 0)                // 有左边吗?
  172.                 if(map[x - 1][y].is_mine)
  173.                         ++count;

  174.         // 右边
  175.         if(x + 1 < MAP_X)        // 有右边吗?
  176.                 if(map[x + 1][y].is_mine)
  177.                         ++count;

  178.         return count;
  179. }

  180. void GenerateCount(void)
  181. {
  182.         for(int i = 0; i < MAP_X; ++i)
  183.         {
  184.                 for(int j = 0; j < MAP_Y; ++j)
  185.                 {
  186.                         if(!map[i][j].is_mine)
  187.                                 map[i][j].count = GetCount(i, j);
  188.                 }
  189.         }
  190. }

  191. int main(void)
  192. {
  193.         srand((unsigned int)time(nullptr));
  194.         HideCursor();
  195.         GlobalInit();

  196.         SetMine(30);
  197.         GenerateCount();
  198.         DrawMap();

  199.         POINT cur = {MAP_X / 2, MAP_Y / 2};
  200.         UpdateCursor(cur);

  201.         char command;
  202.         while(1)
  203.         {
  204.                 command = _getch();
  205.                 switch(command)
  206.                 {
  207.                 case 'q':
  208.                 case 'Q':
  209.                         goto EXIT;
  210.                 case 'w':
  211.                 case 'W':
  212.                         if(cur.y > 0)
  213.                         {
  214.                                 --cur.y;
  215.                                 UpdateCursor(cur);
  216.                         }
  217.                         break;
  218.                 case 's':
  219.                 case 'S':
  220.                         if(cur.y < MAP_Y - 1)
  221.                         {
  222.                                 ++cur.y;
  223.                                 UpdateCursor(cur);
  224.                         }
  225.                         break;
  226.                 case 'a':
  227.                 case 'A':
  228.                         if(cur.x > 0)
  229.                         {
  230.                                 --cur.x;
  231.                                 UpdateCursor(cur);
  232.                         }
  233.                         break;
  234.                 case 'd':
  235.                 case 'D':
  236.                         if(cur.x < MAP_X - 1)
  237.                         {
  238.                                 ++cur.x;
  239.                                 UpdateCursor(cur);
  240.                         }
  241.                         break;
  242.                 case 'f':
  243.                 case 'F':
  244.                         if(!map[cur.x][cur.y].status)
  245.                         {
  246.                                 map[cur.x][cur.y].flag = !map[cur.x][cur.y].flag;
  247.                                 DrawMap();
  248.                         }
  249.                         break;
  250.                 case ' ':
  251.                         if(!map[cur.x][cur.y].flag)
  252.                                 if(SelectTarget(cur))
  253.                                         goto EXIT;
  254.                         break;

  255.                 }

  256.         }

  257. EXIT:
  258.         ShowMap();

  259.         GotoXY(0, 34);
  260.         return 0;
  261. }
复制代码



想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2018-2-26 14:43:08 | 显示全部楼层
1
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复

使用道具 举报

发表于 2018-3-26 22:47:19 | 显示全部楼层
楼主,还有在写吗,我写了一下自动打开的,好像有些bug
  1. #include<bits/stdc++.h>
  2. #include<windows.h>
  3. #include <conio.h>
  4. using namespace std;

  5. const int map_x = 16;
  6. const int map_y = 16;
  7. struct Mapelem{
  8.     bool status = false;
  9.     bool is_mine = false;
  10.     int course = 0;
  11. }Map[map_x][map_y];

  12. void Hidecursor()
  13. {
  14.     CONSOLE_CURSOR_INFO cci;
  15.     cci.bVisible = FALSE;
  16.     cci.dwSize = sizeof(cci);
  17.     HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  18.     SetConsoleCursorInfo(handle, &cci);
  19. }

  20. void gotoxy(int x,int y){
  21.     COORD cod;
  22.     cod.X = x * 2;
  23.     cod.Y = y;
  24.     SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), cod );
  25. }

  26. void print_course(int x,int y){
  27.     if(!Map[x][y].course){
  28.         printf(" ");
  29.         return;
  30.     }
  31.     printf("%d",Map[x][y].course);
  32. }

  33. void drawmap(){
  34.     for(int i=0; i<map_x; i++){
  35.         for(int j=0; j<map_y; j++){
  36.             gotoxy(i,j);
  37.             if(Map[i][j].status){
  38.                 if(Map[i][j].is_mine)
  39.                     printf("║О");
  40.                 else
  41.                     print_course(i,j);
  42.             }
  43.             else
  44.                 printf("║Ж");
  45.         }
  46.     }
  47. }

  48. void UpdateCursor(POINT po)
  49. {
  50.         drawmap();

  51.         gotoxy(po.x, po.y);
  52.         printf("║У");
  53. }

  54. void setmine(int num){
  55.     int x,y;
  56.     for(int i=0; i<num; i++){
  57.         do{
  58.             x = rand()%map_x;
  59.             y = rand()%map_y;
  60.         }while(Map[x][y].is_mine);
  61.         Map[x][y].is_mine = true;
  62.     }
  63. }

  64. int GetCount(int x, int y)
  65. {
  66.         int count = 0;

  67.         // вСио╫г -> срио╫г
  68.         for(int i = 0; i < 3; ++i)
  69.                 if((x - 1 + i >= 0) && (y - 1 >= 0))
  70.                         if(Map[x - 1 + i][y - 1].is_mine)
  71.                                 ++count;

  72.         // вСоб╫г -> сроб╫г
  73.         for(int i = 0; i < 3; ++i)
  74.                 if((x - 1 + i >= 0) && (y + 1 < map_y))
  75.                         if(Map[x - 1 + i][y + 1].is_mine)
  76.                                 ++count;

  77.         // вС╠ъ
  78.         if(x - 1 >= 0)                // спвС╠ъбП?
  79.                 if(Map[x - 1][y].is_mine)
  80.                         ++count;

  81.         // ср╠ъ
  82.         if(x + 1 < map_x)        // спср╠ъбП?
  83.                 if(Map[x + 1][y].is_mine)
  84.                         ++count;

  85.         return count;
  86. }

  87. void GenerateCount(void)
  88. {
  89.         for(int i = 0; i < map_x; ++i)
  90.         {
  91.                 for(int j = 0; j < map_y; ++j)
  92.                 {
  93.                         if(!Map[i][j].is_mine)
  94.                                 Map[i][j].course = GetCount(i, j);
  95.                 }
  96.         }
  97. }

  98. void show_mine(POINT p ){


  99.     if (Map[p.x][p.y].status)
  100.         return;
  101.     else if (Map[p.x][p.y].course>0){
  102.         Map[p.x][p.y].status = true;
  103.         return;
  104.     }
  105.     else{
  106.         Map[p.x][p.y].status = true;
  107.         POINT k;
  108.         int i;
  109.         for(i = 0; i < 3; ++i)
  110.                 if((p.x - 1 + i >= 0) && (p.y - 1 >= 0))
  111.                        {
  112.                             k.x = p.x - 1 +i;
  113.                             k.y = p.y - 1;
  114.                             show_mine(k);
  115.                         }
  116.         // вСоб╫г -> сроб╫г
  117.         for(i = 0; i < 3; ++i)
  118.                 if((p.x - 1 + i >= 0) && (p.y + 1 < map_y))
  119.                         {
  120.                             k.x = p.x - 1 + i;
  121.                             k.y = p.y + 1;
  122.                             show_mine(k);
  123.                         }
  124.         // вС╠ъ
  125.         if(p.x - 1 >= 0)                // спвС╠ъбП?
  126.                 {
  127.                     k.x = p.x - 1;
  128.                     k.y = k.y;
  129.                     show_mine(k);
  130.                 }

  131.         // ср╠ъ
  132.         if(p.x + 1 < map_x)        // спср╠ъбП?
  133.                 {
  134.                     k.x = p.x + 1;
  135.                     k.y = p.y;
  136.                     show_mine(k);
  137.                 }
  138.     }
  139. }

  140. bool SelectTarget(POINT p){
  141.     if(Map[p.x][p.y].status)
  142.         return false;
  143.     if(Map[p.x][p.y].is_mine)
  144.         return true;
  145.     //print_course(p.x,p.y);
  146.     show_mine(p);
  147.     drawmap();
  148.     return false;
  149. }

  150. void showmap(){
  151.     for(int i=0; i<map_x; i++){
  152.         for(int j=0; j<map_y; j++){
  153.             if(!Map[i][j].status){
  154.                 gotoxy(i,j);
  155.                 if(Map[i][j].is_mine)
  156.                     printf("║О");
  157.                 else
  158.                     print_course(i,j);
  159.             }
  160.         }
  161.     }
  162. }

  163. int main(){
  164.     srand((unsigned int)time(0));
  165.     Hidecursor();
  166.     drawmap();
  167.     setmine(30);
  168.     GenerateCount();

  169.     POINT p = {0,0};
  170.     UpdateCursor(p);

  171.     while(1){
  172.         char c = _getch();
  173.         switch(c){
  174.         case 'q':
  175.         case 'Q':
  176.             goto EXIT;
  177.             break;
  178.         case 'a':
  179.         case 'A':
  180.             if(p.x>0){
  181.                 p.x--;
  182.                 UpdateCursor(p);
  183.             }break;
  184.         case 's':
  185.         case 'S':
  186.             if(p.y<15){
  187.                 p.y++;
  188.                 UpdateCursor(p);
  189.             }break;
  190.         case 'W':
  191.         case 'w':
  192.             if(p.y>0){
  193.                 p.y--;
  194.                 UpdateCursor(p);
  195.             }break;
  196.         case 'd':
  197.         case 'D':
  198.             if(p.x<15){
  199.                 p.x++;
  200.                 UpdateCursor(p);
  201.             }break;
  202.         case ' ':
  203.             if(SelectTarget(p))
  204.                 goto EXIT;
  205.             break;
  206.         }
  207.     }
  208.     EXIT:
  209.         showmap();

  210.     return 0;
  211. }
复制代码
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2018-3-26 22:48:59 | 显示全部楼层
我觉得应该再加一个游戏通过的函数
ps:编码问题中文和一些字符无法显示。。。。
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2018-3-26 23:15:05 | 显示全部楼层
mintaka 发表于 2018-3-26 22:48
我觉得应该再加一个游戏通过的函数
ps:编码问题中文和一些字符无法显示。。。。

无标题.png

这是编码问题吗?
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2018-3-27 16:37:07 | 显示全部楼层
谢谢楼主
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2018-3-27 18:30:40 | 显示全部楼层
人造人 发表于 2018-3-26 23:15
这是编码问题吗?

是我电脑的编译器设置问题,原本的星号,方块会变成你这样子,虽然我运行时还是正常,你应该要改一下
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2024-3-28 17:41

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表