#创作计划# #游戏计划#之特别篇1

必看：目录
注意注意，本节课全程高能。
请大家仔细听。
为了学习方便。
请在VS当中新创建一个项目！！！

为了方便大家的学习，需要进行以下设置（由于本人设置好了，所以说这里的图片是从一位dl来的）：
运行你的控制台程序，在窗口中进行以下设置：

保存后，重新启动。
主要原因是因为VS2022默认不在使用命令提示符窗口，而是使用的终端窗口。
而终端窗口会影响我们之后知识的学习。

---

在此之前，我们还要学习三个知识点。

• 控制台

• 随机数

• 项目调试

---

控制台

Console.WriteLine();
Console.Write();
Console.ReadKey();
Console.ReadLine();

这些是我们在第二节课讲的。
当时我们说：Console.ReadKey();是按下任意键开始。
但是我们会发现，控制台上会显示你输入的字符。
那怎么处理，才能达到按下任意键开始这个效果呢？
那就是：

Console.ReadKey(true);

例如：

char k=Console.ReadKey(true).KeyChar;

欸嘿！这不就好了嘛！
自己可以在VS中运行试试。
当然，你输入的字符还是会被储存在k中。
除了输入输出，也是有其他的控制台方法。

Console.Clear();//清空控制台
//设置窗口大小
Console.SetWindowSize(80, 30);// 宽度80字符，高度30行
//必须先设施窗口再设置缓冲区
//缓冲区大小>=窗口大小
//窗口大小<=控制台大小
//设置缓冲区大小（可滚动区域）
Console.SetBufferSize(80, 100);
//设置光标位置
Console.SetCursorPosition(0,1);
//文字颜色
Console.ForegroundColor=ConsoleColor.Red;
Console.WriteLine("红色文字");
Console.ForegroundColor=ConsoleColor.Green;
Console.WriteLine("绿色文字");
Console.ForegroundColor=ConsoleColor.Blue;
Console.WriteLine("蓝色文字");
//重置为默认颜色
Console.ResetColor();
// 设置背景颜色
Console.BackgroundColor=ConsoleColor.Yellow;
Console.ForegroundColor=ConsoleColor.Black;
Console.WriteLine("黑字黄底");
Console.BackgroundColor=ConsoleColor.DarkBlue;
Console.ForegroundColor=ConsoleColor.White;
Console.WriteLine("白字深蓝底");
Console.ResetColor();
//如果我想让全部背景变成深蓝色：
//Console.BackgroundColor=ConsoleColor.DarkBlue;
//Console.Clear();
// 隐藏光标
Console.CursorVisible=false;
Console.WriteLine("光标已隐藏");
// 显示光标
Console.CursorVisible=true;
Console.WriteLine("光标已显示");
//立即退出程序，返回退出代码
Environment.Exit(0); //0表示成功
Environment.Exit(1); //非0表示错误

这个就学完了，练习题：
通过 W.A.S.D 键在控制台中控制一个黄色方块在红色背景中上下左右移动。
注意：边界问题。
知识点：while，switch，输入输出等等。

答案如下：

namespace 控制台相关练习题
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("控制台相关练习题");

            //改背景颜色
            Console.BackgroundColor=ConsoleColor.Red;
            Console.Clear();
            //改变字体颜色
            Console.ForegroundColor=ConsoleColor.Yellow;
            //隐藏光标
            Console.CursorVisible=false;

            //黄色方块感觉像人一样 这个人身上有位置信息
            // x y
            int x=0;
            int y=0;

            //不停的输入 wasd键 都可以控制它移动
            //根据不停 就分析 用while循环是最简单的一种方式
            while (true)
            {
                //第一种清空之前信息的方式
                //Console.Clear();
                Console.SetCursorPosition(x, y);
                Console.Write("■");
                //得到玩家的输入信息
                char c=Console.ReadKey(true).KeyChar;
                //第二种方式把之前的方块擦除了
                Console.SetCursorPosition(x, y);
                Console.Write("  ");
                switch (c)
                {
                    //贯穿
                    case 'W':
                    case 'w':
                        y -= 1;
                        //改变位置过后 判断新位置 是否越界
                        if (y<0)
                        {
                            y=0;
                        }
                        break;
                    case 'A':
                    case 'a':
                        //中文符号 在控制台上占2个位置
                        x -= 2;
                        if (x<0)
                        {
                            x=0;
                        }
                        break;
                    case 'S':
                    case 's':
                        y += 1;
                        if (y>Console.BufferHeight-1)
                        {
                            y=Console.BufferHeight-1;
                        }
                        break;
                    case 'D':
                    case 'd':
                        x += 2;
                        if (x>Console.BufferWidth-2)
                        {
                            x=Console.BufferWidth-2;
                        }
                        break;
                }
            }
        }
    }
}

