512 lines
22 KiB
Rust
512 lines
22 KiB
Rust
mod chat;
|
|
mod controls;
|
|
|
|
use crossterm::event::{read, Event, KeyCode};
|
|
use tui::{backend::Backend, Frame, layout::Layout};
|
|
|
|
use crate::{game::Game, entity::{EntityId, EntityType}, world::Terrain};
|
|
|
|
use self::{chat::{Chat, ChatLine}, controls::Controls};
|
|
|
|
/**
|
|
* |........................|
|
|
* | Conversations/Selection|
|
|
* | |
|
|
* |........................|
|
|
* | Available Options |
|
|
* |........................|
|
|
*/
|
|
|
|
enum AppStatus {
|
|
Initial,
|
|
GuestSelection,
|
|
TalkToGuest(Option<EntityId>),
|
|
Debug,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
enum DebugView {
|
|
Creatures,
|
|
Items,
|
|
Map,
|
|
}
|
|
|
|
struct DebugData<'a> {
|
|
list: Vec<tui::widgets::ListItem<'a>>,
|
|
list_state: tui::widgets::ListState,
|
|
|
|
item_list: Vec<tui::widgets::ListItem<'a>>,
|
|
item_list_state: tui::widgets::ListState,
|
|
|
|
selected: DebugView,
|
|
map_scroll: (u16, u16),
|
|
}
|
|
|
|
pub struct App<'a> {
|
|
game: Game,
|
|
status: AppStatus,
|
|
|
|
// Guest Selection
|
|
guest_list: Vec<tui::widgets::ListItem<'a>>,
|
|
guest_list_state: tui::widgets::ListState,
|
|
|
|
// Conversation
|
|
conversation: Chat,
|
|
conversation_scroll: u16,
|
|
|
|
// Debug
|
|
debug_data: Option<DebugData<'a>>,
|
|
}
|
|
|
|
pub struct DefaultLayout {
|
|
pub status: tui::layout::Rect,
|
|
pub main: tui::layout::Rect,
|
|
pub controls: tui::layout::Rect,
|
|
}
|
|
|
|
impl DefaultLayout {
|
|
pub fn default(rect: tui::layout::Rect) -> DefaultLayout {
|
|
let chunks = Layout::default()
|
|
.direction(tui::layout::Direction::Vertical)
|
|
.constraints(
|
|
[
|
|
tui::layout::Constraint::Length(1),
|
|
tui::layout::Constraint::Min(3),
|
|
tui::layout::Constraint::Length(2)
|
|
]
|
|
.as_ref(),
|
|
).split(rect);
|
|
|
|
DefaultLayout {
|
|
status: chunks[0],
|
|
main: chunks[1],
|
|
controls: chunks[2],
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> App<'a> {
|
|
pub fn new(state: Game) -> App<'a> {
|
|
App {
|
|
game: state,
|
|
guest_list: vec![],
|
|
guest_list_state: tui::widgets::ListState::default(),
|
|
status: AppStatus::Initial,
|
|
conversation: Chat::new(),
|
|
conversation_scroll: 0,
|
|
debug_data: None,
|
|
}
|
|
}
|
|
|
|
pub fn step(&mut self) -> bool {
|
|
match &self.status {
|
|
AppStatus::Initial => {
|
|
// determine guests
|
|
self.guest_list = self.game.state.guests().iter().map(|creature_id| {
|
|
let creature = self.game.state.get_creature(*creature_id).unwrap();
|
|
tui::widgets::ListItem::new(creature.name.clone())
|
|
}).collect();
|
|
self.guest_list_state = tui::widgets::ListState::default();
|
|
self.guest_list_state.select(Some(0));
|
|
self.status = AppStatus::GuestSelection;
|
|
true
|
|
},
|
|
AppStatus::GuestSelection => {
|
|
match read() {
|
|
Ok(Event::Key(event)) => {
|
|
match event.code {
|
|
KeyCode::Up => {
|
|
let selected = self.guest_list_state.selected().unwrap();
|
|
if selected > 0 {
|
|
self.guest_list_state.select(Some(selected - 1));
|
|
}
|
|
},
|
|
KeyCode::Down => {
|
|
let selected = self.guest_list_state.selected().unwrap();
|
|
if selected < self.guest_list.len() - 1 {
|
|
self.guest_list_state.select(Some(selected + 1));
|
|
}
|
|
},
|
|
KeyCode::Enter => {
|
|
if self.game.state.guests().len() > 0 {
|
|
match self.guest_list_state.selected() {
|
|
Some(selected) => {
|
|
let guest_id = &self.game.state.guests()[selected];
|
|
self.conversation = Chat::new();
|
|
self.greet_guest(Some(*guest_id));
|
|
self.status = AppStatus::TalkToGuest(Some(*guest_id));
|
|
},
|
|
None => {}
|
|
}
|
|
}
|
|
},
|
|
KeyCode::Char('?') => {
|
|
self.open_debug();
|
|
},
|
|
KeyCode::Char('.') => {
|
|
self.game.step();
|
|
self.status = AppStatus::Initial;
|
|
},
|
|
KeyCode::Esc => {
|
|
return false;
|
|
},
|
|
_ => {}
|
|
}
|
|
},
|
|
_ => {}
|
|
}
|
|
true
|
|
},
|
|
AppStatus::TalkToGuest(guest) => {
|
|
match read() {
|
|
Ok(Event::Key(event)) => {
|
|
match event.code {
|
|
KeyCode::Esc => {
|
|
self.status = AppStatus::GuestSelection;
|
|
},
|
|
KeyCode::Char('a') => {
|
|
self.ask_business(*guest);
|
|
},
|
|
KeyCode::Up => {
|
|
self.conversation_scroll += 1;
|
|
},
|
|
KeyCode::Down => {
|
|
if self.conversation_scroll > 0 {
|
|
self.conversation_scroll -= 1;
|
|
}
|
|
},
|
|
_ => {}
|
|
}
|
|
},
|
|
_ => {}
|
|
}
|
|
true
|
|
},
|
|
AppStatus::Debug => {
|
|
match read() {
|
|
Ok(Event::Key(event)) => {
|
|
match event.code {
|
|
KeyCode::Esc => {
|
|
self.status = AppStatus::GuestSelection;
|
|
},
|
|
KeyCode::Up => {
|
|
if self.debug_data.as_ref().unwrap().selected == DebugView::Map {
|
|
let (x, y) = self.debug_data.as_ref().unwrap().map_scroll;
|
|
self.debug_data.as_mut().unwrap().map_scroll = (x.saturating_sub(1), y);
|
|
} else {
|
|
let ref mut state = match self.debug_data.as_ref().unwrap().selected {
|
|
DebugView::Creatures => &mut self.debug_data.as_mut().unwrap().list_state,
|
|
DebugView::Items => &mut self.debug_data.as_mut().unwrap().item_list_state,
|
|
_ => &mut self.debug_data.as_mut().unwrap().list_state,
|
|
};
|
|
let selected = state.selected().unwrap();
|
|
if selected > 0 {
|
|
state.select(Some(selected - 1));
|
|
}
|
|
}
|
|
},
|
|
KeyCode::Down => {
|
|
if self.debug_data.as_ref().unwrap().selected == DebugView::Map {
|
|
let (x, y) = self.debug_data.as_ref().unwrap().map_scroll;
|
|
self.debug_data.as_mut().unwrap().map_scroll = (x + 1, y);
|
|
} else {
|
|
let mut max = 0;
|
|
let ref mut state = match self.debug_data.as_ref().unwrap().selected {
|
|
DebugView::Creatures => {
|
|
max = self.debug_data.as_ref().unwrap().list.len() - 1;
|
|
&mut self.debug_data.as_mut().unwrap().list_state
|
|
},
|
|
DebugView::Items => {
|
|
max = self.debug_data.as_ref().unwrap().item_list.len() - 1;
|
|
&mut self.debug_data.as_mut().unwrap().item_list_state
|
|
},
|
|
_ => {
|
|
max = self.debug_data.as_ref().unwrap().list.len() - 1;
|
|
&mut self.debug_data.as_mut().unwrap().list_state
|
|
},
|
|
};
|
|
let selected = state.selected().unwrap();
|
|
if selected < max {
|
|
state.select(Some(selected + 1));
|
|
}
|
|
}
|
|
},
|
|
KeyCode::Left => {
|
|
if self.debug_data.as_ref().unwrap().selected == DebugView::Map {
|
|
let (x, y) = self.debug_data.as_ref().unwrap().map_scroll;
|
|
self.debug_data.as_mut().unwrap().map_scroll = (x, y.saturating_sub(1));
|
|
}
|
|
},
|
|
KeyCode::Right => {
|
|
if self.debug_data.as_ref().unwrap().selected == DebugView::Map {
|
|
let (x, y) = self.debug_data.as_ref().unwrap().map_scroll;
|
|
self.debug_data.as_mut().unwrap().map_scroll = (x, y + 1);
|
|
}
|
|
},
|
|
KeyCode::Char('i') => {
|
|
self.debug_data.as_mut().unwrap().selected = DebugView::Items;
|
|
},
|
|
KeyCode::Char('c') => {
|
|
self.debug_data.as_mut().unwrap().selected = DebugView::Creatures;
|
|
},
|
|
KeyCode::Char('m') => {
|
|
self.debug_data.as_mut().unwrap().selected = DebugView::Map;
|
|
},
|
|
_ => {}
|
|
}
|
|
},
|
|
_ => {}
|
|
}
|
|
true
|
|
}
|
|
}
|
|
}
|
|
|
|
fn open_debug(&mut self) {
|
|
let mut list = vec![];
|
|
let mut item_list = vec![];
|
|
for (id, creature) in self.game.state.creatures.iter() {
|
|
list.push(tui::widgets::ListItem::new(format!("{}: {} ({}) at {}",
|
|
id.1, creature.name,
|
|
creature.profession,
|
|
creature.loc,
|
|
)));
|
|
}
|
|
for (id, item) in self.game.state.items.iter() {
|
|
item_list.push(tui::widgets::ListItem::new(format!("{}: {} ({}) at {}",
|
|
id.1, item.name,
|
|
item.item_type,
|
|
item.owner,
|
|
)));
|
|
}
|
|
|
|
self.debug_data = Some(DebugData {
|
|
list,
|
|
list_state: tui::widgets::ListState::default(),
|
|
item_list,
|
|
item_list_state: tui::widgets::ListState::default(),
|
|
selected: DebugView::Creatures,
|
|
map_scroll: (0, 0),
|
|
});
|
|
self.debug_data.as_mut().unwrap().list_state.select(Some(0));
|
|
self.debug_data.as_mut().unwrap().item_list_state.select(Some(0));
|
|
self.status = AppStatus::Debug;
|
|
}
|
|
|
|
// fn default_layout(&self) -> Layout {
|
|
// DefaultLayout::default()
|
|
// }
|
|
|
|
pub fn draw<B: Backend>(&mut self, f: &mut Frame<B>) {
|
|
match &self.status {
|
|
AppStatus::Initial => {
|
|
self.draw_initial(f);
|
|
},
|
|
AppStatus::GuestSelection => {
|
|
self.draw_guest_selection(f);
|
|
},
|
|
AppStatus::TalkToGuest(guest_id) => {
|
|
self.draw_talk_to_guest(f, *guest_id);
|
|
},
|
|
AppStatus::Debug => {
|
|
self.draw_debug(f);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
fn draw_status<B: Backend>(&self, f: &mut Frame<B>, rect: tui::layout::Rect) {
|
|
|
|
let tavern = self.game.state.world.get_site(
|
|
self.game.state.tavern.unwrap()
|
|
).unwrap();
|
|
|
|
let spans = tui::text::Spans::from(vec![
|
|
tui::text::Span::raw("Date: "),
|
|
tui::text::Span::raw(format!("{}", self.game.state.time)),
|
|
tui::text::Span::raw(" "),
|
|
tui::text::Span::raw("Funds: "),
|
|
tui::text::Span::raw(format!("{} gold coins", tavern.coins)),
|
|
]);
|
|
|
|
let status_text = tui::widgets::Paragraph::new(spans)
|
|
.block(tui::widgets::Block::default().borders(tui::widgets::Borders::LEFT | tui::widgets::Borders::RIGHT))
|
|
.style(tui::style::Style::default().fg(tui::style::Color::White));
|
|
|
|
f.render_widget(status_text, rect);
|
|
}
|
|
|
|
pub fn draw_initial<B: Backend>(&mut self, _f: &mut Frame<B>) {}
|
|
|
|
pub fn draw_guest_selection<B: Backend>(&mut self, f: &mut Frame<B>) {
|
|
let chunks = DefaultLayout::default(f.size());
|
|
|
|
let main_window = tui::widgets::List::new(self.guest_list.clone())
|
|
.block(tui::widgets::Block::default().title("Guests").borders(tui::widgets::Borders::ALL))
|
|
.style(tui::style::Style::default().fg(tui::style::Color::White))
|
|
.highlight_style(tui::style::Style::default().add_modifier(tui::style::Modifier::ITALIC))
|
|
.highlight_symbol(">>");
|
|
|
|
let mut binding = Controls::new();
|
|
let controls = binding
|
|
.add("↑↓".to_owned(), "select guest".to_owned())
|
|
.add("⏎".to_owned(), "talk to guest".to_owned())
|
|
.add(".".to_owned(), "pass one day".to_owned())
|
|
.add("Esc".to_owned(), "quit".to_owned())
|
|
.render();
|
|
|
|
self.draw_status(f, chunks.status);
|
|
f.render_stateful_widget(main_window, chunks.main, &mut self.guest_list_state);
|
|
f.render_widget(controls, chunks.controls);
|
|
}
|
|
|
|
fn draw_talk_to_guest<B: Backend>(&self, f: &mut Frame<B>, guest: Option<EntityId>) {
|
|
let chunks = DefaultLayout::default(f.size());
|
|
|
|
let guest = self.game.state.get_creature(guest.unwrap()).unwrap();
|
|
|
|
let key_style = tui::style::Style::default()
|
|
.add_modifier(tui::style::Modifier::BOLD)
|
|
.fg(tui::style::Color::Green)
|
|
.bg(tui::style::Color::Black);
|
|
|
|
let mut full_text = self.conversation.to_spans();
|
|
full_text.push(tui::text::Spans::from(vec![
|
|
tui::text::Span::styled("(a) ", key_style),
|
|
tui::text::Span::raw("What's your business?\n\n"),
|
|
]));
|
|
full_text.push(tui::text::Spans::from(vec![
|
|
tui::text::Span::styled("(b) ", key_style),
|
|
tui::text::Span::raw("Let's trade?\n\n"),
|
|
]));
|
|
full_text.push(tui::text::Spans::from(vec![
|
|
tui::text::Span::styled("(c) ", key_style),
|
|
tui::text::Span::raw("Heard of anything interesting?\n\n"),
|
|
]));
|
|
let text = tui::text::Text::from(full_text);
|
|
let scroll: u16 = ((text.lines.len() as u16) )
|
|
.checked_sub(
|
|
(chunks.main.height as u16).checked_sub(2).unwrap_or(0) // 2 lines for the border
|
|
)
|
|
.unwrap_or(0)
|
|
.checked_sub(self.conversation_scroll)
|
|
.unwrap_or(0);
|
|
|
|
let main_window = tui::widgets::Paragraph::new(text)
|
|
.block(tui::widgets::Block::default().title(guest.name.clone()).borders(tui::widgets::Borders::ALL))
|
|
.style(tui::style::Style::default().fg(tui::style::Color::White))
|
|
.scroll((scroll, 0));
|
|
|
|
let mut binding = Controls::new();
|
|
let controls = binding
|
|
.add("a-z".to_owned(), "Talk".to_owned())
|
|
.add("Esc".to_owned(), "Back".to_owned())
|
|
.render();
|
|
|
|
self.draw_status(f, chunks.status);
|
|
f.render_widget(main_window, chunks.main);
|
|
f.render_widget(controls, chunks.controls);
|
|
}
|
|
|
|
fn draw_debug<B: Backend>(&mut self, f: &mut Frame<B>) {
|
|
let chunks = DefaultLayout::default(f.size());
|
|
|
|
let data = self.debug_data.as_mut().unwrap();
|
|
|
|
match data.selected {
|
|
DebugView::Creatures => {
|
|
let main_window = tui::widgets::List::new(data.list.clone())
|
|
.block(tui::widgets::Block::default().title("Guests").borders(tui::widgets::Borders::ALL))
|
|
.style(tui::style::Style::default().fg(tui::style::Color::White))
|
|
.highlight_style(tui::style::Style::default().add_modifier(tui::style::Modifier::ITALIC))
|
|
.highlight_symbol(">>");
|
|
f.render_stateful_widget(main_window, chunks.main, &mut data.list_state);
|
|
},
|
|
DebugView::Items => {
|
|
let main_window = tui::widgets::List::new(data.item_list.clone())
|
|
.block(tui::widgets::Block::default().title("Items").borders(tui::widgets::Borders::ALL))
|
|
.style(tui::style::Style::default().fg(tui::style::Color::White))
|
|
.highlight_style(tui::style::Style::default().add_modifier(tui::style::Modifier::ITALIC))
|
|
.highlight_symbol(">>");
|
|
f.render_stateful_widget(main_window, chunks.main, &mut data.item_list_state);
|
|
},
|
|
DebugView::Map => {
|
|
let mut rows = Vec::new();
|
|
for row in self.game.state.world.map.iter() {
|
|
rows.push(tui::text::Spans::from(
|
|
row.iter().map(|tile| {
|
|
match tile.terrain {
|
|
Terrain::Void => tui::text::Span::styled(" ", tui::style::Style::default().bg(tui::style::Color::Rgb(0, 0, 0)).fg(tui::style::Color::Rgb(0, 0, 0))),
|
|
Terrain::DeepOcean => tui::text::Span::styled("~", tui::style::Style::default().bg(tui::style::Color::Rgb(0, 0, 128)).fg(tui::style::Color::Rgb(32, 32, 128))),
|
|
Terrain::Ocean => tui::text::Span::styled("~", tui::style::Style::default().bg(tui::style::Color::Rgb(32, 32, 128)).fg(tui::style::Color::Rgb(128, 128, 128))),
|
|
Terrain::Beach => tui::text::Span::styled("-", tui::style::Style::default().bg(tui::style::Color::Rgb(200, 200, 10)).fg(tui::style::Color::Rgb(100, 100, 10))),
|
|
Terrain::Flats => tui::text::Span::styled("-", tui::style::Style::default().bg(tui::style::Color::Rgb(30, 150, 30)).fg(tui::style::Color::Rgb(30, 200, 30))),
|
|
Terrain::Hills => tui::text::Span::styled("~", tui::style::Style::default().bg(tui::style::Color::Rgb(120, 150, 30)).fg(tui::style::Color::Rgb(120, 150, 30))),
|
|
Terrain::Mountains => tui::text::Span::styled("A", tui::style::Style::default().bg(tui::style::Color::Rgb(120,120,120)).fg(tui::style::Color::Rgb(120,120,120))),
|
|
Terrain::HighMountains => tui::text::Span::styled("A", tui::style::Style::default().bg(tui::style::Color::Rgb(200,200,200)).fg(tui::style::Color::Rgb(200,200,200))),
|
|
}
|
|
}).collect::<Vec<tui::text::Span>>()
|
|
));
|
|
}
|
|
|
|
let main_window = tui::widgets::Paragraph::new(
|
|
tui::text::Text::from(rows)
|
|
)
|
|
.block(tui::widgets::Block::default().title("Map").borders(tui::widgets::Borders::ALL))
|
|
.style(tui::style::Style::default().fg(tui::style::Color::White))
|
|
.scroll(data.map_scroll);
|
|
|
|
f.render_widget(main_window, chunks.main);
|
|
},
|
|
}
|
|
|
|
self.draw_status(f, chunks.status);
|
|
let mut binding = Controls::new();
|
|
let controls = binding
|
|
.add("↑↓".to_owned(), "select guest".to_owned())
|
|
.add("c".to_owned(), "Creatures".to_owned())
|
|
.add("i".to_owned(), "Items".to_owned())
|
|
.add("m".to_owned(), "Map".to_owned())
|
|
.add("Esc".to_owned(), "back".to_owned())
|
|
.render();
|
|
f.render_widget(controls, chunks.controls);
|
|
}
|
|
|
|
/**
|
|
* Conversation
|
|
*/
|
|
fn greet_guest(&mut self, guest_id: Option<EntityId>) {
|
|
let guest = self.game.state.get_creature(guest_id.unwrap()).unwrap();
|
|
self.conversation.add_line(ChatLine::new(
|
|
(EntityType::Creature, 0),
|
|
"You".to_owned(),
|
|
"Greetings traveller!".to_owned(),
|
|
false
|
|
));
|
|
self.conversation.add_line(ChatLine::new(
|
|
guest_id.unwrap(),
|
|
guest.name.clone(),
|
|
"Hello, I'm ".to_owned() + &guest.name + ", nice to meet you! "
|
|
+ "I'm a " + &guest.profession.to_string() + ".",
|
|
false
|
|
));
|
|
self.conversation_scroll = 0;
|
|
}
|
|
|
|
fn ask_business(&mut self, guest: Option<EntityId>) {
|
|
let guest = self.game.state.get_creature(guest.unwrap()).unwrap();
|
|
self.conversation.add_line(ChatLine::new(
|
|
(EntityType::Creature, 0),
|
|
"You".to_owned(),
|
|
"What's your business?".to_owned(),
|
|
false
|
|
));
|
|
self.conversation.add_line(ChatLine::new(
|
|
guest.entity.id,
|
|
guest.name.clone(),
|
|
guest.say_agenda(& self.game.state),
|
|
false
|
|
));
|
|
self.conversation_scroll = 0;
|
|
}
|
|
} |