0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看威廉希尔官方网站 视频
  • 写文章/发帖/加入社区
会员中心
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

C语言零基础项目:自制军棋游戏!详细思路+源码分享

C语言编程学习基地 来源:C语言编程学习基地 2022-12-29 17:14 次阅读

每天一个C语言小项目,提升你的编程能力!

这是一款由 shareli 自创规则的军旗游戏,具体的游戏规则如下:

棋盘大小:6×6。

棋子总数:36。

敌对双方:红,蓝。

棋子类别:红棋(红方操作,14 个),蓝棋(蓝方操作,14 个),紫棋(功能棋,8 个)。

红棋(蓝棋)类型:司令,军长,师长,旅长,团长,营长,连长,班长,军旗,工兵×2,炸弹×2。

紫棋类型:地雷×4,变身棋×4。

【规则说明】

1. 司令最大,工兵最小,大的吃小的,一样就同归于尽,炸弹能炸紫棋和敌方除军旗外所有的棋(炸弹也会消失)。

2. 工兵可挖地雷,挖完后可扛对方棋变身(挖的雷越多,变成的人物越厉害)。

3. 人物棋可吃变,吃后能变成工兵~军长中的一种,有一定几率变成隐藏 BOSS。

4. 人物棋可自杀(算一次操作)。

5. 执棋方进行完一次有效操作后,就换对方执棋(边框颜色表当前执棋方)。

6. 一方棋子(军旗除外)全被消灭,就算输; 同时全部没有,则和棋。

【执棋方能进行的操作】

1. 打开棋子(算一次操作)。

2. 攻击。

3. 移动。

4. 工兵(已挖雷)扛旗。

5. 吃变身卡。

6. 自杀。

【实施游戏操作说明(鼠标操作)】

1. 选择要打开棋子所在的区域,单击。

2~5. 单击选中主动方(棋子边框会变绿),再单击选中被动方。

6. 选中己方棋子,单机鼠标的中键。

注:要进行其他操作,必先撤销当前选定(单击右键撤销)

【人物棋等级一览(等高杀等小)】

工1 班2 连3 营4 团5 旅6 师7 军8 飞8 司9 升9 神10 仙10。

注:“飞、升、神、仙”都为工兵挖雷后扛旗所变,“飞、升、神”能直线飞,“仙”能满天飞。

本项目编译环境:Visual Studio 2019/2022,EasyX插件

完整源代码如下:

#include 
#include 
#include 


#define  CHESIZE  40    // 棋盘尺寸,不能随意调整
#define  RESETX  170
#define  RESETY  350    // 重置原点


typedef enum      // 要用到的棋子ID
{
  si, jun, shi, lv, tuan, 
  ying, lian, pai, ban, gong, 
  fei, chao, zha, qi, lei, bian,
  xian, sheng,  shen
}CHESSID;


typedef enum      // 攻击类型
{
  comatt, preatt, noatt
}ATTSTYLE;


typedef enum      // 当前游戏方和棋子所属方
{
  blue, red, white
}TEAM;


typedef enum      // 选中与未选中
{
  alchoose, unchoose
}CHOOSESTATE;


typedef enum      // 区域状态
{
  unknow, empty, exist
}STATE;


typedef struct      // 坐标
{
  int x;
  int y;
}COOR;


typedef struct      // 棋子
{
  CHESSID    id;    // 棋子的ID
  int        power;  // 棋子的等级
  TEAM       team;  // 所属方
  char       *image;  // 该棋子的图片,考虑到运行问题,本程序用字代替
  int        scoopc;  // 工兵是挖到的地雷数
}CHESS;


typedef struct      // 区域
{
  COOR crdld;      // 区域的左下坐标
  CHESS chess;    // 区域的棋子
  STATE  state;    // 区域状态
}AREA;


typedef struct      // 用户的选择信息
{
  int i;      
  int j;
  CHOOSESTATE state;  // 选择状态
}CHOOSE;