---

随机数

//创建随机数生成器
Random random=new Random();

//生成随机整数
int randomNumber=random.Next();
int randomNumber2=random.Next(100);//0~99随机数
int randomNumber3=random.Next(5,100);//5~99随机数

练习题：
ND打ND2。
ND攻击力为8~12之间的一个值。
ND2防御为10，血量为114514。
在控制台中通过打印信息表现ND打ND2的过程。
描述ND2的掉血情况。
伤害计算公式：攻击力小于防御力时，减血为0，否则减血攻击力和防御力的差值。
知识点：循环、随机数等等。

答案如下：

namespace 随机数练习题
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("随机数练习题");
            int monsterDef=10;
            int monsterHp=114514;
            int MyAtk=0;
            Random r=new Random();
            while (true)
            {
                MyAtk=r.Next(8, 13);
                if( MyAtk > monsterDef )
                {
                    //减血攻击力和防御力的差值
                    //monsterHp=monsterHp-(MyAtk - monsterDef);
                    monsterHp -= MyAtk - monsterDef;
                    Console.WriteLine("ND本次攻击力为{0},造成{1}伤害,ND2剩{2}血", 
                        MyAtk, MyAtk-monsterDef, monsterHp);
                    if( monsterHp<= 0 )
                    {
                        break;
                    }
                }
                else
                {
                    Console.WriteLine("ND本次攻击力为{0},不足以造成伤害", MyAtk);
                }

                Console.WriteLine("请按任意键继续攻击");
                Console.ReadKey(true);
                Console.Clear();
            }

            Console.WriteLine("ND2已死亡");
        }
    }
}//为什么命名这么规范？
//这个后面会出一个特别篇。
//我们现在做习题时变量名可以随便取的哈。

---

项目调试

可以看到，行数旁边有一个灰色的框。
在对应的行数旁边点一下。
会跳红。
然后运行。
发现运行到红色的地方时，程序会直接退出。
这，就叫“断点”。
调试时可以使用：。
F10：逐过程执行（不进入函数内部）。
F11：逐语句执行（进入函数内部）。
鼠标悬停：查看变量当前值。
局部变量窗口：查看所有变量的值。
即时窗口：实时执行代码片段。
4. 条件断点
右键断点→"条件"。
设置条件，如 x > 10，只有满足条件时才中断。

---

做游戏了。

---

需求分析

开始界面
├── 控制台输出
├── 控制台输入
├── 控制台颜色变化
└── 游戏主循环 while
├── 游戏界面
│ └── switch
│ ├── 条件运算符
│ ├── 判断
│ ├── if语句
│ ├── 随机数
│ ├── 回合制战斗
│ ├── 循环
│ └── if语句
└── 结束界面
├── 控制台输出
├── 控制台输入
└── 控制台颜色变化

界面之间的相互切换
├── 开始界面
├── 游戏界面
└── 结束界面

控制台基础设置
我们先新建个项目哈。

第一步：隐藏光标

Console.CursorVisible=false;

第二步：设置窗口大小

int w=50,h=20;
Console.SetWindowSize(w,h);

第三步：设置缓冲区大小

Console.SetBufferSize(w,h);

多个场景
由于游戏结束后可以重新开始。
所以是死循环。

while(true){

}

我们有三个场景。
我们可以给他们编号。
所以要定一个ID。

byte nowSceneID=1;
while(true){

}

中间要判断编号。

byte nowSceneID=1;
while(true){
switch(nowSceneID){
case 1://开始场景
Console.Clear();
Console.WriteLine("开始场景");
break;
case 2://游戏场景
Console.WriteLine("游戏场景");
break;
case 3://结束场景
Console.WriteLine("结束场景");
break;
}
}

