devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C#核心--实践小项目（贪吃蛇）_c#贪吃蛇

作者：喵喵爱编程 | 2024-07-09 16:14:40

赞

踩

c#贪吃蛇

C#核心实践小项目 -- 贪吃蛇

必备知识点--多脚本文件

（可观看CSharp核心--52集进行了解）

必备知识点--UML类图

必备知识点--七大原则

贪吃蛇

项目展示

控制方向的是：WSAD

确定键是：J

需求分析（UML类图）

自个先写--贪吃蛇

结合自己所学进行开发（UML类图是老师提供的，因为自己暂时还不太会绘制，主要是代码逻辑还不够清晰）

补充知识点：

检测键盘是否激活

Console.KeyAvailable == true;

按照UML类图逐个去写逐个去实现（但是有些模块我没有用上）

主要精力是放在了功能实现上

下面是我实现的过程

一、万事开头难--游戏类

（我先确定了开始着手的地方--游戏类，因为它是所有类和方法的汇聚地）

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8. //游戏类
  9.  
  10. namespace 自个先写CSharp核心小项目_贪吃蛇_
  11. {
  12.     enum E_Scene
  13.     {
  14.         BeginID,
  15.         GamingID,
  16.         FinishID,
  17.     }
  18.  
  19.     class Game
  20.     {
  21.         public static int x;
  22.         public static int y;
  23.         public static E_Scene scene = new E_Scene();
  24.         Begin begin = new Begin();
  25.         Finish finish = new Finish();
  26.  
  27.         public Game()
  28.         {
  29.             x = 100;
  30.             y = 30;
  31.             scene = E_Scene.BeginID;
  32.         }
  33.  
  34.         //初始化控制台
  35.         public void Consoles()
  36.         {
  37.             //隐藏光标
  38.             Console.CursorVisible = false;
  39.             //设置舞台大小
  40.             Console.SetWindowSize(x, y);
  41.             Console.SetBufferSize(x, y);
  42.  
  43.         }
  44.  
  45.         //游戏主循环
  46.         public void MajorCycle()
  47.         {
  48.             while (true)
  49.             {
  50.                 //思考一下，为什么把开始场景和结束场景的类申明放在外面，而游戏场景的类申明放循环里面
  51.                 //因为开始结束场景是一成不变的，只需申明一次就够用了
  52.                 //而游戏场景进入一次就会执行出结果出来，每次结果都将不一样，所以每次都得重新申明
  53.                 switch (scene)
  54.                 {
  55.                     case E_Scene.BeginID:
  56.                         Console.Clear();
  57.                         begin.newers();
  58.                         break;
  59.                     case E_Scene.GamingID:
  60.                         Console.Clear();
  61.                         GameScene gameScene = new GameScene();
  62.                         gameScene.newers();
  63.                         break;
  64.                     case E_Scene.FinishID:
  65.                         Console.Clear();
  66.                         finish.newers();
  67.                         break;
  68.                     default:
  69.                         break;
  70.                 }
  71.             }
  72.         }
  73.  
  74.         //场景切换
  75.         public void SceneMove()
  76.         {
  77.  
  78.         }
  79.  
  80.     }
  81. }
二、游戏帧更新接口
1.更新接口

2.开始和结束场景基类

