創作內容

16 GP

C# 迷宮產生器 - 使用 prim's 演算法

作者：貓貓風 ฅ●ω●ฅ│2018-12-20 23:56:48│巴幣：32│人氣：1289
.















此篇為前一篇走迷宮的進階應用

前一篇需要人工手動制造迷宮，如果迷宮很大就會不容易進行製作

製作迷宮的方式可以用很多演算法  例如  深度 / 廣度優先演算法

十字分割演算法、  還有本篇所使用的 普林(Prim)演算法

使用不同的演算法，產生的迷宮複雜度均會有所不同


普林演算法

圖論中的一種演算法，可在加權連通圖里搜索最小生成樹。意即由此演算法搜索到的邊子集所構成的樹中，不但包括了連通圖裡的所有頂點，且其所有邊的權值之和亦為最小。該演算法於1930年由捷克數學家沃伊捷赫·亞爾尼克發現；並在1957年由美國計算機科學家羅伯特·普林獨立發現；1959年，艾茲格·迪科斯徹再次發現了該演算法。因此，在某些場合，普林演算法又被稱為DJP演算法、亞爾尼克演算法或普林－亞爾尼克演算法。

產生迷宮的原理很簡單，一開始先預設一個全部都是牆壁的迷宮

然後開始隨機選擇一做牆進行挖掘，挖掘完成後在找隨機一面相鄰的牆壁進行挖掘

重複上述步驟直到全部打通

如下面順序進行挖掘








依此類推