开始场景逻辑实现
还是掏出这个代码：

byte nowSceneID=1;
while(true){
switch(nowSceneID){
case 1://开始场景
Console.Clear();
Console.WriteLine("开始场景");
break;
case 2://游戏场景
Console.WriteLine("游戏场景");
break;
case 3://结束场景
Console.WriteLine("结束场景");
break;
}
}

我们改一改：

byte nowSceneID=1;
while(true){
switch(nowSceneID){
case 1://开始场景
Console.Clear();
Console.Write("我营救猪猪公主");
break;
case 2://游戏场景
Console.WriteLine("游戏场景");
break;
case 3://结束场景
Console.WriteLine("结束场景");
break;
}
}

我们改一下游戏名位置。

byte nowSceneID=1;
while(true){
switch(nowSceneID){
case 1://开始场景
Console.Clear();
Console.SetCursorPosition(w/2-7,8);
Console.Write("我营救猪猪公主");
break;
case 2://游戏场景
Console.WriteLine("游戏场景");
break;
case 3://结束场景
Console.WriteLine("结束场景");
break;
}
}

因为要输入，所以里面要构建一个自己的死循环。

byte nowSceneID=1;
while(true){
switch(nowSceneID){
case 1://开始场景
Console.Clear();
Console.SetCursorPosition(w/2-7,8);
Console.Write("我营救猪猪公主");
while(true){
char input=Console.ReadKey(true).KeyChar;
switch(input){
case 'W':
case 'w':
break;
case 'S':
case 's':
break;

}
}
break;
case 2://游戏场景
Console.WriteLine("游戏场景");
break;
case 3://结束场景
Console.WriteLine("结束场景");
break;
}
}

改一下光标。

byte nowSceneID=1;
while(true){
switch(nowSceneID){
case 1://开始场景
Console.Clear();
Console.SetCursorPosition(w/2-7,8);
Console.Write("我营救猪猪公主");
while(true){
Console.SetCursorPosition(w/2-4,13);

Console.Write("开始游戏");
Console.SetCursorPosition(w/2-4,15);
Console.Write("退出游戏");
char input=Console.ReadKey(true).KeyChar;
switch(input){
case 'W':
case 'w':
break;
case 'S':
case 's':
break;

}
}
break;
case 2://游戏场景
Console.WriteLine("游戏场景");
break;
case 3://结束场景
Console.WriteLine("结束场景");
break;
}
}

但现在按ws没有任何反应。
不管三七二十一，先搞编号再说。

byte nowSceneID=1;
while(true){
switch(nowSceneID){
case 1://开始场景
Console.Clear();
Console.SetCursorPosition(w/2-7,8);
Console.Write("我营救猪猪公主");
int nowSelIndex = 0;
while(true){
Console.SetCursorPosition(w/2-4,13);
//根据当前选择的编号 来决定 是否变色
 Console.ForegroundColor=nowSelIndex == 0 ? ConsoleColor.Red : ConsoleColor.White;
Console.Write("开始游戏");
Console.ForegroundColor=nowSelIndex == 1 ? ConsoleColor.Red : ConsoleColor.White;
Console.SetCursorPosition(w/2-4,15);
Console.Write("退出游戏");
char input=Console.ReadKey(true).KeyChar;
switch(input){
case 'W':
case 'w':
nowSelIndex--;
if (nowSelIndex < 0){
nowSelIndex = 0;
}
break;
case 'S':
case 's':
nowSelIndex++;
if (nowSelIndex > 1){
 nowSelIndex = 1;
}
break;

}
}
break;
case 2://游戏场景
Console.WriteLine("游戏场景");
break;
case 3://结束场景
Console.WriteLine("结束场景");
break;
}
}

再加一个J，看看按下的是开始还是退出。

case 'J':
case 'j':
    if (nowSelIndex == 0)
    {
        //1.改变当前选择的场景ID
        nowSceneID=2;
        //2.要退出 内层while循环
        isQuitWhile=true;
    }
    else
    {
        //关闭控制台
        Environment.Exit(0);
    }
    break;

