C#实现经典飞行棋游戏的示例代码

2024-04-02 19:04:59 119人浏览薄情痞子

摘要

目录效果展示主函数场景类型枚举控制台基础设置开始及结束场景逻辑游戏场景逻辑固定打印的信息格子类型枚举和格子结构体地图结构体玩家和电脑结

效果展示

主函数

     static void Main(string[] args)
        {
            int w = 50;
            int h = 30;
            ConsoleInit(w, h);

            E_SceneType nowSceneType = E_SceneType.Begin;
            while (true)
            {
                switch (nowSceneType)
                {
                    case E_SceneType.Begin:
                        Console.Clear();
                        GameEndOrBegin(w, h, ref nowSceneType);
                        break;
                    case E_SceneType.Game:
                        Console.Clear();
                        GameScene(w, h, ref nowSceneType);
                        break;
                    case E_SceneType.End:
                        Console.Clear();
                        GameEndOrBegin(w, h, ref nowSceneType);
                        break;
                    default:
                        break;
                }

            }

        }

场景类型枚举

  enum E_SceneType
    {
        Begin,
        Game,
        End,
    }

控制台基础设置

static void ConsoleInit(int w, int h)
        {

            //控制台设置
            Console.CursorVisible = false;
            Console.Setwindowsize(w, h);
            Console.SetBufferSize(w, h);
        }

开始及结束场景逻辑

        static void GameEndOrBegin(int w, int h, ref E_SceneType nowSceneType)
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.SetCursorPosition(nowSceneType == E_SceneType.Begin ? w / 2 - 3 : w / 2 - 4, 8);
            Console.Write(nowSceneType == E_SceneType.Begin ? "飞行棋" : "游戏结束");
            
            //当前选项的编号
            int count = 0;
            bool IsOver = false;

            while (true)
            {
                Console.SetCursorPosition(nowSceneType ==E_SceneType.Begin? w/2-4:w/2-5, 11);
                Console.ForegroundColor = count == 0 ? ConsoleColor.Red : ConsoleColor.White;
                Console.Write(nowSceneType == E_SceneType.Begin? "游戏开始":"回到主菜单");

                Console.SetCursorPosition(w/2-4, 13);
                Console.ForegroundColor = count == 1 ? ConsoleColor.Red : ConsoleColor.White;
                Console.Write("退出游戏");

                switch (Console.ReadKey(true).Key)
                {
                    case ConsoleKey.W:
                        --count;
                        if (count < 0)
                        {
                            count = 0;
                        }
                        break;
                    case ConsoleKey.S:
                        ++count;
                        if (count > 1)
                        {
                            count = 1;
                        }
                        break;
                    case ConsoleKey.J:
                        if(count == 0)
                        {
                            nowSceneType = nowSceneType ==E_SceneType.Begin? E_SceneType.Game:E_SceneType.Begin;
                            IsOver = true;
                        }
                        else
                        {
                            Environment.Exit(0);
                        }
                        break;
                }
                if (IsOver)
                    break;
            }

        }

游戏场景逻辑

        static void GameScene(int w, int h, ref E_SceneType nowSceneType)
        {
            DrawWall(w, h);
            Map map = new Map(14, 3, 80);
            map.Draw();

            Player player = new Player(0, E_Player_Type.Player);
            Player computer = new Player(0, E_Player_Type.Computer);
            DrawPlayer(map, player, computer);

            while (true)
            {
                if (PlayerRandomMove(w, h, ref player, ref computer, map, ref nowSceneType))
                {
                    break;
                }
                if (PlayerRandomMove(w, h, ref computer, ref player, map, ref nowSceneType))
                {
                    break;
                }
            }

        }

        static bool PlayerRandomMove(int w, int h, ref Player p, ref Player otherP, Map map, ref E_SceneType nowSceneType)
        {
            //之后的游戏逻辑
            //玩家扔色子逻辑
            //检测输入
            Console.ReadKey(true);
            //扔色子的逻辑
            bool isGameOver = RandomMove(w, h, ref p, ref otherP, map);
            //绘制地图
            map.Draw();
            //绘制玩家
            DrawPlayer(map, p, otherP);
            //判断是否要结束游戏
            if(isGameOver)
            {
                //卡住程序 让玩家按任意键
                Console.ReadKey(true);
                nowSceneType = E_SceneType.End;
            }
            return isGameOver;
        }

