设为首页收藏一下又不会死！新人公告
切换到窄版

 找回密码
 立即注册→加入我们

QQ登录

只需一步，快速开始

搜索
热搜: 下载 VB C 实现 编写
技术宅的结界»论坛 › 计算机技术 › 源码分享 › [C#] 围猫游戏
返回列表 发新帖
查看: 3342|回复: 2

[C#] 围猫游戏

[复制链接]
mzflz
发表于 2014-12-20 20:28:28 | 显示全部楼层 |阅读模式

欢迎访问技术宅的结界，请注册或者登录吧。

您需要 登录 才可以下载或查看，没有账号？立即注册→加入我们

×
本帖最后由 mzflz 于 2014-12-21 19:07 编辑

这东西虽然使用 面向对象的语言写的，但却没有用到面向对象的思想，这也是本程序的缺点所在，

代码很简单，但不保证可读性。

本程序一定还有Bug，请大神多多指教

不多说了，在这儿只把主要代码粘出来，至于“窗体设计器”生成的代码，大家可以在我上传的附件里找到






  5. using System;
  6. using System.Collections.Generic;
  7. using System.ComponentModel;
  8. using System.Data;
  9. using System.Drawing;
  10. using System.Linq;
  11. using System.Text;
  12. using System.Windows.Forms;
  13. using System.Diagnostics;



  17. namespace WindowsFormsApplication1
  18. {
  19.     struct point
  20.     {
  21.         public int x, y;
  22.     };

  24.     public partial class Form1 : Form
  25.     {
  26.         
  27.         
  28.         int[,] map = new int[4, 4];
  29.         point r = new point {
  30.             x = 2,
  31.             y = 2
  32.         };
  33.         bool isClick = false;
  34.         point click = new point();
  35.         
  36.         public Form1()
  37.         {
  38.             InitializeComponent();
  39.         }

  41.         private void Form1_Load(object sender, EventArgs e)
  42.         {
  43.             
  44.             for (int i = 0; i < 4; i++)
  45.             {
  46.                 for (int j = 0; j < 4; j++)
  47.                 {
  48.                     map[i, j] = 0;
  49.                 }
  50.             }
  51.             map[r.x, r.y] = 2;

  53.         }

  55.         private void Form1_Paint(object sender, PaintEventArgs e)
  56.         {
  57.             Graphics g = e.Graphics;

  59.             for (int i = 0; i < 4; i++) //x
  60.             {
  61.                 for (int j = 0; j < 4; j++) //y
  62.                 {

  64.                     
  65.                         
  66.                         Pen p = Pens.Black;
  67.                         int x = j%2 == 0 ? i * 20 : i*20+10,
  68.                             y = j * 20;
  69.                         const int w = 20, h = 20;

  71.                         g.DrawEllipse(Pens.Black, x, y, 20, 20);
  72.                         if (map[i, j] == 0) g.FillEllipse(Brushes.Red, x, y, w, h); //No Wall or Stone
  73.                         if (map[i, j] == 1) g.FillEllipse(Brushes.Green, x, y, w, h); // Has Green
  74.                         if (map[i, j] == 2) g.FillEllipse(Brushes.Yellow,x,y, w, h);  //Rabbit      

  76.                     

  78.                 }
  79.             }

  81.         }

  83.         private void Form1_MouseClick(object sender, MouseEventArgs e)
  84.         {
  85.             this.isClick = true;
  86.             
  87.             if(e.Y < 80&&(e.X/20)%2 == 0)
  88.             {
  89.                 click.x = (e.X - 10) / 20 ;
  90.                 click.y = (e.Y / 20) ;
  91.             }
  92.             else if(e.Y<80)
  93.             {
  94.                 click.x = e.X / 20;
  95.                 click.y = e.Y / 20;
  96.             }
  97.             else
  98.             {
  99.                 click.x = click.y = -1;
  100.             }

  102.             if(click.x<4&&click.y<4&&click.x>=0&&click.y>=0)
  103.             {
  104.                 if (map[click.x, click.y] == 2) return;
  105.                 map[click.x, click.y] = 1;
  106.                 this.Refresh();

  108.                 move();
  109.                
  110.             }



  114.             
  115.         }
  116.         private void move()
  117.         {
  118.             int left = r.x;
  119.             int right = 4 - r.x;
  120.             int top = r.y;
  121.             int bottom = 4 - r.y;


  124.            /* List<int> list = new List<int>();

  126.             list.Add(left);
  127.             list.Add(right);
  128.             list.Add(top);
  129.             list.Add(bottom);

  131.             list.Sort();
  132.             */
  133.             if (left > right) //right
  134.             {
  135.                 if (top > bottom) // top
  136.                 {
  137.                     
  138.                     bool isX = true, //行上是否有障碍
  139.                         isY = true ; //列上是否有障碍
  140.                     //自上而下遍历
  141.                     for (int i = r.y;i<4;i++)
  142.                     {
  143.                         if (map[r.x, i] == 1)
  144.                         {
  145.                             isY = false;
  146.                             break;

  148.                         }
  149.                     }
  150.                     for (int i = r.x; i < 4; i++)
  151.                     {
  152.                         if (map[i, r.y] == 1)
  153.                         {
  154.                             isX = false;
  155.                             break;
  156.                         }
  157.                     }

  159.                     map[r.x, r.y] = 0;

  161.                     if (bottom > right)
  162.                     {
  163.                         if (isX)
  164.                         {
  165.                             r.x += 1;
  166.                             Check();
  167.                             map[r.x , r.y] = 2;

  169.                         }
  170.                         else
  171.                         {
  172.                             r.y += 1;
  173.                             Check();
  174.                             map[r.x, r.y ] = 2;
  175.                         }
  176.                     }
  177.                     if(bottom<right)
  178.                     {
  179.                         if (isY)
  180.                         {
  181.                             r.y += r.y; Check();
  182.                             map[r.x, r.y] = 2;
  183.                         }
  184.                         else
  185.                         {
  186.                             r.x += 1; Check();
  187.                             map[r.x , r.y] = 2;
  188.                         }
  189.                     }

  191.                   

  193.                 }
  194.                 else if (top < bottom)
  195.                 {
  196.                     bool isX = true, //行上是否有障碍
  197.                        isY = true; //列上是否有障碍

  199.                     for (int i = r.x; i < 4; i++)
  200.                     {
  201.                         if (map[i, r.y] == 1)
  202.                         {
  203.                             isX = false;
  204.                             break;
  205.                         }
  206.                     }

  208.                     for (int i = r.y; i >= 0; i--)
  209.                     {
  210.                         if (map[r.x, i] == 1)
  211.                         {
  212.                             isY = false;
  213.                             break;
  214.                         }
  215.                     }

  217.                     map[r.x, r.y] = 0;

  219.                     if (top < right)
  220.                     {

  222.                         if (isY)
  223.                         {
  224.                             r.y -= 1; Check();
  225.                             map[r.x, r.y ] = 2;
  226.                         }
  227.                         else
  228.                         {
  229.                             r.x += 1; Check();
  230.                             map[r.x , r.y] = 2;
  231.                         }

  233.                     }
  234.                     else if (top >= right)
  235.                     {
  236.                         if (isX)
  237.                         {
  238.                             r.x += 1; Check();
  239.                             map[r.x , r.y] = 2;
  240.                         }
  241.                         else
  242.                         {
  243.                             r.y -= r.y; Check();
  244.                             map[r.x, r.y ] = 2;
  245.                         }
  246.                     }

  248.                     
  249.                 }


  252.             }
  253.             else if (right >=left)
  254.             {
  255.                 if (top >= bottom)
  256.                 {
  257.                     bool isX = true, //行上是否有障碍
  258.                        isY = true; //列上是否有障碍

  260.                     for (int i = r.x; i >= 0;i-- )//x
  261.                     {
  262.                         if (map[i, r.y] == 1)
  263.                         {
  264.                             isX = false;
  265.                             break;
  266.                         }
  267.                     }
  268.                     for (int i = r.y; i < 4; i++)//y
  269.                     {
  270.                         if (map[r.x, i] == 1)
  271.                         {
  272.                             isY = false;
  273.                         }
  274.                     }
  275.                     map[r.x, r.y] = 0;
  276.                     if (left >= bottom)
  277.                     {
  278.                         if (isY)
  279.                         {
  280.                             r.y += 1; Check();
  281.                             map[r.x, r.y] = 2;
  282.                         }
  283.                         else
  284.                         {
  285.                             r.x -= 1; Check();
  286.                             map[r.x , r.y] = 2;
  287.                         }

  289.                     }
  290.                     else if (left <= bottom)
  291.                     {
  292.                         if (isX)
  293.                         {
  294.                             r.x -= 1; Check();
  295.                             map[r.x , r.y] = 2;
  296.                         }
  297.                         else
  298.                         {
  299.                             r.y += 1; Check();
  300.                             map[r.x, r.y ] = 2;
  301.                         }

  303.                     }

  305.                 }
  306.                 else if (top < bottom)
  307.                 {
  308.                     bool isX = true, //行上是否有障碍
  309.                        isY = true; //列上是否有障碍

  311.                     for (int i = r.x; i >= 0;i-- )//x
  312.                     {
  313.                         if (map[i, r.y] == 1)
  314.                         {
  315.                             isX = false;
  316.                             break;
  317.                         }
  318.                     }

  320.                     for (int i = r.y; i >= 0; i--)
  321.                     {
  322.                         if (map[r.x, i] == 1)
  323.                         {
  324.                             isX = false;
  325.                             break;
  326.                         }
  327.                     }
  328.                     map[r.x, r.y] = 0;
  329.                     if (top < left)
  330.                     {
  331.                         if (isY)
  332.                         {
  333.                             r.y -= 1; Check();
  334.                             map[r.x, r.y ] = 2;
  335.                         }
  336.                         else
  337.                         {
  338.                             r.x -= 1; Check();
  339.                             map[r.x , r.y] = 2; }

  341.                     }
  342.                     if (top > left)
  343.                     {
  344.                         if (isX)
  345.                         {
  346.                             r.x -= 1; Check();
  347.                             map[r.x , r.y] = 2;
  348.                         }
  349.                         else
  350.                         {
  351.                             r.y -= 1; Check();
  352.                             map[r.x, r.y ] = 2;
  353.                         }
  354.                     }
  355.                 }
  356.             }

  358.             //if (r.x < 0 || r.x >3 || r.y < 0 || r.y >3)
  359.             //{
  360.                 ;
  361.             //}

  363.             this.Refresh();
  364.             

  366.         }

  368.         private void timer1_Tick(object sender, EventArgs e)
  369.         {
  370.             if (this.Opacity == 1) timer1.Enabled = false;
  371.             this.Opacity += 0.1;
  372.             
  373.         }
  374.         private void Check()
  375.         {
  376.             if (r.x < 0 || r.x > 3 || r.y < 0 || r.y > 3)
  377.             {
  378.                 GameOver();
  379.             }
  380.         }
  381.         private void GameOver()
  382.         {
  383.             MessageBox.Show("Game Over");
  384.             Process p = Process.GetCurrentProcess();

  386.             p.Kill();

  388.             //p.Kill();
  389.         }
  390.     }
  391. }
复制代码


QQ截图20141220195640.png QQ截图20141220195712.png QQ截图20141220195722.png QQ截图20141220202518.png


刚才重新看了下代码，发现了几个bug，修复了下，现在重新把代码发上来





  4. using System;
  5. using System.Collections.Generic;
  6. using System.ComponentModel;
  7. using System.Data;
  8. using System.Drawing;
  9. using System.Linq;
  10. using System.Text;
  11. using System.Windows.Forms;
  12. using System.Diagnostics;




  17. namespace WindowsFormsApplication1
  18. {
  19.     struct point
  20.     {
  21.         public int x, y;
  22.     };
  23.     struct pos : IComparable
  24.     {
  25.         public string name;
  26.         public int distance;
  27.         public static bool operator <(pos a, pos b)
  28.         {
  29.             if (a.distance < b.distance)
  30.             {
  31.                 return true;
  32.             }
  33.             else
  34.             {
  35.                 return false;
  36.             }
  37.         }

  39.         public static bool operator >(pos a, pos b)
  40.         {
  41.             return a.distance > b.distance ? true : false;
  42.         }






  49.         public int CompareTo(object obj)
  50.         {
  51.             pos p = (pos)obj;

  53.             return this.distance.CompareTo(p.distance);
  54.         }
  55.     };
  56.     public partial class Form1 : Form
  57.     {

  59.         bool leftHave = false;
  60.         bool rightHave = false;
  61.         bool topHave = false;
  62.         bool bottomHave = false;
  63.         
  64.         int[,] map = new int[4, 4];
  65.         point r = new point {
  66.             x = 2,
  67.             y = 1
  68.         };
  69.         bool isClick = false;
  70.         point click = new point();

  72.         public Form1()
  73.         {
  74.             InitializeComponent();
  75.         }

  77.         private void Form1_Load(object sender, EventArgs e)
  78.         {
  79.             
  80.             for (int i = 0; i < 4; i++)
  81.             {
  82.                 for (int j = 0; j < 4; j++)
  83.                 {
  84.                     map[i, j] = 0;
  85.                 }
  86.             }
  87.             map[r.x, r.y] = 2;

  89.            

  91.         }

  93.         private void Form1_Paint(object sender, PaintEventArgs e)
  94.         {
  95.             Graphics g = e.Graphics;

  97.             for (int i = 0; i < 4; i++) //x
  98.             {
  99.                 for (int j = 0; j < 4; j++) //y
  100.                 {

  102.                     
  103.                         
  104.                         Pen p = Pens.Black;
  105.                         int x = j%2 == 0 ? i * 20 : i*20+10,
  106.                             y = j * 20;
  107.                         const int w = 20, h = 20;

  109.                         g.DrawEllipse(Pens.Black, x, y, 20, 20);
  110.                         if (map[i, j] == 0) g.FillEllipse(Brushes.Red, x, y, w, h); //No Wall or Stone
  111.                         if (map[i, j] == 1) g.FillEllipse(Brushes.Green, x, y, w, h); // Has Green
  112.                         if (map[i, j] == 2) g.FillEllipse(Brushes.Yellow,x,y, w, h);  //Rabbit      

  114.                     

  116.                 }
  117.             }

  119.         }

  121.         private void Form1_MouseClick(object sender, MouseEventArgs e)
  122.         {
  123.             this.isClick = true;
  124.             
  125.             if(e.Y < 80&&(e.X/20)%2 == 0)
  126.             {
  127.                 click.x = (e.X - 10) / 20 ;
  128.                 click.y = (e.Y / 20) ;
  129.             }
  130.             else if(e.Y<80)
  131.             {
  132.                 click.x = e.X / 20;
  133.                 click.y = e.Y / 20;
  134.             }
  135.             else
  136.             {
  137.                 click.x = click.y = -1;
  138.             }

  140.             if(click.x<4&&click.y<4&&click.x>=0&&click.y>=0)
  141.             {
  142.                 if (map[click.x, click.y] == 2) return;
  143.                 map[click.x, click.y] = 1;
  144.                 this.Refresh();

  146.                 _move();
  147.                
  148.             }



  152.             
  153.         }
  154.         private void move()
  155.         {
  156.             int left = r.x;
  157.             int right = 4 - r.x;
  158.             int top = r.y;
  159.             int bottom = 4 - r.y;


  162.            /* List<int> list = new List<int>();

  164.             list.Add(left);
  165.             list.Add(right);
  166.             list.Add(top);
  167.             list.Add(bottom);

  169.             list.Sort();
  170.             */
  171.             if (left > right) //right
  172.             {
  173.                 if (top > bottom) // top
  174.                 {
  175.                     
  176.                     bool isX = true, //行上是否有障碍
  177.                         isY = true ; //列上是否有障碍
  178.                     //自上而下遍历
  179.                     for (int i = r.y;i<4;i++)
  180.                     {
  181.                         if (map[r.x, i] == 1)
  182.                         {
  183.                             isY = false;
  184.                             break;

  186.                         }
  187.                     }
  188.                     for (int i = r.x; i < 4; i++)
  189.                     {
  190.                         if (map[i, r.y] == 1)
  191.                         {
  192.                             isX = false;
  193.                             break;
  194.                         }
  195.                     }

  197.                     map[r.x, r.y] = 0;

  199.                     if (bottom > right)
  200.                     {
  201.                         if (isX)
  202.                         {
  203.                             r.x += 1;
  204.                             Check();
  205.                             map[r.x , r.y] = 2;

  207.                         }
  208.                         else
  209.                         {
  210.                             r.y += 1;
  211.                             Check();
  212.                             map[r.x, r.y ] = 2;
  213.                         }
  214.                     }
  215.                     if(bottom<right)
  216.                     {
  217.                         if (isY)
  218.                         {
  219.                             r.y += r.y; Check();
  220.                             map[r.x, r.y] = 2;
  221.                         }
  222.                         else
  223.                         {
  224.                             r.x += 1; Check();
  225.                             map[r.x , r.y] = 2;
  226.                         }
  227.                     }

  229.                   

  231.                 }
  232.                 else if (top < bottom)
  233.                 {
  234.                     bool isX = true, //行上是否有障碍
  235.                        isY = true; //列上是否有障碍

  237.                     for (int i = r.x; i < 4; i++)
  238.                     {
  239.                         if (map[i, r.y] == 1)
  240.                         {
  241.                             isX = false;
  242.                             break;
  243.                         }
  244.                     }

  246.                     for (int i = r.y; i >= 0; i--)
  247.                     {
  248.                         if (map[r.x, i] == 1)
  249.                         {
  250.                             isY = false;
  251.                             break;
  252.                         }
  253.                     }

  255.                     map[r.x, r.y] = 0;

  257.                     if (top < right)
  258.                     {

  260.                         if (isY)
  261.                         {
  262.                             r.y -= 1; Check();
  263.                             map[r.x, r.y ] = 2;
  264.                         }
  265.                         else
  266.                         {
  267.                             r.x += 1; Check();
  268.                             map[r.x , r.y] = 2;
  269.                         }

  271.                     }
  272.                     else if (top >= right)
  273.                     {
  274.                         if (isX)
  275.                         {
  276.                             r.x += 1; Check();
  277.                             map[r.x , r.y] = 2;
  278.                         }
  279.                         else
  280.                         {
  281.                             r.y -= r.y; Check();
  282.                             map[r.x, r.y ] = 2;
  283.                         }
  284.                     }

  286.                     
  287.                 }


  290.             }
  291.             else if (right >=left)
  292.             {
  293.                 if (top >= bottom)
  294.                 {
  295.                     bool isX = true, //行上是否有障碍
  296.                        isY = true; //列上是否有障碍

  298.                     for (int i = r.x; i >= 0;i-- )//x
  299.                     {
  300.                         if (map[i, r.y] == 1)
  301.                         {
  302.                             isX = false;
  303.                             break;
  304.                         }
  305.                     }
  306.                     for (int i = r.y; i < 4; i++)//y
  307.                     {
  308.                         if (map[r.x, i] == 1)
  309.                         {
  310.                             isY = false;
  311.                         }
  312.                     }
  313.                     map[r.x, r.y] = 0;
  314.                     if (left >= bottom)
  315.                     {
  316.                         if (isY)
  317.                         {
  318.                             r.y += 1; Check();
  319.                             map[r.x, r.y] = 2;
  320.                         }
  321.                         else
  322.                         {
  323.                             r.x -= 1; Check();
  324.                             map[r.x , r.y] = 2;
  325.                         }

  327.                     }
  328.                     else if (left <= bottom)
  329.                     {
  330.                         if (isX)
  331.                         {
  332.                             r.x -= 1; Check();
  333.                             map[r.x , r.y] = 2;
  334.                         }
  335.                         else
  336.                         {
  337.                             r.y += 1; Check();
  338.                             map[r.x, r.y ] = 2;
  339.                         }

  341.                     }

  343.                 }
  344.                 else if (top < bottom)
  345.                 {
  346.                     bool isX = true, //行上是否有障碍
  347.                        isY = true; //列上是否有障碍

  349.                     for (int i = r.x; i >= 0;i-- )//x
  350.                     {
  351.                         if (map[i, r.y] == 1)
  352.                         {
  353.                             isX = false;
  354.                             break;
  355.                         }
  356.                     }

  358.                     for (int i = r.y; i >= 0; i--)
  359.                     {
  360.                         if (map[r.x, i] == 1)
  361.                         {
  362.                             isX = false;
  363.                             break;
  364.                         }
  365.                     }
  366.                     map[r.x, r.y] = 0;
  367.                     if (top < left)
  368.                     {
  369.                         if (isY)
  370.                         {
  371.                             r.y -= 1; Check();
  372.                             map[r.x, r.y ] = 2;
  373.                         }
  374.                         else
  375.                         {
  376.                             r.x -= 1; Check();
  377.                             map[r.x , r.y] = 2; }

  379.                     }
  380.                     if (top > left)
  381.                     {
  382.                         if (isX)
  383.                         {
  384.                             r.x -= 1; Check();
  385.                             map[r.x , r.y] = 2;
  386.                         }
  387.                         else
  388.                         {
  389.                             r.y -= 1; Check();
  390.                             map[r.x, r.y ] = 2;
  391.                         }
  392.                     }
  393.                 }
  394.             }

  396.             //if (r.x < 0 || r.x >3 || r.y < 0 || r.y >3)
  397.             //{
  398.                 ;
  399.             //}

  401.             this.Refresh();
  402.             

  404.         }

  406.         private void _move()
  407.         {

  409.             int bottom = 3 - r.y;
  410.             int top = r.y;
  411.             int left = r.x;
  412.             int right = 3 - r.x;

  414.             pos[] pp = new pos[4];

  416.             pp[0].name = "top";
  417.             pp[0].distance = top;

  419.             pp[1].name = "bottom";
  420.             pp[1].distance = bottom;

  422.             pp[2].name = "left";
  423.             pp[2].distance = left;

  425.             pp[3].name = "right";
  426.             pp[3].distance = right;

  428.             Array.Sort(pp);


  431.             for (int i = r.y; i >= 0; i--)//top
  432.             {
  433.                 if (map[r.x, i] == 1)
  434.                 {
  435.                     topHave = true;
  436.                     break;
  437.                 }
  438.             }

  440.             for (int i = r.y ; i < 4; i++) // bottom
  441.             {
  442.                 if (map[r.x, i] == 1)
  443.                 {
  444.                     bottomHave = true;
  445.                     break;
  446.                 }
  447.             }

  449.             for (int i = r.x; i >= 0; i--) //left
  450.             {
  451.                 if (map[i,r.y] == 1)
  452.                 {
  453.                     leftHave = true;
  454.                     break;
  455.                 }
  456.             }
  457.             for (int i = r.x; i < 4; i++) //right
  458.             {
  459.                 if (map[i, r.y] == 1)
  460.                 {
  461.                     rightHave = true;
  462.                     break;
  463.                 }
  464.             }


  467.             if (!__move(0,pp))
  468.             {
  469.                 GameOver();
  470.             }

  472.             if (leftHave && rightHave && topHave && bottomHave)
  473.             {
  474.                 MessageBox.Show("You Win");
  475.                 Process p = Process.GetCurrentProcess();
  476.                 p.Kill();

  478.             }



  482.         }

  484.         private bool check()
  485.     {

  487.             if (r.y < 0 || r.y > 3 || r.x < 0 || r.x>3)
  488.             {
  489.                 return false;
  490.             }
  491.             else
  492.                 return true;

  494.     }
  495.         bool __move(int i ,pos[] pp)
  496.         {
  497.             if (i >= 3) return false;



  501.             

  503.             switch (pp[i].name)
  504.             {

  506.                 case "top":
  507.                     {
  508.                         if (topHave) return __move(i + 1, pp);
  509.                         else
  510.                         {
  511.                             return move_top();
  512.                            
  513.                         }
  514.                         break;
  515.                     }
  516.                 case "bottom":
  517.                     {
  518.                         if (bottomHave) return  __move(i + 1, pp);
  519.                         else
  520.                         {
  521.                             return move_bottom();
  522.                         }
  523.                         break;
  524.                     }
  525.                 case "left":
  526.                     {
  527.                         if (leftHave) return __move(i + 1, pp);
  528.                         else
  529.                         {
  530.                             return move_left();
  531.                         }
  532.                         break;
  533.                     }
  534.                 case "right":
  535.                     {
  536.                         if (rightHave) return __move(i + 1, pp);
  537.                         else
  538.                         {
  539.                             return move_right();
  540.                         }
  541.                         break;
  542.                     }
  543.             }

  545.             return true;

  547.         }

  549.         bool move_left()
  550.         {
  551.             map[r.x, r.y] = 0;
  552.             r.x -= 1;

  554.             {
  555.                 if (!check()) return false;
  556.                 map[r.x, r.y] = 2;
  557.                // if (!check()) return false;
  558.                 this.Refresh();
  559.                 return true;
  560.             }
  561.         }

  563.         bool  move_right()
  564.         {
  565.             map[r.x, r.y] = 0;
  566.             r.x += 1;
  567.             if (!check()) return false;
  568.             map[r.x , r.y] = 2;
  569.             this.Refresh();
  570.             return true;
  571.         
  572.            
  573.         }

  575.         bool  move_top()
  576.         {
  577.             
  578.             map[r.x, r.y] = 0;
  579.             r.y -= 1;
  580.             if (!check()) return false;
  581.             map[r.x, r.y] = 2;
  582.             this.Refresh();
  583.             return true;
  584.         }
  585.         bool move_bottom()
  586.         {
  587.            // if (!check()) return false;
  588.             map[r.x, r.y] = 0;
  589.             r.y += 1;
  590.             if (!check()) return false;
  591.             map[r.x, r.y ] = 2;
  592.             this.Refresh();
  593.             return true;
  594.         }

  596.         private void timer1_Tick(object sender, EventArgs e)
  597.         {
  598.             if (this.Opacity == 1) timer1.Enabled = false;
  599.             this.Opacity += 0.1;
  600.             
  601.         }
  602.         private void Check()
  603.         {
  604.             if (r.x < 0 || r.x > 3 || r.y < 0 || r.y > 3)
  605.             {
  606.                 GameOver();
  607.             }
  608.         }
  609.         private void GameOver()
  610.         {
  611.             MessageBox.Show("Game Over");
  612.             Process p = Process.GetCurrentProcess();

  614.             p.Kill();

  616.             //p.Kill();
  617.         }
  618.     }
  619. }
复制代码


============================================================================================================================

游戏

CatchCat.rar

51.66 KB, 下载次数: 5

相关帖子
回复

使用道具 举报

0xAA55
发表于 2014-12-20 22:27:05 | 显示全部楼层
哈哈 创意不错 不过这种是啥语言都能写的。至于面向对象……为什么非得面向对象？你有对象？
回复 赞！ 靠！

使用道具 举报

watermelon
发表于 2020-4-8 16:17:41 | 显示全部楼层
0xAA55 发表于 2014-12-20 22:27
哈哈 创意不错 不过这种是啥语言都能写的。至于面向对象……为什么非得面向对象？你有对象？ ...

真相了，难受。
回复 赞！ 靠！

使用道具 举报

返回列表 发新帖

本版积分规则

QQ|Archiver|小黑屋|技术宅的结界 ( 滇ICP备16008837号 )|网站地图

GMT+8, 2024-11-21 22:29 , Processed in 0.036520 second(s), 26 queries , Gzip On.

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

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