最後附上實作程式碼


  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.ComponentModel;  
  4. using System.Data;  
  5. using System.Drawing;  
  6. using System.Linq;  
  7. using System.Text;  
  8. using System.Windows.Forms;  
  9. using System.Collections;  
  10. using System.Threading;  
  11.   
  12. namespace Maze  
  13. {  
  14.     public partial class Form1 : Form  
  15.     {  
  16.         int[,] _maze;  
  17.         int[] _maze_F;  
  18.         int _size = 23;  
  19.         int _maze_index = 0;  
  20.         int _step_count = 0;  
  21.         bool _is_exit = false;  
  22.         bool _first = false;  
  23.         bool _is_dead = false;  
  24.   
  25.         private delegate void UpdateUI(parameter.status current, Control ctl);   
  26.         private delegate void UpdateText(parameter.status current, String str, Control ctl);
  27.         parameter _para = new parameter();  
  28.   
  29.         private Label[] _label_wall;  
  30.         private Label[] _label_path;  
  31.         private Label[] _label_step;  
  32.         private Label[] _label_obj = new Label[1];  
  33.         private Label[] _label_Exit = new Label[1];  
  34.         private Panel _panel;  
  35.         private int _label_wall_x = 30, _label_wall_y = 30, _label_path_x = 30,
  36.         _label_path_y = 30,  
  37.         _label_obj_x = 90, _label_obj_y = 60;  
  38.         int _label_step_index = 0;  
  39.         Stack _st = new Stack();  
  40.         private Thread _th;  
  41.         //private delegate void UpdateUI(parameter.status current, Control ctl);   
  42.         int pre_x;  
  43.         int pre_y;  
  44.         bool first = true;  
  45.         int[] _record;  
  46.         int index = 1;  
  47.         int r_count = 0, l_count = 0, u_count = 0, d_count = 0, _pre_index = 0;  
  48.         bool _check = true;  
  49.   
  50.         public Form1()  
  51.         {  
  52.             InitializeComponent();  
  53.         }  
  54.   
  55.         private void Form1_Load(object sender, EventArgs e)  
  56.         {  
  57.               
  58.             this.comboBox1.Items.Clear();  
  59.   
  60.             for (int i = 3; i <= _para.max_size; i+=2)  
  61.             {  
  62.                 this.comboBox1.Items.Add(new dropdownList(i.ToString(), i));  
  63.             }  
  64.   
  65.             this.comboBox1.SelectedIndex = 0;  
  66.         }  
  67.   
  68.         private void generate_maze()  
  69.         {  
  70.   
  71.             for (int i = 0; i < _size; i++)  
  72.             {  
  73.                 for (int j = 0; j < _size; j++)  
  74.                 {  
  75.                     _maze_F[_maze_index] = _maze[i, j];  
  76.                     if ((_maze_index + 1) % (_size) == 0)  
  77.                     {  
  78.                         _maze_F[_maze_index] = 1;  
  79.                     }  
  80.                     _maze_index++;  
  81.                 }  
  82.   
  83.             }  
  84.   
  85.             //設定最後一排牆壁  
  86.             for (int ch = 1; ch < _size * _size; ch++)  
  87.             {  
  88.                 if (ch / (_size - 1) == _size)  
  89.                 {  
  90.                     for (int i = (_size * (_size - 1)); i < (_size * (_size - 1)) + (_size - 1); i++)  
  91.                     {  
  92.                         if (i == (_size * (_size - 1)) + (_size - 2))  
  93.                         {  
  94.                             _maze_F[i] = 0; // 出口  
  95.                         }  
  96.                         else  
  97.                         {  
  98.                             _maze_F[i] = 1; //牆  
  99.                         }  
  100.                     }  
  101.                 }  
  102.             }  
  103.   
  104.             _label_obj[0] = new Label();  
  105.             _label_obj[0].AutoSize = false;  
  106.             _label_obj[0].Width = 80;  
  107.             _label_obj[0].Height = 30;  
  108.             _label_obj[0].Text = "";  
  109.             _label_obj[0].Font = new Font("Verdana", 12, FontStyle.Bold);  
  110.             _label_obj[0].ForeColor = Color.Orange;  
  111.             _label_obj[0].BackColor = Color.Lime;  
  112.             _label_obj[0].Location = new Point(_label_obj_x, _label_obj_y);  
  113.             this.Controls.Add(_label_obj[0]);  
  114.             _label_obj[0].BringToFront();  

  116.             for (int i = 0; i < _size * _size; i++)  
  117.             {  
  118.                 if (i % _size == 0)  
  119.                 {  
  120.                     _label_wall_x = 30;  
  121.                     _label_wall_y += 30;  
  122.   
  123.                     _label_path_x = 30;  
  124.                     _label_path_y += 30;  
  125.                 }  
  126.   
  127.                 //產生牆壁  
  128.                 if (_maze_F[i] == 1)  
  129.                 {  
  130.                     _label_wall[i] = new Label();  
  131.   
  132.                     _label_wall[i].AutoSize = false;  
  133.                     _label_wall[i].Width = 80;  
  134.                     _label_wall[i].Height = 30;  
  135.                     _label_wall[i].Text = "-";  
  136.                     _label_wall[i].Font = new Font("Verdana", 12, FontStyle.Bold);    
  137.                     _label_wall[i].ForeColor = Color.Orange;  
  138.                     _label_wall[i].BackColor = Color.Black;  
  139.                     _label_wall[i].Location = new Point(_label_wall_x, _label_wall_y);  
  140.                     this.Controls.Add(_label_wall[i]);  
  141.                     //_label_wall[i].BringToFront();  
  142.                     _label_wall_x += 60;  
  143.                     _label_path_x += 60;  
  144.                     //_panel.Controls.Add(_label_wall[i]);  
  145.                 }  
  146.   
  147.                 //產生通道  
  148.                 else if (_maze_F[i] == 0)  
  149.                 {  
  150.                     _label_path[i] = new Label();  
  151.   
  152.                     _label_path[i].AutoSize = false;  
  153.                     _label_path[i].Width = 80;  
  154.                     _label_path[i].Height = 30;  
  155.                     _label_path[i].Text = "";  
  156.                     _label_path[i].Font = new Font("Verdana", 12, FontStyle.Bold);  
  157.                     _label_path[i].ForeColor = Color.Orange;  
  158.                     _label_path[i].BackColor = Color.Orange;  
  159.                     _label_path[i].Location = new Point(_label_path_x, _label_path_y);  
  160.                     this.Controls.Add(_label_path[i]);  
  161.                     _label_wall_x += 60;  
  162.                     _label_path_x += 60;  
  163.                 }  
  164.             }  
  165.   
  166.             _th = new Thread(walking);  
  167.             _th.Start();  
  168.         }  
  169.   
  170.         private void walking()  
  171.         {  
  172.             //顯示初始座標  
  173.             updatePath(parameter.status.Running, _label_path[0]);  
  174.             updatePath(parameter.status.Running, _label_obj[0]);  
  175.             //定義初始移動位置與方向  
  176.             _pre_index = index;  
  177.             r_count = _pre_index += 1;  
  178.             _pre_index = index;  
  179.             d_count = _pre_index += _size;  
  180.             _pre_index = index;  
  181.             l_count = _pre_index -= 1;  
  182.             _pre_index = index;  
  183.             u_count = _pre_index -= _size;  
  184.   
  185.             while ((r_count < _maze.Length) && (d_count < _maze.Length) && (l_count <
  186.             _maze.Length) && (u_count < _maze.Length) && !_is_dead)  
  187.             {  
  188.                 if (_maze_F[r_count] == 0)  
  189.                 {  
  190.                     _check = true; //有路  
  191.   
  192.                     if (_check)  
  193.                     {  
  194.                         _st.Push(r_count);//在 stack 加進一格的座標  
  195.                     }  
  196.   
  197.                     _label_obj_x += 60; //向右走  
  198.                     _pre_index = r_count;  
  199.                     _maze_F[r_count] = 1; // 走過  
  200.                     updatePath(parameter.status.Running, _label_path[0]);  
  201.                     updatePath(parameter.status.Running, _label_obj[0]);  
  202.                 }  
  203.   
  204.                 else if (_maze_F[d_count] == 0)  
  205.                 {  
  206.                     _check = true; //有路  
  207.   
  208.                     if (_check)  
  209.                     {  
  210.                         _st.Push(d_count);//在 stack 加進一格的座標  
  211.                     }  
  212.   
  213.                     _label_obj_y += 30; //向下走  
  214.                     _pre_index = d_count;  
  215.                     _maze_F[d_count] = 1; // 走過  
  216.                     updatePath(parameter.status.Running, _label_path[0]);  
  217.                     updatePath(parameter.status.Running, _label_obj[0]);  
  218.                 }  
  219.   
  220.                 else if (_maze_F[l_count] == 0)  
  221.                 {  
  222.                     _check = true; //有路  
  223.                     if (_check)  
  224.                     {  
  225.                         _st.Push(l_count);//在 stack 加進一格的座標  
  226.                     }  
  227.                     _label_obj_x -= 60; //向左走  
  228.                     _pre_index = l_count;  
  229.                     _maze_F[l_count] = 1; // 走過  
  230.                     updatePath(parameter.status.Running, _label_path[0]);  
  231.                     updatePath(parameter.status.Running, _label_obj[0]);  
  232.                 }  
  233.                 else if (_maze_F[u_count] == 0)  
  234.                 {  
  235.                     _check = true; //有路  
  236.   
  237.                     if (_check)  
  238.                     {  
  239.                         _st.Push(u_count);//在 stack 加進一格的座標  
  240.                     }  
  241.                     _label_obj_y -= 30; //向上走  
  242.                     _pre_index = u_count;  
  243.                     _maze_F[u_count] = 1; // 走過  
  244.                     updatePath(parameter.status.Running, _label_path[0]);  
  245.                     updatePath(parameter.status.Running, _label_obj[0]);  
  246.                 }  
  247.                 else  
  248.                 {  
  249.                     _check = false;  
  250.                     index = (int)_st.Peek();//三面都圍牆時 將當前位置設定為牆  
  251.                     _maze_F[index] = 1; // 走過  
  252.   
  253.                     _st.Pop();//在 stack 移除後退的格子的座標，退到前一步  
  254.                     try  
  255.                     {  
  256.                         index = (int)_st.Peek();  
  257.                     }  
  258.                     catch  
  259.                     {  
  260.                         updatePath(parameter.status.Dead, _label_obj[0]);  
  261.                         updateText(parameter.status.Dead,"No Exit", textBox1);  
  262.                         _st.Clear();  
  263.                         _th.Abort();  
  264.                         //MessageBox.Show("not found exit");  
  265.                         break;  
  266.                     }  
  267.                     _maze_F[index] = 0;  
  268.   
  269.                     if (_maze_F[index] == 0) //更新移動路徑  
  270.                     {  
  271.                         updatePath(parameter.status.Running, _label_path[0]);  
  272.                         updatePath(parameter.status.Running, _label_obj[0]);  
  273.                     }  
  274.                 }  
  275.   
  276.                 //更新往四個方向座標  
  277.                 r_count = _pre_index + 1;  
  278.                 d_count = _pre_index + _size;  
  279.                 l_count = _pre_index - 1;  
  280.                 u_count = _pre_index - _size;  
  281.   
  282.                 if (u_count == (_size * (_size - 1)) + (_size-2))  
  283.                 {  
  284.                     _is_exit = true;  
  285.                   break;  
  286.                 }  
  287.                 _step_count++;  
  288.                 updateText(parameter.status.Running,"running", textBox1);  
  289.                 updateText(parameter.status.Running,_step_count.ToString(), textBox2);  
  290.                 Thread.Sleep(50);  
  291.             }  
  292.   
  293.             if (_is_exit)  
  294.             {  
  295.                 updatePath(parameter.status.Exit, _label_obj[0]);  
  296.                 updateText(parameter.status.Exit,"Find Exit", textBox1);  
  297.                 //MessageBox.Show("Find Exit");  
  298.                 updateText(parameter.status.button_on, "start", button1);  
  299.                 _first = true;  
  300.                 _st.Clear();  
  301.                 _th.Abort();  
  302.                   
  303.             }  
  304.         }  
  305.   
  306.         private void updatePath(parameter.status current, Control ctl)  
  307.         {  
  308.             if (this.InvokeRequired)  
  309.             {  
  310.                 UpdateUI uu = new UpdateUI(updatePath);  
  311.                 this.Invoke(uu, current, ctl);  
  312.             }  
  313.             else  
  314.             {  
  315.                 if (current == parameter.status.Exit)  
  316.                 {  
  317.                     _label_Exit[0] = new Label();  
  318.                     _label_Exit[0].AutoSize = false;  
  319.                     _label_Exit[0].Width = 80;  
  320.                     _label_Exit[0].Height = 30;  
  321.                     _label_Exit[0].Text = "";  
  322.                     _label_Exit[0].Font = new Font("Verdana", 12, FontStyle.Bold);  
  323.                     _label_Exit[0].ForeColor = Color.Orange;  
  324.                     _label_Exit[0].BackColor = Color.Red;  
  325.                     _label_Exit[0].Location = new Point(_label_obj_x, _label_obj_y);  
  326.                     this.Controls.Add(_label_Exit[0]);  
  327.                     _label_Exit[0].BringToFront();  
  328.                 }  
  329.                 else if (current == parameter.status.Dead)  
  330.                 {  
  331.                     _label_Exit[0] = new Label();  
  332.                     _label_Exit[0].AutoSize = false;  
  333.                     _label_Exit[0].Width = 80;  
  334.                     _label_Exit[0].Height = 30;  
  335.                     _label_Exit[0].Text = "";  
  336.                     _label_Exit[0].Font = new Font("Verdana", 12, FontStyle.Bold);  
  337.                     _label_Exit[0].ForeColor = Color.Orange;  
  338.                     _label_Exit[0].BackColor = Color.Yellow;  
  339.                     _label_Exit[0].Location = new Point(_label_obj_x, _label_obj_y);  
  340.                     this.Controls.Add(_label_Exit[0]);  
  341.                     _label_Exit[0].BringToFront();  
  342.                     button1.Enabled = true;  
  343.                 }  
  344.                 else  
  345.                 {  
  346.                     if (!first)  
  347.                     {  
  348.                             _label_step[_label_step_index] = new Label();  
  349.                             _label_step[_label_step_index].AutoSize = false;  
  350.                             _label_step[_label_step_index].Width = 80;  
  351.                             _label_step[_label_step_index].Height = 30;  
  352.                             _label_step[_label_step_index].Text = "";  
  353.                             _label_step[_label_step_index].Font = new Font("Verdana", 12,
  354.                              FontStyle.Bold);  
  355.                             _label_step[_label_step_index].ForeColor = Color.Orange;  
  356.                             _label_step[_label_step_index].BackColor = Color.Blue;  
  357.                             _label_step[_label_step_index].Location = new Point(pre_x, pre_y);  
  358.                             this.Controls.Add(_label_step[_label_step_index]);  
  359.                             _label_step[_label_step_index].BringToFront();  
  360.                             _label_step_index++;  
  361.                         }          
  362.                     }  
  363.                     _label_obj[0].Location = new Point(_label_obj_x, _label_obj_y);  
  364.                     this.Controls.Add(_label_obj[0]);  
  365.                     _label_obj[0].BringToFront();  
  366.                     pre_x = _label_obj_x;  
  367.                     pre_y = _label_obj_y;  
  368.                     first = false;  
  369.                 }  
  370.   
  371.             }  
  372.         }  
  373.   
  374.         private void updateText(parameter.status current, String str, Control ctl)  
  375.         {  
  376.             if (this.InvokeRequired)  
  377.             {  
  378.                 UpdateText uu = new UpdateText(updateText);  
  379.                 this.Invoke(uu, current,  str, ctl);  
  380.             }  
  381.             else  
  382.             {  
  383.                 ctl.Text = str;  
  384.   
  385.                 if (current == parameter.status.Exit)  
  386.                 {  
  387.                     ctl.BackColor = Color.Lime;  
  388.                 }  
  389.                 else if (current == parameter.status.Running)  
  390.                 {  
  391.                     ctl.BackColor = Color.Orange;  
  392.                 }  
  393.                 else if (current == parameter.status.Dead)  
  394.                 {  
  395.                     ctl.BackColor = Color.Yellow;  
  396.                 }  
  397.                 else if (current == parameter.status.button_on)  
  398.                 {  
  399.                     ctl.Enabled = true;  
  400.                 }  
  401.   
  402.             }  
  403.         }  
  404.   
  405.         private int[,] Prim(int startX, int startY, int widthLimit, int heightLimit, bool
  406.         haveBorder)  
  407.         {  
  408.             //block:不可通行    unBlock:可通行  
  409.             const int block = 1, unBlock = 0;  
  410.             var r = new Random();  
  411.             //迷宮尺寸合法化  
  412.             if (widthLimit < 1)  
  413.                 widthLimit = 1;  
  414.             if (heightLimit < 1)  
  415.                 heightLimit = 1;  
  416.             //迷宮起點合法化  
  417.             if (startX < 0 || startX >= widthLimit)  
  418.                 startX = r.Next(0, widthLimit);  
  419.             if (startY < 0 || startY >= heightLimit)  
  420.                 startY = r.Next(0, heightLimit);  
  421.             //減去邊框所佔的格子  
  422.             if (!haveBorder)  
  423.             {  
  424.                 widthLimit--;  
  425.                 heightLimit--;  
  426.             }  
  427.             //迷宮尺寸換算成帶牆尺寸  
  428.             widthLimit *= 1;  
  429.             heightLimit *= 1;  
  430.             //迷宮起點換算成帶牆起點  
  431.             startX *= 2;  
  432.             startY *= 2;  
  433.             if (haveBorder)  
  434.             {  
  435.                 startX++;  
  436.                 startY++;  
  437.             }  
  438.             //產生空白迷宮  
  439.             var mazeMap = new int[widthLimit + 1, heightLimit + 1];  
  440.             for (int x = 0; x <= widthLimit; x++)  
  441.             {  
  442.                 //mazeMap.Add(new BitArray(heightLimit + 1));  
  443.                 for (int y = 0; y <= heightLimit; y++)  
  444.                 {  
  445.                     mazeMap[x, y] = block;  
  446.                 }  
  447.             }  
  448.   
  449.             //鄰牆列表  
  450.             var blockPos = new List<int>();  
  451.             //將起點作為目標格  
  452.             int targetX = startX, targetY = startY;  
  453.             //將起點標記為通路  
  454.             mazeMap[targetX, targetY] = unBlock;  
  455.   
  456.             //記錄鄰牆  
  457.             if (targetY > 1)  
  458.             {  
  459.                 blockPos.AddRange(new int[] { targetX, targetY - 1, 0 });  
  460.             }  
  461.             if (targetX < widthLimit)  
  462.             {  
  463.                 blockPos.AddRange(new int[] { targetX + 1, targetY, 1 });  
  464.             }  
  465.             if (targetY < heightLimit)  
  466.             {  
  467.                 blockPos.AddRange(new int[] { targetX, targetY + 1, 2 });  
  468.             }  
  469.             if (targetX > 1)  
  470.             {  
  471.                 blockPos.AddRange(new int[] { targetX - 1, targetY, 3 });  
  472.             }  
  473.             while (blockPos.Count > 0)  
  474.             {  
  475.                 //隨機選一堵牆  
  476.                 var blockIndex = r.Next(0, blockPos.Count / 3) * 3;  
  477.                 //找到牆對面的牆  
  478.                 if (blockPos[blockIndex + 2] == 0)  
  479.                 {  
  480.                     targetX = blockPos[blockIndex];  
  481.                     targetY = blockPos[blockIndex + 1] - 1;  
  482.                 }  
  483.                 else if (blockPos[blockIndex + 2] == 1)  
  484.                 {  
  485.                     targetX = blockPos[blockIndex] + 1;  
  486.                     targetY = blockPos[blockIndex + 1];  
  487.                 }  
  488.                 else if (blockPos[blockIndex + 2] == 2)  
  489.                 {  
  490.                     targetX = blockPos[blockIndex];  
  491.                     targetY = blockPos[blockIndex + 1] + 1;  
  492.                 }  
  493.                 else if (blockPos[blockIndex + 2] == 3)  
  494.                 {  
  495.                     targetX = blockPos[blockIndex] - 1;  
  496.                     targetY = blockPos[blockIndex + 1];  
  497.                 }  
  498.                 //如果目標格未連通  
  499.                 if (mazeMap[targetX, targetY] == block)  
  500.                 {  
  501.                     //聯通目標格  
  502.                     mazeMap[blockPos[blockIndex], blockPos[blockIndex + 1]] = unBlock;  
  503.                     mazeMap[targetX, targetY] = unBlock;  
  504.                     //添加目標格相鄰格  
  505.                     if (targetY > 1 && mazeMap[targetX, targetY - 1] == block &&
  506.                     mazeMap[targetX, targetY - 2] == block)  
  507.                     {  
  508.                         blockPos.AddRange(new int[] { targetX, targetY - 1, 0 });  
  509.                     }  
  510.                     if (targetX < widthLimit && mazeMap[targetX + 1, targetY] == block &&
  511.                    mazeMap[targetX + 2, targetY] == block)  
  512.                     {  
  513.                         blockPos.AddRange(new int[] { targetX + 1, targetY, 1 });  
  514.                     }  
  515.                     if (targetY < heightLimit && mazeMap[targetX, targetY + 1] == block &&
  516.                    mazeMap[targetX, targetY + 2] == block)  
  517.                     {  
  518.                         blockPos.AddRange(new int[] { targetX, targetY + 1, 2 });  
  519.                     }  
  520.                     if (targetX > 1 && mazeMap[targetX - 1, targetY] == block &&
  521.                    mazeMap[targetX - 1, targetY] == block)  
  522.                     {  
  523.                         blockPos.AddRange(new int[] { targetX - 1, targetY, 3 });  
  524.                     }  
  525.                 }  
  526.                 blockPos.RemoveRange(blockIndex, 3);  
  527.             }  
  528.             return mazeMap;  
  529.         }  
  530.   
  531.         private void button1_Click(object sender, EventArgs e)  
  532.         {  
  533.             if (_first)  
  534.             {  
  535.                 gc_collect();  
  536.             }  
  537.               
  538.             dropdownList ddL = (dropdownList)this.comboBox1.SelectedItem;  
  539.             button1.Enabled = false;  
  540.             _size = Int32.Parse(ddL.value.ToString());  
  541.             //_size = Int32.Parse(textBox1.Text);  
  542.             //---------init component  
  543.             init_component();  
  544.             generate_maze();  
  545.         }  
  546.   
  547.         private void init_component()  
  548.         {  
  549.             _maze = new int[_size, _size];  
  550.             _maze = Prim(1, 1, _size, _size, true);  
  551.             _maze_F = new int[_size * _size * 2];  
  552.             _label_wall = new Label[_size * _size * 2];  
  553.             _label_path = new Label[_size * _size * 2];  
  554.             _label_step = new Label[_size * _size * 4];  
  555.             //_st = new Stack();  
  556.             _record = new int[_size * _size * 2];  
  557.             _maze_index = 0;  
  558.             _step_count = 0;  
  559.             _is_dead = false;  
  560.             _is_exit = false;  
  561.             first = true;  
  562.   
  563.             index = 1;  
  564.             r_count = 0;  
  565.             l_count = 0;  
  566.             u_count = 0;  
  567.             d_count = 0;  
  568.             _pre_index = 0;  
  569.             _label_wall_x = 30;  
  570.             _label_wall_y = 30;  
  571.             _label_path_x = 30;  
  572.             _label_path_y = 30;  
  573.             _label_obj_x = 90;  
  574.             _label_obj_y = 60;  
  575.             _label_step_index = 0;  
  576.         }  
  577.   
  578.         private void gc_collect()  
  579.         {  
  580.             _maze = null;  
  581.             _maze_F = null;  

  583.             for(int i = 0 ; i < _label_wall.Length ; i++)  
  584.             {  
  585.                 Controls.Remove(_label_wall[i]);  
  586.             }  
  587.             for (int i = 0; i < _label_path.Length; i++)  
  588.             {  
  589.                 Controls.Remove(_label_path[i]);  
  590.             }  
  591.   
  592.             for (int i = 0; i < _label_step.Length; i++)  
  593.             {  
  594.                 Controls.Remove(_label_step[i]);  
  595.             }  
  596.             Controls.Remove(_label_obj[0]);  
  597.             Controls.Remove(_label_Exit[0]);  
  598.   
  599.             _label_wall = null;  
  600.             _label_path = null;  
  601.             _label_step = null;  
  602.             GC.Collect();  
  603.         }  
  604.     }  
  605. }  

執行影片

喜歡16 收藏 引用 留言 推上首頁 檢舉
引用網址：https://home.gamer.com.tw/TrackBack.php?sn=4233022
All rights reserved. 版權所有，保留一切權利

相關創作

同標籤作品搜尋：涼涼風|C#

靈魂潮汐 自動刷活動關卡 Auto Run程式開發 + 載點
C# INI檔讀取與寫入
C# ParameterizedThreadStart 帶參數執行緒用法
Horiba MFC 流量控制器 控制系統開發
C# Excel 輸出異常排除方法

留言共 7 篇留言

珀伽索斯(Ama)：
想到了對對碰遊戲[e1]

12-21 00:00

貓貓風 ฅ●ω●ฅ：
不過應該跟這差很多XD12-21 00:01
嚮鄉紅：
貓貓>口<

12-21 00:19

貓貓風 ฅ●ω●ฅ：
紅紅 > ω <12-21 00:20
PaPaPa：
最近沒什麼時間摸C# 快被cuda搞死了

12-21 17:57

貓貓風 ฅ●ω●ฅ：
cuda 我還沒接觸過也 有空來看看~12-25 00:30
小刀：
讚！

12-21 19:30

貓貓風 ฅ●ω●ฅ：
謝謝刀姊 ><12-25 00:30
Fuwawa：
迷宮還有進階應用...