我们还要退出循环！
把代码和n为1。
我这给出的是：超标准，带空格，最严谨，带缩进的写法！

namespace 入门实践
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 1 控制台基础设置
            //隐藏光标
            Console.CursorVisible = false;
            //通过两个变量来存储 舞台的大小
            int w = 50;
            int h = 30;
            //设置舞台（控制台）的大小
            Console.SetWindowSize(w, h);
            Console.SetBufferSize(w, h);
            #endregion

            #region 2 多个场景
            //当前所在场景的编号
            int nowSceneID = 1;
            while (true)
            {
                //不同的场景ID 进行不同的逻辑处理
                switch (nowSceneID)
                {
                    //开始场景
                    case 1:
                        Console.Clear();
                        #region 3 开始场景逻辑
                        Console.SetCursorPosition(w / 2 - 7, 8);
                        Console.Write("我营救猪猪公主");
                        //当前选项的编号
                        int nowSelIndex = 0;
                        //因为要输入 我们可以构造一个 开始界面自己的 死循环
                        //专门用来处理 开始场景相关的逻辑
                        while (true)
                        {
                            //用一个标识  来处理 想要在while循环内部的switch逻辑执行时 希望退出外层while循环时
                            // 改变标识即可
                            bool isQuitWhile = false;
                            // 显示 内容
                            //先设置光标位置 再显示内容
                            Console.SetCursorPosition(w / 2 - 4, 13);
                            //根据当前选择的编号 来决定 是否变色
                            Console.ForegroundColor = nowSelIndex == 0 ? ConsoleColor.Red : ConsoleColor.White;
                            Console.Write("开始游戏");
                            Console.SetCursorPosition(w / 2 - 4, 15);
                            Console.ForegroundColor = nowSelIndex == 1 ? ConsoleColor.Red : ConsoleColor.White;
                            Console.Write("退出游戏");
                            // 检测 输入
                            // 检测玩家 输入的一个键内容 并且不会再控制台上显示输入的内容
                            char input = Console.ReadKey(true).KeyChar;
                            switch (input)
                            {
                                case 'W':
                                case 'w':
                                    nowSelIndex--;
                                    if (nowSelIndex < 0){
                                    nowSelIndex = 0;
                                    }
                                    break;
                                case 'S':
                                case 's':
                                    nowSelIndex++;
                                    if (nowSelIndex > 1){
                                    nowSelIndex = 1;
                                    }
                                    break;
                                case 'J':
                                case 'j':
                                    if (nowSelIndex == 0)
                                    {
                                        //1.改变当前选择的场景ID
                                        nowSceneID = 2;
                                        //2.要退出 内层while循环
                                        isQuitWhile = true;
                                    }
                                    else
                                    {
                                        //关闭控制台
                                        Environment.Exit(0);
                                    }
                                    break;
                            }

                            if (isQuitWhile)
                            {
                                break;
                            }
                        }
                        #endregion
                        break;
                    //游戏场景
                    case 2:
                        Console.Clear();
                        Console.WriteLine("游戏场景");
                        break;
                    //结束场景
                    case 3:
                        Console.Clear();
                        Console.WriteLine("结束场景");
                        break;
                }
            }
            #endregion
        }
    }
}

不愧是我苦练多年的AL流。
什么？你问前面为什么不写好？
前面的是之前写的，当时有点低血糖，偷了一会懒。
最严谨的写法必须这样写，这个特别篇讲完后谁敢不这样写，我揍死他。
为什么要这样写呢？
你的程序不只是给自己看的。

---

既然开头写好了，要开始写中间的了。
我的想法是这样的。
模仿古早游戏，文字类。
搞个小人，打败魔王，救公主啊。

---

我们先来搞个不懂得墙，俗称：边界。
让DS决定一下颜色吧。

嗯。

首先，我们模仿开始场景，搞个死循环。
papapa开写：