IMAGE image;
AREA area[6][6];    // 定义棋盘大小
CHESS datachess[19];  // 几种基本棋子类型
CHOOSE choose;      // 用户选择信息
MOUSEMSG mmsg;      // 鼠标信息
TEAM  user;        // 执棋方
int lockchessboard = 0;  // 是否锁定棋盘
int i;          // 当前鼠标所在区域的坐标
int j;                         
char *str[]={"工","班","排","连","营","团","旅","师","军","司","棋","炸","变","雷","飞","超","升","神","仙"}; 


void init();      
void initchessbute();  // 给初始化棋子基本参数
void initvalue();
void drawboard();    // 画棋盘
void randomarr(int *);  // 实现棋的随机排列
void judge();
void getpreij();    // 获得当前鼠标所在区域坐标
int  checkij();      // 检查当鼠标所在区域
void open();      // 打开所在区域
int  whemove();      // 判断是否能移动
void move();      // 移动
int  judgeunknow();    // 检测当前未翻开棋子数
ATTSTYLE  wheattack();  // 判断是否能攻击
void kill();      // 杀死当前选择的棋
void killself();    // 自杀
void perishtogether();  // 同归于尽
void getteam();      // 用作改变棋子类型时,对棋子所属方赋值
void userchange();    // 交换执棋方
void judgebunko();    // 判断输赢
void choosearea();    // 选定区域
void cancelchoose();  // 取消选定
void change();      // 变身
void bluewin();      // 蓝方胜利
void redwin();      // 红方胜利
void gamehelp();    // 规则说明
void quit();      // 退出游戏
void peace();      // 和棋
void surrender();    // 投降
void resetchessboard();  // 重置


// 下面几个函数为判断棋子的攻击类型
ATTSTYLE judgegong();  // 判断工兵
ATTSTYLE judgecom();  // 判普通人物
ATTSTYLE judgezha();  // 判断炸弹


void main()        // 主函数
{
  init();


  while (true)
  {
    mmsg = GetMouseMsg();
    getpreij();


    if (mmsg.uMsg == WM_LBUTTONDOWN)   //单击左键
    {
      judge();
    }
    else if (mmsg.uMsg == WM_RBUTTONDOWN
        && choose.state==alchoose) //单击右键
    {
      cancelchoose();
    }
    else if (mmsg.uMsg == WM_MBUTTONDOWN
        && choose.state == alchoose
        && area[choose.i][choose.j].chess.id != zha) //单击中键
    {
      killself();
      cancelchoose();
      userchange();
      judgebunko(); 
    }
  }
}




void init()
{
  initgraph(640, 480);


  setorigin(RESETX, RESETY);    // 重置原点
  setaspectratio(1, -1);      // 把 y 轴上方设为正半轴


  drawboard();
  initvalue();


}


void drawboard()          // 画棋盘
{
  int i1;


  setlinecolor(WHITE);
  for (i1=0; i1<7; i1++)
  {
    line(i1*CHESIZE, 0, i1*CHESIZE, CHESIZE*6);
  }


  for (i1=0; i1<7; i1++)
  {
    line(0, i1*CHESIZE, CHESIZE*6, i1*CHESIZE);
  }




  setlinecolor(WHITE);
  setfillcolor(RED);
  rectangle(-10, -10, CHESIZE*6+10, CHESIZE*6+10);
  floodfill(-1, -1, WHITE);


  rectangle(7*CHESIZE, CHESIZE, 9*CHESIZE, 6*CHESIZE);
  line(7*CHESIZE, 5*CHESIZE, 9*CHESIZE, 5*CHESIZE);
  line(7*CHESIZE, 4*CHESIZE, 9*CHESIZE, 4*CHESIZE);
  line(7*CHESIZE, 3*CHESIZE, 9*CHESIZE, 3*CHESIZE);
  line(7*CHESIZE, 2*CHESIZE, 9*CHESIZE, 2*CHESIZE);
  setaspectratio(1, 1);
  settextstyle(35, 18, "黑体");
  settextcolor(RED);
  outtextxy(7*CHESIZE+2, -6*CHESIZE+2, "帮助");
  settextcolor(BROWN);
  outtextxy(7*CHESIZE+2, -5*CHESIZE+2, "投降");
  settextcolor(GREEN);
  outtextxy(7*CHESIZE+2, -4*CHESIZE+2, "和棋");
  settextcolor(YELLOW);
  outtextxy(7*CHESIZE+2, -3*CHESIZE+2, "重置");
  settextcolor(CYAN);
  outtextxy(7*CHESIZE+2, -2*CHESIZE+2, "退出");


  settextcolor(LIGHTMAGENTA);
  settextstyle(50, 20, "黑体");
  outtextxy(CHESIZE, -CHESIZE*8, "两国军旗");


  setaspectratio(1, -1);
}