12-21 21:17

貓貓風 ฅ●ω●ฅ：
對喔 其實走迷宮的方式也有很多 我這用的是最笨的 可能會走很久12-25 00:30
荒屍：
這個好有趣!!

12-25 00:25

貓貓風 ฅ●ω●ฅ：
荒屍也~ 好久不見 ><
有興趣的話可以一起來研究owo'12-25 00:31
荒屍：
我還在啃讀C語言的基礎概念，目前只會用指令達成兩個數的合..

12-25 00:41

貓貓風 ฅ●ω●ฅ：
好的 有問題歡迎提出 我可以幫忙解答><12-25 01:01
我要留言提醒：您尚未登入，請先登入再留言

16喜歡★s1234567 可決定是否刪除您的留言，請勿發表違反站規文字。

前一篇：C# 老鼠走迷宮... 後一篇：Arduino PM2....

追蹤私訊切換新版閱覽

作品資料夾

繪圖區 (0)
└動物朋友 (3)
└魔界戰記 (15)
└勇造繪 (8)
└鋼彈系列 (23)
└百萬亞瑟王 (20)
└東方系列 (17)
└花樣練習 (3)
└自創人物 (15)
└火影忍者 (2)
└魔塔大陸 (3)
└女王之刃 (5)
└織田信奈的野望 (11)
└ＣＬＡＮＮＡＤ (4)
└里番 (13)
└魔法少女 - 小圓 (5)
└Night狼Mare (4)
└水星領航員 (0)
└約會大作戰 (3)
└時空幻境 (5)
└其他 (44)

