Maze kod.

[TheSpaceMan]

Här är mazekoden jag skrev. Mitt nya uppsåt är att få igång rooms att fungera. Där av det finns en Room struct.
Det är även ett litet mål att markera in områden som regioner, där en region är ett antal noder, det ska fungera enligt systemet att man identifierar alla noder med mer än 2 öppna sidor, den markeras som en shared node. Alla noder efter en shared nod läggs i en gemensam lista tills man når en ny shared node. Alla regions med för få antal medlemar läggs till en annan region om det bara är en 2 vägs korsning. Ev lite regler att vissa regions slår ut alla interna väggar och skapar rum. Här är det iaf. Slit den i stycken och klaga. Room gör inget för stunden. Det är bara rakt av kopierat mitt i arbetet men det borde compilera.

Det enda jag fokuserat på är att inte ha minnesläckor, men det finns nog mycket annat dumt kvar där inne.

En stycke maze.h
header

Radnummer Av/På | Expandera/Minimera | Markera allt

1.  
2. #pragma once
3.  
4. #include <list>
5. #include <vector>
6. #include "DrawFunctions.h"
7.  
8. enum DIR
9. {
10.     UP,
11.     DOWN,
12.     LEFT,
13.     RIGHT,
14.     NRDIR
15. };
16.  
17. static int D2I(DIR dir)
18. {
19.     switch(dir)
20.     {
21.     case UP: case RIGHT:
22.         return -1;
23.         break;
24.     case DOWN: case LEFT:
25.         return 1;
26.         break;
27.     default:
28.         break;
29.     };
30.     return 0;
31. }
32.  
33.  
34. struct MazeNode
35. {
36.     unsigned int X;
37.     unsigned int Y;
38.     bool Open[NRDIR];
39.     bool Visited;
40.     MazeNode()
41.     {
42.         X = Y = 0;
43.         Open[UP] = false;
44.         Open[DOWN] = false;
45.         Open[LEFT] = false;
46.         Open[RIGHT] = false;
47.         Visited = false;
48.     }
49. };
50.  
51. struct Room
52. {
53.     Room(int x, int y, int w, int h)
54.     {
55.         X = x;
56.         Y = y;
57.         Width = w;
58.         Height = h;
59.     }
60.     ROOM()
61.     {
62.         Width = 1;
63.         Height = 1;
64.         X = 0;
65.         Y = 0;
66.     }
67.     int Width;
68.     int Height;
69.     int X;
70.     int Y;
71. };
72.  
73.  
74. class Maze
75. {
76. public:
77.     Maze(int width, int height, int startx,int starty, bool completeInOneFrame);
78.     ~Maze();
79.     void AddRoom(int x, int y, int width, int height);
80.     int getIndex(int x, int y);
81.     MazeNode* getMazeNode(int x, int y);
82.     bool isComplete(){return m_Complete;}
83.     bool nextIteration();
84.     void GenerateSurface();
85.     Surface* getSurface() {return m_Surface;}
86. private:
87. protected:
88.    
89.     bool m_Complete;
90.     MazeNode*   m_CurrentNode;
91.     int m_Width;
92.     int m_Height;
93.     std::list<MazeNode*>    m_Visited;
94.     std::vector<MazeNode>   m_MazeNodes;
95.     Surface*                m_Surface;
96. };
97.  

och maze.cpp

Radnummer Av/På | Expandera/Minimera | Markera allt