void initchessbute()        // 设置棋子基本参数
{
  datachess[0].id = gong;
  datachess[0].power = 1;
  datachess[0].image = str[0];
  datachess[0].scoopc = 0;


  datachess[1].id = ban;
  datachess[1].power = 2;
  datachess[1].image = str[1];
  datachess[1].scoopc = 0;


  datachess[2].id = pai;
  datachess[2].power = 3;
  datachess[2].image = str[2];
  datachess[2].scoopc = 0;


  datachess[3].id = lian;
  datachess[3].power = 4;
  datachess[3].image = str[3];
  datachess[3].scoopc = 0;


  datachess[4].id = ying;
  datachess[4].power = 5;
  datachess[4].image = str[4];
  datachess[4].scoopc = 0;


  datachess[5].id = tuan;
  datachess[5].power = 6;
  datachess[5].image = str[5];
  datachess[5].scoopc = 0;


  datachess[6].id = lv;
  datachess[6].power = 7;
  datachess[6].image = str[6];
  datachess[6].scoopc = 0;


  datachess[7].id = shi;
  datachess[7].power = 8;
  datachess[7].image = str[7];
  datachess[7].scoopc = 0;


  datachess[8].id = jun;
  datachess[8].power = 9;
  datachess[8].image = str[8];
  datachess[8].scoopc = 0;


  datachess[9].id = si;
  datachess[9].power = 10;
  datachess[9].image = str[9];
  datachess[9].scoopc = 0;


  datachess[10].id =  qi;
  datachess[10].power = 100;
  datachess[10].image = str[10];
  datachess[10].scoopc = 0;


  datachess[11].id = zha;
  datachess[11].power = 99;
  datachess[11].image = str[11];
  datachess[11].scoopc = 0;


  datachess[12].id = bian;
  datachess[12].power = 0;
  datachess[12].image = str[12];
  datachess[12].scoopc = 0;


  datachess[13].id = lei;
  datachess[13].power = 98;
  datachess[13].image = str[13];
  datachess[13].scoopc = 0;


  datachess[14].id = fei;
  datachess[14].power = 9;
  datachess[14].image = str[14];
  datachess[14].scoopc = 0;


  datachess[15].id = chao;
  datachess[15].power = 11;
  datachess[15].image = str[15];
  datachess[15].scoopc = 0;


  datachess[16].id = sheng;
  datachess[16].power = 10;
  datachess[16].image = str[16];
  datachess[16].scoopc = 0;


  datachess[17].id = shen;
  datachess[17].power = 11;
  datachess[17].image = str[17];
  datachess[17].scoopc = 0;


  datachess[18].id = xian;
  datachess[18].power = 11;
  datachess[18].image = str[18];
  datachess[18].scoopc = 0;  
}


