632 lines
24 KiB
Rust
632 lines
24 KiB
Rust
use rltk::{GameState, Point, RandomNumberGenerator, Rltk};
|
|
use specs::prelude::*;
|
|
use specs::saveload::{SimpleMarker, SimpleMarkerAllocator};
|
|
extern crate serde;
|
|
|
|
pub mod camera;
|
|
mod components;
|
|
pub mod raws;
|
|
pub use components::*;
|
|
mod map;
|
|
pub use map::*;
|
|
mod player;
|
|
use player::*;
|
|
mod rect;
|
|
pub use rect::Rect;
|
|
mod gamelog;
|
|
mod gui;
|
|
pub mod map_builders;
|
|
mod saveload_system;
|
|
mod spawner;
|
|
mod visibility_system;
|
|
use visibility_system::VisibilitySystem;
|
|
mod monster_ai_system;
|
|
use monster_ai_system::MonsterAI;
|
|
pub mod bystander_ai_system;
|
|
mod map_indexing_system;
|
|
use map_indexing_system::MapIndexingSystem;
|
|
mod damage_system;
|
|
use damage_system::*;
|
|
mod hunger_system;
|
|
mod melee_combat_system;
|
|
mod trigger_system;
|
|
use melee_combat_system::MeleeCombatSystem;
|
|
mod inventory_system;
|
|
use inventory_system::*;
|
|
mod particle_system;
|
|
use particle_system::{ParticleBuilder, DEFAULT_PARTICLE_LIFETIME, LONG_PARTICLE_LIFETIME};
|
|
mod ai;
|
|
mod gamesystem;
|
|
mod random_table;
|
|
mod rex_assets;
|
|
|
|
#[macro_use]
|
|
extern crate lazy_static;
|
|
|
|
//Consts
|
|
pub const SHOW_MAPGEN: bool = false;
|
|
pub const LOG_SPAWNING: bool = true;
|
|
pub const LOG_TICKS: bool = false;
|
|
|
|
#[derive(PartialEq, Copy, Clone)]
|
|
pub enum RunState {
|
|
AwaitingInput,
|
|
PreRun,
|
|
Ticking,
|
|
ShowInventory,
|
|
ShowDropItem,
|
|
ShowRemoveItem,
|
|
ShowTargeting { range: i32, item: Entity, aoe: i32 },
|
|
ActionWithDirection { function: fn(i: i32, j: i32, ecs: &mut World) -> RunState },
|
|
MainMenu { menu_selection: gui::MainMenuSelection },
|
|
SaveGame,
|
|
GameOver,
|
|
NextLevel,
|
|
HelpScreen,
|
|
MagicMapReveal { row: i32, cursed: bool },
|
|
MapGeneration,
|
|
}
|
|
|
|
pub struct State {
|
|
pub ecs: World,
|
|
mapgen_next_state: Option<RunState>,
|
|
mapgen_history: Vec<Map>,
|
|
mapgen_index: usize,
|
|
mapgen_timer: f32,
|
|
}
|
|
|
|
impl State {
|
|
fn generate_world_map(&mut self, new_id: i32) {
|
|
// Visualisation stuff
|
|
self.mapgen_index = 0;
|
|
self.mapgen_timer = 0.0;
|
|
self.mapgen_history.clear();
|
|
let mut rng = self.ecs.write_resource::<rltk::RandomNumberGenerator>();
|
|
let mut player_level = 1;
|
|
{
|
|
let player = self.ecs.read_storage::<Player>();
|
|
let pools = self.ecs.read_storage::<Pools>();
|
|
for (_p, pool) in (&player, &pools).join() {
|
|
player_level = pool.level;
|
|
}
|
|
}
|
|
let mut builder = map_builders::level_builder(new_id, &mut rng, 100, 50, player_level);
|
|
builder.build_map(&mut rng);
|
|
std::mem::drop(rng);
|
|
self.mapgen_history = builder.build_data.history.clone();
|
|
let player_start;
|
|
{
|
|
let mut worldmap_resource = self.ecs.write_resource::<Map>();
|
|
*worldmap_resource = builder.build_data.map.clone();
|
|
// Unwrap so we get a CTD if there's no starting pos.
|
|
player_start = builder.build_data.starting_position.as_mut().unwrap().clone();
|
|
}
|
|
// Spawn entities
|
|
builder.spawn_entities(&mut self.ecs);
|
|
|
|
// Place player and update resources
|
|
let mut player_position = self.ecs.write_resource::<Point>();
|
|
*player_position = Point::new(player_start.x, player_start.y);
|
|
let mut position_components = self.ecs.write_storage::<Position>();
|
|
let player_entity = self.ecs.fetch::<Entity>();
|
|
let player_pos_component = position_components.get_mut(*player_entity);
|
|
if let Some(player_pos_component) = player_pos_component {
|
|
player_pos_component.x = player_start.x;
|
|
player_pos_component.y = player_start.y;
|
|
}
|
|
|
|
// Mark viewshed as dirty (force refresh)
|
|
let mut viewshed_components = self.ecs.write_storage::<Viewshed>();
|
|
let mut telepath_components = self.ecs.write_storage::<Telepath>();
|
|
let vision_vs = viewshed_components.get_mut(*player_entity);
|
|
let telepath_vs = telepath_components.get_mut(*player_entity);
|
|
if let Some(vs) = vision_vs {
|
|
vs.dirty = true;
|
|
}
|
|
if let Some(vs) = telepath_vs {
|
|
vs.dirty = true;
|
|
}
|
|
}
|
|
|
|
fn run_systems(&mut self) {
|
|
let mut mapindex = MapIndexingSystem {};
|
|
let mut vis = VisibilitySystem {};
|
|
let mut regen_system = ai::RegenSystem {};
|
|
let mut energy = ai::EnergySystem {};
|
|
let mut turn_status_system = ai::TurnStatusSystem {};
|
|
let mut quip_system = ai::QuipSystem {};
|
|
let mut mob = MonsterAI {};
|
|
let mut bystanders = bystander_ai_system::BystanderAI {};
|
|
let mut trigger_system = trigger_system::TriggerSystem {};
|
|
let mut melee_system = MeleeCombatSystem {};
|
|
let mut damage_system = DamageSystem {};
|
|
let mut inventory_system = ItemCollectionSystem {};
|
|
let mut item_use_system = ItemUseSystem {};
|
|
let mut item_drop_system = ItemDropSystem {};
|
|
let mut item_remove_system = ItemRemoveSystem {};
|
|
let mut hunger_clock = hunger_system::HungerSystem {};
|
|
let mut particle_system = particle_system::ParticleSpawnSystem {};
|
|
|
|
mapindex.run_now(&self.ecs);
|
|
vis.run_now(&self.ecs);
|
|
regen_system.run_now(&self.ecs);
|
|
energy.run_now(&self.ecs);
|
|
turn_status_system.run_now(&self.ecs);
|
|
quip_system.run_now(&self.ecs);
|
|
mob.run_now(&self.ecs);
|
|
bystanders.run_now(&self.ecs);
|
|
trigger_system.run_now(&self.ecs);
|
|
inventory_system.run_now(&self.ecs);
|
|
item_use_system.run_now(&self.ecs);
|
|
item_drop_system.run_now(&self.ecs);
|
|
item_remove_system.run_now(&self.ecs);
|
|
melee_system.run_now(&self.ecs);
|
|
damage_system.run_now(&self.ecs);
|
|
hunger_clock.run_now(&self.ecs);
|
|
particle_system.run_now(&self.ecs);
|
|
|
|
self.ecs.maintain();
|
|
}
|
|
|
|
fn run_map_index(&mut self) {
|
|
let mut mapindex = MapIndexingSystem {};
|
|
mapindex.run_now(&self.ecs);
|
|
}
|
|
|
|
fn entities_to_remove_on_level_change(&mut self) -> Vec<Entity> {
|
|
let entities = self.ecs.entities();
|
|
let player = self.ecs.read_storage::<Player>();
|
|
let clock = self.ecs.read_storage::<Clock>();
|
|
let backpack = self.ecs.read_storage::<InBackpack>();
|
|
let player_entity = self.ecs.fetch::<Entity>();
|
|
let equipped = self.ecs.read_storage::<Equipped>();
|
|
|
|
let mut to_delete: Vec<Entity> = Vec::new();
|
|
for entity in entities.join() {
|
|
let mut should_delete = true;
|
|
|
|
// Don't delete the turn clock
|
|
let c = clock.get(entity);
|
|
if let Some(_c) = c {
|
|
should_delete = false;
|
|
}
|
|
|
|
// Don't delete player
|
|
let p = player.get(entity);
|
|
if let Some(_p) = p {
|
|
should_delete = false;
|
|
}
|
|
|
|
// Don't delete player's equipment
|
|
let bp = backpack.get(entity);
|
|
if let Some(bp) = bp {
|
|
if bp.owner == *player_entity {
|
|
should_delete = false;
|
|
}
|
|
}
|
|
let eq = equipped.get(entity);
|
|
if let Some(eq) = eq {
|
|
if eq.owner == *player_entity {
|
|
should_delete = false;
|
|
}
|
|
}
|
|
|
|
if should_delete {
|
|
to_delete.push(entity);
|
|
}
|
|
}
|
|
|
|
return to_delete;
|
|
}
|
|
|
|
fn goto_next_level(&mut self) {
|
|
// Delete entities that aren't player/player's equipment
|
|
let to_delete = self.entities_to_remove_on_level_change();
|
|
for target in to_delete {
|
|
self.ecs.delete_entity(target).expect("Unable to delete entity");
|
|
}
|
|
|
|
// Build new map + place player
|
|
let current_id;
|
|
{
|
|
let worldmap_resource = self.ecs.fetch::<Map>();
|
|
current_id = worldmap_resource.id;
|
|
}
|
|
gamelog::record_event("descended", 1);
|
|
self.generate_world_map(current_id + 1);
|
|
|
|
// Notify player, restore health up to a point.
|
|
let player_entity = self.ecs.fetch::<Entity>();
|
|
gamelog::Logger::new()
|
|
.append("Taking a short rest, you manage to")
|
|
.colour((0, 255, 0))
|
|
.append_n("recover some of your strength")
|
|
.period()
|
|
.log();
|
|
let mut pools = self.ecs.write_storage::<Pools>();
|
|
let stats = pools.get_mut(*player_entity);
|
|
if let Some(stats) = stats {
|
|
stats.hit_points.current = i32::max(stats.hit_points.current, stats.hit_points.max / 2);
|
|
}
|
|
}
|
|
|
|
fn game_over_cleanup(&mut self) {
|
|
// Delete everything
|
|
let mut to_delete = Vec::new();
|
|
for e in self.ecs.entities().join() {
|
|
to_delete.push(e);
|
|
}
|
|
for del in to_delete.iter() {
|
|
self.ecs.delete_entity(*del).expect("Deletion failed");
|
|
}
|
|
|
|
// Spawn a new player and build new map
|
|
{
|
|
let player_entity = spawner::player(&mut self.ecs, 0, 0);
|
|
let mut player_entity_writer = self.ecs.write_resource::<Entity>();
|
|
*player_entity_writer = player_entity;
|
|
}
|
|
self.generate_world_map(1);
|
|
|
|
gamelog::setup_log();
|
|
gamelog::record_event("player_level", 1);
|
|
}
|
|
}
|
|
|
|
impl GameState for State {
|
|
fn tick(&mut self, ctx: &mut Rltk) {
|
|
let mut new_runstate;
|
|
{
|
|
let runstate = self.ecs.fetch::<RunState>();
|
|
new_runstate = *runstate;
|
|
}
|
|
// Clear screen
|
|
ctx.cls();
|
|
particle_system::particle_ticker(&mut self.ecs, ctx);
|
|
|
|
match new_runstate {
|
|
RunState::MainMenu { .. } => {}
|
|
_ => {
|
|
// Draw map and ui
|
|
camera::render_camera(&self.ecs, ctx);
|
|
gui::draw_ui(&self.ecs, ctx);
|
|
}
|
|
}
|
|
|
|
match new_runstate {
|
|
RunState::PreRun => {
|
|
self.run_systems();
|
|
self.ecs.maintain();
|
|
new_runstate = RunState::AwaitingInput;
|
|
}
|
|
RunState::AwaitingInput => {
|
|
self.run_map_index();
|
|
// Sanity-checking that the player actually *should*
|
|
// be taking a turn before giving them one. If they
|
|
// don't have a turn component, go back to ticking.
|
|
let mut can_act = false;
|
|
{
|
|
let player_entity = self.ecs.fetch::<Entity>();
|
|
let turns = self.ecs.read_storage::<TakingTurn>();
|
|
if let Some(_) = turns.get(*player_entity) {
|
|
can_act = true;
|
|
}
|
|
}
|
|
if can_act {
|
|
new_runstate = player_input(self, ctx);
|
|
} else {
|
|
new_runstate = RunState::Ticking;
|
|
}
|
|
}
|
|
RunState::Ticking => {
|
|
while new_runstate == RunState::Ticking {
|
|
self.run_systems();
|
|
self.ecs.maintain();
|
|
try_spawn_interval(&mut self.ecs);
|
|
match *self.ecs.fetch::<RunState>() {
|
|
RunState::AwaitingInput => new_runstate = RunState::AwaitingInput,
|
|
RunState::MagicMapReveal { row, cursed } => {
|
|
new_runstate = RunState::MagicMapReveal { row: row, cursed: cursed }
|
|
}
|
|
_ => new_runstate = RunState::Ticking,
|
|
}
|
|
}
|
|
}
|
|
RunState::ShowInventory => {
|
|
let result = gui::show_inventory(self, ctx);
|
|
match result.0 {
|
|
gui::ItemMenuResult::Cancel => new_runstate = RunState::AwaitingInput,
|
|
gui::ItemMenuResult::NoResponse => {}
|
|
gui::ItemMenuResult::Selected => {
|
|
let item_entity = result.1.unwrap();
|
|
let is_ranged = self.ecs.read_storage::<Ranged>();
|
|
let ranged_item = is_ranged.get(item_entity);
|
|
if let Some(ranged_item) = ranged_item {
|
|
let is_aoe = self.ecs.read_storage::<AOE>();
|
|
let aoe_item = is_aoe.get(item_entity);
|
|
if let Some(aoe_item) = aoe_item {
|
|
new_runstate = RunState::ShowTargeting {
|
|
range: ranged_item.range,
|
|
item: item_entity,
|
|
aoe: aoe_item.radius,
|
|
}
|
|
} else {
|
|
new_runstate =
|
|
RunState::ShowTargeting { range: ranged_item.range, item: item_entity, aoe: 0 }
|
|
}
|
|
} else {
|
|
let mut intent = self.ecs.write_storage::<WantsToUseItem>();
|
|
intent
|
|
.insert(*self.ecs.fetch::<Entity>(), WantsToUseItem { item: item_entity, target: None })
|
|
.expect("Unable to insert intent.");
|
|
new_runstate = RunState::Ticking;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
RunState::ShowDropItem => {
|
|
let result = gui::drop_item_menu(self, ctx);
|
|
match result.0 {
|
|
gui::ItemMenuResult::Cancel => new_runstate = RunState::AwaitingInput,
|
|
gui::ItemMenuResult::NoResponse => {}
|
|
gui::ItemMenuResult::Selected => {
|
|
let item_entity = result.1.unwrap();
|
|
let mut intent = self.ecs.write_storage::<WantsToDropItem>();
|
|
intent
|
|
.insert(*self.ecs.fetch::<Entity>(), WantsToDropItem { item: item_entity })
|
|
.expect("Unable to insert intent");
|
|
new_runstate = RunState::Ticking;
|
|
}
|
|
}
|
|
}
|
|
RunState::ShowRemoveItem => {
|
|
let result = gui::remove_item_menu(self, ctx);
|
|
match result.0 {
|
|
gui::ItemMenuResult::Cancel => new_runstate = RunState::AwaitingInput,
|
|
gui::ItemMenuResult::NoResponse => {}
|
|
gui::ItemMenuResult::Selected => {
|
|
let item_entity = result.1.unwrap();
|
|
let mut intent = self.ecs.write_storage::<WantsToRemoveItem>();
|
|
intent
|
|
.insert(*self.ecs.fetch::<Entity>(), WantsToRemoveItem { item: item_entity })
|
|
.expect("Unable to insert intent");
|
|
new_runstate = RunState::Ticking;
|
|
}
|
|
}
|
|
}
|
|
RunState::ShowTargeting { range, item, aoe } => {
|
|
let result = gui::ranged_target(self, ctx, range, aoe);
|
|
match result.0 {
|
|
gui::ItemMenuResult::Cancel => new_runstate = RunState::AwaitingInput,
|
|
gui::ItemMenuResult::NoResponse => {}
|
|
gui::ItemMenuResult::Selected => {
|
|
let mut intent = self.ecs.write_storage::<WantsToUseItem>();
|
|
intent
|
|
.insert(*self.ecs.fetch::<Entity>(), WantsToUseItem { item, target: result.1 })
|
|
.expect("Unable to insert intent.");
|
|
new_runstate = RunState::Ticking;
|
|
}
|
|
}
|
|
}
|
|
RunState::ActionWithDirection { function } => {
|
|
new_runstate = gui::get_input_direction(&mut self.ecs, ctx, function);
|
|
}
|
|
RunState::MainMenu { .. } => {
|
|
let result = gui::main_menu(self, ctx);
|
|
match result {
|
|
gui::MainMenuResult::NoSelection { selected } => {
|
|
new_runstate = RunState::MainMenu { menu_selection: selected }
|
|
}
|
|
gui::MainMenuResult::Selected { selected } => match selected {
|
|
gui::MainMenuSelection::NewGame => new_runstate = RunState::PreRun,
|
|
gui::MainMenuSelection::LoadGame => {
|
|
saveload_system::load_game(&mut self.ecs);
|
|
new_runstate = RunState::AwaitingInput;
|
|
saveload_system::delete_save();
|
|
}
|
|
gui::MainMenuSelection::Quit => {
|
|
::std::process::exit(0);
|
|
}
|
|
},
|
|
}
|
|
}
|
|
RunState::SaveGame => {
|
|
saveload_system::save_game(&mut self.ecs);
|
|
new_runstate = RunState::MainMenu { menu_selection: gui::MainMenuSelection::LoadGame };
|
|
}
|
|
RunState::GameOver => {
|
|
let result = gui::game_over(ctx);
|
|
match result {
|
|
gui::YesNoResult::NoSelection => {}
|
|
gui::YesNoResult::Yes => {
|
|
self.game_over_cleanup();
|
|
new_runstate = RunState::MapGeneration;
|
|
self.mapgen_next_state =
|
|
Some(RunState::MainMenu { menu_selection: gui::MainMenuSelection::NewGame });
|
|
}
|
|
}
|
|
}
|
|
RunState::NextLevel => {
|
|
self.goto_next_level();
|
|
self.mapgen_next_state = Some(RunState::PreRun);
|
|
new_runstate = RunState::MapGeneration;
|
|
}
|
|
RunState::HelpScreen => {
|
|
let result = gui::show_help(ctx);
|
|
match result {
|
|
gui::YesNoResult::NoSelection => {}
|
|
gui::YesNoResult::Yes => {
|
|
gamelog::record_event("looked_for_help", 1);
|
|
new_runstate = RunState::AwaitingInput;
|
|
}
|
|
}
|
|
}
|
|
RunState::MagicMapReveal { row, cursed } => {
|
|
let mut map = self.ecs.fetch_mut::<Map>();
|
|
|
|
// Could probably toss this into a function somewhere, and/or
|
|
// have multiple simple animations for it.
|
|
for x in 0..map.width {
|
|
let idx;
|
|
if x % 2 == 0 {
|
|
idx = map.xy_idx(x as i32, row);
|
|
} else {
|
|
idx = map.xy_idx(x as i32, (map.height as i32 - 1) - (row));
|
|
}
|
|
if !cursed {
|
|
map.revealed_tiles[idx] = true;
|
|
} else {
|
|
map.revealed_tiles[idx] = false;
|
|
}
|
|
}
|
|
|
|
// Dirtify viewshed only if cursed, so our currently visible tiles aren't removed too
|
|
if cursed {
|
|
let player_entity = self.ecs.fetch::<Entity>();
|
|
let mut viewshed_components = self.ecs.write_storage::<Viewshed>();
|
|
let viewshed = viewshed_components.get_mut(*player_entity);
|
|
if let Some(viewshed) = viewshed {
|
|
viewshed.dirty = true;
|
|
}
|
|
}
|
|
|
|
if row as usize == map.height as usize - 1 {
|
|
new_runstate = RunState::Ticking;
|
|
} else {
|
|
new_runstate = RunState::MagicMapReveal { row: row + 1, cursed: cursed };
|
|
}
|
|
}
|
|
RunState::MapGeneration => {
|
|
if !SHOW_MAPGEN {
|
|
new_runstate = self.mapgen_next_state.unwrap();
|
|
}
|
|
if self.mapgen_history.len() != 0 {
|
|
ctx.cls();
|
|
camera::render_debug_map(&self.mapgen_history[self.mapgen_index], ctx);
|
|
|
|
self.mapgen_timer += ctx.frame_time_ms;
|
|
if self.mapgen_timer > 300.0 {
|
|
self.mapgen_timer = 0.0;
|
|
self.mapgen_index += 1;
|
|
if self.mapgen_index >= self.mapgen_history.len() {
|
|
new_runstate = self.mapgen_next_state.unwrap();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
let mut runwriter = self.ecs.write_resource::<RunState>();
|
|
*runwriter = new_runstate;
|
|
}
|
|
|
|
damage_system::delete_the_dead(&mut self.ecs);
|
|
|
|
let _ = rltk::render_draw_buffer(ctx);
|
|
}
|
|
}
|
|
|
|
const DISPLAYWIDTH: i32 = 105;
|
|
const DISPLAYHEIGHT: i32 = 56;
|
|
|
|
fn main() -> rltk::BError {
|
|
// Embedded resources for use in wasm build
|
|
const CURSES_14_16_BYTES: &[u8] = include_bytes!("../resources/curses14x16.png");
|
|
rltk::embedding::EMBED.lock().add_resource("resources/curses14x16.png".to_string(), CURSES_14_16_BYTES);
|
|
|
|
//rltk::link_resource!(CURSES14X16, "../resources/curses_14x16.png");
|
|
|
|
use rltk::RltkBuilder;
|
|
let context = RltkBuilder::new()
|
|
.with_title("rust-rl")
|
|
.with_dimensions(DISPLAYWIDTH, DISPLAYHEIGHT)
|
|
.with_font("curses14x16.png", 14, 16)
|
|
.with_tile_dimensions(14, 16)
|
|
.with_simple_console(DISPLAYWIDTH, DISPLAYHEIGHT, "curses14x16.png")
|
|
//.with_simple_console_no_bg(DISPLAYWIDTH, DISPLAYHEIGHT, "terminal8x8.jpg")
|
|
.build()?;
|
|
|
|
let mut gs = State {
|
|
ecs: World::new(),
|
|
mapgen_next_state: Some(RunState::MainMenu { menu_selection: gui::MainMenuSelection::NewGame }),
|
|
mapgen_index: 0,
|
|
mapgen_history: Vec::new(),
|
|
mapgen_timer: 0.0,
|
|
};
|
|
|
|
gs.ecs.register::<Position>();
|
|
gs.ecs.register::<Renderable>();
|
|
gs.ecs.register::<Prop>();
|
|
gs.ecs.register::<Player>();
|
|
gs.ecs.register::<Clock>();
|
|
gs.ecs.register::<Monster>();
|
|
gs.ecs.register::<Bystander>();
|
|
gs.ecs.register::<Quips>();
|
|
gs.ecs.register::<Mind>();
|
|
gs.ecs.register::<Viewshed>();
|
|
gs.ecs.register::<Telepath>();
|
|
gs.ecs.register::<Name>();
|
|
gs.ecs.register::<BlocksTile>();
|
|
gs.ecs.register::<BlocksVisibility>();
|
|
gs.ecs.register::<Door>();
|
|
gs.ecs.register::<Pools>();
|
|
gs.ecs.register::<Attributes>();
|
|
gs.ecs.register::<Skills>();
|
|
gs.ecs.register::<HungerClock>();
|
|
gs.ecs.register::<WantsToMelee>();
|
|
gs.ecs.register::<SufferDamage>();
|
|
gs.ecs.register::<Item>();
|
|
gs.ecs.register::<GrantsXP>();
|
|
gs.ecs.register::<LootTable>();
|
|
gs.ecs.register::<Energy>();
|
|
gs.ecs.register::<TakingTurn>();
|
|
gs.ecs.register::<Equippable>();
|
|
gs.ecs.register::<Equipped>();
|
|
gs.ecs.register::<MeleeWeapon>();
|
|
gs.ecs.register::<NaturalAttacks>();
|
|
gs.ecs.register::<ArmourClassBonus>();
|
|
gs.ecs.register::<Cursed>();
|
|
gs.ecs.register::<ProvidesHealing>();
|
|
gs.ecs.register::<InflictsDamage>();
|
|
gs.ecs.register::<Ranged>();
|
|
gs.ecs.register::<AOE>();
|
|
gs.ecs.register::<Digger>();
|
|
gs.ecs.register::<Confusion>();
|
|
gs.ecs.register::<MagicMapper>();
|
|
gs.ecs.register::<InBackpack>();
|
|
gs.ecs.register::<WantsToPickupItem>();
|
|
gs.ecs.register::<WantsToDropItem>();
|
|
gs.ecs.register::<WantsToRemoveItem>();
|
|
gs.ecs.register::<WantsToUseItem>();
|
|
gs.ecs.register::<Consumable>();
|
|
gs.ecs.register::<SingleActivation>();
|
|
gs.ecs.register::<Wand>();
|
|
gs.ecs.register::<ProvidesNutrition>();
|
|
gs.ecs.register::<Destructible>();
|
|
gs.ecs.register::<Hidden>();
|
|
gs.ecs.register::<EntryTrigger>();
|
|
gs.ecs.register::<EntityMoved>();
|
|
gs.ecs.register::<MultiAttack>();
|
|
gs.ecs.register::<ParticleLifetime>();
|
|
gs.ecs.register::<SimpleMarker<SerializeMe>>();
|
|
gs.ecs.register::<SerializationHelper>();
|
|
gs.ecs.insert(SimpleMarkerAllocator::<SerializeMe>::new());
|
|
|
|
raws::load_raws();
|
|
|
|
gs.ecs.insert(rltk::RandomNumberGenerator::new());
|
|
gs.ecs.insert(Map::new(1, 64, 64, 0, "New Map")); // Map
|
|
gs.ecs.insert(Point::new(0, 0)); // Player pos
|
|
let player_entity = spawner::player(&mut gs.ecs, 0, 0);
|
|
gs.ecs.insert(player_entity); // Player entity
|
|
gs.ecs.insert(RunState::MapGeneration {}); // RunState
|
|
gs.ecs.insert(particle_system::ParticleBuilder::new());
|
|
gs.ecs.insert(rex_assets::RexAssets::new());
|
|
|
|
gamelog::setup_log();
|
|
gamelog::record_event("player_level", 1);
|
|
gs.generate_world_map(1);
|
|
|
|
rltk::main_loop(context, gs)
|
|
}
|