namespace 入门实践
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 1 控制台基础设置
            //隐藏光标
            Console.CursorVisible = false;
            //通过两个变量来存储 舞台的大小
            int w = 50;
            int h = 30;
            //设置舞台（控制台）的大小
            Console.SetWindowSize(w, h);
            Console.SetBufferSize(w, h);
            #endregion

            #region 2 多个场景
            //当前所在场景的编号
            int nowSceneID = 1;
            while (true)
            {
                //不同的场景ID 进行不同的逻辑处理
                switch (nowSceneID)
                {
                    //开始场景
                    case 1:
                        Console.Clear();
                        #region 3 开始场景逻辑
                        Console.SetCursorPosition(w / 2 - 7, 8);
                        Console.Write("我营救猪猪公主");
                        //当前选项的编号
                        int nowSelIndex = 0;
                        //因为要输入 我们可以构造一个 开始界面自己的 死循环
                        //专门用来处理 开始场景相关的逻辑
                        while (true)
                        {
                            //用一个标识  来处理 想要在while循环内部的switch逻辑执行时 希望退出外层while循环时
                            // 改变标识即可
                            bool isQuitWhile = false;
                            // 显示 内容
                            //先设置光标位置 再显示内容
                            Console.SetCursorPosition(w / 2 - 4, 13);
                            //根据当前选择的编号 来决定 是否变色
                            Console.ForegroundColor = nowSelIndex == 0 ? ConsoleColor.Red : ConsoleColor.White;
                            Console.Write("开始游戏");
                            Console.SetCursorPosition(w / 2 - 4, 15);
                            Console.ForegroundColor = nowSelIndex == 1 ? ConsoleColor.Red : ConsoleColor.White;
                            Console.Write("退出游戏");
                            // 检测 输入
                            // 检测玩家 输入的一个键内容 并且不会再控制台上显示输入的内容
                            char input = Console.ReadKey(true).KeyChar;
                            switch (input)
                            {
                                case 'W':
                                case 'w':
                                    nowSelIndex--;
                                    if (nowSelIndex < 0)
                                    {
                                        nowSelIndex = 0;
                                    }
                                    break;
                                case 'S':
                                case 's':
                                    nowSelIndex++;
                                    if (nowSelIndex > 1)
                                    {
                                        nowSelIndex = 1;
                                    }
                                    break;
                                case 'J':
                                case 'j':
                                    if (nowSelIndex == 0)
                                    {
                                        //1.改变当前选择的场景ID
                                        nowSceneID = 2;
                                        //2.要退出 内层while循环
                                        isQuitWhile = true;
                                    }
                                    else
                                    {
                                        //关闭控制台
                                        Environment.Exit(0);
                                    }
                                    break;
                            }

                            if (isQuitWhile)
                            {
                                break;
                            }
                        }
                        #endregion
                        break;
                    //游戏场景
                    case 2:
                        Console.Clear();
                        
                        //游戏场景的死循环 专门用来 检测 玩家输入相关的循环
                        while(true)
                        {

                        }
                        break;
                    //结束场景
                    case 3:
                        Console.Clear();
                        Console.WriteLine("结束场景");
                        break;
                }
            }
            #endregion
        }
    }
}

okkk，接下来写墙了。
注注注意，要写while外面的哈。

