paul/cdungeon
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: paul:18dcff18b1ec13917134832dfb41307df293299d
Branches Tags
paul:main
..
compare: paul:167ab4f5b8c4a288820d5d37663888b6cf4f5130
Branches Tags
paul:main

No commits in common. "18dcff18b1ec13917134832dfb41307df293299d" and "167ab4f5b8c4a288820d5d37663888b6cf4f5130" have entirely different histories.
18dcff18b1 ... 167ab4f5b8

6 changed files with 46 additions and 106 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,2 +1 @@
target
*.swp

2
activate
View File

@ -1,2 +0,0 @@
export PATH=$PATH:/Users/paul/Source/cdungeon/target/debug
alias cdg='cd $(cdungeon)'

7
design/v0.txt
View File

@ -40,10 +40,3 @@ Single-char
⎕ Music ⎕ something
was wäre mit
- seitwärts gehen
- mehr räume anzeigen
- aktuellen raum live updaten
- beep boops/animation wenn irgendwas im aktuellen raum passiert
- position beim hochgehen merken
- hintergrund rendern

125
src/game.rs
View File

@ -1,11 +1,13 @@
use std::{
error::Error, ffi::{OsString}, fmt::{self}, fs, path::PathBuf, process::Command
};
use std::{fs, path::PathBuf};
use color_eyre::eyre::Result;
use crossterm::event::{Event, KeyCode};
use ratatui::{
buffer::{Buffer, Cell}, layout::{Constraint, Layout, Rect}, prelude::Backend, style::Color, text::{Line, Text}, widgets::{Block, Widget}, Frame, Terminal
Frame,
buffer::{Buffer, Cell},
layout::{Constraint, Layout, Rect},
style::Color,
text::{Line, Text},
widgets::{Block, Widget},
};
use crate::geometry::{Grid, P2, V2};
@ -16,7 +18,7 @@ pub struct GameModel {
room: Room,
}
#[derive(Clone, Debug)]
#[derive(Clone)]
pub enum GameEvent {
Quit,
Nop,
@ -24,10 +26,9 @@ pub enum GameEvent {
PlayerDash(V2<isize>),
Interact,
Navigate(NavigationTarget),
Run(OsString, Vec<OsString>),
}
#[derive(Clone, Debug)]
#[derive(Clone)]
pub enum NavigationTarget {
Path(PathBuf),
Parent,
@ -61,7 +62,7 @@ struct Room {
tiles: Grid<Tile>,
}
#[derive(Clone, Debug)]
#[derive(Clone)]
struct Tile {
style: TileStyle,
action: Option<GameEvent>,
@ -94,40 +95,21 @@ impl Tile {
}
}
pub enum UpdateResult {
ShouldExit(PathBuf),
NewModel(GameModel),
}
#[derive(Debug)]
struct GameError {}
impl fmt::Display for GameError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "ouch game broken")
}
}
impl Error for GameError {}
impl GameModel {
pub fn new(path: PathBuf) -> Result<Self> {
let path = path.canonicalize()?;
let mut entries: Vec<PathBuf> = fs::read_dir(&path)?
.filter_map(|entry| entry.ok().map(|entry| entry.path()))
pub fn new(path: PathBuf) -> Self {
let path = path.canonicalize().unwrap();
let mut entries: Vec<PathBuf> = fs::read_dir(&path)
.unwrap()
.map(|entry| entry.unwrap().path())
.collect();
entries.sort();
let max_entry_length = entries
.iter()
.filter_map(|entry| {
entry
.file_name()
.map(|entry| entry.to_string_lossy().chars().count())
})
.map(|entry| entry.file_name().unwrap().to_string_lossy().chars().count())
.max()
.unwrap_or(0);
Ok(Self {
Self {
player_pos: P2::new(10, 2),
room: Room {
tiles: {
@ -166,14 +148,12 @@ impl GameModel {
} else {
tiles
.get_mut(P2::new(10, 2 + i as isize))
.map(|tile| *tile = Tile::new(TileStyle::Box).with_action(GameEvent::Run("vim".into(), vec![
entry.into()
])));
.map(|tile| *tile = Tile::new(TileStyle::Box));
}
for (j, c) in entry
.file_name()
.ok_or(GameError {})?
.unwrap()
.to_string_lossy()
.chars()
.enumerate()
@ -189,26 +169,25 @@ impl GameModel {
},
path,
})
}
}
pub fn update<T: Backend>(self, event: Event, terminal: &mut Terminal<T>) -> Result<UpdateResult> {
self.update_game(GameEvent::from_crossterm(event), terminal)
pub fn update(self, event: Event) -> Result<Self, PathBuf> {
self.update_game(GameEvent::from_crossterm(event))
}
fn update_game<T: Backend>(self, event: GameEvent, terminal: &mut Terminal<T>) -> Result<UpdateResult> {
use UpdateResult::*;
Ok(match event {
GameEvent::Quit => ShouldExit(self.path),
GameEvent::Nop => NewModel(self),
fn update_game(self, event: GameEvent) -> Result<Self, PathBuf> {
match event {
GameEvent::Quit => Err(self.path),
GameEvent::Nop => Ok(self),
GameEvent::PlayerMove(direction) => {
let player_pos = self.player_pos + direction;
if let Some(target_tile) = self.room.tiles.get(player_pos)
&& target_tile.may_enter()
{
NewModel(Self { player_pos, ..self })
Ok(Self { player_pos, ..self })
} else {
NewModel(self)
Ok(self)
}
}
GameEvent::PlayerDash(direction) => {
@ -227,7 +206,7 @@ impl GameModel {
break;
}
}
NewModel(Self { player_pos, ..self })
Ok(Self { player_pos, ..self })
}
GameEvent::Interact => {
let opt_action = self
@ -237,36 +216,27 @@ impl GameModel {
.and_then(|tile| tile.action.clone());
if let Some(action) = opt_action {
self.update_game(action, terminal)?
self.update_game(action)
} else {
NewModel(self)
Ok(self)
}
}
GameEvent::Navigate(target) => {
let path = match target {
NavigationTarget::Path(path) => path,
NavigationTarget::Parent => {
self.path.parent().ok_or(GameError {})?.to_path_buf()
}
NavigationTarget::Parent => self.path.parent().unwrap().to_path_buf(),
};
NewModel(Self::new(path)?)
Ok(Self::new(path))
}
GameEvent::Run(cmd, args) => {
Command::new(&cmd).args(args).spawn().unwrap().wait().unwrap();
// TODO: Figure out why terminal isn't cleared on exit.
terminal.clear().unwrap();
NewModel(self)
}
})
}
}
pub fn render(&self, frame: &mut Frame) {
let layout =
Layout::vertical([Constraint::Fill(1), Constraint::Length(4)]).split(frame.area());
Layout::vertical([Constraint::Fill(1), Constraint::Length(3)]).split(frame.area());
let camera_block_area = layout[0];
let bottom_bar_area = layout[1];
let info_block_area = layout[1];
let camera_block = Block::bordered()
.title("camera")
@ -274,30 +244,15 @@ impl GameModel {
let camera_area = camera_block.inner(camera_block_area);
let camera = CameraWidget::new(self);
let bottom_bar_layout = Layout::horizontal([
Constraint::Fill(1),
Constraint::Fill(1),
]).split(bottom_bar_area);
let info_block_area = bottom_bar_layout[0];
let debug_block_area = bottom_bar_layout[1];
let info_block = Block::bordered().title("cwd");
let info_area = info_block.inner(info_block_area);
let info = Text::raw(self.path.to_string_lossy());
let debug_block = Block::bordered().title("debug");
let debug_area = info_block.inner(debug_block_area);
let debug = Text::raw(self.room.tiles.get(self.player_pos).map(|tile| format!("{:?}\n{:?}", tile.style, tile.action)).unwrap_or("".to_string()));
frame.render_widget(camera_block, camera_block_area);
frame.render_widget(camera, camera_area);
frame.render_widget(info_block, info_block_area);
frame.render_widget(info, info_area);
frame.render_widget(debug_block, debug_block_area);
frame.render_widget(debug, debug_area);
}
fn render_tiles(&self) -> Grid<TileStyle> {
@ -305,7 +260,7 @@ impl GameModel {
self.room
.tiles
.get(P2::new(x as isize, y as isize))
.expect("programmer error: copying a grid shouldnt yield OOB errors")
.unwrap()
.style
.clone()
});
@ -318,7 +273,7 @@ impl GameModel {
}
}
#[derive(Clone, Debug)]
#[derive(Clone)]
enum TileStyle {
Floor,
Player,
@ -328,12 +283,12 @@ enum TileStyle {
Box,
}
#[derive(Clone, Debug)]
#[derive(Clone)]
struct Portal {
kind: PortalKind,
}
#[derive(Clone, Debug)]
#[derive(Clone)]
enum PortalKind {
Ladder,
Portal,

2
src/geometry.rs
View File

@ -104,4 +104,4 @@ impl<T> Grid<T> {
None
}
}
}
}

15
src/main.rs
View File

@ -4,18 +4,13 @@ mod geometry;
use std::path::PathBuf;
use color_eyre::eyre::Result;
use crossterm::{
event::{self, DisableMouseCapture, EnableMouseCapture},
execute,
terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use crossterm::{event::{self, DisableMouseCapture, EnableMouseCapture}, execute, terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode}};
use ratatui::{
Terminal,
prelude::{Backend, CrosstermBackend},
};
use game::GameModel;
use game::UpdateResult;
fn main() -> Result<()> {
enable_raw_mode()?;
@ -38,14 +33,14 @@ fn main() -> Result<()> {
}
fn main_loop<T: Backend>(terminal: &mut Terminal<T>) -> Result<PathBuf> {
let mut model = GameModel::new(PathBuf::from("."))?;
let mut model = GameModel::new(PathBuf::from("."));
loop {
terminal.draw(|frame| model.render(frame))?;
let term_event = event::read()?;
match model.update(term_event, terminal)? {
UpdateResult::NewModel(new_model) => model = new_model,
UpdateResult::ShouldExit(path) => break Ok(path),
match model.update(term_event) {
Ok(new_model) => model = new_model,
Err(path) => break Ok(path),
}
}
}