Advertisement
Guest User

Untitled

a guest
Jan 16th, 2017
70
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.77 KB | None | 0 0
  1. //////////////////////////////////////////////////////////
  2. // //
  3. // Recursive backtracing maze generation //
  4. // //
  5. // Feel free to use and or modify the //
  6. // script for your own needs //
  7. // //
  8. // Only thing I ask is for you to //
  9. // keep this header here //
  10. // //
  11. // Script by: DarkAngel2096 //
  12. // SteamID: id/DarkAngel2096 //
  13. // //
  14. //////////////////////////////////////////////////////////
  15.  
  16. main()
  17. {
  18. thread mazeGen();
  19.  
  20. level.rows = 15;
  21. level.colums = 15;
  22. }
  23.  
  24. mazeGen()
  25. {
  26. activator = getEnt("mazeGenActivate", "targetname");
  27. mazeWalls = getEntArray("mazeWall", "targetname");
  28.  
  29. building = 0;
  30.  
  31. while(true)
  32. {
  33. activator waittill("trigger", player);
  34.  
  35. switch(building)
  36. {
  37. case 0:
  38. {
  39. building = 1;
  40.  
  41. makeMaze();
  42. wait 1;
  43.  
  44. generateRandomMaze();
  45. wait 1;
  46.  
  47. setSpawnAndEnd();
  48. wait 1;
  49.  
  50. doubledPlacement();
  51. wait 5;
  52.  
  53. placeWalls(mazeWalls);
  54. wait 1;
  55.  
  56. break;
  57. }
  58.  
  59. case 1:
  60. {
  61. building = 0;
  62.  
  63. destroyMaze(mazeWalls);
  64.  
  65. break;
  66. }
  67. }
  68. }
  69. }
  70.  
  71. makeMaze()
  72. {
  73. level.mazeGrid = [];
  74.  
  75. for(i = 0; i < level.rows; i++)
  76. {
  77. level.mazeGrid[i] = [];
  78.  
  79. for(j = 0; j < level.colums; j++)
  80. {
  81. level.mazeGrid[i][j] = cellElement(i, j);
  82. }
  83. }
  84.  
  85. iPrintLnBold("Grid done.");
  86. }
  87.  
  88. cellElement(i, j)
  89. {
  90. wallPlacement[0] = true; //west
  91. wallPlacement[1] = true; //south
  92. wallPlacement[2] = true; //east
  93. wallPlacement[3] = true; //north
  94.  
  95. cell = spawnStruct();
  96.  
  97. cell.xPlace = i;
  98. cell.yPlace = j;
  99.  
  100. cell.visited = false;
  101. cell.walls = wallPlacement;
  102.  
  103. return cell;
  104. }
  105.  
  106. generateRandomMaze()
  107. {
  108. current = level.mazeGrid[0][0];
  109. current.visited = true;
  110. path = [];
  111. path[0] = current;
  112.  
  113. while(true)
  114. {
  115. unvisitedNearby = unvisitedNeighbours(current.xPlace, current.yPlace);
  116.  
  117. if(unvisitedNearby.size)
  118. {
  119. nextCell = unvisitedNearby[randomInt(unvisitedNearby.size)];
  120. removeWalls(current, nextCell);
  121. nextCell.visited = true;
  122. path[path.size] = nextCell;
  123. current = nextCell;
  124. }
  125. else if(path.size > 1)
  126. {
  127. path[path.size - 1] = undefined;
  128. current = path[path.size - 1];
  129. }
  130. else
  131. break;
  132. }
  133.  
  134. iPrintLnBold("Generation done.");
  135. }
  136.  
  137. unvisitedNeighbours(xAxis, yAxis)
  138. {
  139. array = [];
  140.  
  141. if(xAxis > 0 && level.mazeGrid[xAxis - 1][yAxis].visited == false)
  142. array[array.size] = level.mazeGrid[xAxis - 1][yAxis];
  143.  
  144. if(xAxis < level.mazeGrid.size - 1 && level.mazeGrid[xAxis + 1][yAxis].visited == false)
  145. array[array.size] = level.mazeGrid[xAxis + 1][yAxis];
  146.  
  147. if(yAxis > 0 && level.mazeGrid[xAxis][yAxis - 1].visited == false)
  148. array[array.size] = level.mazeGrid[xAxis][yAxis - 1];
  149.  
  150. if(yAxis < level.mazeGrid[0].size - 1 && level.mazeGrid[xAxis][yAxis + 1].visited == false)
  151. array[array.size] = level.mazeGrid[xAxis][yAxis + 1];
  152.  
  153. return array;
  154. }
  155.  
  156. removeWalls(start, end)
  157. {
  158. if(end.xPlace - start.xPlace == 1)
  159. {
  160. level.mazeGrid[end.xPlace][end.yPlace].walls[0] = false;
  161. level.mazeGrid[start.xPlace][start.yPlace].walls[2] = false;
  162. }
  163. else if(end.xPlace - start.xPlace == -1 )
  164. {
  165. level.mazeGrid[end.xPlace][end.yPlace].walls[2] = false;
  166. level.mazeGrid[start.xPlace][start.yPlace].walls[0] = false;
  167. }
  168. else if(end.yPlace - start.yPlace == 1)
  169. {
  170. level.mazeGrid[end.xPlace][end.yPlace].walls[1] = false;
  171. level.mazeGrid[start.xPlace][start.yPlace].walls[3] = false;
  172. }
  173. else
  174. {
  175. level.mazeGrid[end.xPlace][end.yPlace].walls[3] = false;
  176. level.mazeGrid[start.xPlace][start.yPlace].walls[1] = false;
  177. }
  178. }
  179.  
  180. setSpawnAndEnd()
  181. {
  182. randomEnd = randomInt(level.mazeGrid.size - 1);
  183. lastRow = level.mazeGrid[0].size - 1;
  184.  
  185. level.mazeGrid[0][0].walls[1] = false;
  186.  
  187. level.mazeGrid[randomEnd][lastRow].walls[3] = false;
  188.  
  189. iPrintLnBold("Spawn and end made.");
  190. }
  191.  
  192. doubledPlacement()
  193. {
  194. for(i = 0; i < level.mazeGrid.size; i++)
  195. {
  196. for(j = 0; j < level.mazeGrid[0].size; j++)
  197. {
  198. if(j < level.mazeGrid[0].size - 1)
  199. {
  200. if(level.mazeGrid[i][j].walls[3] == true && level.mazeGrid[i][j + 1].walls[1] == true)
  201. {
  202. level.mazeGrid[i][j + 1].walls[1] = false;
  203. }
  204. }
  205.  
  206. if(i < level.mazeGrid.size - 1)
  207. {
  208. if(level.mazeGrid[i][j].walls[2] == true && level.mazeGrid[i + 1][j].walls[0] == true)
  209. {
  210. level.mazeGrid[i + 1][j].walls[0] = false;
  211. }
  212. }
  213. }
  214. }
  215.  
  216. iPrintLnBold("Double walls checked.");
  217. }
  218.  
  219. placeWalls(mazeWalls)
  220. {
  221. mazeOrigin = getEnt("mazeOrigin", "targetname");
  222.  
  223. yAxisOffset = 0;
  224. xAxisOffset = 0;
  225. wallNumber = 0;
  226. moveTime = 0.05;
  227.  
  228. for(i = 0; i < level.mazeGrid.size; i++)
  229. {
  230. xAxisOffset = (i * 200) * -1;
  231.  
  232. for(j = 0; j < level.mazeGrid[0].size; j++)
  233. {
  234. yAxisOffset = j * 200;
  235.  
  236. for(k = 0; k < 4; k++)
  237. {
  238. if(level.mazeGrid[i][j].walls[k])
  239. {
  240. switch(k)
  241. {
  242. case 0:
  243. mazeWalls[wallNumber] moveTo(mazeOrigin.origin + (yAxisOffset + 0, xAxisOffset + 100, 0), moveTime);
  244. mazeWalls[wallNumber] rotateTo((0, 90, 0), moveTime);
  245. mazeWalls[wallNumber] waittill("movedone");
  246. wallNumber++;
  247. break;
  248. case 1:
  249. mazeWalls[wallNumber] moveTo(mazeOrigin.origin + (yAxisOffset - 100, xAxisOffset + 0, 0), moveTime);
  250. mazeWalls[wallNumber] rotateTo((0, 0, 0), moveTime);
  251. mazeWalls[wallNumber] waittill("movedone");
  252. wallNumber++;
  253. break;
  254. case 2:
  255. mazeWalls[wallNumber] moveTo(mazeOrigin.origin + (yAxisOffset + 0, xAxisOffset - 100, 0), moveTime);
  256. mazeWalls[wallNumber] rotateTo((0, 90, 0), moveTime);
  257. mazeWalls[wallNumber] waittill("movedone");
  258. wallNumber++;
  259. break;
  260. case 3:
  261. mazeWalls[wallNumber] moveTo(mazeOrigin.origin + (yAxisOffset + 100, xAxisOffset + 0, 0), moveTime);
  262. mazeWalls[wallNumber] rotateTo((0, 0, 0), moveTime);
  263. mazeWalls[wallNumber] waittill("movedone");
  264. wallNumber++;
  265. break;
  266. }
  267. }
  268. }
  269. }
  270. }
  271.  
  272. iPrintLnBold("MAZE DONE!");
  273. }
  274.  
  275. destroyMaze(mazeWalls)
  276. {
  277. wallSpawn = getEnt("wallSpawns", "targetname");
  278.  
  279. for(i = 0; i < mazeWalls.size; i++)
  280. {
  281. mazeWalls[i] moveTo(wallSpawn.origin + (i * 12, 0, 0), 0.05);
  282. mazeWalls[i] rotateTo((0, 0, 0), 0.05);
  283. mazeWalls[i] waittill("movedone");
  284. }
  285.  
  286. iPrintLnBold("Destroying complete.");
  287. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement