/src/com/robotacid/level/Map.as

http://github.com/st33d/red-rogue · ActionScript · 1531 lines · 1141 code · 209 blank · 181 comment · 770 complexity · 50395cf73eaf47634c7a3667aac502a9 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. package com.robotacid.level {
    2. 

  2. 	import com.robotacid.engine.Altar;
    3. 

  3. 	import com.robotacid.engine.ChaosWall;
    4. 

  4. 	import com.robotacid.engine.Character;
    5. 

  5. 	import com.robotacid.engine.ColliderEntity;
    6. 

  6. 	import com.robotacid.engine.ColliderEntitySensor;
    7. 

  7. 	import com.robotacid.engine.Effect;
    8. 

  8. 	import com.robotacid.engine.FadeLight;
    9. 

  9. 	import com.robotacid.engine.Gate;
    10. 

  10. 	import com.robotacid.engine.Item;
    11. 

  11. 	import com.robotacid.engine.MapTileConverter;
    12. 

  12. 	import com.robotacid.engine.MapTileManager;
    13. 

  13. 	import com.robotacid.engine.Player;
    14. 

  14. 	import com.robotacid.engine.Portal;
    15. 

  15. 	import com.robotacid.engine.Stone;
    16. 

  16. 	import com.robotacid.engine.Torch;
    17. 

  17. 	import com.robotacid.engine.Trap;
    18. 

  18. 	import com.robotacid.engine.Writing;
    19. 

  19. 	import com.robotacid.geom.Pixel;
    20. 

  20. 	import com.robotacid.gfx.BlitRect;
    21. 

  21. 	import com.robotacid.gfx.BlitSprite;
    22. 

  22. 	import com.robotacid.gfx.Renderer;
    23. 

  23. 	import com.robotacid.phys.Collider;
    24. 

  24. 	import com.robotacid.util.array.randomiseArray;
    25. 

  25. 	import com.robotacid.util.Rng;
    26. 

  26. 	import flash.display.Bitmap;
    27. 

  27. 	import flash.display.BitmapData;
    28. 

  28. 	import flash.display.Sprite;
    29. 

  29. 	import flash.geom.Point;
    30. 

  30. 	import flash.geom.Rectangle;
    31. 

  31. 	
    32. 

  32. 	/**
    33. 

  33. 	 * This is the random map generator
    34. 

  34. 	 *
    35. 

  35. 	 * The layout for every level is calculated in here.
    36. 

  36. 	 * 
    37. 

  37. 	 * MapBitmap creates the passage ways and creates a connectivity graph to place ladders and ledges
    38. 

  38. 	 * the convertMapBitmap method converts that data into references to graphics and entities
    39. 

  39. 	 * within that method Content.populateLevel distributes monsters and treasure
    40. 

  40. 	 *
    41. 

  41. 	 * @author Aaron Steed, robotacid.com
    42. 

  42. 	 */
    43. 

  43. 	public class Map {
    44. 

  44. 		
    45. 

  45. 		public static var game:Game;
    46. 

  46. 		public static var renderer:Renderer;
    47. 

  47. 		public static var random:Rng;
    48. 

  48. 		public static var seed:uint = 0;
    49. 

  49. 		
    50. 

  50. 		public var level:int;
    51. 

  51. 		public var type:int;
    52. 

  52. 		public var width:int;
    53. 

  53. 		public var height:int;
    54. 

  54. 		public var start:Pixel;
    55. 

  55. 		public var stairsUp:Pixel;
    56. 

  56. 		public var stairsDown:Pixel;
    57. 

  57. 		public var portals:Vector.<Pixel>;
    58. 

  58. 		public var zone:int;
    59. 

  59. 		public var completionCount:int;
    60. 

  60. 		public var completionTotal:int;
    61. 

  61. 		public var cleared:Boolean;
    62. 

  62. 		
    63. 

  63. 		public var bitmap:MapBitmap;
    64. 

  64. 		
    65. 

  65. 		private var i:int, j:int;
    66. 

  66. 		
    67. 

  67. 		public var layers:Array;
    68. 

  68. 		
    69. 

  69. 		// types
    70. 

  70. 		public static const MAIN_DUNGEON:int = 0;
    71. 

  71. 		public static const ITEM_DUNGEON:int = 1;
    72. 

  72. 		public static const AREA:int = 2;
    73. 

  73. 		
    74. 

  74. 		// zones
    75. 

  75. 		public static const DUNGEONS:int = 0;
    76. 

  76. 		public static const SEWERS:int = 1;
    77. 

  77. 		public static const CAVES:int = 2;
    78. 

  78. 		public static const CHAOS:int = 3;
    79. 

  79. 		
    80. 

  80. 		// layers
    81. 

  81. 		public static const BACKGROUND:int = 0;
    82. 

  82. 		public static const BLOCKS:int = 1;
    83. 

  83. 		public static const ENTITIES:int = 2;
    84. 

  84. 		
    85. 

  85. 		// outside area levels
    86. 

  86. 		public static const OVERWORLD:int = 0;
    87. 

  87. 		public static const UNDERWORLD:int = 1;
    88. 

  88. 		
    89. 

  89. 		public static const LAYER_NUM:int = 3;
    90. 

  90. 		
    91. 

  91. 		public static const BACKGROUND_WIDTH:int = 8;
    92. 

  92. 		public static const BACKGROUND_HEIGHT:int = 8;
    93. 

  93. 		
    94. 

  94. 		public static const UNDERWORLD_BOAT_MIN:int = 8;
    95. 

  95. 		public static const UNDERWORLD_BOAT_MAX:int = 17;
    96. 

  96. 		public static const UNDERWORLD_PORTAL_X:int = 13;
    97. 

  97. 		public static const OVERWORLD_STAIRS_X:int = 12;
    98. 

  98. 		public static const OVERWORLD_PORTAL_X:int = 17;
    99. 

  99. 		
    100. 

  100. 		public static const LEVELS_PER_ZONE:int = 3;
    101. 

  101. 		public static const ZONE_TOTAL:int = 4;
    102. 

  102. 		
    103. 

  103. 		public static const ZONE_NAMES:Vector.<String> = Vector.<String>(["dungeons", "sewers", "caves", "chaos"]);
    104. 

  104. 		
    105. 

  105. 		public function Map(level:int, type:int = MAIN_DUNGEON) {
    106. 

  106. 			this.level = level;
    107. 

  107. 			this.type = type;
    108. 

  108. 			completionCount = completionTotal = 0;
    109. 

  109. 			layers = [];
    110. 

  110. 			portals = new Vector.<Pixel>();
    111. 

  111. 			if(type == MAIN_DUNGEON || type == ITEM_DUNGEON){
    112. 

  112. 				zone = game.content.getLevelZone(level);
    113. 

  113. 			} else {
    114. 

  114. 				zone = 0;
    115. 

  115. 			}
    116. 

  116. 			
    117. 

  117. 			if(type == MAIN_DUNGEON){
    118. 

  118. 				if(level > 0){
    119. 

  119. 					random.r = game.content.getSeed(level, type);
    120. 

  120. 					bitmap = new MapBitmap(level, type, zone);
    121. 

  121. 					width = bitmap.width;
    122. 

  122. 					height = bitmap.height;
    123. 

  123. 					convertMapBitmap(bitmap.bitmapData);
    124. 

  124. 				} else {
    125. 

  125. 					createTestBed();
    126. 

  126. 				}
    127. 

  127. 				
    128. 

  128. 			} else if(type == ITEM_DUNGEON){
    129. 

  129. 				random.r = game.content.getSeed(level, type);
    130. 

  130. 				var sideDungeonSize:int = 1 + (Number(level) / 10);
    131. 

  131. 				bitmap = new MapBitmap(sideDungeonSize, type, zone);
    132. 

  132. 				width = bitmap.width;
    133. 

  133. 				height = bitmap.height;
    134. 

  134. 				convertMapBitmap(bitmap.bitmapData);
    135. 

  135. 				
    136. 

  136. 			} else if(type == AREA){
    137. 

  137. 				if(level == OVERWORLD){
    138. 

  138. 					createOverworld();
    139. 

  139. 				} else if(level == UNDERWORLD){
    140. 

  140. 					createUnderworld();
    141. 

  141. 				}
    142. 

  142. 			}
    143. 

  143. 			createBackground();
    144. 

  144. 			
    145. 

  145. 			// remove gate pixels over exits for ai graph
    146. 

  146. 			if(stairsDown && bitmap.bitmapData.getPixel32(stairsDown.x, stairsDown.y) == MapBitmap.GATE) bitmap.bitmapData.setPixel32(stairsDown.x, stairsDown.y, MapBitmap.EMPTY);
    147. 

  147. 			if(stairsUp && bitmap.bitmapData.getPixel32(stairsUp.x, stairsUp.y) == MapBitmap.GATE) bitmap.bitmapData.setPixel32(stairsUp.x, stairsUp.y, MapBitmap.EMPTY);
    148. 

  148. 			for(i = 0; i < portals.length; i++){
    149. 

  149. 				if(bitmap.bitmapData.getPixel32(portals[i].x, portals[i].y) == MapBitmap.GATE) bitmap.bitmapData.setPixel32(portals[i].x, portals[i].y, MapBitmap.EMPTY);
    150. 

  150. 			}
    151. 

  151. 			
    152. 

  152. 			//bitmap.scaleX = bitmap.scaleY = 2;
    153. 

  153. 			//game.addChild(bitmap);
    154. 

  154. 			
    155. 

  155. 		}
    156. 

  156. 		
    157. 

  157. 		/* Create the test bed
    158. 

  158. 		 *
    159. 

  159. 		 * This is a debugging playground for testing new content and trying to lure consistent
    160. 

  160. 		 * bugs out into the open (which is nigh on fucking impossible in a procedural world)
    161. 

  161. 		 */
    162. 

  162. 		public function createTestBed():void{
    163. 

  163. 			
    164. 

  164. 			bitmap = new MapBitmap(0, AREA);
    165. 

  165. 			
    166. 

  166. 			width = bitmap.width;
    167. 

  167. 			height = bitmap.height;
    168. 

  168. 			// background
    169. 

  169. 			layers.push(createGrid(null, width, height));
    170. 

  170. 			// blocks - start with a full grid
    171. 

  171. 			layers.push(createGrid(MapTileConverter.WALL, width, height));
    172. 

  172. 			// game objects
    173. 

  173. 			layers.push(createGrid(null, width, height));
    174. 

  174. 			
    175. 

  175. 			fill(0, 1, 1, width-2, height-2, layers[BLOCKS]);
    176. 

  176. 			
    177. 

  177. 			// access point
    178. 

  178. 			setPortal((width * 0.5) >> 0, height - 2, <portal type={Portal.PORTAL} targetLevel={-1} targetType={Map.MAIN_DUNGEON} />);
    179. 

  179. 			start = portals[0];
    180. 

  180. 			
    181. 

  181. 			// set zone for background debugging
    182. 

  182. 			zone = (game.gameMenu.editorList.dungeonLevelList.selection) / LEVELS_PER_ZONE;
    183. 

  183. 			if(zone >= 4) zone = CHAOS;
    184. 

  184. 		}
    185. 

  185. 		
    186. 

  186. 		/* This is where we convert our map template into a level proper made of tileIds and other
    187. 

  187. 		 * information
    188. 

  188. 		 */
    189. 

  189. 		public function convertMapBitmap(bitmapData:BitmapData):void{
    190. 

  190. 			width = bitmapData.width;
    191. 

  191. 			height = bitmapData.height;
    192. 

  192. 			// background
    193. 

  193. 			layers.push(createGrid(null, bitmapData.width, bitmapData.height));
    194. 

  194. 			// blocks - start with a full grid
    195. 

  195. 			layers.push(createGrid(MapTileConverter.WALL, bitmapData.width, bitmapData.height));
    196. 

  196. 			// game objects
    197. 

  197. 			layers.push(createGrid(null, bitmapData.width, bitmapData.height));
    198. 

  198. 			
    199. 

  199. 			var pixels:Vector.<uint> = bitmapData.getVector(bitmapData.rect);
    200. 

  200. 			
    201. 

  201. 			// create ladders, ledges and features
    202. 

  202. 			
    203. 

  203. 			// do a first pass to set up pit-traps and secrets and remove them from pixels[]
    204. 

  204. 			// it makes the convoluted ledge/ladder checks simpler
    205. 

  205. 			var r:int, c:int;
    206. 

  206. 			for(i = width; i < pixels.length - width; i++){
    207. 

  207. 				c = i % width;
    208. 

  208. 				r = i / width;
    209. 

  209. 				if(pixels[i] == MapBitmap.PIT){
    210. 

  210. 					createPitTrap(c, r);
    211. 

  211. 					pixels[i] = MapBitmap.WALL;
    212. 

  212. 				} else if(pixels[i] == MapBitmap.SECRET){
    213. 

  213. 					createSecretWall(c, r);
    214. 

  214. 					pixels[i] = MapBitmap.WALL;
    215. 

  215. 				} else if(pixels[i] == MapBitmap.GATE){
    216. 

  216. 					// gates are created later
    217. 

  217. 					pixels[i] = MapBitmap.EMPTY;
    218. 

  218. 				}
    219. 

  219. 			}
    220. 

  220. 			// now for ladders, ledges and empty spaces
    221. 

  221. 			for(i = width; i < pixels.length - width; i++){
    222. 

  222. 				c = i % width;
    223. 

  223. 				r = i / width;
    224. 

  224. 				if(pixels[i] == MapBitmap.EMPTY && pixels[i + width] == MapBitmap.LADDER_LEDGE){
    225. 

  225. 					layers[BLOCKS][r][c] = MapTileConverter.LADDER_TOP;
    226. 

  226. 				} else if(pixels[i] == MapBitmap.LEDGE && pixels[i + width] == MapBitmap.LADDER_LEDGE){
    227. 

  227. 					
    228. 

  228. 					
    229. 

  229. 					if((pixels[i - 1] == MapBitmap.EMPTY || pixels[i - 1] == MapBitmap.LADDER) && (pixels[i + 1] == MapBitmap.EMPTY || pixels[i + 1] == MapBitmap.LADDER)){
    230. 

  230. 						
    231. 

  231. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_TOP_LEDGE;
    232. 

  232. 						
    233. 

  233. 					} else if((pixels[i - 1] == MapBitmap.EMPTY || pixels[i - 1] == MapBitmap.LADDER) && (pixels[i + 1] == MapBitmap.LEDGE || pixels[i + 1] == MapBitmap.LADDER_LEDGE)){
    234. 

  234. 						
    235. 

  235. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_TOP_LEDGE_END_LEFT;
    236. 

  236. 						
    237. 

  237. 					} else if((pixels[i - 1] == MapBitmap.EMPTY || pixels[i - 1] == MapBitmap.LADDER) && pixels[i + 1] == MapBitmap.WALL){
    238. 

  238. 						
    239. 

  239. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_TOP_LEDGE_START_RIGHT_END;
    240. 

  240. 						
    241. 

  241. 					} else if(pixels[i - 1] == MapBitmap.WALL && (pixels[i + 1] == MapBitmap.LEDGE || pixels[i + 1] == MapBitmap.LADDER_LEDGE)){
    242. 

  242. 						
    243. 

  243. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_TOP_LEDGE_START_LEFT;
    244. 

  244. 						
    245. 

  245. 					} else if(pixels[i - 1] == MapBitmap.WALL && pixels[i + 1] == MapBitmap.WALL){
    246. 

  246. 						
    247. 

  247. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_TOP_LEDGE_SINGLE;
    248. 

  248. 						
    249. 

  249. 					} else if((pixels[i - 1] == MapBitmap.LEDGE || pixels[i - 1] == MapBitmap.LADDER_LEDGE) && pixels[i + 1] == MapBitmap.WALL){
    250. 

  250. 						
    251. 

  251. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_TOP_LEDGE_START_RIGHT;
    252. 

  252. 						
    253. 

  253. 					} else if((pixels[i - 1] == MapBitmap.LEDGE || pixels[i - 1] == MapBitmap.LADDER_LEDGE) && (pixels[i + 1] == MapBitmap.EMPTY || pixels[i + 1] == MapBitmap.LADDER)){
    254. 

  254. 						
    255. 

  255. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_TOP_LEDGE_END_RIGHT;
    256. 

  256. 						
    257. 

  257. 					} else if(pixels[i - 1] == MapBitmap.WALL && (pixels[i + 1] == MapBitmap.EMPTY || pixels[i + 1] == MapBitmap.LADDER)){
    258. 

  258. 						
    259. 

  259. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_TOP_LEDGE_START_LEFT_END;
    260. 

  260. 						
    261. 

  261. 					} else if((pixels[i - 1] == MapBitmap.LEDGE || pixels[i - 1] == MapBitmap.LADDER_LEDGE) && (pixels[i + 1] == MapBitmap.LEDGE || pixels[i + 1] == MapBitmap.LADDER_LEDGE)){
    262. 

  262. 						
    263. 

  263. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_TOP_LEDGE_MIDDLE;
    264. 

  264. 					}
    265. 

  265. 					
    266. 

  266. 					
    267. 

  267. 					
    268. 

  268. 				} else if(pixels[i] == MapBitmap.LADDER_LEDGE){
    269. 

  269. 					
    270. 

  270. 					if((pixels[i - 1] == MapBitmap.EMPTY || pixels[i - 1] == MapBitmap.LADDER) && (pixels[i + 1] == MapBitmap.EMPTY || pixels[i + 1] == MapBitmap.LADDER)){
    271. 

  271. 						
    272. 

  272. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_LEDGE;
    273. 

  273. 						
    274. 

  274. 					} else if((pixels[i - 1] == MapBitmap.EMPTY || pixels[i - 1] == MapBitmap.LADDER) && (pixels[i + 1] == MapBitmap.LEDGE || pixels[i + 1] == MapBitmap.LADDER_LEDGE)){
    275. 

  275. 						
    276. 

  276. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_LEDGE_END_LEFT;
    277. 

  277. 						
    278. 

  278. 					} else if((pixels[i - 1] == MapBitmap.EMPTY || pixels[i - 1] == MapBitmap.LADDER) && pixels[i + 1] == MapBitmap.WALL){
    279. 

  279. 						
    280. 

  280. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_LEDGE_START_RIGHT_END;
    281. 

  281. 						
    282. 

  282. 					} else if(pixels[i - 1] == MapBitmap.WALL && (pixels[i + 1] == MapBitmap.LEDGE || pixels[i + 1] == MapBitmap.LADDER_LEDGE)){
    283. 

  283. 						
    284. 

  284. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_LEDGE_START_LEFT;
    285. 

  285. 						
    286. 

  286. 					} else if(pixels[i - 1] == MapBitmap.WALL && pixels[i + 1] == MapBitmap.WALL){
    287. 

  287. 						
    288. 

  288. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_LEDGE_SINGLE;
    289. 

  289. 						
    290. 

  290. 					} else if((pixels[i - 1] == MapBitmap.LEDGE || pixels[i - 1] == MapBitmap.LADDER_LEDGE) && pixels[i + 1] == MapBitmap.WALL){
    291. 

  291. 						
    292. 

  292. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_LEDGE_START_RIGHT;
    293. 

  293. 						
    294. 

  294. 					} else if((pixels[i - 1] == MapBitmap.LEDGE || pixels[i - 1] == MapBitmap.LADDER_LEDGE) && (pixels[i + 1] == MapBitmap.EMPTY || pixels[i + 1] == MapBitmap.LADDER)){
    295. 

  295. 						
    296. 

  296. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_LEDGE_END_RIGHT;
    297. 

  297. 						
    298. 

  298. 					} else if(pixels[i - 1] == MapBitmap.WALL && (pixels[i + 1] == MapBitmap.EMPTY || pixels[i + 1] == MapBitmap.LADDER)){
    299. 

  299. 						
    300. 

  300. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_LEDGE_START_LEFT_END;
    301. 

  301. 						
    302. 

  302. 					} else if((pixels[i - 1] == MapBitmap.LEDGE || pixels[i - 1] == MapBitmap.LADDER_LEDGE) && (pixels[i + 1] == MapBitmap.LEDGE || pixels[i + 1] == MapBitmap.LADDER_LEDGE)){
    303. 

  303. 						
    304. 

  304. 						layers[BLOCKS][r][c] = MapTileConverter.LADDER_LEDGE_MIDDLE;
    305. 

  305. 					}
    306. 

  306. 					
    307. 

  307. 				} else if(pixels[i] == MapBitmap.LADDER){
    308. 

  308. 					layers[BLOCKS][r][c] = MapTileConverter.LADDER;
    309. 

  309. 				} else if(pixels[i] == MapBitmap.LEDGE){
    310. 

  310. 					
    311. 

  311. 					if((pixels[i - 1] == MapBitmap.EMPTY || pixels[i - 1] == MapBitmap.LADDER) && (pixels[i + 1] == MapBitmap.EMPTY || pixels[i + 1] == MapBitmap.LADDER)){
    312. 

  312. 						
    313. 

  313. 						layers[BLOCKS][r][c] = MapTileConverter.LEDGE;
    314. 

  314. 						
    315. 

  315. 					} else if((pixels[i - 1] == MapBitmap.EMPTY || pixels[i - 1] == MapBitmap.LADDER) && (pixels[i + 1] == MapBitmap.LEDGE || pixels[i + 1] == MapBitmap.LADDER_LEDGE)){
    316. 

  316. 						
    317. 

  317. 						layers[BLOCKS][r][c] = MapTileConverter.LEDGE_END_LEFT;
    318. 

  318. 						
    319. 

  319. 					} else if((pixels[i - 1] == MapBitmap.EMPTY || pixels[i - 1] == MapBitmap.LADDER) && pixels[i + 1] == MapBitmap.WALL){
    320. 

  320. 						
    321. 

  321. 						layers[BLOCKS][r][c] = MapTileConverter.LEDGE_START_RIGHT_END;
    322. 

  322. 						
    323. 

  323. 					} else if(pixels[i - 1] == MapBitmap.WALL && (pixels[i + 1] == MapBitmap.LEDGE || pixels[i + 1] == MapBitmap.LADDER_LEDGE)){
    324. 

  324. 						
    325. 

  325. 						layers[BLOCKS][r][c] = MapTileConverter.LEDGE_START_LEFT;
    326. 

  326. 						
    327. 

  327. 					} else if(pixels[i - 1] == MapBitmap.WALL && pixels[i + 1] == MapBitmap.WALL){
    328. 

  328. 						
    329. 

  329. 						layers[BLOCKS][r][c] = MapTileConverter.LEDGE_SINGLE;
    330. 

  330. 						
    331. 

  331. 					} else if((pixels[i - 1] == MapBitmap.LEDGE || pixels[i - 1] == MapBitmap.LADDER_LEDGE) && pixels[i + 1] == MapBitmap.WALL){
    332. 

  332. 						
    333. 

  333. 						layers[BLOCKS][r][c] = MapTileConverter.LEDGE_START_RIGHT;
    334. 

  334. 						
    335. 

  335. 					} else if((pixels[i - 1] == MapBitmap.LEDGE || pixels[i - 1] == MapBitmap.LADDER_LEDGE) && (pixels[i + 1] == MapBitmap.EMPTY || pixels[i + 1] == MapBitmap.LADDER)){
    336. 

  336. 						
    337. 

  337. 						layers[BLOCKS][r][c] = MapTileConverter.LEDGE_END_RIGHT;
    338. 

  338. 						
    339. 

  339. 					} else if(pixels[i - 1] == MapBitmap.WALL && (pixels[i + 1] == MapBitmap.EMPTY || pixels[i + 1] == MapBitmap.LADDER)){
    340. 

  340. 						
    341. 

  341. 						layers[BLOCKS][r][c] = MapTileConverter.LEDGE_START_LEFT_END;
    342. 

  342. 						
    343. 

  343. 					} else if((pixels[i - 1] == MapBitmap.LEDGE || pixels[i - 1] == MapBitmap.LADDER_LEDGE) && (pixels[i + 1] == MapBitmap.LEDGE || pixels[i + 1] == MapBitmap.LADDER_LEDGE)){
    344. 

  344. 						
    345. 

  345. 						layers[BLOCKS][r][c] = MapTileConverter.LEDGE_MIDDLE;
    346. 

  346. 					}
    347. 

  347. 					
    348. 

  348. 				} else if(pixels[i] == MapBitmap.EMPTY){
    349. 

  349. 					layers[BLOCKS][r][c] = 0;
    350. 

  350. 				}
    351. 

  351. 			}
    352. 

  352. 			
    353. 

  353. 			// create access points
    354. 

  354. 			var portalXMLs:Array = game.content.getPortals(level, type);
    355. 

  355. 			var portalType:int;
    356. 

  356. 			if(type == MAIN_DUNGEON){
    357. 

  357. 				
    358. 

  358. 				createAccessPoint(Portal.STAIRS, sortRoomsTopWards);
    359. 

  359. 				for(i = 0; i < portalXMLs.length; i++){
    360. 

  360. 					portalType = portalXMLs[i].@type;
    361. 

  361. 					createAccessPoint(portalType, null, portalXMLs[i]);
    362. 

  362. 				}
    363. 

  363. 				createAccessPoint(Portal.STAIRS, sortRoomsBottomWards);
    364. 

  364. 			
    365. 

  365. 				
    366. 

  366. 			} else if(type == ITEM_DUNGEON){
    367. 

  367. 				for(i = 0; i < portalXMLs.length; i++){
    368. 

  368. 					portalType = portalXMLs[i].@type;
    369. 

  369. 					createAccessPoint(portalType, i == 0 ? sortRoomsTopWards : null, portalXMLs[i]);
    370. 

  370. 				}
    371. 

  371. 			}
    372. 

  372. 			
    373. 

  373. 			// reload pixels - access point creation altered the bitmap
    374. 

  374. 			pixels = bitmapData.getVector(bitmapData.rect);
    375. 

  375. 			
    376. 

  376. 			// gates may fragment the level, so we need as many options for placing a key as possible
    377. 

  377. 			if(bitmap.gates.length) createGates();
    378. 

  378. 			
    379. 

  379. 			// a good dungeon needs to be full of loot and monsters
    380. 

  380. 			// in comes the content manager to mete out a decent amount of action and reward per level
    381. 

  381. 			// content manager stocks are limited to avoid scumming
    382. 

  382. 			completionCount += game.content.populateLevel(type, level, bitmap, layers, random);
    383. 

  383. 			
    384. 

  384. 			// now add some extra flavour
    385. 

  385. 			createOtherTraps(pixels);
    386. 

  386. 			// beyond the starting position of the underworld portal, the minion cannot have written anything
    387. 

  387. 			if(level <= Writing.story.length && type == MAIN_DUNGEON) createWritings(pixels);
    388. 

  388. 			createAltars(pixels);
    389. 

  389. 			if(zone == DUNGEONS) createTorches(pixels);
    390. 

  390. 			createDecor(pixels);
    391. 

  391. 			createChaosWalls(pixels);
    392. 

  392. 			createCritters();
    393. 

  393. 			
    394. 

  394. 			completionTotal = completionCount;
    395. 

  395. 			cleared = game.content.getCleared(level, type);
    396. 

  396. 			if(cleared) completionTotal = completionCount = 0;
    397. 

  397. 		}
    398. 

  398. 		
    399. 

  399. 		/* Create the overworld
    400. 

  400. 		 *
    401. 

  401. 		 * The overworld is present to create a contrast with the dungeon. It is in colour and so
    402. 

  402. 		 * are you. There is a health stone for restoring health and a grindstone -
    403. 

  403. 		 * an allegory of improving yourself in the real world as opposed to a fantasy where
    404. 

  404. 		 * you kill people to better yourself
    405. 

  405. 		 */
    406. 

  406. 		public function createOverworld():void{
    407. 

  407. 			
    408. 

  408. 			bitmap = new MapBitmap(OVERWORLD, AREA);
    409. 

  409. 			
    410. 

  410. 			width = bitmap.width;
    411. 

  411. 			height = bitmap.height;
    412. 

  412. 			layers.push(createGrid(null, width, height));
    413. 

  413. 			// blocks - start with a full grid
    414. 

  414. 			layers.push(createGrid(1, width, height));
    415. 

  415. 			// game objects
    416. 

  416. 			layers.push(createGrid(null, width, height));
    417. 

  417. 			
    418. 

  418. 			fill(0, 1, 0, width-2, height-1, layers[BLOCKS]);
    419. 

  419. 			
    420. 

  420. 			// create the grindstone and healstone
    421. 

  421. 			layers[BLOCKS][height - 2][1] = MapTileConverter.WALL;
    422. 

  422. 			layers[ENTITIES][height - 2][1] = MapTileConverter.HEAL_STONE;
    423. 

  423. 			layers[BLOCKS][height - 2][width - 2] = MapTileConverter.WALL;
    424. 

  424. 			layers[ENTITIES][height - 2][width - 2] = MapTileConverter.GRIND_STONE;
    425. 

  425. 			
    426. 

  426. 			var portalXMLs:Array = game.content.getPortals(level, type);
    427. 

  427. 			if(portalXMLs.length){
    428. 

  428. 				// given that there can only be one type of portal on the overworld - the rogue's portal
    429. 

  429. 				// we create the rogue's portal here
    430. 

  430. 				setPortal(OVERWORLD_PORTAL_X, height - 2, portalXMLs[0]);
    431. 

  431. 			}
    432. 

  432. 			
    433. 

  433. 			setStairsDown(OVERWORLD_STAIRS_X, height - 2);
    434. 

  434. 			
    435. 

  435. 			// the player may have left content on the overworld as a sort of bank
    436. 

  436. 			game.content.populateLevel(type, OVERWORLD, bitmap, layers, random);
    437. 

  437. 		}
    438. 

  438. 		
    439. 

  439. 		/* Create the underworld
    440. 

  440. 		 *
    441. 

  441. 		 * The underworld is where the minion came from. It consists of a boat on the river Styx under a black
    442. 

  442. 		 * sky where stars are exploding. Death (an NPC) is there.
    443. 

  443. 		 */
    444. 

  444. 		public function createUnderworld():void{
    445. 

  445. 			
    446. 

  446. 			bitmap = new MapBitmap(UNDERWORLD, AREA);
    447. 

  447. 			
    448. 

  448. 			width = bitmap.width;
    449. 

  449. 			height = bitmap.height;
    450. 

  450. 			layers.push(createGrid(null, width, height));
    451. 

  451. 			// blocks - start with a full grid
    452. 

  452. 			layers.push(createGrid(1, width, height));
    453. 

  453. 			// game objects
    454. 

  454. 			layers.push(createGrid(null, width, height));
    455. 

  455. 			
    456. 

  456. 			fill(0, 1, 0, width-2, height-1, layers[BLOCKS]);
    457. 

  457. 			
    458. 

  458. 			// create the boat
    459. 

  459. 			fill(MapTileConverter.WALL, UNDERWORLD_BOAT_MIN, height - 2, UNDERWORLD_BOAT_MAX - UNDERWORLD_BOAT_MIN, 1, layers[BLOCKS]);
    460. 

  460. 			setValue(UNDERWORLD_BOAT_MIN, height - 3, BLOCKS, MapTileConverter.WALL);
    461. 

  461. 			setValue(UNDERWORLD_BOAT_MAX - 1, height - 3, BLOCKS, MapTileConverter.WALL);
    462. 

  462. 			
    463. 

  463. 			var portalXMLs:Array = game.content.getPortals(level, type);
    464. 

  464. 			if(portalXMLs.length){
    465. 

  465. 				setPortal(UNDERWORLD_PORTAL_X, height - 3, portalXMLs[0]);
    466. 

  466. 			}
    467. 

  467. 			
    468. 

  468. 			// the player may have left content on the underworld as a sort of bank
    469. 

  469. 			game.content.populateLevel(type, UNDERWORLD, bitmap, layers, random);
    470. 

  470. 			
    471. 

  471. 			// create sensors to resolve any contact with the waters
    472. 

  472. 			var waterSensor:ColliderEntitySensor = new ColliderEntitySensor(
    473. 

  473. 				new Rectangle(Game.SCALE, -3 + (height - 1) * Game.SCALE, (width - 2) * Game.SCALE, 3),
    474. 

  474. 				underworldWaterCallback
    475. 

  475. 			)
    476. 

  476. 			
    477. 

  477. 			// create death
    478. 

  478. 			var deathCharacter:Stone = new Stone((UNDERWORLD_PORTAL_X - 3) * Game.SCALE, (height - 2) * Game.SCALE, Stone.DEATH);
    479. 

  479. 			layers[ENTITIES][height - 2][UNDERWORLD_PORTAL_X - 3] = deathCharacter;
    480. 

  480. 		}
    481. 

  481. 		
    482. 

  482. 		/* Resolves what happens to entities that fall in the water in the Underworld */
    483. 

  483. 		public static function underworldWaterCallback(colliderEntity:ColliderEntity):void{
    484. 

  484. 			if(colliderEntity is Item){
    485. 

  485. 				renderer.createSparkRect(colliderEntity.collider, 20, 0, -1);
    486. 

  486. 				colliderEntity.active = false;
    487. 

  487. 			} else if(colliderEntity is Character){
    488. 

  488. 				Effect.teleportCharacter(colliderEntity as Character, new Pixel(UNDERWORLD_PORTAL_X + 1, MapBitmap.UNDERWORLD_HEIGHT - 3));
    489. 

  489. 			}
    490. 

  490. 		}
    491. 

  491. 		
    492. 

  492. 		/* Creates an entry/exit point for the level - used to set stairs and portals generated by the portal rune */
    493. 

  493. 		public function createAccessPoint(type:int, sort:Function = null, xml:XML = null):void{
    494. 

  494. 			var index:int = 0;
    495. 

  495. 			var rooms:Vector.<Room> = bitmap.rooms;
    496. 

  496. 			if(Boolean(sort)) rooms.sort(sort);
    497. 

  497. 			var portalRoom:Room = rooms[index];
    498. 

  498. 			
    499. 

  499. 			var r:int, c:int, pos:uint;
    500. 

  500. 			var candidates:Vector.<Surface> = new Vector.<Surface>();
    501. 

  501. 			var choice:Surface;
    502. 

  502. 			var surface:Surface;
    503. 

  503. 			var i:int;
    504. 

  504. 			
    505. 

  505. 			do{
    506. 

  506. 				candidates.length = 0;
    507. 

  507. 				for(i = 0; i < portalRoom.surfaces.length; i++){
    508. 

  508. 					surface = portalRoom.surfaces[i];
    509. 

  509. 					if(goodPortalPosition(surface.x, surface.y, random.value() < 0.2)){
    510. 

  510. 						candidates.push(surface);
    511. 

  511. 					}
    512. 

  512. 				}
    513. 

  513. 				if(candidates.length){
    514. 

  514. 					choice = candidates[random.rangeInt(candidates.length)];
    515. 

  515. 				} else {
    516. 

  516. 					if(index == rooms.length - 1) throw new Error("failed to create portal");
    517. 

  517. 					else {
    518. 

  518. 						index++;
    519. 

  519. 						portalRoom = rooms[index];
    520. 

  520. 					}
    521. 

  521. 				}
    522. 

  522. 				
    523. 

  523. 			} while(candidates.length == 0);
    524. 

  524. 			
    525. 

  525. 			if(type == Portal.STAIRS){
    526. 

  526. 				if(sort == sortRoomsTopWards) setStairsUp(choice.x, choice.y);
    527. 

  527. 				else if(sort == sortRoomsBottomWards) setStairsDown(choice.x, choice.y);
    528. 

  528. 			} else {
    529. 

  529. 				setPortal(choice.x, choice.y, xml);
    530. 

  530. 			}
    531. 

  531. 			
    532. 

  532. 			Surface.removeSurface(choice.x, choice.y);
    533. 

  533. 			
    534. 

  534. 		}
    535. 

  535. 		
    536. 

  536. 		// room sorting callbacks
    537. 

  537. 		public static function sortRoomsTopWards(a:Room, b:Room):Number{
    538. 

  538. 			if(a.y < b.y) return -1;
    539. 

  539. 			else if(a.y > b.y) return 1;
    540. 

  540. 			return 0;
    541. 

  541. 		}
    542. 

  542. 		public static function sortRoomsBottomWards(a:Room, b:Room):Number{
    543. 

  543. 			if(a.y > b.y) return -1;
    544. 

  544. 			else if(a.y < b.y) return 1;
    545. 

  545. 			return 0;
    546. 

  546. 		}
    547. 

  547. 		
    548. 

  548. 		/* Creates a stairway up */
    549. 

  549. 		public function setStairsUp(x:int, y:int):void{
    550. 

  550. 			layers[ENTITIES][y][x] = MapTileConverter.STAIRS_UP;
    551. 

  551. 			// prevent background decorator from creating graphics covering portals
    552. 

  552. 			if(bitmap.bitmapData.getPixel32(x, y) == MapBitmap.EMPTY) bitmap.bitmapData.setPixel32(x, y, MapBitmap.GATE);
    553. 

  553. 			stairsUp = new Pixel(x, y);
    554. 

  554. 			if(isPortalToPreviousLevel(x, y, Portal.STAIRS, level - 1, level > 1 ? MAIN_DUNGEON : AREA)){
    555. 

  555. 				start = stairsUp;
    556. 

  556. 				if(Surface.map[y][x] && Surface.map[y][x].room) Surface.map[y][x].room.start = true;
    557. 

  557. 			}
    558. 

  558. 		}
    559. 

  559. 		
    560. 

  560. 		/* Creates a stairway down */
    561. 

  561. 		public function setStairsDown(x:int, y:int):void{
    562. 

  562. 			layers[ENTITIES][y][x] = MapTileConverter.STAIRS_DOWN;
    563. 

  563. 			// prevent background decorator from creating graphics covering portals
    564. 

  564. 			if(bitmap.bitmapData.getPixel32(x, y) == MapBitmap.EMPTY) bitmap.bitmapData.setPixel32(x, y, MapBitmap.GATE);
    565. 

  565. 			stairsDown = new Pixel(x, y);
    566. 

  566. 			if(isPortalToPreviousLevel(x, y, Portal.STAIRS, level + 1, MAIN_DUNGEON)){
    567. 

  567. 				start = stairsDown;
    568. 

  568. 				if(Surface.map[y][x] && Surface.map[y][x].room) Surface.map[y][x].room.start = true;
    569. 

  569. 			}
    570. 

  570. 		}
    571. 

  571. 		
    572. 

  572. 		/* Creates a portal */
    573. 

  573. 		public function setPortal(x:int, y:int, xml:XML):void{
    574. 

  574. 			var p:Pixel = new Pixel(x, y);
    575. 

  575. 			var portal:Portal = Content.XMLToEntity(x, y, xml, level, type);
    576. 

  576. 			game.portalHash[portal.hashKey] = portal;
    577. 

  577. 			if(type == AREA){
    578. 

  578. 				portal.maskPortalBase(level);
    579. 

  579. 			}
    580. 

  580. 			layers[ENTITIES][y][x] = portal;
    581. 

  581. 			// prevent background decorator from creating graphics covering portals
    582. 

  582. 			if(bitmap.bitmapData.getPixel32(x, y) == MapBitmap.EMPTY) bitmap.bitmapData.setPixel32(x, y, MapBitmap.GATE);
    583. 

  583. 			if(isPortalToPreviousLevel(x, y, int(xml.@type), int(xml.@targetLevel), int(xml.@targetType))){
    584. 

  584. 				start = p;
    585. 

  585. 				if(Surface.map[y][x] && Surface.map[y][x].room) Surface.map[y][x].room.start = true;
    586. 

  586. 			}
    587. 

  587. 			portals.push(p);
    588. 

  588. 		}
    589. 

  589. 		
    590. 

  590. 		/* Is this portal going to be the entry point for the level?
    591. 

  591. 		 * 
    592. 

  592. 		 * Map.start and Game.entrance are used by the game engine to set the camera and entry point for the level
    593. 

  593. 		 * which is why this query belongs in a function to be called by various elements
    594. 

  594. 		 * 
    595. 

  595. 		 * The logic follows: does this portal lead to the last level you were on
    596. 

  596. 		 * 
    597. 

  597. 		 * This used to be a lot more complicated till I refactored portals */
    598. 

  598. 		public static function isPortalToPreviousLevel(x:int, y:int, type:int, targetLevel:int, targetType:int):Boolean{
    599. 

  599. 			return Player.previousPortalType == type && Player.previousLevel == targetLevel && Player.previousMapType == targetType;
    600. 

  600. 		}
    601. 

  601. 		
    602. 

  602. 		/* Getting a good position for the portals is complex.
    603. 

  603. 		 * We want clear spaces to each side and solid floor below - preferably walls below on stairs down
    604. 

  604. 		 * we also don't want to appear next to another portal - portals have frilly edges
    605. 

  605. 		 * - hence the mess in this method */
    606. 

  606. 		public function goodPortalPosition(x:int, y:int, ledgeAllowed:Boolean = true):Boolean{
    607. 

  607. 			var p:Pixel;
    608. 

  608. 			for(var i:int = 0; i < portals.length; i++){
    609. 

  609. 				p = portals[i];
    610. 

  610. 				if(
    611. 

  611. 					(p.x == x && (p.y == y || p.y == y - 1 || p.y == y + 1)) ||
    612. 

  612. 					(p.y == y && (p.x == x || p.x == x - 1 || p.x == x + 1))
    613. 

  613. 				){
    614. 

  614. 					return false;
    615. 

  615. 				}
    616. 

  616. 			}
    617. 

  617. 			if(stairsUp){
    618. 

  618. 				p = stairsUp;
    619. 

  619. 				if(
    620. 

  620. 					(p.x == x && (p.y == y || p.y == y - 1 || p.y == y + 1)) ||
    621. 

  621. 					(p.y == y && (p.x == x || p.x == x - 1 || p.x == x + 1))
    622. 

  622. 				){
    623. 

  623. 					return false;
    624. 

  624. 				}
    625. 

  625. 			}
    626. 

  626. 			if(stairsDown){
    627. 

  627. 				p = stairsDown;
    628. 

  628. 				if(
    629. 

  629. 					(p.x == x && (p.y == y || p.y == y - 1 || p.y == y + 1)) ||
    630. 

  630. 					(p.y == y && (p.x == x || p.x == x - 1 || p.x == x + 1))
    631. 

  631. 				){
    632. 

  632. 					return false;
    633. 

  633. 				}
    634. 

  634. 			}
    635. 

  635. 			var pos:uint = bitmap.bitmapData.getPixel32(x, y);
    636. 

  636. 			var posAbove:uint = bitmap.bitmapData.getPixel32(x, y - 1);
    637. 

  637. 			var posBelow:uint = bitmap.bitmapData.getPixel32(x, y + 1);
    638. 

  638. 			var posLeft:uint =  bitmap.bitmapData.getPixel32(x - 1, y);
    639. 

  639. 			var posRight:uint =  bitmap.bitmapData.getPixel32(x + 1, y);
    640. 

  640. 			if(bitmap.leftSecretRoom && bitmap.leftSecretRoom.contains(x, y)) return false;
    641. 

  641. 			if(bitmap.rightSecretRoom && bitmap.rightSecretRoom.contains(x, y)) return false;
    642. 

  642. 			return (
    643. 

  643. 				(posAbove != MapBitmap.WALL && posAbove != MapBitmap.GATE) &&
    644. 

  644. 				(posLeft != MapBitmap.WALL && posRight != MapBitmap.WALL) &&
    645. 

  645. 				(posLeft != MapBitmap.GATE && posRight != MapBitmap.GATE) &&
    646. 

  646. 				(posLeft != MapBitmap.SECRET && posRight != MapBitmap.SECRET) &&
    647. 

  647. 				(posBelow == MapBitmap.WALL || (posBelow == MapBitmap.LEDGE && ledgeAllowed)) &&
    648. 

  648. 				(pos == MapBitmap.EMPTY || pos == MapBitmap.LEDGE)
    649. 

  649. 			);
    650. 

  650. 		}
    651. 

  651. 		
    652. 

  652. 		/* Adds critters to the level - decorative entites that squish on contact */
    653. 

  653. 		public function createCritters():void{
    654. 

  654. 			
    655. 

  655. 			// the compiler won't let me create this as a constant so I have to drop it in here
    656. 

  656. 			// better than resorting to magic numbers I suppose
    657. 

  657. 			var ZONE_CRITTERS:Array = [
    658. 

  658. 				[MapTileConverter.SPIDER, MapTileConverter.SPIDER, MapTileConverter.BAT, MapTileConverter.RAT],
    659. 

  659. 				[MapTileConverter.RAT, MapTileConverter.RAT, MapTileConverter.RAT, MapTileConverter.RAT, MapTileConverter.SPIDER],
    660. 

  660. 				[MapTileConverter.BAT, MapTileConverter.BAT, MapTileConverter.BAT, MapTileConverter.BAT, MapTileConverter.RAT, MapTileConverter.SPIDER],
    661. 

  661. 				[MapTileConverter.COG, MapTileConverter.COG_RAT, MapTileConverter.COG_SPIDER, MapTileConverter.COG_BAT]
    662. 

  662. 			];
    663. 

  663. 			
    664. 

  664. 			var critterPalette:Array = ZONE_CRITTERS[zone];
    665. 

  665. 			var r:int, c:int, critterId:int;
    666. 

  666. 			var critterNum:int = Math.sqrt(width * height) * 1.25;
    667. 

  667. 			var breaker:int = 0;
    668. 

  668. 			
    669. 

  669. 			while(critterNum){
    670. 

  670. 				
    671. 

  671. 				r = 1 + random.range(bitmap.height - 1);
    672. 

  672. 				c = 1 + random.range(bitmap.width - 1);
    673. 

  673. 				critterId = critterPalette[random.rangeInt(critterPalette.length)];
    674. 

  674. 				
    675. 

  675. 				// may god forgive me for this if statement:
    676. 

  676. 				if(
    677. 

  677. 					!layers[ENTITIES][r][c] &&
    678. 

  678. 					layers[BLOCKS][r][c] != 1 &&
    679. 

  679. 					(
    680. 

  680. 						(
    681. 

  681. 							(
    682. 

  682. 								critterId == MapTileConverter.RAT ||
    683. 

  683. 								critterId == MapTileConverter.COG_RAT
    684. 

  684. 							)&&
    685. 

  685. 							(
    686. 

  686. 								bitmap.bitmapData.getPixel32(c, r + 1) == MapBitmap.LEDGE ||
    687. 

  687. 								bitmap.bitmapData.getPixel32(c, r + 1) == MapBitmap.LADDER_LEDGE ||
    688. 

  688. 								layers[BLOCKS][r + 1][c] == MapTileConverter.WALL
    689. 

  689. 							)
    690. 

  690. 						) ||
    691. 

  691. 						(
    692. 

  692. 							(
    693. 

  693. 								critterId == MapTileConverter.SPIDER ||
    694. 

  694. 								critterId == MapTileConverter.BAT ||
    695. 

  695. 								critterId == MapTileConverter.COG_SPIDER ||
    696. 

  696. 								critterId == MapTileConverter.COG_BAT
    697. 

  697. 							) &&
    698. 

  698. 							(
    699. 

  699. 								layers[BLOCKS][r - 1][c] == MapTileConverter.WALL &&
    700. 

  700. 								bitmap.bitmapData.getPixel32(c, r - 1) != MapBitmap.PIT
    701. 

  701. 							)
    702. 

  702. 						) ||
    703. 

  703. 						(
    704. 

  704. 							critterId == MapTileConverter.COG &&
    705. 

  705. 							(
    706. 

  706. 								(
    707. 

  707. 									layers[BLOCKS][r - 1][c] == MapTileConverter.WALL &&
    708. 

  708. 									bitmap.bitmapData.getPixel32(c, r - 1) != MapBitmap.PIT
    709. 

  709. 								) ||
    710. 

  710. 								layers[BLOCKS][r + 1][c] == MapTileConverter.WALL ||
    711. 

  711. 								layers[BLOCKS][r][c - 1] == MapTileConverter.WALL ||
    712. 

  712. 								layers[BLOCKS][r][c + 1] == MapTileConverter.WALL
    713. 

  713. 							)
    714. 

  714. 						)
    715. 

  715. 					)
    716. 

  716. 				){
    717. 

  717. 					layers[ENTITIES][r][c] = critterId;
    718. 

  718. 					critterNum--;
    719. 

  719. 				}
    720. 

  720. 				if((breaker++) > 1000) break;
    721. 

  721. 			}
    722. 

  722. 		}
    723. 

  723. 		
    724. 

  724. 		/* Create barriers in the dungeon */
    725. 

  725. 		public function createGates():void{
    726. 

  726. 			
    727. 

  727. 			// debug for repeating levels
    728. 

  728. 			//trace(random.seed);
    729. 

  729. 			
    730. 

  730. 			var i:int, j:int, site:Pixel, n:int, entranceCol:uint, surface:Surface, gate:Gate, item:Item;
    731. 

  731. 			var connections:BitmapData = bitmap.bitmapData.clone();
    732. 

  732. 			connections.threshold(connections, connections.rect, new Point(), "!=", MapBitmap.WALL, 0xFF000000);
    733. 

  733. 			var connectionsBuffer:BitmapData = connections.clone();
    734. 

  734. 			var fragmented:Boolean = false;
    735. 

  735. 			var connectionPixels:Vector.<uint>;
    736. 

  736. 			var gateType:int;
    737. 

  737. 			var checkCol:uint;
    738. 

  738. 			var fragmentationSites:Vector.<Pixel> = new Vector.<Pixel>();
    739. 

  739. 			
    740. 

  740. 			// scrape for fragmentation sites
    741. 

  741. 			for(i = bitmap.gates.length - 1; i > -1; i--){
    742. 

  742. 				site = bitmap.gates[i];
    743. 

  743. 				
    744. 

  744. 				// nanny-condition, in a perfect world I won't have put an entity here
    745. 

  745. 				if(!layers[ENTITIES][site.y][site.x]){
    746. 

  746. 					
    747. 

  747. 					// do a connectivity test
    748. 

  748. 					connections.setPixel32(site.x, site.y, 0xFFFFFFFF);
    749. 

  749. 					connections.floodFill(site.x + 1, site.y, 0xFF0000FF);
    750. 

  750. 					connections.floodFill(site.x - 1, site.y, 0xFF00FF00);
    751. 

  751. 					
    752. 

  752. 					// fragmentation means a section of the dungeon will be hermetically
    753. 

  753. 					// sealed from all manner of access (no dropping in, no teleport)
    754. 

  754. 					if(connections.getColorBoundsRect(0xFFFFFFFF, 0xFF0000FF).width){
    755. 

  755. 						fragmentationSites.push(site);
    756. 

  756. 						bitmap.gates.splice(i, 1);
    757. 

  757. 						
    758. 

  758. 						//trace("fragmentation", site);
    759. 

  759. 					}
    760. 

  760. 					// revert to buffer
    761. 

  761. 					connections = connectionsBuffer.clone();
    762. 

  762. 				} else {
    763. 

  763. 					bitmap.gates.splice(i, 1);
    764. 

  764. 				}
    765. 

  765. 			}
    766. 

  766. 			
    767. 

  767. 			if(fragmentationSites.length){
    768. 

  768. 				site = fragmentationSites[random.rangeInt(fragmentationSites.length)];
    769. 

  769. 				connections.setPixel32(site.x, site.y, 0xFFFFFFFF);
    770. 

  770. 				connections.floodFill(site.x + 1, site.y, 0xFF0000FF);
    771. 

  771. 				connections.floodFill(site.x - 1, site.y, 0xFF00FF00);
    772. 

  772. 				
    773. 

  773. 				// fragmentation debugging
    774. 

  774. 				//var temp:Bitmap = new Bitmap(connections);
    775. 

  775. 				//game.addChild(temp);
    776. 

  776. 				
    777. 

  777. 				// iterate through surfaces and mark them as connected to the entrance or not
    778. 

  778. 				entranceCol = connections.getPixel32(start.x, start.y);
    779. 

  779. 				connectionPixels = connections.getVector(connections.rect);
    780. 

  780. 				for(j = 0; j < Surface.surfaces.length; j++){
    781. 

  781. 					surface = Surface.surfaces[j];
    782. 

  782. 					n = surface.x + surface.y * width;
    783. 

  783. 					checkCol = connectionPixels[n];
    784. 

  784. 					if(checkCol == entranceCol){
    785. 

  785. 						surface.nearEntrance = true;
    786. 

  786. 					}
    787. 

  787. 				}
    788. 

  788. 				
    789. 

  789. 				// create a location for the key to the gate,
    790. 

  790. 				// try not to put it next to the entrance or the gate
    791. 

  791. 				var minDist:int = 10;
    792. 

  792. 				var collapseMinDist:int = 100;
    793. 

  793. 				do{
    794. 

  794. 					surface = Surface.surfaces[random.rangeInt(Surface.surfaces.length)];
    795. 

  795. 					if(collapseMinDist-- <= 0){
    796. 

  796. 						collapseMinDist = 100;
    797. 

  797. 						minDist--;
    798. 

  798. 					}
    799. 

  799. 				} while(
    800. 

  800. 					!surface.nearEntrance ||
    801. 

  801. 					layers[ENTITIES][surface.y][surface.x] ||
    802. 

  802. 					(
    803. 

  803. 						Math.abs(start.x - surface.x) < minDist &&
    804. 

  804. 						Math.abs(start.y - surface.y) < minDist
    805. 

  805. 					) ||
    806. 

  806. 					(
    807. 

  807. 						Math.abs(site.x - surface.x) < minDist &&
    808. 

  808. 						Math.abs(site.y - surface.y) < minDist
    809. 

  809. 					) ||
    810. 

  810. 					!bitmap.adjustedMapRect.contains((surface.x + 0.5) * Game.SCALE, (surface.y + 0.5) * Game.SCALE)
    811. 

  811. 				);
    812. 

  812. 				
    813. 

  813. 				// key
    814. 

  814. 				var xml:XML =<item name={0} type={Item.KEY} level={0} />;
    815. 

  815. 				item = Content.XMLToEntity(surface.x, surface.y, xml);
    816. 

  816. 				item.dropToMap(surface.x, surface.y, false);
    817. 

  817. 				layers[ENTITIES][surface.y][surface.x] = item;
    818. 

  818. 				gateType = Gate.LOCK;
    819. 

  819. 				Surface.removeSurface(surface.x, surface.y);
    820. 

  820. 				
    821. 

  821. 				// pressure pad
    822. 

  822. 				
    823. 

  823. 				// to do
    824. 

  824. 				
    825. 

  825. 				// an illustration of fragmentation needs to be saved for Effect.teleportCharacter
    826. 

  826. 				// and for wall walkers that change race inside a locked area
    827. 

  827. 				Surface.fragmentationMap = connections;
    828. 

  828. 				Surface.entranceCol = entranceCol;
    829. 

  829. 				
    830. 

  830. 				gateType = Gate.LOCK;
    831. 

  831. 				gate = new Gate(site.x * Game.SCALE, site.y * Game.SCALE, gateType);
    832. 

  832. 				gate.mapX = site.x;
    833. 

  833. 				gate.mapY = site.y;
    834. 

  834. 				gate.mapZ = MapTileManager.ENTITY_LAYER;
    835. 

  835. 				layers[ENTITIES][site.y][site.x] = gate;
    836. 

  836. 				Surface.removeSurface(site.x, site.y);
    837. 

  837. 			}
    838. 

  838. 			
    839. 

  839. 			// pick a random normal site for a raise gate or chaos gate
    840. 

  840. 			if(bitmap.gates.length){
    841. 

  841. 				i = -1 + random.rangeInt(4);
    842. 

  842. 				while(i-- > 0){
    843. 

  843. 					site = bitmap.gates[random.rangeInt(bitmap.gates.length)];
    844. 

  844. 					if(layers[ENTITIES][site.y][site.x]) continue;
    845. 

  845. 					if(zone == CHAOS) gateType = random.coinFlip() ? Gate.CHAOS : Gate.RAISE;
    846. 

  846. 					else gateType = Gate.RAISE;
    847. 

  847. 					gate = new Gate(site.x * Game.SCALE, site.y * Game.SCALE, gateType);
    848. 

  848. 					gate.mapX = site.x;
    849. 

  849. 					gate.mapY = site.y;
    850. 

  850. 					gate.mapZ = MapTileManager.ENTITY_LAYER;
    851. 

  851. 					layers[ENTITIES][site.y][site.x] = gate;
    852. 

  852. 					Surface.removeSurface(site.x, site.y);
    853. 

  853. 				}
    854. 

  854. 			}
    855. 

  855. 		}
    856. 

  856. 		
    857. 

  857. 		/* Generate patches of readable text */
    858. 

  858. 		public function createWritings(pixels:Vector.<uint>):void{
    859. 

  859. 			
    860. 

  860. 			Writing.writings = new Vector.<Writing>();
    861. 

  861. 			
    862. 

  862. 			var i:int, n:int;
    863. 

  863. 			var surface:Surface, writing:Writing;
    864. 

  864. 			
    865. 

  865. 			var range:int = (height - 1) * width - 1;
    866. 

  866. 			var candidates:Vector.<Surface> = new Vector.<Surface>();
    867. 

  867. 			
    868. 

  868. 			for(i = 0; i < Surface.surfaces.length; i++){
    869. 

  869. 				surface = Surface.surfaces[i];
    870. 

  870. 				if(surface.properties == (Collider.SOLID | Collider.WALL)){
    871. 

  871. 					n = surface.x + surface.y * width;
    872. 

  872. 					if(
    873. 

  873. 						n > width + 1 && n < range &&
    874. 

  874. 						(pixels[n + (width + 1)] == MapBitmap.WALL || pixels[n + (width + 1)] == MapBitmap.LEDGE) &&
    875. 

  875. 						(pixels[n + width] == MapBitmap.WALL || pixels[n + width] == MapBitmap.LEDGE) &&
    876. 

  876. 						(pixels[n + (width - 1)] == MapBitmap.WALL || pixels[n + (width - 1)] == MapBitmap.LEDGE) &&
    877. 

  877. 						pixels[n] == MapBitmap.EMPTY &&
    878. 

  878. 						pixels[n - 1] == MapBitmap.EMPTY &&
    879. 

  879. 						pixels[n + 1] == MapBitmap.EMPTY &&
    880. 

  880. 						Surface.map[surface.y][surface.x - 1] &&
    881. 

  881. 						Surface.map[surface.y][surface.x + 1]
    882. 

  882. 					){
    883. 

  883. 						candidates.push(surface);
    884. 

  884. 					}	
    885. 

  885. 				}
    886. 

  886. 			}
    887. 

  887. 			//trace("candidates", candidates.length);
    888. 

  888. 			if(candidates.length){
    889. 

  889. 				
    890. 

  890. 				var index:int;
    891. 

  891. 				var writings:int = 1 + random.rangeInt(3);
    892. 

  892. 				//trace("writings", writings);
    893. 

  893. 				var level:int = this.level - 1;
    894. 

  894. 				
    895. 

  895. 				// randomise selections
    896. 

  896. 				var selection:Array = [];
    897. 

  897. 				var levelArray:Array = Writing.story[level];
    898. 

  898. 				for(i = 0; i < levelArray.length; i++){
    899. 

  899. 					selection.push(i);
    900. 

  900. 				}
    901. 

  901. 				randomiseArray(selection, random);
    902. 

  902. 				while((writings--) && selection.length && candidates.length){
    903. 

  903. 					n = random.rangeInt(candidates.length);
    904. 

  904. 					surface = candidates[n];
    905. 

  905. 					candidates.splice(n, 1);
    906. 

  906. 					i = surface.x + surface.y * width;
    907. 

  907. 					if(
    908. 

  908. 						pixels[i] == MapBitmap.EMPTY &&
    909. 

  909. 						pixels[i + 1] == MapBitmap.EMPTY &&
    910. 

  910. 						pixels[i - 1] == MapBitmap.EMPTY
    911. 

  911. 					){
    912. 

  912. 						index = selection.pop();
    913. 

  913. 						writing = new Writing(surface.x, surface.y, levelArray[index], level, index);
    914. 

  914. 						writing.mapZ = MapTileManager.ENTITY_LAYER;
    915. 

  915. 						layers[ENTITIES][surface.y][surface.x] = writing;
    916. 

  916. 						Surface.removeSurface(surface.x, surface.y);
    917. 

  917. 						// hack to avoid over writing
    918. 

  918. 						pixels[i] = MapBitmap.GATE;
    919. 

  919. 						pixels[i + 1] = MapBitmap.GATE;
    920. 

  920. 						pixels[i - 1] = MapBitmap.GATE;
    921. 

  921. 					}
    922. 

  922. 				}
    923. 

  923. 			}
    924. 

  924. 		}
    925. 

  925. 		
    926. 

  926. 		/* Generate slot machines */
    927. 

  927. 		public function createAltars(pixels:Vector.<uint>):void{
    928. 

  928. 			
    929. 

  929. 			var totalAltars:int = game.content.getAltars(level, type);
    930. 

  930. 			if(totalAltars <= 0) return;
    931. 

  931. 			
    932. 

  932. 			var i:int, n:int;
    933. 

  933. 			var surface:Surface, altar:Altar;
    934. 

  934. 			
    935. 

  935. 			var range:int = (height - 1) * width - 1;
    936. 

  936. 			var candidates:Vector.<Surface> = new Vector.<Surface>();
    937. 

  937. 			
    938. 

  938. 			for(i = 0; i < Surface.surfaces.length; i++){
    939. 

  939. 				surface = Surface.surfaces[i];
    940. 

  940. 				if(surface.properties == (Collider.SOLID | Collider.WALL)){
    941. 

  941. 					n = surface.x + surface.y * width;
    942. 

  942. 					if(
    943. 

  943. 						n > width + 1 && n < range &&
    944. 

  944. 						(pixels[n + (width + 1)] == MapBitmap.WALL || pixels[n + (width + 1)] == MapBitmap.LEDGE) &&
    945. 

  945. 						(pixels[n + width] == MapBitmap.WALL || pixels[n + width] == MapBitmap.LEDGE) &&
    946. 

  946. 						(pixels[n + (width - 1)] == MapBitmap.WALL || pixels[n + (width - 1)] == MapBitmap.LEDGE) &&
    947. 

  947. 						pixels[n] == MapBitmap.EMPTY &&
    948. 

  948. 						pixels[n - 1] == MapBitmap.EMPTY &&
    949. 

  949. 						pixels[n + 1] == MapBitmap.EMPTY &&
    950. 

  950. 						Surface.map[surface.y][surface.x - 1] &&
    951. 

  951. 						Surface.map[surface.y][surface.x + 1]
    952. 

  952. 					){
    953. 

  953. 						candidates.push(surface);
    954. 

  954. 					}	
    955. 

  955. 				}
    956. 

  956. 			}
    957. 

  957. 			//trace("candidates", candidates.length);
    958. 

  958. 			if(candidates.length){
    959. 

  959. 				
    960. 

  960. 				while((totalAltars--) &&  candidates.length){
    961. 

  961. 					n = random.rangeInt(candidates.length);
    962. 

  962. 					surface = candidates[n];
    963. 

  963. 					candidates.splice(n, 1);
    964. 

  964. 					i = surface.x + surface.y * width;
    965. 

  965. 					if(
    966. 

  966. 						pixels[i] == MapBitmap.EMPTY &&
    967. 

  967. 						pixels[i + 1] == MapBitmap.EMPTY &&
    968. 

  968. 						pixels[i - 1] == MapBitmap.EMPTY &&
    969. 

  969. 						!layers[ENTITIES][surface.y][surface.x + 1] &&
    970. 

  970. 						!layers[ENTITIES][surface.y][surface.x - 1]
    971. 

  971. 					){
    972. 

  972. 						altar = new Altar(new AltarMC, surface.x, surface.y);
    973. 

  973. 						layers[ENTITIES][surface.y][surface.x] = altar;
    974. 

  974. 						Surface.removeSurface(surface.x, surface.y);
    975. 

  975. 					}
    976. 

  976. 				}
    977. 

  977. 			}
    978. 

  978. 		}
    979. 

  979. 		
    980. 

  980. 		/* Create lights in the dungeon */
    981. 

  981. 		public function createTorches(pixels:Vector.<uint>):void{
    982. 

  982. 			var i:int, n:int, room:Room, surface:Surface, torch:Torch;
    983. 

  983. 			for(i = 0; i < bitmap.rooms.length; i++){
    984. 

  984. 				room = bitmap.rooms[i];
    985. 

  985. 				if(room.surfaces.length){
    986. 

  986. 					surface = room.surfaces[random.rangeInt(room.surfaces.length)];
    987. 

  987. 					n = surface.x + surface.y * width;
    988. 

  988. 					if(
    989. 

  989. 						pixels[n] == MapBitmap.EMPTY &&
    990. 

  990. 						!layers[ENTITIES][surface.y][surface.x]
    991. 

  991. 					){
    992. 

  992. 						torch = new Torch(new TorchMC, surface.x, surface.y);
    993. 

  993. 						layers[ENTITIES][surface.y][surface.x] = torch;
    994. 

  994. 						Surface.removeSurface(surface.x, surface.y);
    995. 

  995. 					}
    996. 

  996. 				}
    997. 

  997. 			}
    998. 

  998. 		}
    999. 

  999. 		
    1000. 

  1000. 		/* Generate decorative background graphics */
    1001. 

  1001. 		public function createDecor(pixels:Vector.<uint>):void{
    1002. 

  1002. 			
    1003. 

  1003. 			var pixel:uint, i:int, n:int, r:int, c:int, good:Boolean, type:String;
    1004. 

  1004. 			
    1005. 

  1005. 			for(i = width; i < pixels.length - width; i++){
    1006. 

  1006. 				pixel = pixels[i];
    1007. 

  1007. 				if(pixel == MapBitmap.EMPTY){
    1008. 

  1008. 					r = i / width;
    1009. 

  1009. 					c = i % width;
    1010. 

  1010. 					// pillar, chain, recess
    1011. 

  1011. 					if(zone == DUNGEONS){
    1012. 

  1012. 						// pillar / chain
    1013. 

  1013. 						if(pixels[i - width] == MapBitmap.WALL && random.value() < 0.4){
    1014. 

  1014. 							// single pillars spawn very easily, so they need to be reduced in popularity
    1015. 

  1015. 							if(pixels[i + width] == MapBitmap.WALL && random.value() < 0.4){
    1016. 

  1016. 								layers[BACKGROUND][r][c] = random.coinFlip() ? MapTileConverter.PILLAR_SINGLE1 : MapTileConverter.PILLAR_SINGLE2;
    1017. 

  1017. 							} else if(pixels[i + width] == MapBitmap.EMPTY){
    1018. 

  1018. 								// test for pillar or chain
    1019. 

  1019. 								good = true;
    1020. 

  1020. 								for(n = i + width; n < pixels.length; n += width){
    1021. 

  1021. 									if(pixels[n] != MapBitmap.EMPTY){
    1022. 

  1022. 										if(pixels[n] == MapBitmap.WALL || pixels[n] == MapBitmap.LEDGE){
    1023. 

  1023. 											if(pixels[n] == MapBitmap.WALL) type = "pillar";
    1024. 

  1024. 											else if(pixels[n] == MapBitmap.LEDGE) type = "chain";
    1025. 

  1025. 											n -= width;
    1026. 

  1026. 										} else {
    1027. 

  1027. 											good = false;
    1028. 

  1028. 										}
    1029. 

  1029. 										break;
    1030. 

  1030. 									}
    1031. 

  1031. 								}
    1032. 

  1032. 								if(good){
    1033. 

  1033. 									// choose pillar or chain
    1034. 

  1034. 									if(type == "pillar"){
    1035. 

  1035. 										layers[BACKGROUND][r][c] = MapTileConverter.PILLAR_TOP;
    1036. 

  1036. 										r = n / width;
    1037. 

  1037. 										c = n % width;
    1038. 

  1038. 										layers[BACKGROUND][r][c] = MapTileConverter.PILLAR_BOTTOM;
    1039. 

  1039. 										for(n -= width; n > i; n -= width){
    1040. 

  1040. 											r = n / width;
    1041. 

  1041. 											c = n % width;
    1042. 

  1042. 											layers[BACKGROUND][r][c] = random.coinFlip() ? MapTileConverter.PILLAR_MID1 : MapTileConverter.PILLAR_MID2;
    1043. 

  1043. 										}
    1044. 

  1044. 									} else if(type == "chain"){
    1045. 

  1045. 										layers[BACKGROUND][r][c] = MapTileConverter.CHAIN_TOP;
    1046. 

  1046. 										r = n / width;
    1047. 

  1047. 										c = n % width;
    1048. 

  1048. 										layers[BACKGROUND][r][c] = MapTileConverter.CHAIN_BOTTOM;
    1049. 

  1049. 										for(n -= width; n > i; n -= width){
    1050. 

  1050. 											r = n / width;
    1051. 

  1051. 											c = n % width;
    1052. 

  1052. 											layers[BACKGROUND][r][c] = MapTileConverter.CHAIN_MID;
    1053. 

  1053. 										}
    1054. 

  1054. 									}
    1055. 

  1055. 								}
    1056. 

  1056. 							}
    1057. 

  1057. 						// skull
    1058. 

  1058. 						} else if((pixels[i + width] == MapBitmap.WALL || pixels[i + width] == MapBitmap.LEDGE) && random.value() < 0.01 && !layers[BACKGROUND][r][c]){
    1059. 

  1059. 							layers[BACKGROUND][r][c] = MapTileConverter.SKULL;
    1060. 

  1060. 							
    1061. 

  1061. 						// recess (avoid putting a recess above a portal)
    1062. 

  1062. 						} else if(random.value() < 0.05 && !layers[BACKGROUND][r][c] && pixels[i + width] != MapBitmap.GATE){
    1063. 

  1063. 							layers[BACKGROUND][r][c] = MapTileConverter.RECESS;
    1064. 

  1064. 						}
    1065. 

  1065. 						
    1066. 

  1066. 					// outlet, drain
    1067. 

  1067. 					} else if(zone == SEWERS){
    1068. 

  1068. 						// skull
    1069. 

  1069. 						if((pixels[i + width] == MapBitmap.WALL || pixels[i + width] == MapBitmap.LEDGE) && random.value() < 0.01){
    1070. 

  1070. 							layers[BACKGROUND][r][c] = MapTileConverter.SKULL;
    1071. 

  1071. 							
    1072. 

  1072. 						// drain
    1073. 

  1073. 						} else if(pixels[i + width] == MapBitmap.WALL && random.value() < 0.05){
    1074. 

  1074. 							layers[BACKGROUND][r][c] = MapTileConverter.DRAIN;
    1075. 

  1075. 							
    1076. 

  1076. 						// outlet
    1077. 

  1077. 						} else if(pixels[i - width] == MapBitmap.WALL && random.value() < 0.05){
    1078. 

  1078. 							layers[BACKGROUND][r][c] = MapTileConverter.OUTLET;
    1079. 

  1079. 						}
    1080. 

  1080. 					// stalagmite, crack
    1081. 

  1081. 					} else if(zone == CAVES){
    1082. 

  1082. 						// crack
    1083. 

  1083. 						if(random.value() < 0.01 && !layers[BACKGROUND][r][c]){
    1084. 

  1084. 							layers[BACKGROUND][r][c] = [MapTileConverter.CRACK1, MapTileConverter.CRACK2, MapTileConverter.CRACK3][game.random.rangeInt(3)];
    1085. 

  1085. 							
    1086. 

  1086. 						// skull
    1087. 

  1087. 						} else if((pixels[i + width] == MapBitmap.WALL || pixels[i + width] == MapBitmap.LEDGE) && random.value() < 0.01){
    1088. 

  1088. 							layers[BACKGROUND][r][c] = MapTileConverter.SKULL;
    1089. 

  1089. 							
    1090. 

  1090. 						// stalagmite
    1091. 

  1091. 						} else if(pixels[i + width] == MapBitmap.WALL && random.value() < 0.4){
    1092. 

  1092. 							layers[BACKGROUND][r][c] = [MapTileConverter.STALAGMITE1, MapTileConverter.STALAGMITE2, MapTileConverter.STALAGMITE3, MapTileConverter.STALAGMITE4][game.random.rangeInt(4)];
    1093. 

  1093. 							
    1094. 

  1094. 						// stalagtite
    1095. 

  1095. 						} else if(pixels[i - width] == MapBitmap.WALL && random.value() < 0.4){
    1096. 

  1096. 							layers[BACKGROUND][r][c] = [MapTileConverter.STALAGTITE1, MapTileConverter.STALAGTITE2, MapTileConverter.STALAGTITE3, MapTileConverter.STALAGTITE4][game.random.rangeInt(4)];
    1097. 

  1097. 						}
    1098. 

  1098. 						
    1099. 

  1099. 					// growth
    1100. 

  1100. 					} else if(zone == CHAOS){
    1101. 

  1101. 						// skull
    1102. 

  1102. 						if((pixels[i + width] == MapBitmap.WALL || pixels[i + width] == MapBitmap.LEDGE) && random.value() < 0.01){
    1103. 

  1103. 							layers[BACKGROUND][r][c] = MapTileConverter.SKULL;
    1104. 

  1104. 							
    1105. 

  1105. 						// growth up
    1106. 

  1106. 						} else if(pixels[i + width] == MapBitmap.WALL && random.value() < 0.5){
    1107. 

  1107. 							layers[BACKGROUND][r][c] = [MapTileConverter.GROWTH1, MapTileConverter.GROWTH2, MapTileConverter.GROWTH3, MapTileConverter.GROWTH4, MapTileConverter.GROWTH5, MapTileConverter.GROWTH6][game.random.rangeInt(6)];
    1108. 

  1108. 							
    1109. 

  1109. 						// growth down
    1110. 

  1110. 						} else if(pixels[i - width] == MapBitmap.WALL && random.value() < 0.5){
    1111. 

  1111. 							layers[BACKGROUND][r][c] = [MapTileConverter.GROWTH7, MapTileConverter.GROWTH8, MapTileConverter.GROWTH9, MapTileConverter.GROWTH10, MapTileConverter.GROWTH11, MapTileConverter.GROWTH12][game.random.rangeInt(6)];
    1112. 

  1112. 						}
    1113. 

  1113. 					}
    1114. 

  1114. 				}
    1115. 

  1115. 			}
    1116. 

  1116. 			// put stairs in background to over print decor
    1117. 

  1117. 			if(stairsUp) layers[BACKGROUND][stairsUp.y][stairsUp.x] = MapTileConverter.STAIRS_UP_GFX;
    1118. 

  1118. 			if(stairsDown) layers[BACKGROUND][stairsDown.y][stairsDown.x] = MapTileConverter.STAIRS_DOWN_GFX;
    1119. 

  1119. 		}
    1120. 

  1120. 		
    1121. 

  1121. 		/* Sprinkle on some chaos walls to make exploring weirder */
    1122. 

  1122. 		public function createChaosWalls(pixels:Vector.<uint>):void{
    1123. 

  1123. 			ChaosWall.init(width, height);
    1124. 

  1124. 			
    1125. 

  1125. 			// we only put chaos walls in corridors, so we need a stretch of three wall blocks to
    1126. 

  1126. 			// either side of the chaos wall
    1127. 

  1127. 			var i:int, r:int, c:int, n:int;
    1128. 

  1128. 			for(i = width; i < pixels.length - width; i++){
    1129. 

  1129. 				c = i % width;
    1130. 

  1130. 				r = i / width;
    1131. 

  1131. 				if(c > 0 && c < width - 1 && pixels[i] == MapBitmap.EMPTY){
    1132. 

  1132. 					if(zone == CHAOS && !layers[ENTITIES][r][c] && !layers[BLOCKS][r][c] && random.value() < 0.4){
    1133. 

  1133. 						if(pixels[i + width] == MapBitmap.WALL){
    1134. 

  1134. 							n = i;
    1135. 

  1135. 							while(n > width && pixels[n] == MapBitmap.EMPTY && !layers[ENTITIES][r][c] && !layers[BLOCKS][r][c]){
    1136. 

  1136. 								layers[ENTITIES][r][c] = new ChaosWall(c, r);
    1137. 

  1137. 								layers[BLOCKS][r][c] = MapTileConverter.WALL;
    1138. 

  1138. 								n -= width;
    1139. 

  1139. 								r = n / width;
    1140. 

  1140. 							}
    1141. 

  1141. 						}
    1142. 

  1142. 						if(pixels[i - width] == MapBitmap.WALL){
    1143. 

  1143. 							n = i;
    1144. 

  1144. 							while(n < pixels.length - width && pixels[n] == MapBitmap.EMPTY && !layers[ENTITIES][r][c] && !layers[BLOCKS][r][c]){
    1145. 

  1145. 								layers[ENTITIES][r][c] = new ChaosWall(c, r);
    1146. 

  1146. 								layers[BLOCKS][r][c] = MapTileConverter.WALL;
    1147. 

  1147. 								n += width;
    1148. 

  1148. 								r = n / width;
    1149. 

  1149. 							}
    1150. 

  1150. 						}
    1151. 

  1151. 						if(pixels[i - 1] == MapBitmap.WALL){
    1152. 

  1152. 							n = i;
    1153. 

  1153. 							while(n < pixels.length - width && pixels[n] == MapBitmap.EMPTY && !layers[ENTITIES][r][c] && !layers[BLOCKS][r][c]){
    1154. 

  1154. 								layers[ENTITIES][r][c] = new ChaosWall(c, r);
    1155. 

  1155. 								layers[BLOCKS][r][c] = MapTileConverter.WALL;
    1156. 

  1156. 								n++;
    1157. 

  1157. 								c = n % width;
    1158. 

  1158. 							}
    1159. 

  1159. 						}
    1160. 

  1160. 						if(pixels[i + 1] == MapBitmap.WALL){
    1161. 

  1161. 							n = i;
    1162. 

  1162. 							while(n > width && pixels[n] == MapBitmap.EMPTY && !layers[ENTITIES][r][c] && !layers[BLOCKS][r][c]){
    1163. 

  1163. 								layers[ENTITIES][r][c] = new ChaosWall(c, r);
    1164. 

  1164. 								layers[BLOCKS][r][c] = MapTileConverter.WALL;
    1165. 

  1165. 								n--;
    1166. 

  1166. 								c = n % width;
    1167. 

  1167. 							}
    1168. 

  1168. 						}
    1169. 

  1169. 					} else {
    1170. 

  1170. 						if(
    1171. 

  1171. 							// horizontal corridor
    1172. 

  1172. 							(
    1173. 

  1173. 								pixels[(i - width) - 1] == MapBitmap.WALL && 
    1174. 

  1174. 								pixels[i - width] == MapBitmap.WALL && 
    1175. 

  1175. 								pixels[(i - width) + 1] == MapBitmap.WALL && 
    1176. 

  1176. 								pixels[(i + width) - 1] == MapBitmap.WALL && 
    1177. 

  1177. 								pixels[i + width] == MapBitmap.WALL && 
    1178. 

  1178. 								pixels[(i + width) + 1] == MapBitmap.WALL
    1179. 

  1179. 							) ||
    1180. 

  1180. 							// vertical corridor
    1181. 

  1181. 							(
    1182. 

  1182. 								pixels[(i - width) - 1] == MapBitmap.WALL && 
    1183. 

  1183. 								pixels[i - 1] == MapBitmap.WALL && 
    1184. 

  1184. 								pixels[(i + width) - 1] == MapBitmap.WALL && 
    1185. 

  1185. 								pixels[(i - width) + 1] == MapBitmap.WALL && 
    1186. 

  1186. 								pixels[i + 1] == MapBitmap.WALL && 
    1187. 

  1187. 								pixels[(i + width) + 1] == MapBitmap.WALL
    1188. 

  1188. 							)
    1189. 

  1189. 						){
    1190. 

  1190. 							if(random.value() < 0.4 && !layers[ENTITIES][r][c] && !layers[BLOCKS][r][c]){
    1191. 

  1191. 							//if(!layers[ENTITIES][r][c]){
    1192. 

  1192. 								layers[ENTITIES][r][c] = new ChaosWall(c, r);
    1193. 

  1193. 								layers[BLOCKS][r][c] = MapTileConverter.WALL;
    1194. 

  1194. 							}
    1195. 

  1195. 						}
    1196. 

  1196. 					}
    1197. 

  1197. 				}
    1198. 

  1198. 			}
    1199. 

  1199. 		}
    1200. 

  1200. 		
    1201. 

  1201. 		/* This adds traps other than pit traps to the level */
    1202. 

  1202. 		public function createOtherTraps(pixels:Vector.<uint>):void{
    1203. 

  1203. 			
    1204. 

  1204. 			// TRAPS BY ZONE
    1205. 

  1205. 			
    1206. 

  1206. 			// All zones have pit traps
    1207. 

  1207. 			
    1208. 

  1208. 			// the compiler won't let me create this as a constant so I have to drop it in here
    1209. 

  1209. 			// better than resorting to magic numbers I suppose
    1210. 

  1210. 			var ZONE_TRAPS:Array = [
    1211. 

  1211. 				[Trap.TELEPORT_DART],
    1212. 

  1212. 				[Trap.STUN_MUSHROOM, Trap.TELEPORT_DART, Trap.CONFUSION_MUSHROOM],
    1213. 

  1213. 				[Trap.STUN_MUSHROOM, Trap.BLEED_DART, Trap.CONFUSION_MUSHROOM, Trap.FEAR_MUSHROOM],
    1214. 

  1214. 				[Trap.MONSTER_PORTAL, Trap.STUN_MUSHROOM, Trap.BLEED_DART, Trap.TELEPORT_DART, Trap.CONFUSION_MUSHROOM, Trap.FEAR_MUSHROOM]
    1215. 

  1215. 			];
    1216. 

  1216. 			
    1217. 

  1217. 			var totalTraps:int = game.content.getTraps(level, type) - bitmap.pitTraps;
    1218. 

  1218. 			completionCount += totalTraps;
    1219. 

  1219. 			if(totalTraps == 0) return;
    1220. 

  1220. 			
    1221. 

  1221. 			var dartPos:Pixel;
    1222. 

  1222. 			var trapPositions:Vector.<Surface> = new Vector.<Surface>();
    1223. 

  1223. 			var surface:Surface;
    1224. 

  1224. 			var mapWidth:int = bitmap.bitmapData.width;
    1225. 

  1225. 			var n:int;
    1226. 

  1226. 			
    1227. 

  1227. 			for(i = 0; i < Surface.surfaces.length; i++){
    1228. 

  1228. 				surface = Surface.surfaces[i];
    1229. 

  1229. 				if(surface.properties == (Collider.SOLID | Collider.WALL)){
    1230. 

  1230. 					if(layers[ENTITIES][surface.y][surface.x]) continue;
    1231. 

  1231. 					for(j = surface.x + surface.y * mapWidth; j > mapWidth; j -= mapWidth){
    1232. 

  1232. 						// no combining ladders or pit traps with dart traps
    1233. 

  1233. 						// it confuses the trap and it's unfair to have to climb a ladder into a dart
    1234. 

  1234. 						if(pixels[j] == MapBitmap.LADDER || pixels[j] == MapBitmap.LADDER_LEDGE || pixels[j] == MapBitmap.PIT){
    1235. 

  1235. 							break;
    1236. 

  1236. 						} else if(pixels[j] == MapBitmap.WALL){
    1237. 

  1237. 							trapPositions.push(surface);
    1238. 

  1238. 							break;
    1239. 

  1239. 						}
    1240. 

  1240. 					}
    1241. 

  1241. 				}
    1242. 

  1242. 			}
    1243. 

  1243. 			
    1244. 

  1244. 			var trapIndex:int, trapPos:Surface, trapType:int, sprite:Sprite, trap:Trap;
    1245. 

  1245. 			
    1246. 

  1246. 			while(totalTraps > 0 && trapPositions.length > 0){
    1247. 

  1247. 				trapIndex = random.range(trapPositions.length);
    1248. 

  1248. 				trapPos = trapPositions[trapIndex];
    1249. 

  1249. 				trapType = ZONE_TRAPS[zone][random.rangeInt(ZONE_TRAPS[zone].length)];
    1250. 

  1250. 				sprite = new Sprite();
    1251. 

  1251. 				sprite.x = trapPos.x * Game.SCALE;
    1252. 

  1252. 				sprite.y = (trapPos.y + 1) * Game.SCALE;
    1253. 

  1253. 				if(trapType != Trap.MONSTER_PORTAL){
    1254. 

  1254. 					// get dart gun position
    1255. 

  1255. 					dartPos = trapPos.copy();
    1256. 

  1256. 					while(pixels[dartPos.x + dartPos.y * width] != MapBitmap.WALL){
    1257. 

  1257. 						dartPos.y--;
    1258. 

  1258. 					}
    1259. 

  1259. 				} else {
    1260. 

  1260. 					dartPos = null;
    1261. 

  1261. 				}
    1262. 

  1262. 				trap = new Trap(sprite, trapPos.x, trapPos.y + 1, trapType, dartPos);
    1263. 

  1263. 				trap.mapX = trapPos.x;
    1264. 

  1264. 				trap.mapY = trapPos.y + 1;
    1265. 

  1265. 				trap.mapZ = MapTileManager.ENTITY_LAYER;
    1266. 

  1266. 				layers[ENTITIES][trapPos.y + 1][trapPos.x] = trap;
    1267. 

  1267. 				trapPositions.splice(trapIndex, 1);
    1268. 

  1268. 				Surface.removeSurface(trapPos.x, trapPos.y);
    1269. 

  1269. 				totalTraps--;
    1270. 

  1270. 			}
    1271. 

  1271. 		}
    1272. 

  1272. 		
    1273. 

  1273. 		/* Debugging or set-piece method */
    1274. 

  1274. 		public function createCharacter(x:int, y:int, name:int, level:int):void{
    1275. 

  1275. 			var characterXML:XML = <character />;
    1276. 

  1276. 			characterXML.@name = name;
    1277. 

  1277. 			characterXML.@type = Character.MONSTER;
    1278. 

  1278. 			characterXML.@level = level;
    1279. 

  1279. 			layers[ENTITIES][y][x] = Content.XMLToEntity(x, y, characterXML);
    1280. 

  1280. 		}
    1281. 

  1281. 		
    1282. 

  1282. 		public function setValue(x:int, y:int, z:int, value:*):void{
    1283. 

  1283. 			layers[z][y][x] = value;
    1284. 

  1284. 		}
    1285. 

  1285. 		
    1286. 

  1286. 		public function getValue(x:int, y:int, z:int):*{
    1287. 

  1287. 			return layers[z][y][x];
    1288. 

  1288. 		}
    1289. 

  1289. 		
    1290. 

  1290. 		/* Creates a secret wall that can be broken through */
    1291. 

  1291. 		public function createSecretWall(x:int, y:int):void{
    1292. 

  1292. 			var side:int;
    1293. 

  1293. 			if(x > width * 0.5) side = Collider.RIGHT;
    1294. 

  1294. 			else side = Collider.LEFT;
    1295. 

  1295. 			var wall:Stone = new Stone(x * Game.SCALE, y * Game.SCALE, Stone.SECRET_WALL, side);
    1296. 

  1296. 			wall.mapX = x;
    1297. 

  1297. 			wall.mapY = y;
    1298. 

  1298. 			wall.mapZ = MapTileManager.ENTITY_LAYER;
    1299. 

  1299. 			layers[ENTITIES][y][x] = wall;
    1300. 

  1300. 			completionCount++;
    1301. 

  1301. 		}
    1302. 

  1302. 		
    1303. 

  1303. 		/* Creates a pit trap */
    1304. 

  1304. 		public function createPitTrap(x:int, y:int):void{
    1305. 

  1305. 			var sprite:Spri…
    1306.