开始场景类
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. //开始场景
  8.  
  9. namespace 自个先写CSharp核心小项目_贪吃蛇_
  10. {
  11.     class Begin : BeginAndFinish
  12.     {
  13.         public Begin()
  14.         {
  15.             str = "贪吃蛇";
  16.             str1 = "开始游戏";
  17.             str2 = "结束游戏";
  18.         }
  19.  
  20.         //重写更新方法
  21.         public override void newers()
  22.         {
  23.             Console.SetCursorPosition(48, 10);
  24.             Console.ForegroundColor = ConsoleColor.White;
  25.             Console.WriteLine(str);
  26.             Console.SetCursorPosition(47, 13);
  27.             Console.ForegroundColor = key == 1 ? ConsoleColor.Red : ConsoleColor.White;
  28.             Console.WriteLine(str1);
  29.             Console.SetCursorPosition(47, 15);
  30.             Console.ForegroundColor = key == 2 ? ConsoleColor.Red : ConsoleColor.White;
  31.             Console.WriteLine(str2);
  32.  
  33.             char c = Console.ReadKey(true).KeyChar;
  34.             switch (c)
  35.             {
  36.                 case 'W':
  37.                 case 'w':
  38.                     key = 1;
  39.                     break;
  40.                 case 'S':
  41.                 case 's':
  42.                     key = 2;
  43.                     break;
  44.                 case 'J':
  45.                 case 'j':
  46.                     if (key == 2)
  47.                     {
  48.                         //关闭控制台
  49.                         Environment.Exit(0);
  50.                     }
  51.                     Game.scene = (E_Scene)key;
  52.                     break;
  53.                 default:
  54.                     break;
  55.             }
  56.         }
  57.     }
  58. }
结束场景类
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. //结束场景
  8.  
  9. namespace 自个先写CSharp核心小项目_贪吃蛇_
  10. {
  11.     class Finish : BeginAndFinish
  12.     {
  13.         string str0;
  14.         public static int num;
  15.  
  16.         public Finish()
  17.         {
  18.             key = 0;
  19.             str = "游戏结束";
  20.             str0 = "本次游戏的长度为:";
  21.             str1 = "回到开始界面";
  22.             str2 = "结束游戏";
  23.         }
  24.  
  25.         //重写更新方法
  26.         public override void newers()
  27.         {
  28.             Console.SetCursorPosition(47, 10);
  29.             Console.ForegroundColor = ConsoleColor.White;
  30.             Console.WriteLine(str);
  31.             Console.SetCursorPosition(42, 12);
  32.             Console.ForegroundColor = ConsoleColor.White;
  33.             Console.WriteLine(str0 + num);
  34.             Console.SetCursorPosition(45, 15);
  35.             Console.ForegroundColor = key == 0 ? ConsoleColor.Red : ConsoleColor.White;
  36.             Console.WriteLine(str1);
  37.             Console.SetCursorPosition(47, 17);
  38.             Console.ForegroundColor = key == 2 ? ConsoleColor.Red : ConsoleColor.White;
  39.             Console.WriteLine(str2);
  40.  
  41.             char c = Console.ReadKey(true).KeyChar;
  42.             switch (c)
  43.             {
  44.                 case 'W':
  45.                 case 'w':
  46.                     key = 0;
  47.                     break;
  48.                 case 'S':
  49.                 case 's':
  50.                     key = 2;
  51.                     break;
  52.                 case 'J':
  53.                 case 'j':
  54.                     if (key == 2)
  55.                     {
  56.                         //关闭控制台
  57.                         Environment.Exit(0);
  58.                     }
  59.                     Game.scene = (E_Scene)key;
  60.                     break;
  61.                 default:
  62.                     break;
  63.             }
  64.         }
  65.  
  66.     }
  67. }

（这里面其实可以把这些方法提取到开始和结束场景基类里面的，但我懒，没有去整！！！）

3.游戏场景类

（第二个大类，游戏里的墙壁、食物、蛇、各种方法等等都汇聚在这个类中）

三、游戏场景中的各类
1.绘制接口

2.游戏对象类

（讲真的这个类没怎么用上，具体怎么用我还得看看老师是怎么用的）

3.位置结构体

（这个是完全没有用上！！）

4.地图墙壁类

5.食物类

6.蛇类--（最复杂的类）

蛇身体类--没用上

