main.rs 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442
  1. extern crate serde;
  2. extern crate rltk;
  3. use rltk::{Console, GameState, Rltk, Point};
  4. extern crate specs;
  5. use specs::prelude::*;
  6. use specs::saveload::{SimpleMarker, SimpleMarkerAllocator};
  7. #[macro_use]
  8. extern crate specs_derive;
  9. mod components;
  10. pub use components::*;
  11. mod map;
  12. pub use map::*;
  13. mod player;
  14. use player::*;
  15. mod rect;
  16. pub use rect::Rect;
  17. mod visibility_system;
  18. use visibility_system::VisibilitySystem;
  19. mod monster_ai_system;
  20. use monster_ai_system::MonsterAI;
  21. mod map_indexing_system;
  22. use map_indexing_system::MapIndexingSystem;
  23. mod melee_combat_system;
  24. use melee_combat_system::MeleeCombatSystem;
  25. mod damage_system;
  26. use damage_system::DamageSystem;
  27. mod gui;
  28. mod gamelog;
  29. mod spawner;
  30. mod inventory_system;
  31. use inventory_system::{ ItemCollectionSystem, ItemUseSystem, ItemDropSystem, ItemRemoveSystem };
  32. pub mod saveload_system;
  33. pub mod random_table;
  34. pub mod particle_system;
  35. pub mod hunger_system;
  36. pub mod rex_assets;
  37. pub mod trigger_system;
  38. pub mod map_builders;
  39. #[macro_use]
  40. extern crate generator;
  41. rltk::add_wasm_support!();
  42. #[derive(PartialEq, Copy, Clone)]
  43. pub enum RunState { AwaitingInput,
  44. PreRun,
  45. PlayerTurn,
  46. MonsterTurn,
  47. ShowInventory,
  48. ShowDropItem,
  49. ShowTargeting { range : i32, item : Entity},
  50. MainMenu { menu_selection : gui::MainMenuSelection },
  51. SaveGame,
  52. NextLevel,
  53. ShowRemoveItem,
  54. GameOver,
  55. MagicMapReveal { row : i32 }
  56. }
  57. pub struct State {
  58. pub ecs: World
  59. }
  60. impl State {
  61. fn run_systems(&mut self) {
  62. let mut mapindex = MapIndexingSystem{};
  63. mapindex.run_now(&self.ecs);
  64. let mut vis = VisibilitySystem{};
  65. vis.run_now(&self.ecs);
  66. let mut mob = MonsterAI{};
  67. mob.run_now(&self.ecs);
  68. let mut triggers = trigger_system::TriggerSystem{};
  69. triggers.run_now(&self.ecs);
  70. let mut melee = MeleeCombatSystem{};
  71. melee.run_now(&self.ecs);
  72. let mut damage = DamageSystem{};
  73. damage.run_now(&self.ecs);
  74. let mut pickup = ItemCollectionSystem{};
  75. pickup.run_now(&self.ecs);
  76. let mut itemuse = ItemUseSystem{};
  77. itemuse.run_now(&self.ecs);
  78. let mut drop_items = ItemDropSystem{};
  79. drop_items.run_now(&self.ecs);
  80. let mut item_remove = ItemRemoveSystem{};
  81. item_remove.run_now(&self.ecs);
  82. let mut hunger = hunger_system::HungerSystem{};
  83. hunger.run_now(&self.ecs);
  84. let mut particles = particle_system::ParticleSpawnSystem{};
  85. particles.run_now(&self.ecs);
  86. self.ecs.maintain();
  87. }
  88. }
  89. impl GameState for State {
  90. fn tick(&mut self, ctx : &mut Rltk) {
  91. let mut newrunstate;
  92. {
  93. let runstate = self.ecs.fetch::<RunState>();
  94. newrunstate = *runstate;
  95. }
  96. ctx.cls();
  97. particle_system::cull_dead_particles(&mut self.ecs, ctx);
  98. match newrunstate {
  99. RunState::MainMenu{..} => {}
  100. RunState::GameOver{..} => {}
  101. _ => {
  102. draw_map(&self.ecs, ctx);
  103. let positions = self.ecs.read_storage::<Position>();
  104. let renderables = self.ecs.read_storage::<Renderable>();
  105. let hidden = self.ecs.read_storage::<Hidden>();
  106. let map = self.ecs.fetch::<Map>();
  107. let mut data = (&positions, &renderables, !&hidden).join().collect::<Vec<_>>();
  108. data.sort_by(|&a, &b| b.1.render_order.cmp(&a.1.render_order) );
  109. for (pos, render, _hidden) in data.iter() {
  110. let idx = map.xy_idx(pos.x, pos.y);
  111. if map.visible_tiles[idx] { ctx.set(pos.x, pos.y, render.fg, render.bg, render.glyph) }
  112. }
  113. gui::draw_ui(&self.ecs, ctx);
  114. }
  115. }
  116. match newrunstate {
  117. RunState::PreRun => {
  118. self.run_systems();
  119. self.ecs.maintain();
  120. newrunstate = RunState::AwaitingInput;
  121. }
  122. RunState::AwaitingInput => {
  123. newrunstate = player_input(self, ctx);
  124. }
  125. RunState::PlayerTurn => {
  126. self.run_systems();
  127. self.ecs.maintain();
  128. match *self.ecs.fetch::<RunState>() {
  129. RunState::MagicMapReveal{ .. } => newrunstate = RunState::MagicMapReveal{ row: 0 },
  130. _ => newrunstate = RunState::MonsterTurn
  131. }
  132. }
  133. RunState::MonsterTurn => {
  134. self.run_systems();
  135. self.ecs.maintain();
  136. newrunstate = RunState::AwaitingInput;
  137. }
  138. RunState::ShowInventory => {
  139. let result = gui::show_inventory(self, ctx);
  140. match result.0 {
  141. gui::ItemMenuResult::Cancel => newrunstate = RunState::AwaitingInput,
  142. gui::ItemMenuResult::NoResponse => {}
  143. gui::ItemMenuResult::Selected => {
  144. let item_entity = result.1.unwrap();
  145. let is_ranged = self.ecs.read_storage::<Ranged>();
  146. let is_item_ranged = is_ranged.get(item_entity);
  147. if let Some(is_item_ranged) = is_item_ranged {
  148. newrunstate = RunState::ShowTargeting{ range: is_item_ranged.range, item: item_entity };
  149. } else {
  150. let mut intent = self.ecs.write_storage::<WantsToUseItem>();
  151. intent.insert(*self.ecs.fetch::<Entity>(), WantsToUseItem{ item: item_entity, target: None }).expect("Unable to insert intent");
  152. newrunstate = RunState::PlayerTurn;
  153. }
  154. }
  155. }
  156. }
  157. RunState::ShowDropItem => {
  158. let result = gui::drop_item_menu(self, ctx);
  159. match result.0 {
  160. gui::ItemMenuResult::Cancel => newrunstate = RunState::AwaitingInput,
  161. gui::ItemMenuResult::NoResponse => {}
  162. gui::ItemMenuResult::Selected => {
  163. let item_entity = result.1.unwrap();
  164. let mut intent = self.ecs.write_storage::<WantsToDropItem>();
  165. intent.insert(*self.ecs.fetch::<Entity>(), WantsToDropItem{ item: item_entity }).expect("Unable to insert intent");
  166. newrunstate = RunState::PlayerTurn;
  167. }
  168. }
  169. }
  170. RunState::ShowRemoveItem => {
  171. let result = gui::remove_item_menu(self, ctx);
  172. match result.0 {
  173. gui::ItemMenuResult::Cancel => newrunstate = RunState::AwaitingInput,
  174. gui::ItemMenuResult::NoResponse => {}
  175. gui::ItemMenuResult::Selected => {
  176. let item_entity = result.1.unwrap();
  177. let mut intent = self.ecs.write_storage::<WantsToRemoveItem>();
  178. intent.insert(*self.ecs.fetch::<Entity>(), WantsToRemoveItem{ item: item_entity }).expect("Unable to insert intent");
  179. newrunstate = RunState::PlayerTurn;
  180. }
  181. }
  182. }
  183. RunState::ShowTargeting{range, item} => {
  184. let result = gui::ranged_target(self, ctx, range);
  185. match result.0 {
  186. gui::ItemMenuResult::Cancel => newrunstate = RunState::AwaitingInput,
  187. gui::ItemMenuResult::NoResponse => {}
  188. gui::ItemMenuResult::Selected => {
  189. let mut intent = self.ecs.write_storage::<WantsToUseItem>();
  190. intent.insert(*self.ecs.fetch::<Entity>(), WantsToUseItem{ item, target: result.1 }).expect("Unable to insert intent");
  191. newrunstate = RunState::PlayerTurn;
  192. }
  193. }
  194. }
  195. RunState::MainMenu{ .. } => {
  196. let result = gui::main_menu(self, ctx);
  197. match result {
  198. gui::MainMenuResult::NoSelection{ selected } => newrunstate = RunState::MainMenu{ menu_selection: selected },
  199. gui::MainMenuResult::Selected{ selected } => {
  200. match selected {
  201. gui::MainMenuSelection::NewGame => newrunstate = RunState::PreRun,
  202. gui::MainMenuSelection::LoadGame => {
  203. saveload_system::load_game(&mut self.ecs);
  204. newrunstate = RunState::AwaitingInput;
  205. saveload_system::delete_save();
  206. }
  207. gui::MainMenuSelection::Quit => { ::std::process::exit(0); }
  208. }
  209. }
  210. }
  211. }
  212. RunState::GameOver => {
  213. let result = gui::game_over(ctx);
  214. match result {
  215. gui::GameOverResult::NoSelection => {}
  216. gui::GameOverResult::QuitToMenu => {
  217. self.game_over_cleanup();
  218. newrunstate = RunState::MainMenu{ menu_selection: gui::MainMenuSelection::NewGame };
  219. }
  220. }
  221. }
  222. RunState::SaveGame => {
  223. saveload_system::save_game(&mut self.ecs);
  224. newrunstate = RunState::MainMenu{ menu_selection : gui::MainMenuSelection::LoadGame };
  225. }
  226. RunState::NextLevel => {
  227. self.goto_next_level();
  228. newrunstate = RunState::PreRun;
  229. }
  230. RunState::MagicMapReveal{row} => {
  231. let mut map = self.ecs.fetch_mut::<Map>();
  232. for x in 0..MAPWIDTH {
  233. let idx = map.xy_idx(x as i32,row);
  234. map.revealed_tiles[idx] = true;
  235. }
  236. if row as usize == MAPHEIGHT-1 {
  237. newrunstate = RunState::MonsterTurn;
  238. } else {
  239. newrunstate = RunState::MagicMapReveal{ row: row+1 };
  240. }
  241. }
  242. }
  243. {
  244. let mut runwriter = self.ecs.write_resource::<RunState>();
  245. *runwriter = newrunstate;
  246. }
  247. damage_system::delete_the_dead(&mut self.ecs);
  248. }
  249. }
  250. impl State {
  251. fn entities_to_remove_on_level_change(&mut self) -> Vec<Entity> {
  252. let entities = self.ecs.entities();
  253. let player = self.ecs.read_storage::<Player>();
  254. let backpack = self.ecs.read_storage::<InBackpack>();
  255. let player_entity = self.ecs.fetch::<Entity>();
  256. let equipped = self.ecs.read_storage::<Equipped>();
  257. let mut to_delete : Vec<Entity> = Vec::new();
  258. for entity in entities.join() {
  259. let mut should_delete = true;
  260. // Don't delete the player
  261. let p = player.get(entity);
  262. if let Some(_p) = p {
  263. should_delete = false;
  264. }
  265. // Don't delete the player's equipment
  266. let bp = backpack.get(entity);
  267. if let Some(bp) = bp {
  268. if bp.owner == *player_entity {
  269. should_delete = false;
  270. }
  271. }
  272. let eq = equipped.get(entity);
  273. if let Some(eq) = eq {
  274. if eq.owner == *player_entity {
  275. should_delete = false;
  276. }
  277. }
  278. if should_delete {
  279. to_delete.push(entity);
  280. }
  281. }
  282. to_delete
  283. }
  284. fn goto_next_level(&mut self) {
  285. // Delete entities that aren't the player or his/her equipment
  286. let to_delete = self.entities_to_remove_on_level_change();
  287. for target in to_delete {
  288. self.ecs.delete_entity(target).expect("Unable to delete entity");
  289. }
  290. // Build a new map and place the player
  291. let current_depth;
  292. {
  293. let worldmap_resource = self.ecs.fetch::<Map>();
  294. current_depth = worldmap_resource.depth;
  295. }
  296. self.generate_world_map(current_depth + 1);
  297. // Notify the player and give them some health
  298. let player_entity = self.ecs.fetch::<Entity>();
  299. let mut gamelog = self.ecs.fetch_mut::<gamelog::GameLog>();
  300. gamelog.entries.insert(0, "You descend to the next level, and take a moment to heal.".to_string());
  301. let mut player_health_store = self.ecs.write_storage::<CombatStats>();
  302. let player_health = player_health_store.get_mut(*player_entity);
  303. if let Some(player_health) = player_health {
  304. player_health.hp = i32::max(player_health.hp, player_health.max_hp / 2);
  305. }
  306. }
  307. fn game_over_cleanup(&mut self) {
  308. // Delete everything
  309. let mut to_delete = Vec::new();
  310. for e in self.ecs.entities().join() {
  311. to_delete.push(e);
  312. }
  313. for del in to_delete.iter() {
  314. self.ecs.delete_entity(*del).expect("Deletion failed");
  315. }
  316. // Spawn a new player
  317. {
  318. let player_entity = spawner::player(&mut self.ecs, 0, 0);
  319. let mut player_entity_writer = self.ecs.write_resource::<Entity>();
  320. *player_entity_writer = player_entity;
  321. }
  322. // Build a new map and place the player
  323. self.generate_world_map(1);
  324. }
  325. fn generate_world_map(&mut self, new_depth : i32) {
  326. let mut builder = map_builders::random_builder(new_depth);
  327. builder.build_map();
  328. let player_start;
  329. {
  330. let mut worldmap_resource = self.ecs.write_resource::<Map>();
  331. *worldmap_resource = builder.get_map();
  332. player_start = builder.get_starting_position();
  333. }
  334. // Spawn bad guys
  335. builder.spawn_entities(&mut self.ecs);
  336. // Place the player and update resources
  337. let (player_x, player_y) = (player_start.x, player_start.y);
  338. let mut player_position = self.ecs.write_resource::<Point>();
  339. *player_position = Point::new(player_x, player_y);
  340. let mut position_components = self.ecs.write_storage::<Position>();
  341. let player_entity = self.ecs.fetch::<Entity>();
  342. let player_pos_comp = position_components.get_mut(*player_entity);
  343. if let Some(player_pos_comp) = player_pos_comp {
  344. player_pos_comp.x = player_x;
  345. player_pos_comp.y = player_y;
  346. }
  347. // Mark the player's visibility as dirty
  348. let mut viewshed_components = self.ecs.write_storage::<Viewshed>();
  349. let vs = viewshed_components.get_mut(*player_entity);
  350. if let Some(vs) = vs {
  351. vs.dirty = true;
  352. }
  353. }
  354. }
  355. fn main() {
  356. let mut context = Rltk::init_simple8x8(80, 50, "Hello Rust World", "resources");
  357. context.with_post_scanlines(true);
  358. let mut gs = State {
  359. ecs: World::new()
  360. };
  361. gs.ecs.register::<Position>();
  362. gs.ecs.register::<Renderable>();
  363. gs.ecs.register::<Player>();
  364. gs.ecs.register::<Viewshed>();
  365. gs.ecs.register::<Monster>();
  366. gs.ecs.register::<Name>();
  367. gs.ecs.register::<BlocksTile>();
  368. gs.ecs.register::<CombatStats>();
  369. gs.ecs.register::<WantsToMelee>();
  370. gs.ecs.register::<SufferDamage>();
  371. gs.ecs.register::<Item>();
  372. gs.ecs.register::<ProvidesHealing>();
  373. gs.ecs.register::<InflictsDamage>();
  374. gs.ecs.register::<AreaOfEffect>();
  375. gs.ecs.register::<Consumable>();
  376. gs.ecs.register::<Ranged>();
  377. gs.ecs.register::<InBackpack>();
  378. gs.ecs.register::<WantsToPickupItem>();
  379. gs.ecs.register::<WantsToUseItem>();
  380. gs.ecs.register::<WantsToDropItem>();
  381. gs.ecs.register::<Confusion>();
  382. gs.ecs.register::<SimpleMarker<SerializeMe>>();
  383. gs.ecs.register::<SerializationHelper>();
  384. gs.ecs.register::<Equippable>();
  385. gs.ecs.register::<Equipped>();
  386. gs.ecs.register::<MeleePowerBonus>();
  387. gs.ecs.register::<DefenseBonus>();
  388. gs.ecs.register::<WantsToRemoveItem>();
  389. gs.ecs.register::<ParticleLifetime>();
  390. gs.ecs.register::<HungerClock>();
  391. gs.ecs.register::<ProvidesFood>();
  392. gs.ecs.register::<MagicMapper>();
  393. gs.ecs.register::<Hidden>();
  394. gs.ecs.register::<EntryTrigger>();
  395. gs.ecs.register::<EntityMoved>();
  396. gs.ecs.register::<SingleActivation>();
  397. gs.ecs.insert(SimpleMarkerAllocator::<SerializeMe>::new());
  398. gs.ecs.insert(Map::new(1));
  399. gs.ecs.insert(Point::new(0, 0));
  400. gs.ecs.insert(rltk::RandomNumberGenerator::new());
  401. let player_entity = spawner::player(&mut gs.ecs, 0, 0);
  402. gs.ecs.insert(player_entity);
  403. gs.ecs.insert(RunState::MainMenu{ menu_selection: gui::MainMenuSelection::NewGame });
  404. gs.ecs.insert(gamelog::GameLog{ entries : vec!["Welcome to Rusty Roguelike".to_string()] });
  405. gs.ecs.insert(particle_system::ParticleBuilder::new());
  406. gs.ecs.insert(rex_assets::RexAssets::new());
  407. gs.generate_world_map(1);
  408. rltk::main_loop(context, gs);
  409. }