1.  
2. #include "Maze.h"
3.  
4. int Maze::getIndex(int x, int y)
5. {
6.     return x+y*m_Width;
7.  
8. }
9.  
10.  
11. Maze::~Maze()
12. {
13.     delete m_Surface;
14. }
15. MazeNode* Maze::getMazeNode(int x, int y)
16. {
17.     MazeNode* result = NULL;
18.     if( (x >= 0 && x < m_Width) &&
19.         (y >= 0 && y < m_Height) )
20.     {
21.         result = &m_MazeNodes[getIndex(x,y)];
22.     }
23.     return result;
24. }
25.  
26.  
27. Maze::Maze(int width, int height, int startx, int starty, bool completeInOneFrame = false)
28. {
29.     m_Complete = completeInOneFrame;
30.     m_Width  = width;
31.     m_Height = height;
32.     m_MazeNodes.resize(width*height);
33.     m_Surface = new Surface((width*2)+1,(height*2)+1);
34.     clearScreen(m_Surface,rgb(0,0,0));
35.     for(int y = 0; y < height; y++)
36.     {
37.         for(int x = 0; x < width; x++)
38.         {
39.             MazeNode* currentNode = getMazeNode(x,y);
40.  
41.             currentNode->X = x;
42.             currentNode->Y = y;
43.             currentNode->Visited = false;
44.         }
45.     }
46.     m_CurrentNode = getMazeNode(startx,starty);
47.     if(completeInOneFrame)
48.     {
49.         while(nextIteration());
50.     }
51. }
52.  
53. bool Maze::nextIteration()
54. {
55.     MazeNode* nextNode = NULL;
56.     int x = m_CurrentNode->X;
57.     int y = m_CurrentNode->Y;
58.    
59.     std::vector<MazeNode*> mazenodes;
60.     MazeNode* currentNode = NULL;
61.    
62.     currentNode = getMazeNode(x+D2I(LEFT),y);
63.     if(currentNode)
64.     {
65.         if(!currentNode->Visited)
66.         {
67.             mazenodes.push_back(currentNode);
68.         }
69.     }
70.  
71.     currentNode = getMazeNode(x+D2I(RIGHT),y);
72.     if(currentNode)
73.     {
74.         if(!currentNode->Visited)
75.         {
76.             mazenodes.push_back(currentNode);
77.         }
78.     }
79.  
80.     currentNode = getMazeNode(x,y+D2I(UP));
81.     if(currentNode)
82.     {
83.         if(!currentNode->Visited)
84.         {
85.             mazenodes.push_back(currentNode);
86.         }
87.     }
88.  
89.     currentNode = getMazeNode(x,y+D2I(DOWN));
90.     if(currentNode)
91.     {
92.         if(!currentNode->Visited)
93.         {
94.             mazenodes.push_back(currentNode);
95.         }
96.     }
97.  
98.     if(mazenodes.size())
99.     {
100.         MazeNode* targetNode = mazenodes[rand()%mazenodes.size()];
101.         m_Visited.push_back(m_CurrentNode);
102.  
103.         if(m_CurrentNode->X > targetNode->X)
104.         {
105.             m_CurrentNode->Open[RIGHT]= true;
106.         }
107.         if(m_CurrentNode->Y < targetNode->Y)
108.         {
109.             m_CurrentNode->Open[DOWN]= true;
110.         }
111.        
112.         if(m_CurrentNode->X < targetNode->X)
113.         {
114.             m_CurrentNode->Open[LEFT]= true;
115.         }
116.         if(m_CurrentNode->Y > targetNode->Y)
117.         {
118.             m_CurrentNode->Open[UP]= true;
119.         }
120.         m_CurrentNode = targetNode;
121.         m_CurrentNode->Visited = true;
122.     }
123.     else
124.     {
125.         if(m_Visited.size())
126.         {
127.             if(m_Visited.back())
128.             {
129.                 m_CurrentNode = m_Visited.back();
130.             }
131.             m_Visited.pop_back();
132.         }
133.         else
134.         {
135.             m_Complete = true;
136.         }
137.     }
138.     return m_Complete;
139. }
140.  
141. void Maze::GenerateSurface()
142. {
143.     if(!m_Surface)
144.     {
145.         return;
146.     }
147.     for(int y = 0; y < m_Height; y++)
148.     {
149.         for(int x = 0; x < m_Width; x++)
150.         {
151.             MazeNode* currentNode = getMazeNode(x,y);
152.             int targetX = x*2;
153.             int targetY = y*2;
154.  
155.             int white = rgb(255,255,255);
156.  
157.            
158.             putPixel(m_Surface,targetX,targetY,white);
159.             if(currentNode->Open[UP])
160.             {
161.                 putPixel(m_Surface,targetX,targetY+D2I(UP),white);
162.             }
163.             if(currentNode->Open[DOWN])
164.             {
165.                 putPixel(m_Surface,targetX,targetY+D2I(DOWN),white);
166.             }
167.             if(currentNode->Open[LEFT])
168.             {
169.                 putPixel(m_Surface,targetX+D2I(LEFT),targetY,white);
170.             }
171.             if(currentNode->Open[RIGHT])
172.             {
173.                 putPixel(m_Surface,targetX+D2I(RIGHT),targetY,white);
174.             }
175.         }
176.     }
177.     for(std::list<MazeNode*>::iterator iter = m_Visited.begin(); iter != m_Visited.end(); iter++)
178.     {
179.         MazeNode* currentNode = *iter;
180.         putPixel(m_Surface,currentNode->X*2,currentNode->Y*2,rgb(0,255,0));
181.     }
182. };
183.  

[Hildenborg]

Du inspirerar mig.

Får mig att börja minnas en kod som jag planerade men aldrig skrev...
När jag experimenterade med libnoise (http://libnoise.sourceforge.net/), så tänkte jag ut ett system att via oct-tree bygga 3D noise, och ha ett tröskelvärde för vad som var solitt och vad som var tomrum. Och sedan skulle jag genom att arbeta mig nedåt genom mitt oct-tree, så kunde jag analysera vad som skulle bli väggar. Och på det sättet kunde man skapa 3D labyrinter som mer eller mindre liknade grottor.

Eftersom det sannolikt kunde bli dåliga genereringar, så var tanken att sitta och gå igenom x antal genereringar och välja ut de seeds som var bra.
Kunde varit en bra grund till en Descent (http://en.wikipedia.org/wiki/Descent_(computer_game)) klon...

[TheSpaceMan]

Mjo det jag tänker skulle kunna producera samma sak med, finns inget som hindrar mig från att använda djup i genereringen, regionsvägg tömningen jag funderar på skulle även den fungera för att öppna upp grottor som du nämner i flera dimensioner.

Den skulle vara area perfekt med så det gick att ta sig över hela det område man anger, och bara genom att slänga in closed nodes så kan man forma området med.

[Hildenborg]

När jag postade min ide' om hur man skulle kunna generera grottor etc. med libnoise, så kände jag att jag inte lyckades beskriva vad jag menade... Och jag kom inte på hur jag skulle kunna beskriva det bättre heller... Så, nu under semestern så har jag pillat lite, och är ännu inte färdig, men på min blog: http://www.hildenborg.com/ så kan man iaf. få ett hum om vad det handlar om nu.

[Flink]

När jag postade min ide' om hur man skulle kunna generera grottor etc. med libnoise, så kände jag att jag inte lyckades beskriva vad jag menade... Och jag kom inte på hur jag skulle kunna beskriva det bättre heller... Så, nu under semestern så har jag pillat lite, och är ännu inte färdig, men på min blog: http://www.hildenborg.com/ så kan man iaf. få ett hum om vad det handlar om nu.

Oh maan, ser sjukt awesome ut, grottutforskning är awesome.