蛇类
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. //蛇类
  8.  
  9. namespace 自个先写CSharp核心小项目_贪吃蛇_
  10. {
  11.     //移动方向枚举
  12.     enum E_Move
  13.     {
  14.         Up,
  15.         Down,
  16.         Left,
  17.         Right,
  18.     }
  19.  
  20.     class Snake
  21.     {
  22.         string snakeHead = "●";
  23.         string snakeBody = "◎";
  24.         int x = 10;
  25.         int y = 5;
  26.         E_Move move = E_Move.Down;
  27.         char c;
  28.         Foods foods = new Foods();
  29.         int bodyNum = 0;
  30.         //标识符
  31.         int[] num1 = new int[10000];
  32.         int[] num2 = new int[10000];
  33.         //打印出长度
  34.         public string longs = "当前长度为:";
  35.  
  36.         //蛇绘制
  37.         public void SnakePlan()
  38.         {
  39.             //打印长度
  40.             Console.SetCursorPosition(2, 1);
  41.             Console.ForegroundColor = ConsoleColor.Red;
  42.             Console.WriteLine(longs + bodyNum);
  43.  
  44.             Finish.num = bodyNum;
  45.  
  46.             //蛇头的绘制
  47.             Console.SetCursorPosition(x, y);
  48.             Console.ForegroundColor = ConsoleColor.Yellow;
  49.             Console.WriteLine(snakeHead);
  50.  
  51.             //蛇身的绘制
  52.             for (int i = 0; i < bodyNum; i++)
  53.             {
  54.                 Console.SetCursorPosition(num1[i], num2[i]);
  55.                 Console.ForegroundColor = ConsoleColor.Green;
  56.                 Console.WriteLine(snakeBody);
  57.             }
  58.         }
  59.  
  60.         //蛇清除
  61.         public void SnakeClear()
  62.         {
  63.             //打印长度清除
  64.             Console.SetCursorPosition(2, 1);
  65.             Console.WriteLine("               ");
  66.             //蛇头的清除
  67.             Console.SetCursorPosition(x, y);
  68.             Console.WriteLine("  ");
  69.  
  70.             //蛇身的清除
  71.             for (int i = 0; i < bodyNum; i++)
  72.             {
  73.                 Console.SetCursorPosition(num1[i], num2[i]);
  74.                 Console.WriteLine("  ");
  75.             }
  76.         }
  77.  
  78.         //蛇转向
  79.         public void SnakeTurn()
  80.         {
  81.             //老师漏讲的知识点，Console.KeyAvailable -- 检测键盘是否被激活
  82.             if (Console.KeyAvailable == true)
  83.             {
  84.                 c = Console.ReadKey(true).KeyChar;
  85.                 switch (c)
  86.                 {
  87.                     case 'W':
  88.                     case 'w':
  89.                         if (move == E_Move.Down && bodyNum != 0)
  90.                         {
  91.                             move = E_Move.Down;
  92.                         }
  93.                         else
  94.                         {
  95.                             move = E_Move.Up;
  96.                         }
  97.                         break;
  98.                     case 'S':
  99.                     case 's':
  100.                         if (move == E_Move.Up && bodyNum != 0)
  101.                         {
  102.                             move = E_Move.Up;
  103.                         }
  104.                         else
  105.                         {
  106.                             move = E_Move.Down;
  107.                         }
  108.                         break;
  109.                     case 'A':
  110.                     case 'a':
  111.                         if (move == E_Move.Right && bodyNum != 0)
  112.                         {
  113.                             move = E_Move.Right;
  114.                         }
  115.                         else
  116.                         {
  117.                             move = E_Move.Left;
  118.                         }
  119.                         break;
  120.                     case 'D':
  121.                     case 'd':
  122.                         if (move == E_Move.Left && bodyNum != 0)
  123.                         {
  124.                             move = E_Move.Left;
  125.                         }
  126.                         else
  127.                         {
  128.                             move = E_Move.Right;
  129.                         }
  130.                         break;
  131.                     default:
  132.                         break;
  133.                 }
  134.             }
  135.             
  136.         } 
  137.  
  138.         //吃食物
  139.  
  140.         //死亡
  141.  
  142.         
  143.  
  144.  
  145.         //蛇移动 -- (包含了蛇绘制、蛇转向、吃食物）
  146.         public void SnakeMove()
  147.         {
  148.             if(foods.x == 0 || foods.y == 0)
  149.             {
  150.                 foods.Plan();
  151.             }
  152.             SnakeTurn();
  153.             switch (move)
  154.             {
  155.                 case E_Move.Up:
  156.                     SnakeClear();
  157.                     y -= 1;
  158.                     //判断是否死亡
  159.                     //撞墙死亡
  160.                     if (y == 0)
  161.                     {
  162.                         Game.scene = E_Scene.FinishID;
  163.                         GameScene.bo = false;
  164.                         break;
  165.                     }
  166.                     //撞身体死亡
  167.                     for (int i = 0; i < bodyNum; i++)
  168.                     {
  169.                         if(num1[i] == x && num2[i] == y)
  170.                         {
  171.                             Game.scene = E_Scene.FinishID;
  172.                             GameScene.bo = false;
  173.                             break;
  174.                         }
  175.                     }
  176.  
  177.                     if (foods.x == x && foods.y == y)
  178.                     {
  179.                         foods.Plan();
  180.                         //给个判断，让生成的food不会出现在有蛇身体的位置上
  181.                         for (int i = 0; i < bodyNum; i++)
  182.                         {
  183.                             if (foods.x == num1[i] && foods.y == num2[i])
  184.                             {
  185.                                 Console.SetCursorPosition(foods.x, foods.y);
  186.                                 Console.WriteLine("  ");
  187.                                 foods.Plan();
  188.                                 i = 0;
  189.                             }
  190.                         }
  191.  
  192.                         bodyNum += 1;
  193.                         for (int i = bodyNum - 1; i > 0; i--)
  194.                         {
  195.                             num1[i] = num1[i - 1];
  196.                             num2[i] = num2[i - 1];
  197.                         }
  198.                         num1[0] = x;
  199.                         num2[0] = y + 1;
  200.                     }
  201.                     else
  202.                     {
  203.                         for (int i = bodyNum - 1; i > 0; i--)
  204.                         {
  205.                             num1[i] = num1[i - 1];
  206.                             num2[i] = num2[i - 1];
  207.                         }
  208.                         num1[0] = x;
  209.                         num2[0] = y + 1;
  210.                     }
  211.                     SnakePlan();
  212.                     
  213.                     break;
  214.                 case E_Move.Down:
  215.                     SnakeClear();
  216.                     y += 1;
  217.                     //判断是否死亡
  218.                     //撞墙死亡
  219.                     if (y == 29)
  220.                     {
  221.                         Game.scene = E_Scene.FinishID;
  222.                         GameScene.bo = false;
  223.                         break;
  224.                     }
  225.                     //撞身体死亡
  226.                     for (int i = 0; i < bodyNum; i++)
  227.                     {
  228.                         if (num1[i] == x && num2[i] == y)
  229.                         {
  230.                             Game.scene = E_Scene.FinishID;
  231.                             GameScene.bo = false;
  232.                             break;
  233.                         }
  234.                     }
  235.  
  236.                     if (foods.x == x && foods.y == y)
  237.                     {
  238.                         foods.Plan();
  239.                         //给个判断，让生成的food不会出现在有蛇身体的位置上
  240.                         for (int i = 0; i < bodyNum; i++)
  241.                         {
  242.                             if (foods.x == num1[i] && foods.y == num2[i])
  243.                             {
  244.                                 Console.SetCursorPosition(foods.x, foods.y);
  245.                                 Console.WriteLine("  ");
  246.                                 foods.Plan();
  247.                                 i = 0;
  248.                             }
  249.                         }
  250.  
  251.                         bodyNum += 1;
  252.                         for (int i = bodyNum - 1; i > 0; i--)
  253.                         {
  254.                             num1[i] = num1[i - 1];
  255.                             num2[i] = num2[i - 1];
  256.                         }
  257.                         num1[0] = x;
  258.                         num2[0] = y - 1;
  259.                     }
  260.                     else
  261.                     {
  262.                         for (int i = bodyNum - 1; i > 0; i--)
  263.                         {
  264.                             num1[i] = num1[i - 1];
  265.                             num2[i] = num2[i - 1];
  266.                         }
  267.                         num1[0] = x;
  268.                         num2[0] = y - 1;
  269.                     }
  270.                     SnakePlan();
  271.                     break;
  272.                 case E_Move.Left:
  273.                     SnakeClear();
  274.                     x -= 2;
  275.                     //判断是否死亡
  276.                     //撞墙死亡
  277.                     if (x == 0)
  278.                     {
  279.                         Game.scene = E_Scene.FinishID;
  280.                         GameScene.bo = false;
  281.                         break;
  282.                     }
  283.                     //撞身体死亡
  284.                     for (int i = 0; i < bodyNum; i++)
  285.                     {
  286.                         if (num1[i] == x && num2[i] == y)
  287.                         {
  288.                             Game.scene = E_Scene.FinishID;
  289.                             GameScene.bo = false;
  290.                             break;
  291.                         }
  292.                     }
  293.  
  294.                     if (foods.x == x && foods.y == y)
  295.                     {
  296.                         foods.Plan();
  297.                         //给个判断，让生成的food不会出现在有蛇身体的位置上
  298.                         for (int i = 0; i < bodyNum; i++)
  299.                         {
  300.                             if (foods.x == num1[i] && foods.y == num2[i])
  301.                             {
  302.                                 Console.SetCursorPosition(foods.x, foods.y);
  303.                                 Console.WriteLine("  ");
  304.                                 foods.Plan();
  305.                                 i = 0;
  306.                             }
  307.                         }
  308.  
  309.                         bodyNum += 1;
  310.                         for (int i = bodyNum - 1; i > 0; i--)
  311.                         {
  312.                             num1[i] = num1[i - 1];
  313.                             num2[i] = num2[i - 1];
  314.                         }
  315.                         num1[0] = x + 2;
  316.                         num2[0] = y;
  317.                     }
  318.                     else
  319.                     {
  320.                         for (int i = bodyNum - 1; i > 0; i--)
  321.                         {
  322.                             num1[i] = num1[i - 1];
  323.                             num2[i] = num2[i - 1];
  324.                         }
  325.                         num1[0] = x + 2;
  326.                         num2[0] = y;
  327.                     }
  328.                     SnakePlan();
  329.                     break;
  330.                 case E_Move.Right:
  331.                     SnakeClear();
  332.                     x += 2;
  333.                     //判断是否死亡
  334.                     //撞墙死亡
  335.                     if (x == 98)
  336.                     {
  337.                         Game.scene = E_Scene.FinishID;
  338.                         GameScene.bo = false;
  339.                         break;
  340.                     }
  341.                     //撞身体死亡
  342.                     for (int i = 0; i < bodyNum; i++)
  343.                     {
  344.                         if (num1[i] == x && num2[i] == y)
  345.                         {
  346.                             Game.scene = E_Scene.FinishID;
  347.                             GameScene.bo = false;
  348.                             break;
  349.                         }
  350.                     }
  351.  
  352.                     if (foods.x == x && foods.y == y)
  353.                     {
  354.                         foods.Plan();
  355.                         //给个判断，让生成的food不会出现在有蛇身体的位置上
  356.                         for (int i = 0; i < bodyNum; i++)
  357.                         {
  358.                             if (foods.x == num1[i] && foods.y == num2[i])
  359.                             {
  360.                                 Console.SetCursorPosition(foods.x, foods.y);
  361.                                 Console.WriteLine("  ");
  362.                                 foods.Plan();
  363.                                 i = 0;
  364.                             }
  365.                         }
  366.  
  367.                         bodyNum += 1;
  368.                         for (int i = bodyNum - 1; i > 0; i--)
  369.                         {
  370.                             num1[i] = num1[i - 1];
  371.                             num2[i] = num2[i - 1];
  372.                         }
  373.                         num1[0] = x - 2;
  374.                         num2[0] = y;
  375.                     }
  376.                     else
  377.                     {
  378.                         for (int i = bodyNum - 1; i > 0; i--)
  379.                         {
  380.                             num1[i] = num1[i - 1];
  381.                             num2[i] = num2[i - 1];
  382.                         }
  383.                         num1[0] = x - 2;
  384.                         num2[0] = y;
  385.                     }
  386.                     SnakePlan();
  387.                     break;
  388.                 default:
  389.                     break;
  390.             }
  391.         }
  392.  
  393.     }
  394. }
全部代码文件：看资源
实现视频展示：

C#核心实践项目（自个先写）--贪吃蛇

总结：

代码有点屎山，but跑起来就好！！！

还是知识点运用的不够，很多没用上。

跟着老师实现--贪吃蛇

一.需求分析 -- 就是UML类图

二.游戏对象和场景更新接口
1.游戏类 ---- Game 

场景类型枚举 ---- E_SceneType

2.场景更新接口 ---- ISceneUpdate

三、实现多场景切换
1.游戏场景类

2.开始和结束场景基类

3.开始场景

将Game类中的nowScene 改为静态的

将Game类中的场景切换方法也改静态的

4.结束场景

Game中的调用也改

四、游戏场景逻辑实现
1.游戏对象基类的实现
绘制接口

游戏对象类

位置结构体

2.继承游戏对象基类的对象
地图墙壁类

食物类

蛇身子类

3.地图对象

在GameScene实现Map中的方法

到这里可以实现的功能有：三个场景

4.蛇对象

5.蛇对象移动 -- （Lesson7 部分）
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using 贪吃蛇.Lesson3;
  7. using 贪吃蛇.Lesson4;
  8.  
  9. namespace 贪吃蛇.Lesson6
  10. {
  11.     /// <summary>
  12.     /// 蛇的移动方向
  13.     /// </summary>
  14.     enum E_MoveDir
  15.     {
  16.         Up,
  17.         Down,
  18.         Left,
  19.         Right,
  20.     }
  21.  
  22.     class Snake : IDraw
  23.     {
  24.         SnakeBody[] bodys;
  25.         //记录当前蛇的长度
  26.         int nowNum;
  27.         //当前移动方向
  28.         E_MoveDir dir;
  29.  
  30.         public Snake(int x, int y)
  31.         {
  32.             //粗暴的方法 直接申明200个空间 来装蛇身体的数组
  33.             bodys = new SnakeBody[200];
  34.  
  35.             bodys[0] = new SnakeBody(E_SnakeBody_Type.Head, x, y);
  36.             nowNum = 1;
  37.  
  38.             dir = E_MoveDir.Down;
  39.         }
  40.  
  41.         public void Draw()
  42.         {
  43.             //画一节一节的身子
  44.             for (int i = 0; i < nowNum; i++)
  45.             {
  46.                 bodys[i].Draw();
  47.             }
  48.         }
  49.  
  50.         #region Lesson7 蛇的移动
  51.         public void Move()
  52.         {
  53.             //移动前
  54.             //擦除最后一个位置
  55.             Console.SetCursorPosition(bodys[nowNum - 1].pos.x, bodys[nowNum - 1].pos.y);
  56.             Console.WriteLine("  ");
  57.  
  58.             //再移动
  59.             switch (dir)
  60.             {
  61.                 case E_MoveDir.Up:
  62.                     --bodys[0].pos.y;
  63.                     break;
  64.                 case E_MoveDir.Down:
  65.                     ++bodys[0].pos.y;
  66.                     break;
  67.                 case E_MoveDir.Left:
  68.                     bodys[0].pos.x -= 2;
  69.                     break;
  70.                 case E_MoveDir.Right:
  71.                     bodys[0].pos.x += 2;
  72.                     break;
  73.                 default:
  74.                     break;
  75.             }
  76.  
  77.         }
  78.  
  79.         #endregion
  80.  
  81.     }
  82. }