namespace 入门实践
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 1 控制台基础设置
            //隐藏光标
            Console.CursorVisible = false;
            //通过两个变量来存储 舞台的大小
            int w = 50;
            int h = 30;
            //设置舞台（控制台）的大小
            Console.SetWindowSize(w, h);
            Console.SetBufferSize(w, h);
            #endregion

            #region 2 多个场景
            //当前所在场景的编号
            int nowSceneID = 1;
            while (true)
            {
                //不同的场景ID 进行不同的逻辑处理
                switch (nowSceneID)
                {
                    //开始场景
                    case 1:
                        Console.Clear();
                        #region 3 开始场景逻辑
                        Console.SetCursorPosition(w / 2 - 7, 8);
                        Console.Write("我营救猪猪公主");
                        //当前选项的编号
                        int nowSelIndex = 0;
                        //因为要输入 我们可以构造一个 开始界面自己的 死循环
                        //专门用来处理 开始场景相关的逻辑
                        while (true)
                        {
                            //用一个标识  来处理 想要在while循环内部的switch逻辑执行时 希望退出外层while循环时
                            // 改变标识即可
                            bool isQuitWhile = false;
                            // 显示 内容
                            //先设置光标位置 再显示内容
                            Console.SetCursorPosition(w / 2 - 4, 13);
                            //根据当前选择的编号 来决定 是否变色
                            Console.ForegroundColor = nowSelIndex == 0 ? ConsoleColor.Red : ConsoleColor.White;
                            Console.Write("开始游戏");
                            Console.SetCursorPosition(w / 2 - 4, 15);
                            Console.ForegroundColor = nowSelIndex == 1 ? ConsoleColor.Red : ConsoleColor.White;
                            Console.Write("退出游戏");
                            // 检测 输入
                            // 检测玩家 输入的一个键内容 并且不会再控制台上显示输入的内容
                            char input = Console.ReadKey(true).KeyChar;
                            switch (input)
                            {
                                case 'W':
                                case 'w':
                                    nowSelIndex--;
                                    if (nowSelIndex < 0)
                                    {
                                        nowSelIndex = 0;
                                    }
                                    break;
                                case 'S':
                                case 's':
                                    nowSelIndex++;
                                    if (nowSelIndex > 1)
                                    {
                                        nowSelIndex = 1;
                                    }
                                    break;
                                case 'J':
                                case 'j':
                                    if (nowSelIndex == 0)
                                    {
                                        //1.改变当前选择的场景ID
                                        nowSceneID = 2;
                                        //2.要退出 内层while循环
                                        isQuitWhile = true;
                                    }
                                    else
                                    {
                                        //关闭控制台
                                        Environment.Exit(0);
                                    }
                                    break;
                            }

                            if (isQuitWhile)
                            {
                                break;
                            }
                        }
                        #endregion
                        break;
                    //游戏场景
                    case 2:
                        Console.Clear();
                        #region 4 不变的红墙
                        //设置颜色为红色
                        Console.ForegroundColor = ConsoleColor.Red;
                        //画墙
                        //上方的墙
                        for (int i = 0; i < w; i+=2)
                        {
                            Console.SetCursorPosition(i, 0);
                            Console.Write("■");
                        }
                        //下方墙
                        for (int i = 0; i <= w - 2; i += 2)
                        {
                            Console.SetCursorPosition(i, h-1);
                            Console.Write("■");
                        }
                        //中间墙
                        for (int i = 0; i <= w - 2; i += 2)
                        {
                            Console.SetCursorPosition(i, h-6);
                            Console.Write("■");
                        }
                        //左边的墙
                        for (int i = 0; i < h; i++)
                        {
                            Console.SetCursorPosition(0, i);
                            Console.Write("■");
                        }
                        //右边的墙 
                        for (int i = 0; i < h; i++)
                        {
                            Console.SetCursorPosition(w-2, i);
                            Console.Write("■");
                        }
                        #endregion 
                        //游戏场景的死循环 专门用来 检测 玩家输入相关的循环
                        while (true)
                        {

                        }
                        break;
                    //结束场景
                    case 3:
                        Console.Clear();
                        

                        Console.WriteLine("结束场景");
                        break;
                }
            }
            #endregion
        }
    }
}

这个逻辑很简单，当然，这个墙的写法不止这一个，大家可以在课后讨论，有想法者可私信我。

没错，接下来就是魔王了，俗称：boss。
是要在while里写的。
但是属性的声明不能在while里面写。
X=24。
Y=15。
AtkMin=7。
AtkMax=13。
HP=100。
Icon="■"。
我们如何申明一个颜色变量？
ConsoleColor Color=ConsoleColor.Green;
当然了，这些数据可以根据自己喜好更改。
实际写代码时，一定要写bossXXX，符合命名规范。
注意要加空格，当然，如果你是自己玩的话，当我没说。
然后，boss的显示有一个必要条件，XP>0。
写个if判断即可。
最终代码如下：

using System;

namespace 入门实践
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 1 控制台基础设置
            //隐藏光标
            Console.CursorVisible = false;
            //通过两个变量来存储 舞台的大小
            int w = 50;
            int h = 30;
            //设置舞台（控制台）的大小
            Console.SetWindowSize(w, h);
            Console.SetBufferSize(w, h);
            #endregion

            #region 2 多个场景
            //当前所在场景的编号
            int nowSceneID = 1;
            while (true)
            {
                //不同的场景ID 进行不同的逻辑处理
                switch (nowSceneID)
                {
                    //开始场景
                    case 1:
                        Console.Clear();
                        #region 3 开始场景逻辑
                        Console.SetCursorPosition(w / 2 - 7, 8);
                        Console.Write("我营救猪猪公主");
                        //当前选项的编号
                        int nowSelIndex = 0;
                        //因为要输入 我们可以构造一个 开始界面自己的 死循环
                        //专门用来处理 开始场景相关的逻辑
                        while (true)
                        {
                            //用一个标识  来处理 想要在while循环内部的switch逻辑执行时 希望退出外层while循环时
                            // 改变标识即可
                            bool isQuitWhile = false;
                            // 显示 内容
                            //先设置光标位置 再显示内容
                            Console.SetCursorPosition(w / 2 - 4, 13);
                            //根据当前选择的编号 来决定 是否变色
                            Console.ForegroundColor = nowSelIndex == 0 ? ConsoleColor.Red : ConsoleColor.White;
                            Console.Write("开始游戏");
                            Console.SetCursorPosition(w / 2 - 4, 15);
                            Console.ForegroundColor = nowSelIndex == 1 ? ConsoleColor.Red : ConsoleColor.White;
                            Console.Write("退出游戏");
                            // 检测 输入
                            // 检测玩家 输入的一个键内容 并且不会再控制台上显示输入的内容
                            char input = Console.ReadKey(true).KeyChar;
                            switch (input)
                            {
                                case 'W':
                                case 'w':
                                    --nowSelIndex;
                                    if (nowSelIndex < 0)
                                    {
                                        nowSelIndex = 0;
                                    }
                                    break;
                                case 'S':
                                case 's':
                                    ++nowSelIndex;
                                    if (nowSelIndex > 1)
                                    {
                                        nowSelIndex = 1;
                                    }
                                    break;
                                case 'J':
                                case 'j':
                                    if (nowSelIndex == 0)
                                    {
                                        //1.改变当前选择的场景ID
                                        nowSceneID = 2;
                                        //2.要退出 内层while循环
                                        isQuitWhile = true;
                                    }
                                    else
                                    {
                                        //关闭控制台
                                        Environment.Exit(0);
                                    }
                                    break;
                            }

                            if (isQuitWhile)
                            {
                                break;
                            }
                        }
                        #endregion
                        break;
                    //游戏场景
                    case 2:
                        Console.Clear();
                        #region 4 不变的红墙
                        //设置颜色为红色
                        Console.ForegroundColor = ConsoleColor.Red;
                        //画墙
                        //上方墙
                        for (int i = 0; i < w; i += 2)
                        {
                            //上方墙
                            Console.SetCursorPosition(i, 0);
                            Console.Write("■");
                            //下方墙
                            Console.SetCursorPosition(i, h - 1);
                            Console.Write("■");
                            //中间墙
                            Console.SetCursorPosition(i, h - 6);
                            Console.Write("■");
                        }
                        //左边的墙
                        for (int i = 0; i < h; i++)
                        {
                            //左边的墙
                            Console.SetCursorPosition(0, i);
                            Console.Write("■");
                            //右边的墙
                            Console.SetCursorPosition(w - 2, i);
                            Console.Write("■");
                        }
                        #endregion

                        #region 5 boss属性相关
                        int bossX = 24;
                        int bossY = 15;
                        int bossAtkMin = 7;
                        int bossAtkMax = 13;
                        int bossHp = 100;
                        string bossIcon = "■";
                        //申明一个 颜色变量
                        ConsoleColor bossColor = ConsoleColor.Green;
                        #endregion

                        //游戏场景的死循环 专门用来 检测 玩家输入相关循环
                        while (true)
                        {
                            #region 5 boss属性相关
                            //boss活着时才绘制
                            if (bossHp > 0)
                            {
                                //绘制boss图标
                                Console.SetCursorPosition(bossX, bossY);
                                Console.ForegroundColor = bossColor;
                                Console.Write(bossIcon);
                            }
                            #endregion
                        }
                        break;
                    //结束场景
                    case 3:
                        Console.Clear();
                        Console.WriteLine("结束场景");
                        break;
                }
            }
            #endregion
        }
    }
}

未完待续……