void initvalue()          // 初始化值
{
  CHESS chess[36];
  int random[36];
  int count;
  int i1, j1;
  
  initchessbute();


  randomarr(random);


  for (i1=0; i1<=11; i1++)
  {
    chess[i1] = datachess[i1];
    chess[i1].team = red;
  }
  chess[i1] = datachess[11];
  chess[i1].team = red;
  chess[i1+1] = datachess[0];
  chess[i1+1].team = red;


  for (i1=0; i1<=11; i1++)
  {
    chess[i1+14] = datachess[i1];
    chess[i1+14].team = blue;
  }
  chess[i1+14] = datachess[11];
  chess[i1+14].team = blue;
  chess[i1+15] = datachess[0];
  chess[i1+15].team = blue;  


  for (i1=0; i1<4; i1++)
  {
    chess[i1+28] = datachess[12];
    chess[i1+28].team = white;
    chess[i1+32] = datachess[13];
    chess[i1+32].team = white;
  }


  setfillcolor(YELLOW);
  for (count=0, i1=0; i1<6; i1++)
  {
    for (j1=0; j1<6; j1++, count++)
    {
      area[i1][j1].chess = chess[random[count]];
      area[i1][j1].crdld.x = i1 * CHESIZE + 1;
      area[i1][j1].crdld.y = j1 * CHESIZE + 1;
      area[i1][j1].state = unknow;
      floodfill(area[i1][j1].crdld.x, area[i1][j1].crdld.y, WHITE);
    }
  }
  user = red;
  choose.state = unchoose;


}


void randomarr(int random[])    // 得到0~36数字的随机排列
{
  int i1, j1;
  int flag = 0;


  srand(time(NULL));
  random[0] = rand() % 36 ;


  for (i1=1; i1<36; i1++)
  {
    while (1)
    {
      random[i1] = rand() % 36 ;
      for (j1=0; j1=0 && i<=5 && j>=0 && j<=5 && (mmsg.x-RESETX)>0 && -(mmsg.y-RESETY)>0))
      {
        return 1;
      }
      else
      {
        return 0;
      }
    }
    else
    {
      return 0;
    }
  }
}


// 打开操作
void open()
{
  setfillcolor(BLACK);
  floodfill(area[i][j].crdld.x, area[i][j].crdld.y, WHITE);


  setaspectratio(1, 1);
  if (area[i][j].chess.team == blue)
  {
    settextcolor(BLUE);
  }
  else if (area[i][j].chess.team == red)
  {
    settextcolor(RED);
  }
  else
  {
    settextcolor(MAGENTA);
  }
  settextstyle(35, 18, "黑体");
  outtextxy(area[i][j].crdld.x, -area[i][j].crdld.y-CHESIZE+2, area[i][j].chess.image);
  area[i][j].state = exist;
  setaspectratio(1, -1);
}


// 判断是否能移动
int whemove()
{
  if (area[choose.i][choose.j].chess.id==fei || area[choose.i][choose.j].chess.id==sheng
    || area[choose.i][choose.j].chess.id==shen)
  {
    if (choose.i==i && abs(choose.j-j)<=5 || choose.j==j && abs(choose.i-i)<=5)
    {
      return 1;
    }
    else
    {
      return 0;
    }
  }
  else if (area[choose.i][choose.j].chess.id == xian)
  {
    return 1;
  }
  else
  {
    if (choose.i==i && abs(choose.j-j)==1 || choose.j==j && abs(choose.i-i)==1)
    {
      return 1;
    }
    else
    {
      return 0;
    }
  }
}


// 移动
void move()
{
  setfillcolor(BLACK);
  floodfill(area[choose.i][choose.j].crdld.x, area[choose.i][choose.j].crdld.y, GREEN);
  
  setaspectratio(1, 1);
  if (area[choose.i][choose.j].chess.id==gong && area[choose.i][choose.j].chess.scoopc>0)
  {
    if (area[choose.i][choose.j].chess.team == blue)
    {
      settextcolor(LIGHTBLUE);
    }
    else
    {
      settextcolor(LIGHTRED);
    }
  }
  else
  {
    if (user == blue)
    {
      settextcolor(BLUE);
    }
    else 
    {
      settextcolor(RED);
    }
  }
  settextstyle(35, 18, "黑体");
  outtextxy(area[i][j].crdld.x, -area[i][j].crdld.y-CHESIZE+2, area[choose.i][choose.j].chess.image);


  area[choose.i][choose.j].state = empty;
  area[i][j].state = exist;
  area[i][j].chess = area[choose.i][choose.j].chess;
  setaspectratio(1, -1);
}


// 判断是否能攻击,并返回攻击类型
ATTSTYLE  wheattack()                              
{
  if (whemove())
  {
    if (area[choose.i][choose.j].chess.id == gong)
    {
      return judgegong();
    }
    else if (area[choose.i][choose.j].chess.id == zha)
    {
      return judgezha();
    }
    else
    {
      return judgecom();
    }
  }
  else
  {
    return noatt;
  }
      
}


// 判断工兵
ATTSTYLE judgegong()                    
{
  if (area[i][j].chess.team != white)
  {
    if (area[choose.i][choose.j].chess.team != area[i][j].chess.team)
    {
      if (area[i][j].chess.id==gong || area[i][j].chess.id==zha)
      {
        return preatt;
      }
      else if (area[i][j].chess.id == qi)
      {
        if (area[choose.i][choose.j].chess.scoopc == 0)
        {
          return noatt;
        }
        else if (area[choose.i][choose.j].chess.scoopc == 1)
        {
          area[choose.i][choose.j].chess = datachess[14];
          getteam();
          return comatt;
        }
        else if (area[choose.i][choose.j].chess.scoopc == 2)
        {
          area[choose.i][choose.j].chess = datachess[16];
          getteam();
          return comatt;
        }
        else if (area[choose.i][choose.j].chess.scoopc == 3)
        {
          area[choose.i][choose.j].chess = datachess[17];
          getteam();
          return comatt;
        }
        else
        {
          area[choose.i][choose.j].chess = datachess[18];
          getteam();
          return comatt;
        }
      }
      else
      {
        return noatt;
      }
    }
    else
    {
      return noatt;
    }
  }
  else
  {
    if (area[i][j].chess.id == lei)
    {
      area[choose.i][choose.j].chess.scoopc++;
      return comatt;
    }
    else
    {
      change();
      return comatt;
    }
  }
}


// 判断炸弹
ATTSTYLE judgezha()                          
{
  if (area[choose.i][choose.j].chess.team != area[i][j].chess.team)
  {
    if (area[i][j].chess.id != qi)
    {
      return preatt;
    }
    else
    {
      return noatt;
    }
  }
  else
  {
    return noatt;
  }
}


// 判断普通人物  
ATTSTYLE judgecom()                    
{
  if (area[i][j].chess.team != white)
  {
    if (area[choose.i][choose.j].chess.team != area[i][j].chess.team)
    {
      if (area[choose.i][choose.j].chess.power==area[i][j].chess.power || area[i][j].chess.id==zha)
      {
        return preatt;
      }
      else if (area[choose.i][choose.j].chess.power > area[i][j].chess.power)
      {
        return comatt;
      }
      else 
      {
        return noatt;
      }
    }
    else
    {
      return noatt;
    }
  }
  else
  {
    if (area[i][j].chess.id == lei)
    {
      return noatt;
    }
    else
    {
      change();
      return comatt;
    }
  }
}


// 变身
void change()                              
{
  int x;
  x = rand() % 50;
  if (x == 6)
  {
    area[choose.i][choose.j].chess = datachess[15];
    getteam();
  }
  else
  {
    x = rand() % 4;
    if (x == 3)
    {
      x = rand() % 2;
      if (x == 0)
      {
        area[choose.i][choose.j].chess = datachess[7];
      }
      else
      {
        area[choose.i][choose.j].chess = datachess[8];
      }
      
      getteam();
    }
    else
    {
      x = rand() % 6;
      area[choose.i][choose.j].chess = datachess[x];


      getteam();
    }
  }
}


// 对棋子所属方赋值
void getteam()                       
{
  if (user == blue)
  {
    area[choose.i][choose.j].chess.team = blue;
  }
  else
  {
    area[choose.i][choose.j].chess.team = red;
  }
}


// 杀死对方
void kill()                        
{
  move();
}


// 自杀
void killself()                     
{
  setfillcolor(BLACK);
  floodfill(area[choose.i][choose.j].crdld.x, area[choose.i][choose.j].crdld.y, GREEN);
  area[choose.i][choose.j].state = empty;
}


// 同归于尽
void perishtogether()              
{
  setfillcolor(BLACK);
  cancelchoose();
  floodfill(area[choose.i][choose.j].crdld.x, area[choose.i][choose.j].crdld.y, WHITE);
  floodfill(area[i][j].crdld.x, area[i][j].crdld.y, WHITE);


  area[choose.i][choose.j].state = empty;
  area[i][j].state = empty;
}


// 切换执棋方
void userchange()                    
{
  if (user == blue)
  {
    user = red;
    setfillcolor(RED);
    floodfill(-1, -1, WHITE);
  }
  else
  {
    user = blue;
    setfillcolor(BLUE);
    floodfill(-1, -1, WHITE);
  }
}


// 判断输赢
void judgebunko()                          
{
  int i1, j1;
  int num1 = 0, num2 = 0;


  for (i1=0; i1<6; i1++)
  {
    for (j1=0; j1<6; j1++)
    {
      if (area[i1][j1].state != empty)
      {
        if (area[i1][j1].chess.team==red && area[i1][j1].chess.id!=qi)
        {
          num1++;
        }
        else if(area[i1][j1].chess.team==blue && area[i1][j1].chess.id!=qi)
        {
          num2++;
        }
      }
    }
  }
  
  if (num1==0 && num2!=0)
  {
    bluewin();
  }


  if (num2==0 && num1!=0)
  {
    redwin();
  }
  
  if (num1==0 && num2==0)
  {
    peace();
  }
}


// 蓝方胜
void bluewin()                   
{
  setaspectratio(1, 1);
  settextcolor(BLUE);
  settextstyle(50, 20, "黑体");
  outtextxy(CHESIZE, -CHESIZE*8, "蓝方胜利");
  setaspectratio(1, -1);
  setfillcolor(BLUE);
  floodfill(-1, -1, WHITE);


  lockchessboard = 1;              //锁定棋盘
}


// 红方胜
void redwin()                    
{
  setaspectratio(1, 1);
  settextcolor(RED);
  settextstyle(50, 20, "黑体");
  outtextxy(CHESIZE, -CHESIZE*8, "红方胜利");
  setaspectratio(1, -1);
  setfillcolor(RED);
  floodfill(-1, -1, WHITE);


  lockchessboard = 1;
}


// 和棋
void peace()                      
{ 
  setaspectratio(1, 1); 
  settextcolor(GREEN);
  settextstyle(50, 20, "黑体");
  outtextxy(CHESIZE, -CHESIZE*8, "握手言和");
  setaspectratio(1, -1);
  setfillcolor(GREEN);
  floodfill(-1, -1, WHITE);


  lockchessboard = 1;
}


// 投降
void surrender()                   
{
  if (user == blue)
  {
    redwin();
  }
  else
  {
    bluewin();
  }
}


// 重置
void resetchessboard()              
{
  cleardevice();
  init();
}