6.蛇对象改变移动方向（Lesson8 部分）
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using 贪吃蛇.Lesson3;
  7. using 贪吃蛇.Lesson4;
  8.  
  9. namespace 贪吃蛇.Lesson6
  10. {
  11.     /// <summary>
  12.     /// 蛇的移动方向
  13.     /// </summary>
  14.     enum E_MoveDir
  15.     {
  16.         Up,
  17.         Down,
  18.         Left,
  19.         Right,
  20.     }
  21.  
  22.     class Snake : IDraw
  23.     {
  24.         SnakeBody[] bodys;
  25.         //记录当前蛇的长度
  26.         int nowNum;
  27.         //当前移动方向
  28.         E_MoveDir dir;
  29.  
  30.         public Snake(int x, int y)
  31.         {
  32.             //粗暴的方法 直接申明200个空间 来装蛇身体的数组
  33.             bodys = new SnakeBody[200];
  34.  
  35.             bodys[0] = new SnakeBody(E_SnakeBody_Type.Head, x, y);
  36.             nowNum = 1;
  37.  
  38.             dir = E_MoveDir.Down;
  39.         }
  40.  
  41.         public void Draw()
  42.         {
  43.             //画一节一节的身子
  44.             for (int i = 0; i < nowNum; i++)
  45.             {
  46.                 bodys[i].Draw();
  47.             }
  48.         }
  49.  
  50.         #region Lesson7 蛇的移动
  51.         public void Move()
  52.         {
  53.             //移动前
  54.             //擦除最后一个位置
  55.             Console.SetCursorPosition(bodys[nowNum - 1].pos.x, bodys[nowNum - 1].pos.y);
  56.             Console.WriteLine("  ");
  57.  
  58.             //再移动
  59.             switch (dir)
  60.             {
  61.                 case E_MoveDir.Up:
  62.                     --bodys[0].pos.y;
  63.                     break;
  64.                 case E_MoveDir.Down:
  65.                     ++bodys[0].pos.y;
  66.                     break;
  67.                 case E_MoveDir.Left:
  68.                     bodys[0].pos.x -= 2;
  69.                     break;
  70.                 case E_MoveDir.Right:
  71.                     bodys[0].pos.x += 2;
  72.                     break;
  73.                 default:
  74.                     break;
  75.             }
  76.  
  77.         }
  78.  
  79.         #endregion
  80.  
  81.         #region Lesson8 改变方向
  82.         public void ChangeDir(E_MoveDir dir)
  83.         {
  84.             //只有头部的时候 可以直接左转右 右转左 上转下 下转上
  85.             //有身体时 这些情况就不能直接转
  86.             if (this.dir == dir || 
  87.                 nowNum > 1 && 
  88.                 (this.dir == E_MoveDir.Up && dir == E_MoveDir.Down || 
  89.                 this.dir == E_MoveDir.Down && dir == E_MoveDir.Up || 
  90.                 this.dir == E_MoveDir.Left && dir == E_MoveDir.Right || 
  91.                 this.dir == E_MoveDir.Right && dir == E_MoveDir.Left))
  92.             {
  93.                 return;
  94.             }
  95.  
  96.             //只要没有 return 就记录外面传入的方向 之后就会按照这个方向去移动
  97.             this.dir = dir;
  98.         }
  99.         #endregion
  100.  
  101.     }
  102. }

