xolatile
/
xhads
1
1
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Prototype game engine for Heroes of Might & Magic, featuring a gameplay plot-twist...
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
361 Revīzija
1 Atzars
5.8MB
Atzars: master
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'master'
${ noResults }
xhads/source/world.adb

430 rindas
21KB
Neapstrādāts Patstāvīgā saite Vainot Vēsture 

  1. -- Copyright (c) 2024 - Ognjen 'xolatile' Milan Robovic

  2. --

  3. -- GNU General Public Licence (version 3 or later)

  4. 

  5. with core, ui, resource, equipment, unit, construction, chad, effect;

  6. 

  7. use type core.cursor_code;

  8. 

  9. package body world is

  10. 

  11. ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

  12. 

  13. 	view_reach : constant integer := 96;

  14. 

  15. 	landmark_limit     : constant integer := 90;

  16. 	location_limit     : constant integer := 30;

  17. 	construction_limit : constant natural := 60;

  18. 	equipment_limit    : constant natural := 600;

  19. 	unit_limit         : constant natural := 60;

  20. 

  21. 	earth              : core.sprite;

  22. 	dark               : core.sprite;

  23. 	border_upper       : core.sprite;

  24. 	border_lower       : core.sprite;

  25. 	border_left        : core.sprite;

  26. 	border_right       : core.sprite;

  27. 	corner_upper_left  : core.sprite;

  28. 	corner_upper_right : core.sprite;

  29. 	corner_lower_left  : core.sprite;

  30. 	corner_lower_right : core.sprite;

  31. 

  32.                                              ------------------------------------------------------------------------------------------

  33. 

  34. 	procedure configure is

  35. 	begin

  36. 		core.echo (core.comment, "Configuring world components...");

  37. 		--

  38. 		earth              := core.import_sprite (core.folder & "/game/world/terrain/earth.png",            1, 1);

  39. 		dark               := core.import_sprite (core.folder & "/game/world/dark.png",                     1, 1);

  40. 		border_upper       := core.import_sprite (core.folder & "/game/world/frame/border_upper.png",       1, 1);

  41. 		border_lower       := core.import_sprite (core.folder & "/game/world/frame/border_lower.png",       1, 1);

  42. 		border_left        := core.import_sprite (core.folder & "/game/world/frame/border_left.png",        1, 1);

  43. 		border_right       := core.import_sprite (core.folder & "/game/world/frame/border_right.png",       1, 1);

  44. 		corner_upper_left  := core.import_sprite (core.folder & "/game/world/frame/corner_upper_left.png",  1, 1);

  45. 		corner_upper_right := core.import_sprite (core.folder & "/game/world/frame/corner_upper_right.png", 1, 1);

  46. 		corner_lower_left  := core.import_sprite (core.folder & "/game/world/frame/corner_lower_left.png",  1, 1);

  47. 		corner_lower_right := core.import_sprite (core.folder & "/game/world/frame/corner_lower_right.png", 1, 1);

  48. 		--

  49. 		for index in landmark_index loop

  50. 			landmarks (index) := core.import_sprite (file_path => core.folder & "/game/world/landmark/" & core.lowercase (index'image) & ".png",

  51. 			                                         frames    => landmark_trait (index).frames,

  52. 			                                         states    => 1);

  53. 		end loop;

  54. 		--

  55. 		for index in location_index loop

  56. 			locations (index) := core.import_sprite (file_path => core.folder & "/game/world/location/" & core.lowercase (index'image) & ".png",

  57. 			                                         frames    => location_trait (index).frames,

  58. 			                                         states    => location_trait (index).states);

  59. 		end loop;

  60. 	end configure;

  61. 

  62.                                              ------------------------------------------------------------------------------------------

  63. 

  64. 	procedure make (index : in biome; width, height, chad_limit : in natural) is

  65. 	begin

  66. 		core.echo (core.comment, "-- Procedurally generating new map...");

  67. 		--

  68. 		core.echo (core.comment, "-- -- Map type       : " & index'image);

  69. 		core.echo (core.comment, "-- -- Map width      :"  & width'image);

  70. 		core.echo (core.comment, "-- -- Map height     :"  & height'image);

  71. 		core.echo (core.comment, "-- -- Landmark count :"  & landmark_limit'image);

  72. 		--

  73. 		map.kind       := index;

  74. 		map.width      := width;

  75. 		map.height     := height;

  76. 		map.chad_limit := chad_limit;

  77. 		map.chad_count := 0;

  78. 		--

  79. 		map.earth         := new integer_matrix   (0 .. map.width - 1, 0 .. map.height - 1);

  80. 		map.clips         := new boolean_matrix   (0 .. map.width - 1, 0 .. map.height - 1);

  81. 		map.views         := new boolean_matrix   (0 .. map.width - 1, 0 .. map.height - 1);

  82. 		map.landmarks     := new entity_array     (1 .. landmark_limit);

  83. 		map.locations     := new entity_array     (1 .. location_limit);

  84. 		map.constructions := new entity_array     (1 .. construction_limit);

  85. 		map.equipments    := new entity_array     (1 .. equipment_limit);

  86. 		map.units         := new entity_array     (1 .. unit_limit);

  87. 		map.chads         := new chad.value_array (1 .. map.chad_limit);

  88. 		--

  89. 		for x in 0 .. width - 1 loop

  90. 			for y in 0 .. height - 1 loop

  91. 				map.earth    (x, y) := (if core.random (0, 23) < 19 then core.random (0, 11) else core.random (0, 23));

  92. 				map.clips    (x, y) := false;

  93. 				map.views    (x, y) := false;

  94. 			end loop;

  95. 		end loop;

  96. 		--

  97. 		for index in 1 .. landmark_limit loop

  98. 			map.landmarks (index).index := core.random (0, landmark_count - 1);

  99. 			map.landmarks (index).state := 0;

  100. 			map.landmarks (index).x     := core.random (6, map.width  - 6);

  101. 			map.landmarks (index).y     := core.random (6, map.height - 6);

  102. 			--

  103. 			if landmark_trait (landmark_index'val (map.landmarks (index).index)).clip then

  104. 				declare reach_x : constant natural := landmarks (landmark_index'val (map.landmarks (index).index)).width  / core.base;

  105. 				        reach_y : constant natural := landmarks (landmark_index'val (map.landmarks (index).index)).height / core.base;

  106. 				begin

  107. 					for x in 0 .. reach_x - 1 loop

  108. 						for y in 0 .. reach_y - 1 loop

  109. 							map.clips (map.landmarks (index).x + x, map.landmarks (index).y + y) := true;

  110. 						end loop;

  111. 					end loop;

  112. 				end;

  113. 			end if;

  114. 		end loop;

  115. 		--

  116. 		for index in 1 .. location_limit loop

  117. 			map.locations (index).index := core.random (0, location_count - 1);

  118. 			map.locations (index).state := 0;

  119. 			map.locations (index).x     := core.random (6, map.width  - 6);

  120. 			map.locations (index).y     := core.random (6, map.height - 6);

  121. 			--

  122. 			if location_trait (location_index'val (map.locations (index).index)).clip then

  123. 				declare reach_x : constant natural := locations (location_index'val (map.locations (index).index)).width  / core.base;

  124. 				        reach_y : constant natural := locations (location_index'val (map.locations (index).index)).height / core.base;

  125. 				begin

  126. 					for x in 0 .. reach_x - 1 loop

  127. 						for y in 0 .. reach_y - 1 loop

  128. 							map.clips (map.locations (index).x + x, map.locations (index).y + y) := true;

  129. 						end loop;

  130. 					end loop;

  131. 				end;

  132. 			end if;

  133. 		end loop;

  134. 		--

  135. 		for index in 1 .. construction_limit loop

  136. 			map.constructions (index).index := core.random (0, construction.count - 1);

  137. 			map.constructions (index).state := 0;

  138. 			map.constructions (index).x     := core.random (6, map.width          - 6);

  139. 			map.constructions (index).y     := core.random (6, map.height         - 6);

  140. 			--

  141. 			declare reach_x : constant natural := construction.sprite (construction.enumeration'val (map.constructions (index).index)).width  / core.base;

  142. 			        reach_y : constant natural := construction.sprite (construction.enumeration'val (map.constructions (index).index)).height / core.base;

  143. 			begin

  144. 				for x in 0 .. reach_x - 1 loop

  145. 					for y in 0 .. reach_y - 1 loop

  146. 						map.clips (map.constructions (index).x + x, map.constructions (index).y + y) := true;

  147. 					end loop;

  148. 				end loop;

  149. 			end;

  150. 		end loop;

  151. 		--

  152. 		for index in 1 .. equipment_limit loop

  153. 			map.equipments (index).index := core.random (0, equipment.count - 1);

  154. 			map.equipments (index).state := 0;

  155. 			map.equipments (index).x     := core.random (0, map.width  - 1);

  156. 			map.equipments (index).y     := core.random (0, map.height - 1);

  157. 		end loop;

  158. 		--

  159. 		for index in 1 .. unit_limit loop

  160. 			map.units (index).index := core.random (0, unit.count - 1);

  161. 			map.units (index).state := 0;

  162. 			map.units (index).x     := core.random (0, map.width  - 1);

  163. 			map.units (index).y     := core.random (0, map.height - 1);

  164. 			--

  165. 			map.clips (map.units (index).x, map.units (index).y) := true;

  166. 		end loop;

  167. 		--

  168. 		core.echo (core.success, "Finished procedurally generating new map.");

  169. 	end make;

  170. 

  171.                                              ------------------------------------------------------------------------------------------

  172. 

  173. 	procedure draw is

  174. 		offset : core.vector := ((core.window_width  - core.base) / 2,

  175. 		                         (core.window_height - core.base) / 2);

  176. 	begin

  177. 		for vertical in 0 .. map.height - 1 loop

  178. 			exit when offset.y + (vertical - core.camera.y) * core.base * core.zoom > core.window_height;

  179. 			--

  180. 			for horizontal in 0 .. map.width - 1 loop

  181. 				exit when offset.x + (horizontal - core.camera.x) * core.base * core.zoom > core.window_width;

  182. 				--

  183. 				if not ((horizontal - core.camera.x) ** 2 + (vertical - core.camera.y) ** 2 > view_reach * 2) then

  184. 					map.views (horizontal, vertical) := true;

  185. 				end if;

  186. 			end loop;

  187. 		end loop;

  188. 		--

  189. 		declare x      : constant integer := core.base * core.zoom * (-1 - core.camera.x) + offset.x;

  190. 		        y      : constant integer := core.base * core.zoom * (-1 - core.camera.y) + offset.y;

  191. 		        width  : constant integer := core.base * core.zoom * (map.width  + 2);

  192. 		        height : constant integer := core.base * core.zoom * (map.height + 2);

  193. 		begin

  194. 			core.draw_horizontally (border_upper, x + core.base * core.zoom,         y,                                  width  - 2 * core.base * core.zoom, core.zoom);

  195. 			core.draw_horizontally (border_lower, x + core.base * core.zoom,         y - core.base * core.zoom + height, width  - 2 * core.base * core.zoom, core.zoom);

  196. 			core.draw_vertically   (border_left,  x,                                 y + core.base * core.zoom,          height - 2 * core.base * core.zoom, core.zoom);

  197. 			core.draw_vertically   (border_right, x - core.base * core.zoom + width, y + core.base * core.zoom,          height - 2 * core.base * core.zoom, core.zoom);

  198. 			--

  199. 			core.draw (corner_upper_left,  x,                                 y,                                  factor => core.zoom);

  200. 			core.draw (corner_upper_right, x - core.base * core.zoom + width, y,                                  factor => core.zoom);

  201. 			core.draw (corner_lower_left,  x,                                 y - core.base * core.zoom + height, factor => core.zoom);

  202. 			core.draw (corner_lower_right, x - core.base * core.zoom + width, y - core.base * core.zoom + height, factor => core.zoom);

  203. 		end;

  204. 		--

  205. 		for vertical in 0 .. map.height - 1 loop

  206. 			exit when offset.y + (vertical - core.camera.y) * core.base * core.zoom > core.window_height;

  207. 			--

  208. 			for horizontal in 0 .. map.width - 1 loop

  209. 				exit when offset.x + (horizontal - core.camera.x) * core.base * core.zoom > core.window_width;

  210. 				--

  211. 				if map.views (horizontal, vertical) then

  212. 					core.draw (data   => earth,

  213. 					           x      => offset.x + (horizontal - core.camera.x) * core.base * core.zoom,

  214. 					           y      => offset.y + (vertical   - core.camera.y) * core.base * core.zoom,

  215. 					           u      => core.base * biome'pos (map.kind) * 4,

  216. 					           v      => core.base * map.earth (horizontal, vertical),

  217. 					           width  => core.base,

  218. 					           height => core.base);

  219. 					--~--

  220. 					if  core.cursor.x > offset.x + (horizontal - core.camera.x    ) * core.base * core.zoom - 6

  221. 					and core.cursor.x < offset.x + (horizontal - core.camera.x + 1) * core.base * core.zoom + 6

  222. 					and core.cursor.y > offset.y + (vertical   - core.camera.y    ) * core.base * core.zoom - 6

  223. 					and core.cursor.y < offset.y + (vertical   - core.camera.y + 1) * core.base * core.zoom + 6

  224. 					and core.cursor_mode = core.cursor_left

  225. 					and not ui.prioritize then

  226. 						map.chads (1).x := horizontal;

  227. 						map.chads (1).y := vertical;

  228. 						core.cursor_mode := core.cursor_none;

  229. 					end if;

  230. 				end if;

  231. 			end loop;

  232. 		end loop;

  233. 		--

  234. 		for index in 1 .. landmark_limit loop

  235. 			if map.views (map.landmarks (index).x, map.landmarks (index).y) then

  236. 				core.draw (data => landmarks (landmark_index'val (map.landmarks (index).index)),

  237. 				           x    => offset.x + (map.landmarks (index).x - core.camera.x) * core.base * core.zoom,

  238. 				           y    => offset.y + (map.landmarks (index).y - core.camera.y) * core.base * core.zoom);

  239. 				if  core.cursor_inside (x      => offset.x + (map.landmarks (index).x - core.camera.x) * core.base * core.zoom,

  240. 				                        y      => offset.y + (map.landmarks (index).y - core.camera.y) * core.base * core.zoom,

  241. 				                        width  => landmarks (landmark_index'val (map.landmarks (index).index)).width,

  242. 				                        height => landmarks (landmark_index'val (map.landmarks (index).index)).height)

  243. 				and core.cursor_mode = core.cursor_right

  244. 				and not ui.prioritize then

  245. 					core.write_text_box (landmark_trait (landmark_index'val (map.landmarks (index).index)).name);

  246. 				end if;

  247. 			end if;

  248. 		end loop;

  249. 		--

  250. 		for index in 1 .. location_limit loop

  251. 			if map.views (map.locations (index).x, map.locations (index).y) then

  252. 				core.draw (data   => locations (location_index'val (map.locations (index).index)),

  253. 				           x      => offset.x + (map.locations (index).x - core.camera.x) * core.base * core.zoom,

  254. 				           y      => offset.y + (map.locations (index).y - core.camera.y) * core.base * core.zoom,

  255. 				           v      => locations (location_index'val (map.locations (index).index)).height * map.locations (index).state,

  256. 				           width  => locations (location_index'val (map.locations (index).index)).width,

  257. 				           height => locations (location_index'val (map.locations (index).index)).height);

  258. 				if  core.cursor_inside (x      => offset.x + (map.locations (index).x - core.camera.x) * core.base * core.zoom,

  259. 				                        y      => offset.y + (map.locations (index).y - core.camera.y) * core.base * core.zoom,

  260. 				                        width  => locations (location_index'val (map.locations (index).index)).width,

  261. 				                        height => locations (location_index'val (map.locations (index).index)).height)

  262. 				and core.cursor_mode = core.cursor_right

  263. 				and not ui.prioritize then

  264. 					core.write_text_box (location_trait (location_index'val (map.locations (index).index)).name);

  265. 				end if;

  266. 			end if;

  267. 			--

  268. 			if map.locations (index).state = 1 and core.animation_time = 0 then

  269. 				map.locations (index).state := 2;

  270. 			end if;

  271. 			--

  272. 			if  core.camera.x > map.locations (index).x - 2

  273. 			and core.camera.x < map.locations (index).x + 1 + locations (location_index'val (map.locations (index).index)).width  / core.base

  274. 			and core.camera.y > map.locations (index).y - 2

  275. 			and core.camera.y < map.locations (index).y + 1 + locations (location_index'val (map.locations (index).index)).height / core.base

  276. 			and map.locations (index).state = 0

  277. 			and core.signal_code'pos (core.signal_mode) = core.signal_code'pos (core.signal_e)

  278. 			and not ui.prioritize then

  279. 				effect.apply (location_trait (location_index'val (map.locations (index).index)).evoke);

  280. 				--

  281. 				map.locations (index).state := 1;

  282. 			end if;

  283. 		end loop;

  284. 		--

  285. 		for index in 1 .. construction_limit loop

  286. 			if map.views (map.constructions (index).x, map.constructions (index).y) then

  287. 				construction.draw_plus (construction.enumeration'val (map.constructions (index).index),

  288. 				                        offset.x + (map.constructions (index).x - core.camera.x) * core.base * core.zoom,

  289. 				                        offset.y + (map.constructions (index).y - core.camera.y) * core.base * core.zoom);

  290. 			end if;

  291. 		end loop;

  292. 		--

  293. 		for index in 1 .. equipment_limit loop

  294. 			if map.views (map.equipments (index).x, map.equipments (index).y) then

  295. 				equipment.draw_plus (equipment.enumeration'val (map.equipments (index).index),

  296. 				                     core.idle,

  297. 				                     offset.x + (map.equipments (index).x - core.camera.x) * core.base * core.zoom,

  298. 				                     offset.y + (map.equipments (index).y - core.camera.y) * core.base * core.zoom);

  299. 			end if;

  300. 			--

  301. 			if  map.equipments (index).x = core.camera.x

  302. 			and map.equipments (index).y = core.camera.y

  303. 			and core.signal_code'pos (core.signal_mode) = core.signal_code'pos (core.signal_e) then

  304. 				if chad.take_equipment_item (map.chads (1), equipment.enumeration'val (map.equipments (index).index)) then

  305. 					map.equipments (index).index := equipment.enumeration'pos (equipment.none);

  306. 				end if;

  307. 			end if;

  308. 		end loop;

  309. 		--

  310. 		for index in 1 .. unit_limit loop

  311. 			if map.views (map.units (index).x, map.units (index).y) then

  312. 				unit.draw_full (map.units (index).index,

  313. 				                offset.x + (map.units (index).x - core.camera.x) * core.base * core.zoom,

  314. 				                offset.y + (map.units (index).y - core.camera.y) * core.base * core.zoom);

  315. 			end if;

  316. 		end loop;

  317. 		--

  318. 		for index in 1 .. map.chad_count loop

  319. 			if map.views (map.chads (index).x, map.chads (index).y) then

  320. 				chad.draw (map.chads (index),

  321. 				           offset.x + (map.chads (index).x - core.camera.x) * core.base * core.zoom,

  322. 				           offset.y + (map.chads (index).y - core.camera.y) * core.base * core.zoom);

  323. 			end if;

  324. 		end loop;

  325. 		--

  326. 		for vertical in 0 .. map.height - 1 loop

  327. 			exit when offset.y + (vertical - core.camera.y) * core.base * core.zoom > core.window_height;

  328. 			--

  329. 			for horizontal in 0 .. map.width - 1 loop

  330. 				exit when offset.x + (horizontal - core.camera.x) * core.base * core.zoom > core.window_width;

  331. 				--

  332. 				if (horizontal - core.camera.x) ** 2 + (vertical - core.camera.y) ** 2 > view_reach then

  333. 					core.draw (data   => dark,

  334. 					           x      => offset.x + (horizontal - core.camera.x) * core.base * core.zoom,

  335. 					           y      => offset.y + (vertical   - core.camera.y) * core.base * core.zoom);

  336. 				end if;

  337. 			end loop;

  338. 		end loop;

  339. 	end draw;

  340. 

  341.                                              ------------------------------------------------------------------------------------------

  342. 

  343. 	procedure mapshot (file_path : in string) is

  344. 	begin

  345. 		core.create_image (map.width, map.height);

  346. 		--

  347. 		for vertical in 0 .. map.height - 1 loop

  348. 			for horizontal in 0 .. map.width - 1 loop

  349. 				core.render_image (data   => earth,

  350. 				                   x      => horizontal * core.base,

  351. 				                   y      => vertical   * core.base,

  352. 				                   u      => core.base * biome'pos (map.kind) * 4,

  353. 				                   v      => core.base * map.earth (horizontal, vertical),

  354. 				                   width  => core.base,

  355. 				                   height => core.base);

  356. 			end loop;

  357. 		end loop;

  358. 		--

  359. 		for index in 1 .. landmark_limit loop

  360. 			core.render_image (data   => landmarks (landmark_index'val (map.landmarks (index).index)),

  361. 			                   x      => map.landmarks (index).x * core.base,

  362. 			                   y      => map.landmarks (index).y * core.base,

  363. 			                   u      => 0,

  364. 			                   v      => 0,

  365. 			                   width  => landmarks (landmark_index'val (map.landmarks (index).index)).width,

  366. 			                   height => landmarks (landmark_index'val (map.landmarks (index).index)).height);

  367. 		end loop;

  368. 		--

  369. 		for index in 1 .. location_limit loop

  370. 			core.render_image (data   => locations (location_index'val (map.locations (index).index)),

  371. 			                   x      => map.locations (index).x * core.base,

  372. 			                   y      => map.locations (index).y * core.base,

  373. 			                   u      => 0,

  374. 			                   v      => 0,

  375. 			                   width  => locations (location_index'val (map.locations (index).index)).width,

  376. 			                   height => locations (location_index'val (map.locations (index).index)).height);

  377. 		end loop;

  378. 		--

  379. 		for index in 1 .. construction_limit loop

  380. 			core.render_image (data   => construction.sprite (construction.enumeration'val (map.constructions (index).index)),

  381. 			                   x      => map.constructions (index).x * core.base,

  382. 			                   y      => map.constructions (index).y * core.base,

  383. 			                   u      => 0,

  384. 			                   v      => 0,

  385. 			                   width  => construction.sprite (construction.enumeration'val (map.constructions (index).index)).width,

  386. 			                   height => construction.sprite (construction.enumeration'val (map.constructions (index).index)).height);

  387. 		end loop;

  388. 		--

  389. 		for index in 1 .. equipment_limit loop

  390. 			core.render_image (data   => equipment.sprite (equipment.enumeration'val (map.equipments (index).index)),

  391. 			                   x      => map.equipments (index).x * core.base,

  392. 			                   y      => map.equipments (index).y * core.base,

  393. 			                   u      => 0,

  394. 			                   v      => 0,

  395. 			                   width  => equipment.sprite (equipment.enumeration'val (map.equipments (index).index)).width,

  396. 			                   height => equipment.sprite (equipment.enumeration'val (map.equipments (index).index)).height);

  397. 		end loop;

  398. 		--

  399. 		core.export_image (file_path);

  400. 		--

  401. 		core.echo (core.success, "Exported current world mapshot.");

  402. 		--

  403. 		core.dash;

  404. 	end mapshot;

  405. 

  406.                                              ------------------------------------------------------------------------------------------

  407. 

  408. 	procedure reveal_map is

  409. 	begin

  410. 		for x in 0 .. map.width - 1 loop

  411. 			for y in 0 .. map.height - 1 loop

  412. 				map.views (x, y) := true;

  413. 			end loop;

  414. 		end loop;

  415. 	end reveal_map;

  416. 

  417.                                              ------------------------------------------------------------------------------------------

  418. 

  419. 	procedure add_chad (data : in chad.value) is

  420. 	begin

  421. 		core.echo_when (map.chad_count = map.chad_limit, core.failure, "Can't add new chad, limit reached.");

  422. 		core.increment (map.chad_count);

  423. 		--

  424. 		map.chads (map.chad_count) := data;

  425. 	end add_chad;

  426. 

  427. ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

  428. 

  429. end world;