// 游戏说明
void gamehelp()              
{
  getimage(&image, -10, -10, 500, 350);
  cleardevice();


  setorigin(50, 0);
  setaspectratio(1, 1);


  settextcolor(RED);
  settextstyle(14, 0, "黑体");
  outtextxy(-50, 0, "注:单击鼠标左键回到游戏界面");


  settextcolor(WHITE);
  settextstyle(24, 0, "黑体");
  outtextxy(230, 5, "游戏说明");
  settextstyle(12, 0, "宋体");
  outtextxy(0, 35, "棋盘大小:6*6;              棋子总数:36;            敌对双方:红,蓝");
  outtextxy(0, 60, "棋子类别:红棋(红方操作,14个) 蓝棋(蓝方操作,14个) 紫棋(功能棋,8个)");
  outtextxy(0, 85, "红棋(蓝棋)类型:司令,军长,师长,旅长,团长,营长,连长,班长,军旗,工兵*2,炸弹*2.");
  outtextxy(0, 100, "紫棋类型:地雷*4,变身棋*4.  注:'*'后面表示该棋的数量,没注则只有一个");
  outtextxy(0, 125, "规则说明:1.司令最大,工兵最小,大的吃小的,一样就同归于尽,");
  outtextxy(textwidth("规则说明:1."), 140, "炸弹能炸紫棋和敌方除军旗外所有的棋(炸弹也会消失)." );
  outtextxy(textwidth("规则说明:"), 155, "2.工兵可挖地雷,挖完后可扛对方棋变身(挖的雷越多,变成的人物越厉害).");
  outtextxy(textwidth("规则说明:"), 170, "3.人物棋可吃变,吃后能变成工兵~军长中的一种,有一定几率变成隐藏BOSS.");
  outtextxy(textwidth("规则说明:"), 185, "4.人物棋可自杀(算一次操作).");
  outtextxy(textwidth("规则说明:"), 200, "5.执棋方进行完一次有效操作后,就换对方执棋(边框颜色表当前执棋方).");
  outtextxy(textwidth("规则说明:"), 215, "6.一方棋子(军旗除外)全被消灭,就算输; 同时全部没有,则和棋.");
  outtextxy(0, 240, "执棋方能进行的操作:操作1:打开棋子(算一次操作).");
  outtextxy(textwidth("执棋方能进行的操作:"), 255, "操作2:攻击.");
  outtextxy(textwidth("执棋方能进行的操作:"), 270, "操作3:移动.");
  outtextxy(textwidth("执棋方能进行的操作:"), 285, "操作4:工兵(已挖雷)扛旗.");
  outtextxy(textwidth("执棋方能进行的操作:"), 300, "操作5:吃变身卡.");
  outtextxy(textwidth("执棋方能进行的操作:"), 315, "操作6:自杀.");
  outtextxy(0, 340, "实施游戏操作说明(鼠标操作):实施操作1:选择要打开棋子所在的区域,单击.");
  outtextxy(textwidth("实施游戏操作说明(鼠标操作):"), 355, "实施操作2~5:单击选中主动方(棋子边框会变绿)");
  outtextxy(textwidth("实施游戏操作说明(鼠标操作):实施操作2~5:"), 370, "再单击选中被动方.");
  outtextxy(textwidth("实施游戏操作说明(鼠标操作):"), 385, "实施操作6:选中己方棋子,单机鼠标的中键.");
  settextcolor(RED);
  outtextxy(textwidth("实施游戏操作说明(鼠标操作):"), 400,"注:要进行其他操作,必先撤销当前选定(单击右键撤销)");
  settextcolor(WHITE);
  setlinecolor(WHITE);
  line(-30, 420, 570, 420);
  outtextxy(0, 425, "人物棋等级一览(等高杀等小):工1 班2 连3 营4 团5 旅6 师7");
  outtextxy(textwidth("人物棋等级一览(等高杀等小):"), 440, "军8 飞8 司9 升9 神10 仙10");
  outtextxy(0, 455, "注:'飞' '升' '神' '仙' 都为工兵挖雷后扛旗所变,'飞''升''神'能直线飞,'仙'能满天飞");


  while (true)
  {
    mmsg = GetMouseMsg();


    if (mmsg.uMsg == WM_LBUTTONDOWN)
    {
      break;
    }
  }


  cleardevice();
  setorigin(RESETX, RESETY);
  setaspectratio(1, -1);
  putimage(-10, -10, &image);
}


// 退出游戏
void quit()     
{
  closegraph();
}

大家赶紧去动手试试吧!

审核编辑:汤梓红

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • 游戏
    +关注

    关注

    2

    文章

    742

    浏览量

    26313
  • C语言
    +关注

    关注

    180

    文章

    7604

    浏览量

    136714
  • 编程
    +关注

    关注

    88

    文章

    3614

    浏览量

    93698
  • 源码
    +关注

    关注

    8

    文章

    639

    浏览量

    29185

原文标题:C语言零基础项目:自制军棋游戏!详细思路+源码分享

文章出处:【微信号:cyuyanxuexi,微信公众号:C语言编程学习基地】欢迎添加关注!文章转载请注明出处。