在GameScene里面实现调用

7.撞墙撞身体结束游戏 -- （Lesson9 部分）
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using 贪吃蛇.Lesson3;
  7. using 贪吃蛇.Lesson4;
  8. using 贪吃蛇.Lesson5;
  9.  
  10. namespace 贪吃蛇.Lesson6
  11. {
  12.     /// <summary>
  13.     /// 蛇的移动方向
  14.     /// </summary>
  15.     enum E_MoveDir
  16.     {
  17.         Up,
  18.         Down,
  19.         Left,
  20.         Right,
  21.     }
  22.  
  23.     class Snake : IDraw
  24.     {
  25.         SnakeBody[] bodys;
  26.         //记录当前蛇的长度
  27.         int nowNum;
  28.         //当前移动方向
  29.         E_MoveDir dir;
  30.  
  31.         public Snake(int x, int y)
  32.         {
  33.             //粗暴的方法 直接申明200个空间 来装蛇身体的数组
  34.             bodys = new SnakeBody[200];
  35.  
  36.             bodys[0] = new SnakeBody(E_SnakeBody_Type.Head, x, y);
  37.             nowNum = 1;
  38.  
  39.             dir = E_MoveDir.Down;
  40.         }
  41.  
  42.         public void Draw()
  43.         {
  44.             //画一节一节的身子
  45.             for (int i = 0; i < nowNum; i++)
  46.             {
  47.                 bodys[i].Draw();
  48.             }
  49.         }
  50.  
  51.         #region Lesson7 蛇的移动
  52.         public void Move()
  53.         {
  54.             //移动前
  55.             //擦除最后一个位置
  56.             Console.SetCursorPosition(bodys[nowNum - 1].pos.x, bodys[nowNum - 1].pos.y);
  57.             Console.WriteLine("  ");
  58.  
  59.             //再移动
  60.             switch (dir)
  61.             {
  62.                 case E_MoveDir.Up:
  63.                     --bodys[0].pos.y;
  64.                     break;
  65.                 case E_MoveDir.Down:
  66.                     ++bodys[0].pos.y;
  67.                     break;
  68.                 case E_MoveDir.Left:
  69.                     bodys[0].pos.x -= 2;
  70.                     break;
  71.                 case E_MoveDir.Right:
  72.                     bodys[0].pos.x += 2;
  73.                     break;
  74.                 default:
  75.                     break;
  76.             }
  77.  
  78.         }
  79.  
  80.         #endregion
  81.  
  82.         #region Lesson8 改变方向
  83.         public void ChangeDir(E_MoveDir dir)
  84.         {
  85.             //只有头部的时候 可以直接左转右 右转左 上转下 下转上
  86.             //有身体时 这些情况就不能直接转
  87.             if (this.dir == dir || 
  88.                 nowNum > 1 && 
  89.                 (this.dir == E_MoveDir.Up && dir == E_MoveDir.Down || 
  90.                 this.dir == E_MoveDir.Down && dir == E_MoveDir.Up || 
  91.                 this.dir == E_MoveDir.Left && dir == E_MoveDir.Right || 
  92.                 this.dir == E_MoveDir.Right && dir == E_MoveDir.Left))
  93.             {
  94.                 return;
  95.             }
  96.  
  97.             //只要没有 return 就记录外面传入的方向 之后就会按照这个方向去移动
  98.             this.dir = dir;
  99.         }
  100.         #endregion
  101.  
  102.         #region Lesson9 撞墙撞身体结束逻辑
  103.         public bool CheckEnd(Map map)
  104.         {
  105.             for (int i = 0; i < map.walls.Length; i++)
  106.             {
  107.                 if (bodys[0].pos == map.walls[i].pos)
  108.                 {
  109.                     return true;
  110.                 }
  111.             }
  112.  
  113.             for (int i = 1; i < nowNum; i++)
  114.             {
  115.                 if (bodys[0].pos == bodys[i].pos)
  116.                 {
  117.                     return true;
  118.                 }
  119.             }
  120.  
  121.             return false;
  122.         }
  123.         #endregion
  124.  
  125.     }
  126. }

GameScene中调用

8.蛇吃食物

Snake类里面添加的相关方法 -- (Lesson10 部分）

GameScene类中调用

9.蛇长身体

Snake类中添加方法

（加了Lesson11--长身体AddBody方法，在Lesson10吃食物方法里面调用了AddBody方法，然后在Lesson7中添加了蛇尾跟着蛇头移动的逻辑处理）

至此跟着老师进行的制作的功能都已实现

视频展示

C#核心实践--贪吃蛇（老师实现的）

完整代码在资源里。

总结一下下

还是得多敲多练，多想想怎么让代码更精简，逻辑怎么更清晰！

多挤些时间啊！

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号