固定打印的信息

        static void DrawWall(int w, int h)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            //横着的墙
            for (int i = 0; i < w; i+=2)
            {
                //最上面一行
                Console.SetCursorPosition(i, 0);
                Console.Write("■");

                //中间一行
                Console.SetCursorPosition(i, h-6);
                Console.Write("■");
                Console.SetCursorPosition(i, h - 11);
                Console.Write("■");

                //最下面一行
                Console.SetCursorPosition(i, h-1);
                Console.Write("■");
            }

            //竖着的墙
            for(int i = 0; i < h; i++)
            {
                //左边的墙
                Console.SetCursorPosition(0, i);
                Console.Write("■");

                //右边的墙
                Console.SetCursorPosition(w-2, i);
                Console.Write("■");
            }

            Console.SetCursorPosition(2, h - 5);
            Console.ForegroundColor = ConsoleColor.White;
            Console.Write("按任意键开始扔色子");

            Console.SetCursorPosition(2, h - 10);
            Console.Write("□：普通格子");

            Console.SetCursorPosition(2, h - 9);
            Console.ForegroundColor = ConsoleColor.Blue;
            Console.Write("■：暂停，一回合不动");

            Console.SetCursorPosition(22,h - 9);
            Console.ForegroundColor = ConsoleColor.Red;
            Console.Write("●：炸弹，倒退5格");

            Console.SetCursorPosition(2, h - 8);
            Console.ForegroundColor = ConsoleColor.White;
            Console.Write("×：时空隧道，随机倒退，暂停，交换位置");

            Console.SetCursorPosition(2, h - 7);
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.Write("★：玩家  ");

            Console.SetCursorPosition(11, h - 7);
            Console.ForegroundColor = ConsoleColor.Magenta;
            Console.Write("▲：电脑  ");

            Console.SetCursorPosition(20, h - 7);
            Console.ForegroundColor = ConsoleColor.Blue;
            Console.Write("◎：玩家电脑重合");
        }