收藏 人收藏

    评论

    相关推荐

    C语言零基项目:涂格子(点灯)游戏详细思路+源码分享

    点灯游戏是一个十分有趣的智力游戏:有一行N行N列的灯,开始时全部是灭的,当你点击其中一盏灯时他的上下左右(若存在的话)状态全部改变,现在要求你在限定的时间内以最少地步数,将全部的灯点亮。
    发表于 12-16 09:47 875次阅读

    C语言零基项目:贪吃蛇!详细思路+源码分享

    每天一个C语言项目,提升你的编程能力!
    发表于 12-19 11:04 711次阅读

    零基础怎样学习C语言呢?

    零基础学c语言如何开始
    发表于 05-15 10:23

    C语言游戏源码分享

    C语言游戏源码24点火柴人俄罗斯等等等35个游戏源码网盘分享链接:https://pan.ba
    发表于 04-12 17:11

    C语言零基础入门教学资料汇总下载

    C语言零基础入门教学资料汇总下载
    发表于 05-29 10:41 132次下载

    C语言零基项目:打字母游戏详细思路+源码分享

    今天就用C语言写了这么个打字母的小程序,就是以前学习机上那种字母往下掉,然后按相应键字母消失的游戏
    发表于 12-15 15:02 642次阅读

    C语言零基项目:迷宫游戏详细思路+源码分享

    每天一个C语言项目,提升你的编程能力!
    的头像 发表于 12-21 10:08 967次阅读

    C语言零基项目:生命游戏详细思路+源码分享

    生命游戏不需要任何玩家,它是一个二维矩形世界,这个世界中的每个方格居住着一个活细胞或为空。
    的头像 发表于 12-22 11:17 1027次阅读

    C语言零基项目:推箱子游戏详细思路+源码分享

    推箱子是一个来自日本的古老游戏,目的是在训练你的逻辑思考能力。在一个狭小的仓库中,要求把木箱放到指定的位置,稍不小心就会出现箱子无法移动或者通道被堵住的情况,所以需要巧妙的利用有限的空间和通道,合理安排移动的次序和位置,才能顺利的完成任务。
    的头像 发表于 12-27 10:38 843次阅读

    C语言零基项目:黑白棋游戏详细思路+源码分享

    《黑白棋》也叫翻转棋或者奥赛罗,其游戏过程是相互翻转对方的棋子,最后以棋盘上谁的棋子多来判断胜负。虽然规则简单,但是变化复杂,是典型的易学难精,奥妙无穷,不信您就试试看吧!
    的头像 发表于 12-29 11:12 995次阅读

    C语言零基项目:对对碰(消除类)游戏详细思路+源码分享

    游戏中消除的对象为各种各样的头像,包括树、小车、草莓和酒瓶等一些头像。玩家通关移动这些头像位置凑够一定数量的相同图标即可消除。
    的头像 发表于 01-03 11:13 782次阅读

    C语言零基项目:吃豆人小游戏详细思路+源码分享

    《吃豆游戏》是一款休闲小游戏,和贪吃蛇,球球大作战吃食物都是有差不多的游戏逻辑。
    的头像 发表于 01-03 11:38 1504次阅读

    C语言项目:矿井逃生游戏(密室)!详细思路+源码分享

    密室逃脱相信大部分都玩过了吧?本游戏就是一种用C语言写的类似的游戏,因为用手电筒照明找路,所以有点像矿工的样子,还是叫它矿井逃生吧!(以下是游戏
    的头像 发表于 01-07 09:41 1427次阅读

    C语言项目:接球小游戏自制)!详细思路+源码分享

    用VS写了一个小小的游戏,在界面右侧有运行时间,接到的小球个数等信息,有 10 个小球下落,玩家可以控制一个盒子左右移动(方向键),来接小球,按 Esc 键退出,最后会显示接到的小球的数目/分数。
    的头像 发表于 01-09 11:00 905次阅读

    C语言零基项目:打飞机游戏!300行源码分享+详细思路

    游戏中,你操控你的防空车尽可能的多击落飞机,躲避飞机扔的炸弹。
    的头像 发表于 01-11 09:31 1053次阅读