roguelike-game/src/spawner.rs

224 lines
6.2 KiB
Rust
Raw Normal View History

2022-02-01 15:41:08 -05:00
//! Spawns things
2021-12-10 20:16:48 -05:00
use std::collections::HashMap;
use ::rltk::{Point, RandomNumberGenerator};
2021-12-24 10:38:44 -05:00
use ::specs::prelude::*;
use ::specs::saveload::{MarkedBuilder, SimpleMarker};
2021-12-10 20:16:48 -05:00
use crate::components::*;
use crate::random_table::MasterTable;
2022-01-25 09:58:30 -05:00
use crate::raws::{
get_spawn_table_for_depth, spawn_all_spells, spawn_named_entity, SpawnType, RAWS,
};
use crate::{colors, Map, MasterDungeonMap, Rect, TileType};
/// Spawns the player and returns their entity object
pub fn player(ecs: &mut World, player_x: i32, player_y: i32) -> Entity {
2022-01-25 09:58:30 -05:00
spawn_all_spells(ecs);
2022-01-04 11:11:38 -05:00
let player = ecs
.create_entity()
.with(Position::from((player_x, player_y)))
.with(Renderable {
glyph: rltk::to_cp437('@'),
fg: colors::YELLOW,
bg: colors::BLACK,
2021-11-04 09:54:38 -04:00
render_order: 0,
})
.with(Player {})
2021-11-05 10:41:47 -04:00
.with(Viewshed::default())
.with(Name::from("Player"))
.with(HungerClock::default())
.with(Attributes::new(11))
.with(Skills::new(1))
.with(Pools::player_pools())
2022-01-25 11:15:32 -05:00
.with(EquipmentChanged {})
.with(LightSource::torch_light())
.with(Initiative::default())
2022-01-11 14:16:23 -05:00
.with(Faction::from("Player"))
.with(KnownSpells::default())
2021-11-08 13:58:40 -05:00
.marked::<SimpleMarker<SerializeMe>>()
2022-01-04 11:11:38 -05:00
.build();
// Starting equipment
let starting_equipment_carried = ["Dried Sausage", "Beer", "Shortbow"];
let starting_equipment_equipped = [
2022-01-04 11:11:38 -05:00
"Rusty Longsword",
"Stained Tunic",
"Torn Trousers",
"Old Boots",
];
for equipment in starting_equipment_carried.iter() {
spawn_named_entity(
&RAWS.lock().unwrap(),
ecs,
*equipment,
SpawnType::Carried { by: player },
);
}
for equipment in starting_equipment_equipped.iter() {
spawn_named_entity(
&RAWS.lock().unwrap(),
ecs,
*equipment,
SpawnType::Equipped { by: player },
);
}
2022-01-04 11:11:38 -05:00
// Starting hangover
ecs.create_entity()
.with(StatusEffect { target: player })
.with(Duration { turns: 10 })
.with(Name::from("Hangover"))
.with(AttributeBonus::hangover())
.marked::<SimpleMarker<SerializeMe>>()
.build();
2022-01-04 11:11:38 -05:00
player
}
const MAX_MONSTERS: i32 = 4;
fn room_table(map_depth: i32) -> MasterTable {
2021-12-23 13:07:50 -05:00
get_spawn_table_for_depth(&RAWS.lock().unwrap(), map_depth)
}
/// fills a room with stuff!
#[allow(clippy::map_entry)]
pub fn spawn_room(
map: &Map,
rng: &mut RandomNumberGenerator,
room: &Rect,
map_depth: i32,
spawn_list: &mut Vec<(usize, String)>,
) {
let mut possible_targets: Vec<usize> = Vec::new();
// Borrow scope - to keep access to the map separated
{
for y in room.y1 + 1..room.y2 {
for x in room.x1 + 1..room.x2 {
let idx = map.xy_idx(x, y);
if map.tiles[idx] == TileType::Floor {
possible_targets.push(idx);
}
}
}
}
spawn_region(map, rng, &possible_targets, map_depth, spawn_list);
}
pub fn spawn_region(
2021-12-14 14:15:22 -05:00
_map: &Map,
rng: &mut RandomNumberGenerator,
area: &[usize],
map_depth: i32,
spawn_list: &mut Vec<(usize, String)>,
) {
2021-11-12 14:12:15 -05:00
let spawn_table = room_table(map_depth);
let mut spawn_points: HashMap<usize, String> = HashMap::new();
let mut areas: Vec<usize> = Vec::from(area);
// Scope to keep the borrow checker happy
{
let num_spawns = i32::min(
areas.len() as i32,
rng.roll_dice(1, MAX_MONSTERS + 3) + (map_depth - 1) - 3,
);
if num_spawns == 0 {
return;
}
for _i in 0..num_spawns {
let array_index = if areas.len() == 1 {
0_usize
} else {
(rng.roll_dice(1, areas.len() as i32) - 1) as usize
};
let map_idx = areas[array_index];
spawn_points.insert(map_idx, spawn_table.roll(rng));
areas.remove(array_index);
}
}
// Actually spawn the monsters
for spawn in spawn_points.iter() {
spawn_list.push((*spawn.0, spawn.1.to_string()));
}
}
/// Spawns a named entity (name in tuple.1) at the location in (tuple.0)
2021-12-10 14:29:03 -05:00
pub fn spawn_entity(ecs: &mut World, spawn: &(&usize, &String)) {
2022-01-25 11:15:32 -05:00
let width: usize;
{
width = ecs.fetch::<Map>().width as usize;
}
let (idx, name) = *spawn;
2022-01-25 11:42:02 -05:00
if name == "None" || name.is_empty() {
return;
}
let x = (*idx % width) as i32;
let y = (*idx / width) as i32;
let item_result = spawn_named_entity(
2021-12-23 11:38:37 -05:00
&RAWS.lock().unwrap(),
2022-01-04 11:11:38 -05:00
ecs,
name,
2021-12-23 11:38:37 -05:00
SpawnType::AtPosition { x, y },
);
2022-01-25 11:42:02 -05:00
if item_result.is_none() {
2022-01-25 11:15:32 -05:00
::rltk::console::log(format!("WARNING: We don't know how to spawn [{}]!", name));
}
2021-12-17 13:53:14 -05:00
}
pub fn spawn_town_portal(ecs: &mut World) {
// Get current position & depth
let map = ecs.fetch::<Map>();
let player_depth = map.depth;
let player_pos = ecs.fetch::<Point>();
let player_x = player_pos.x;
let player_y = player_pos.y;
std::mem::drop(player_pos);
std::mem::drop(map);
// Find part of the town for the portal
let dm = ecs.fetch::<MasterDungeonMap>();
let town_map = dm.get_map(1).unwrap();
let mut stairs_idx = 0;
for (idx, tt) in town_map.tiles.iter().enumerate() {
if *tt == TileType::DownStairs {
stairs_idx = idx;
}
}
let portal_x = (stairs_idx as i32 % town_map.width) - 2;
let portal_y = stairs_idx as i32 / town_map.width;
std::mem::drop(dm);
// Spawn the portal itself
ecs.create_entity()
.with(OtherLevelPosition {
x: portal_x,
y: portal_y,
depth: 1,
})
.with(Renderable {
glyph: ::rltk::to_cp437('♥'),
fg: colors::CYAN,
bg: colors::BLACK,
render_order: 0,
})
.with(EntryTrigger {})
.with(TeleportTo {
x: player_x,
y: player_y,
depth: player_depth,
player_only: true,
})
.with(Name::from("Town Portal"))
.with(SingleActivation {})
.build();
}