格子类型枚举和格子结构体

    enum E_Grid_Type
    {
        NORMal,
        Boom,
        Pause,
        Tunnel,
    }

    /// <summary>
    /// 位置信息结构体
    /// </summary>
    struct Vector2
    {
        public int x;
        public int y;

        public Vector2(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }

    struct Grid
    {
        //格子的类型
        public E_Grid_Type _type;
        //格子的位置
        public Vector2 pos;
        //构造函数
        public Grid(int x, int y, E_Grid_Type type)
        {
            pos.x = x;
            pos.y = y;
            _type = type;
        }
        
        //画一个格子
        public void Draw()
        {
            Console.SetCursorPosition(pos.x, pos.y);
            switch(_type)
            {
                case E_Grid_Type.Normal:
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.Write("□");
                    break;
                case E_Grid_Type.Boom:
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.Write("●");
                    break;
                case E_Grid_Type.Pause:
                    Console.ForegroundColor = ConsoleColor.Blue;
                    Console.Write("■");
                    break;
                case E_Grid_Type.Tunnel:
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.Write("×");
                    break;
            }
        }
    }

地图结构体

    struct Map
    {
        public Grid[] grids;
        public Map(int x, int y, int num)
        {
            grids = new Grid[num];
            int indexX = 0;
            int indexY = 0;
            int stepNum = 2;

            Random r = new Random();
            int randomNum;
            for(int i = 0; i < num; i++)
            {
                randomNum = r.Next(0, 101);
                if(randomNum < 85 || i == 0 || i == num - 1)
                {
                    //普通格子
                    grids[i]._type = E_Grid_Type.Normal;
                }
                else if(randomNum < 90 && randomNum >=85)
                {
                    //炸弹
                    grids[i]._type = E_Grid_Type.Boom;
                }
                else if(randomNum < 95 && randomNum >=90)
                {
                    //暂停
                    grids[i]._type = E_Grid_Type.Pause;
                }
                else
                {
                    //时空隧道
                    grids[i]._type = E_Grid_Type.Tunnel;
                }

                grids[i].pos = new Vector2(x, y);

                if(indexX == 10)
                {
                    y += 1;
                    indexY++;
                    if(indexY == 2)
                    {
                        indexX = 0;
                        indexY = 0;
                        stepNum = -stepNum;
                    }
                }
                else
                {
                    x += stepNum;
                    indexX++;
                }
            }
        }
        public void Draw()
        {
            for (int i = 0; i < grids.Length; i++)
            {
                grids[i].Draw();
            }
        }
    }

玩家和电脑结构体

    enum E_Player_Type
    {
        Player,
        Computer,
    }

    struct Player
    {
        public E_Player_Type type;
        public int nowIndex;
        //是否暂停的标识
        public bool isPause;

        public Player(int index, E_Player_Type type)
        {
            nowIndex = index;
            this.type = type;
            isPause = false;
        }
        
        public void Draw(Map mapinfo)
        {
            //从传入的地图中得到格子信息
            Grid grid = mapInfo.grids[nowIndex];
            Console.SetCursorPosition(grid.pos.x, grid.pos.y);
            switch(type)
            {
                case E_Player_Type.Player:
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.Write("★");
                    break;
                case E_Player_Type.Computer:
                    Console.ForegroundColor = ConsoleColor.Magenta;
                    Console.Write("▲");
                    break;
            }
        }
    }

绘制玩家

        static void DrawPlayer(Map map, Player player, Player computer)
        {
            //重合时
            if(player.nowIndex == computer.nowIndex)
            {
                //得到重合的位置
                Grid grid = map.grids[player.nowIndex];
                Console.SetCursorPosition(grid.pos.x, grid.pos.y);
                Console.ForegroundColor = ConsoleColor.DarkGreen;
                Console.Write("◎");
            }
            //不重合时
            else
            {
                player.Draw(map);
                computer.Draw(map);
            }
        }

扔骰子逻辑

        //擦除提示的函数
        static void ClearInfo(int h)
        {
            Console.SetCursorPosition(2, h - 5);
            Console.Write("                                             ");
            Console.SetCursorPosition(2, h - 4);
            Console.Write("                                             ");
            Console.SetCursorPosition(2, h - 3);
            Console.Write("                                             ");
            Console.SetCursorPosition(2, h - 2);
            Console.Write("                                             ");
        }

        /// <summary>
        /// 扔色子函数
        /// </summary>>
        /// <param name="w">窗口的宽</param>
        /// <param name="h">窗口的高</param>
        /// <param name="p">扔色子的对象</param>
        /// <param name="map">地图信息</param>
        /// <returns>默认返回false 代表没有结束</returns>
        static bool RandomMove(int w, int h, ref Player p, ref Player otherP, Map map)
        {
            //擦除之前显示的提示信息
            ClearInfo(h);
            //根据扔色子的玩家类型，决定信息的颜色
            Console.ForegroundColor = p.type == E_Player_Type.Player ? ConsoleColor.Cyan : ConsoleColor.Magenta;

            //扔色子之前判断玩家是否处于暂停状态
            if(p.isPause)
            {
                Console.SetCursorPosition(2, h - 5);
                Console.Write("处于暂停状态，{0}需要暂停一回合", p.type == E_Player_Type.Player ? "你" : "电脑");
                Console.SetCursorPosition(2, h - 4);
                Console.Write("请按任意键，让{0}开始扔色子", p.type == E_Player_Type.Player ? "电脑" : "你");
                //停止暂停
                p.isPause = false;
                return false;
            }

            //扔色子目的是改变玩家或电脑的位置 计算位置的变化
            //扔色子 随机一个1到6的数字，加上去
            Random r = new Random();
            int randomNum = r.Next(1, 7);
            p.nowIndex += randomNum;

            //打印扔的点数
            Console.SetCursorPosition(2, h - 5);
            Console.Write("{0}扔出的点数为：{1}", p.type == E_Player_Type.Player ? "你" : "电脑", randomNum);

            //首先判断是否到终点了
            if(p.nowIndex >= map.grids.Length - 1)
            {
                p.nowIndex = map.grids.Length - 1;
                Console.SetCursorPosition(2, h - 4);
                if(p.type == E_Player_Type.Player)
                {
                    Console.Write("恭喜你，率先到达了终点");
                }
                else
                {
                    Console.Write("很遗憾，电脑率先到达了终点");
                }
                Console.SetCursorPosition(2, h - 3);
                Console.Write("请按任意键结束");
                return true;
            }
            else
            {
                //没有到终点 就判断当前对象到了一个什么类型的格子
                Grid grid = map.grids[p.nowIndex];

                switch(grid._type)
                {
                    case E_Grid_Type.Normal:
                        Console.SetCursorPosition(2, h - 4);
                        Console.Write("{0}到达了一个安全位置", p.type == E_Player_Type.Player ? "你" : "电脑");
                        Console.SetCursorPosition(2, h - 3);
                        Console.Write("请按任意键，让{0}开始扔色子", p.type == E_Player_Type.Player ? "电脑" : "你");
                        break;
                    case E_Grid_Type.Boom:
                        p.nowIndex -= 5;
                        if(p.nowIndex < 0)
                        {
                            p.nowIndex = 0;
                        }
                        Console.SetCursorPosition(2, h - 4);
                        Console.Write("{0}踩到了炸弹，退后5格", p.type == E_Player_Type.Player ? "你" : "电脑");
                        Console.SetCursorPosition(2, h - 3);
                        Console.Write("请按任意键，让{0}开始扔色子", p.type == E_Player_Type.Player ? "电脑" : "你");
                        break;
                    case E_Grid_Type.Pause:
                        p.isPause = true;
                        Console.SetCursorPosition(2, h - 4);
                        Console.Write("{0}到达了暂停点，你需要暂停一回合", p.type == E_Player_Type.Player ? "你" : "电脑");
                        Console.SetCursorPosition(2, h - 3);
                        Console.Write("请按任意键，让{0}开始扔色子", p.type == E_Player_Type.Player ? "电脑" : "你");
                        break;
                    case E_Grid_Type.Tunnel:
                        Console.SetCursorPosition(2, h - 4);
                        Console.Write("{0}踩到了时空隧道", p.type == E_Player_Type.Player ? "你" : "电脑");

                        //随机
                        randomNum = r.Next(1, 91);
                        if(randomNum <= 30)
                        {
                            //倒退
                            p.nowIndex -= 5;
                            if(p.nowIndex < 0)
                            {
                                p.nowIndex = 0;
                            }
                            Console.SetCursorPosition(2, h - 5);
                            Console.Write("触发倒退5格");
                        }
                        else if(randomNum <= 60)
                        {
                            p.isPause = true;
                            Console.SetCursorPosition(2, h - 3);
                            Console.Write("触发暂停一回合");
                        }
                        else
                        {
                            int tmp = p.nowIndex;
                            p.nowIndex = otherP.nowIndex;
                            otherP.nowIndex = tmp;
                            Console.SetCursorPosition(2, h - 3);
                            Console.Write("惊喜，双方交换位置");
                        }

                        Console.SetCursorPosition(2, h - 2);
                        Console.Write("请按任意键，让{0}开始扔色子", p.type == E_Player_Type.Player ? "电脑" : "你");
                        break;
                }
            }

            //默认没有结束
            return false;
        }

以上就是C#实现经典飞行棋游戏的示例代码的详细内容，更多关于C#飞行棋的资料请关注编程网其它相关文章！

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: C#实现经典飞行棋游戏的示例代码

本文链接: https://www.lsjlt.com/news/138308.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

C#实现经典飞行棋游戏的示例代码

目录效果展示主函数场景类型枚举控制台基础设置开始及结束场景逻辑游戏场景逻辑固定打印的信息格子类型枚举和格子结构体地图结构体玩家和电脑结...

99+

2024-04-02
C/C++实现经典象棋游戏的示例代码

目录大体思路效果展示核心代码大体思路采用面相过程的设计方式实现，类似于我们平时做的课程设计，实现这样的小游戏无非就是多了图形处理库。这里使用的是acllib图形库。设计这种小游戏...

99+

2024-04-02
C#实现经典飞行棋游戏的脚本怎么写

今天小编给大家分享一下C#实现经典飞行棋游戏的脚本怎么写的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。效果展示主函数&nbs...

99+

2023-06-29
C语言实现经典小游戏井字棋的示例代码

目录前言一、井字棋游戏的主流程二、游戏部分1.游戏函数2.初始化棋盘3.打印棋盘4.玩家下棋5.电脑下棋（两个难度等级）6.判断游戏是否结束三、运行展示四、源码展示前言这是我在学...

99+

2022-11-13

C语言井字棋游戏 C语言井字棋 C语言游戏
Java实现经典游戏飞机大战-I的示例代码

目录前言主要设计功能截图代码实现启动类核心类核心算法总结前言《飞机大战-I》是一款融合了街机、竞技等多种元素的经典射击手游。华丽精致的游戏画面，超炫带感的技能特效，超火爆画面让你肾...

99+

2024-04-02
C#实现飞行棋游戏

飞行棋主要是讲的方法怎么应用，充分的去理解方法和方法的调用，整体收获还是很大的。我想的是说一下整体的思路。在编程的时间里，逻辑是最重要的，先干嘛后干嘛，对吧。直接上个飞行棋的图，...

99+

2024-04-02
Java实现经典游戏2048的示例代码

目录前言主要设计功能截图代码实现界面布局类业务逻辑类总结前言 2014年Gabriele Cirulli利用周末的时间写2048这个游戏的程序，仅仅只是好玩而已。他想用一种不同的视觉...

99+

2024-04-02
Java实现经典游戏FlappyBird的示例代码

目录前言主要设计功能截图代码实现游戏启动类核心类工具类总结前言《布谷鸟闯关-简单版》是一个基于java的布谷鸟闯关游戏，摁上键控制鸟的位置穿过管道间的缝隙，需要做碰撞检测，监听键盘...

99+

2024-04-02
Java实现经典游戏打砖块游戏的示例代码

目录前言主要设计功能截图代码实现游戏核心类小球类砖块类总结前言《JAVA打砖块》游戏是自制的游戏。玩家操作一根萤幕上水平的“棒子”，让一颗不断弹来弹去的&l...

99+

2024-04-02
100行C#代码实现经典扫雷游戏

目录布局生成雷区左键扫雷和右键标记翻面功能布局布局效果如下，下面每个“网格”都是一个按钮，点击按钮，就会有相应的事件发生。由于UniformGrid中每...

99+

2023-02-27

C#实现扫雷游戏 C#扫雷游戏 C#扫雷 C#游戏
JAVA实现经典扫雷游戏的示例代码

目录前言主要设计功能截图代码实现总结前言 windows自带的游戏《扫雷》是陪伴了无数人的经典游戏，本程序参考《扫雷》的规则进行了简化，用java语言实现，采用了swing技术进行了...

99+

2024-04-02
C语言实现经典扫雷小游戏的示例代码

目录一、游戏简介二、游戏实现1.初始化棋盘2.打印棋盘3.布置雷4.排查雷三、源文件1.game.h2.game.c3.Test.c一、游戏简介游戏初始界面有两个选择，选项&ldq...

99+

2022-11-13

C语言扫雷游戏 C语言扫雷 C语言游戏
C语言实现经典windows游戏扫雷的示例代码

目录1. 前言2. 准备工作3. 设计思路4. 定义数组5. 初始化6. 打印7. 布置雷8. 排查雷9. 完整代码game.hgame.ctest.c1. 前言大家好，我是努力学...

99+

2022-11-13

C语言扫雷游戏 C语言扫雷 C语言游戏
C#实现简单的飞行棋游戏

本文实例为大家分享了C#实现简单飞行棋游戏的具体代码，供大家参考，具体内容如下下面展示完整代码： namespace 飞行棋 { class Program ...

99+

2024-04-02
C#如何用代码实现飞行棋简单小游戏

本篇内容主要讲解“C#如何用代码实现飞行棋简单小游戏”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“C#如何用代码实现飞行棋简单小游戏”吧!目标：实现飞行棋游戏基础功能玩家在地图触发道具：获得道具...

99+

2023-06-14
Java实现经典游戏推箱子的示例代码

目录前言主要设计功能截图代码实现核心类声音播放类总结前言《推箱子》推箱子是一个古老的游戏，目的是在训练你的逻辑思考能力。在一个狭小的仓库中，要求把木箱放到指定的位置，稍不小心就会出...

99+

2024-04-02
Java实现经典游戏泡泡堂的示例代码

目录前言主要设计功能截图代码实现游戏启动类核心监听类核心线程类总结前言《泡泡堂I》是一个基于java的自制游戏，游戏设计为双人pk积分赛模式，在这个模式里面，玩家只要率先达到一定分...

99+

2024-04-02
C#实现简单的飞行棋小游戏

本文实例为大家分享了C#实现简单飞行棋小游戏的具体代码，供大家参考，具体内容如下 1.玩家姓名的输入 2.对屏幕进行清屏 3.初始化地图 4.玩家A和玩家B玩游戏 using S...

99+

2024-04-02
C#实现简单飞行棋小游戏

本文实例为大家分享了C#实现简单飞行棋小游戏的具体代码，供大家参考，具体内容如下目标：实现飞行棋游戏基础功能玩家在地图触发道具： 1、获得道具,可以进行一次选择 1–交换位置 2...

99+

2024-04-02
JAVA实现经典游戏坦克大战的示例代码

目录前言主要设计功能截图代码实现总结前言小时候大家都玩过坦克大战吧，熟悉的旋律和丰富的关卡陪伴了我们一整个寒暑假，还记得传说中的经典坦克大战吗？那些怀旧的记忆，伴随着我们一起走过...

99+

2024-04-02