文章區 (0)
└自然描寫 (71)
└心情日記 (117)
└閒情逸致 (19)
└情感抒發 (43)
└幻 (64)

點點文 (16)

類小說 (9)

神魔之塔 (12)
└地獄級關卡 (86)
└單雙週關卡 (81)
└無限迴廊 (11)
└特殊關卡 (25)
└主線任務 (6)
└黃道十二宮ＥＸ (11)

勇造文 (41)

黑歷史 (11)

程式設計 (0)
└android (8)
└Web (2)
└arduino (32)
└C# (88)
└algorithm (2)
└python (4)

電腦系統相關 (33)

電路設計 (4)

貓咪大戰爭 (140)

闇影詩章 (15)

遊戲相關 (66)

動漫相關 (6)

公主連結 (51)

各種家電 / 電器 周邊 (19)

原神 (93)

崩壞：星穹鐵道 (35)

PVC模型收集 (4)

碧藍航線 (24)

未分類 (110)

robert286 給 ლ(´•д• ̀ლ：
ლ(´•д• ̀ლ看更多我要大聲說16小時前


face基於日前微軟官方表示 Internet Explorer 不再支援新的網路標準，可能無法使用新的應用程式來呈現網站內容，在瀏覽器支援度及網站安全性的雙重考量下，為了讓巴友們有更好的使用體驗，巴哈姆特即將於 2019年9月2日 停止支援 Internet Explorer 瀏覽器的頁面呈現和功能。
屆時建議您使用下述瀏覽器來瀏覽巴哈姆特：
。Google Chrome（推薦）
。Mozilla Firefox
。Microsoft Edge（Windows10以上的作業系統版本才可使用）

face我們了解您不想看到廣告的心情⋯ 若您願意支持巴哈姆特永續經營，請將 gamer.com.tw 加入廣告阻擋工具的白名單中，謝謝 !【教學】