378 lines
9.8 KiB
Rust
378 lines
9.8 KiB
Rust
use std::{fs::read_to_string, ops::Rem};
|
|
|
|
use marble_engine::{
|
|
board::Board,
|
|
parse,
|
|
tile::{Direction, GateType, MathOp, MirrorType, PTile, Tile},
|
|
tile_from_char, Machine,
|
|
};
|
|
use raylib::prelude::*;
|
|
|
|
mod marble_engine;
|
|
mod util;
|
|
use util::*;
|
|
|
|
#[derive(Debug)]
|
|
struct Game {
|
|
source_board: Board,
|
|
machine: Machine,
|
|
sim_state: SimState,
|
|
view_offset: Vector2,
|
|
zoom: i32,
|
|
output_as_text: bool,
|
|
input_as_text: bool,
|
|
active_tool: Tool,
|
|
tool_menu_math: MathOp,
|
|
tool_menu_gate: GateType,
|
|
tool_menu_arrow: Direction,
|
|
tool_menu_mirror: MirrorType,
|
|
input_text_selected: bool,
|
|
sim_speed: f32,
|
|
time_since_step: f32,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
enum Tool {
|
|
None,
|
|
SetTile(Tile),
|
|
Math,
|
|
Gate,
|
|
Arrow,
|
|
Mirror,
|
|
Number,
|
|
// SelectArea,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
enum SimState {
|
|
Editing,
|
|
Running,
|
|
Stepping,
|
|
}
|
|
|
|
fn main() {
|
|
let (mut rl, thread) = raylib::init()
|
|
.resizable()
|
|
.title("good window title")
|
|
.build();
|
|
rl.set_target_fps(60);
|
|
rl.set_window_min_size(640, 480);
|
|
rl.set_mouse_cursor(MouseCursor::MOUSE_CURSOR_CROSSHAIR);
|
|
rl.set_exit_key(None);
|
|
|
|
let mut textures = Textures::default();
|
|
textures.load_dir("assets", &mut rl, &thread);
|
|
textures.load_dir("assets/tiles", &mut rl, &thread);
|
|
|
|
let mut game = Game::new_sandbox();
|
|
let board = parse(&read_to_string("boards/adder.mbl").unwrap());
|
|
game.load_board(board);
|
|
|
|
while !rl.window_should_close() {
|
|
game.input(&rl);
|
|
let mut d = rl.begin_drawing(&thread);
|
|
d.clear_background(Color::new(64, 64, 64, 255));
|
|
game.gui(&mut d, &textures);
|
|
}
|
|
}
|
|
|
|
impl Game {
|
|
fn new_sandbox() -> Self {
|
|
Self {
|
|
source_board: Board::new_empty(16, 16),
|
|
machine: Machine::new_empty(1),
|
|
sim_state: SimState::Editing,
|
|
view_offset: Vector2::zero(),
|
|
zoom: 1,
|
|
active_tool: Tool::None,
|
|
output_as_text: false,
|
|
input_as_text: false,
|
|
input_text_selected: false,
|
|
sim_speed: 8.,
|
|
time_since_step: 0.,
|
|
tool_menu_math: MathOp::Add,
|
|
tool_menu_gate: GateType::Equal,
|
|
tool_menu_arrow: Direction::Right,
|
|
tool_menu_mirror: MirrorType::Forward,
|
|
}
|
|
}
|
|
|
|
fn load_board(&mut self, board: Board) {
|
|
self.source_board = board;
|
|
}
|
|
|
|
fn start_sim(&mut self) {
|
|
self.machine.reset();
|
|
self.machine.set_board(self.source_board.clone());
|
|
}
|
|
|
|
fn rotate_tool(&mut self, shift: bool) {
|
|
match &self.active_tool {
|
|
Tool::Math => {
|
|
self.tool_menu_math = match self.tool_menu_math {
|
|
MathOp::Add => MathOp::Sub,
|
|
MathOp::Sub => MathOp::Mul,
|
|
MathOp::Mul => MathOp::Div,
|
|
MathOp::Div => MathOp::Rem,
|
|
MathOp::Rem => MathOp::Add,
|
|
}
|
|
}
|
|
Tool::Gate => {
|
|
self.tool_menu_gate = match self.tool_menu_gate {
|
|
GateType::LessThan => GateType::GreaterThan,
|
|
GateType::GreaterThan => GateType::Equal,
|
|
GateType::Equal => GateType::NotEqual,
|
|
GateType::NotEqual => GateType::LessThan,
|
|
}
|
|
}
|
|
Tool::Arrow => {
|
|
self.tool_menu_arrow = if shift {
|
|
self.tool_menu_arrow.left()
|
|
} else {
|
|
self.tool_menu_arrow.right()
|
|
}
|
|
}
|
|
Tool::Mirror => {
|
|
self.tool_menu_mirror = match self.tool_menu_mirror {
|
|
MirrorType::Forward => MirrorType::Back,
|
|
MirrorType::Back => MirrorType::Forward,
|
|
}
|
|
}
|
|
Tool::None => (),
|
|
Tool::SetTile(_) => (),
|
|
Tool::Number => (),
|
|
}
|
|
}
|
|
|
|
fn input(&mut self, rl: &RaylibHandle) {
|
|
if self.sim_state == SimState::Running {
|
|
self.time_since_step += rl.get_frame_time();
|
|
if self.time_since_step > 1. / self.sim_speed {
|
|
self.time_since_step = 0.;
|
|
self.machine.step();
|
|
}
|
|
}
|
|
if rl.is_key_pressed(KeyboardKey::KEY_SPACE) {
|
|
match self.sim_state {
|
|
SimState::Editing => {
|
|
self.start_sim();
|
|
self.machine.step();
|
|
}
|
|
SimState::Running => (),
|
|
SimState::Stepping => self.machine.step(),
|
|
}
|
|
self.sim_state = SimState::Stepping;
|
|
}
|
|
if rl.is_key_pressed(KeyboardKey::KEY_ESCAPE) {
|
|
self.sim_state = SimState::Editing;
|
|
}
|
|
if rl.is_key_pressed(KeyboardKey::KEY_ENTER) {
|
|
match self.sim_state {
|
|
SimState::Editing => {
|
|
self.start_sim();
|
|
self.sim_state = SimState::Running;
|
|
}
|
|
SimState::Running => self.sim_state = SimState::Editing,
|
|
SimState::Stepping => self.sim_state = SimState::Running,
|
|
}
|
|
}
|
|
|
|
if rl.get_mouse_wheel_move() > 0. && self.zoom < 3 {
|
|
self.zoom += 1;
|
|
}
|
|
if rl.get_mouse_wheel_move() < 0. && self.zoom > 0 {
|
|
self.zoom -= 1;
|
|
}
|
|
if rl.is_mouse_button_down(MouseButton::MOUSE_BUTTON_MIDDLE) {
|
|
self.view_offset += rl.get_mouse_delta()
|
|
}
|
|
if rl.is_mouse_button_pressed(MouseButton::MOUSE_BUTTON_RIGHT) {
|
|
self.view_offset = Vector2::zero();
|
|
}
|
|
}
|
|
|
|
fn draw_board(&self, d: &mut RaylibDrawHandle, textures: &Textures) {
|
|
if self.sim_state == SimState::Editing {
|
|
self.source_board
|
|
.draw(d, textures, self.view_offset, self.zoom);
|
|
} else {
|
|
self.machine
|
|
.board()
|
|
.draw(d, textures, self.view_offset, self.zoom);
|
|
self.machine
|
|
.draw_marble_values(d, self.view_offset, self.zoom);
|
|
}
|
|
}
|
|
|
|
fn gui(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
|
|
self.draw_board(d, textures);
|
|
|
|
let height = d.get_screen_height();
|
|
let footer_height = 95;
|
|
let footer_top = (height - footer_height) as f32;
|
|
d.draw_rectangle(
|
|
0,
|
|
height - footer_height,
|
|
d.get_screen_width(),
|
|
footer_height,
|
|
Color::new(32, 32, 32, 255),
|
|
);
|
|
|
|
let tile_size = (16 << self.zoom) as f32;
|
|
let grid_spill_x = (self.view_offset.x).rem(tile_size) - tile_size;
|
|
let grid_spill_y = (self.view_offset.y).rem(tile_size) - tile_size;
|
|
d.gui_grid(
|
|
Rectangle::new(
|
|
grid_spill_x,
|
|
grid_spill_y,
|
|
d.get_screen_width() as f32 * 2.,
|
|
height as f32 - grid_spill_y - footer_height as f32,
|
|
),
|
|
None,
|
|
tile_size,
|
|
1,
|
|
);
|
|
|
|
d.gui_check_box(
|
|
Rectangle::new(5., footer_top + 5., 25., 25.),
|
|
Some(rstr!("output as text")),
|
|
&mut self.output_as_text,
|
|
);
|
|
let out_text = if self.output_as_text {
|
|
String::from_utf8_lossy(self.machine.output()).to_string()
|
|
} else {
|
|
format!("{:?}", self.machine.output())
|
|
};
|
|
d.draw_text(&out_text, 5, footer_top as i32 + 35, 20, Color::WHITE);
|
|
|
|
let mut input_text = String::from_utf8_lossy(self.machine.input()).to_string();
|
|
if text_input(
|
|
d,
|
|
Rectangle::new(5., footer_top + 60., 200., 25.),
|
|
&mut input_text,
|
|
&mut self.input_text_selected,
|
|
) {
|
|
self.machine.set_input(input_text.into_bytes());
|
|
}
|
|
|
|
let mut tool_button = |(row, col): (i32, i32), texture: &str, tool_option: Tool| {
|
|
let border = 4.;
|
|
let gap = 2.;
|
|
let bound_offset = 32. + gap * 2. + border * 2.;
|
|
texture_button(
|
|
d,
|
|
Vector2 {
|
|
x: 300. + col as f32 * bound_offset - if col < 0 { 15. } else { 0. },
|
|
y: footer_top + 5. + row as f32 * bound_offset,
|
|
},
|
|
textures.get(texture),
|
|
tool_option,
|
|
&mut self.active_tool,
|
|
32.,
|
|
border,
|
|
);
|
|
};
|
|
tool_button((0, -1), "eraser", Tool::SetTile(tile_from_char(' ')));
|
|
tool_button((1, -1), "transparent", Tool::None);
|
|
|
|
tool_button((0, 0), "marble", Tool::SetTile(tile_from_char('o')));
|
|
tool_button((0, 1), "block", Tool::SetTile(tile_from_char('#')));
|
|
tool_button((0, 2), "bag_off", Tool::SetTile(tile_from_char('B')));
|
|
tool_button((0, 3), "trigger_off", Tool::SetTile(tile_from_char('*')));
|
|
tool_button((0, 4), "input_off", Tool::SetTile(tile_from_char('I')));
|
|
tool_button((0, 5), "output_off", Tool::SetTile(tile_from_char('P')));
|
|
tool_button((0, 6), "flipper_off", Tool::SetTile(tile_from_char('F')));
|
|
|
|
tool_button(
|
|
(1, 0),
|
|
"wire_horizontal_off",
|
|
Tool::SetTile(tile_from_char('-')),
|
|
);
|
|
tool_button(
|
|
(1, 1),
|
|
"wire_vertical_off",
|
|
Tool::SetTile(tile_from_char('|')),
|
|
);
|
|
tool_button((1, 2), "wire_cross_off", Tool::SetTile(tile_from_char('+')));
|
|
tool_button(
|
|
(1, 3),
|
|
&Tile::Arrow(self.tool_menu_arrow).texture(),
|
|
Tool::Arrow,
|
|
);
|
|
tool_button(
|
|
(1, 4),
|
|
&Tile::Mirror(self.tool_menu_mirror).texture(),
|
|
Tool::Mirror,
|
|
);
|
|
tool_button(
|
|
(1, 5),
|
|
&Tile::Powerable(PTile::Math(self.tool_menu_math), false).texture(),
|
|
Tool::Math,
|
|
);
|
|
tool_button(
|
|
(1, 6),
|
|
&Tile::Powerable(PTile::Gate(self.tool_menu_gate), false).texture(),
|
|
Tool::Gate,
|
|
);
|
|
|
|
let is_shift = d.is_key_down(KeyboardKey::KEY_LEFT_SHIFT);
|
|
if d.is_key_pressed(KeyboardKey::KEY_R) {
|
|
self.rotate_tool(is_shift);
|
|
}
|
|
|
|
let mouse_pos = d.get_mouse_position();
|
|
if self.sim_state == SimState::Editing && mouse_pos.y < footer_top {
|
|
let tile_pos = (mouse_pos - self.view_offset) / (16 << self.zoom) as f32;
|
|
let tile_pos = Vector2::new(tile_pos.x.floor(), tile_pos.y.floor());
|
|
|
|
let tile_screen_pos = tile_pos * (16 << self.zoom) as f32 + self.view_offset;
|
|
|
|
if self.active_tool != Tool::None {
|
|
let tex = match self.active_tool {
|
|
Tool::None => unreachable!(),
|
|
Tool::SetTile(t) => {
|
|
if t == Tile::Blank {
|
|
"selection".into()
|
|
} else {
|
|
t.texture()
|
|
}
|
|
}
|
|
Tool::Math => format!("{}_off", self.tool_menu_math.texture_name()),
|
|
Tool::Gate => format!("{}_off", self.tool_menu_gate.texture_name()),
|
|
Tool::Arrow => self.tool_menu_arrow.arrow_texture_name().into(),
|
|
Tool::Mirror => self.tool_menu_mirror.texture_name().into(),
|
|
Tool::Number => todo!(),
|
|
};
|
|
|
|
d.draw_texture_ex(
|
|
textures.get(&tex),
|
|
tile_screen_pos,
|
|
0.,
|
|
(1 << self.zoom) as f32,
|
|
Color::new(255, 255, 255, 100),
|
|
);
|
|
}
|
|
if d.is_mouse_button_down(MouseButton::MOUSE_BUTTON_LEFT) {
|
|
match self.active_tool {
|
|
Tool::None => (),
|
|
Tool::SetTile(tile) => self.source_board.set(tile_pos.into(), tile),
|
|
Tool::Math => self.source_board.set(
|
|
tile_pos.into(),
|
|
Tile::Powerable(PTile::Math(self.tool_menu_math), false),
|
|
),
|
|
Tool::Gate => self.source_board.set(
|
|
tile_pos.into(),
|
|
Tile::Powerable(PTile::Gate(self.tool_menu_gate), false),
|
|
),
|
|
Tool::Arrow => self
|
|
.source_board
|
|
.set(tile_pos.into(), Tile::Arrow(self.tool_menu_arrow)),
|
|
Tool::Mirror => self
|
|
.source_board
|
|
.set(tile_pos.into(), Tile::Mirror(self.tool_menu_mirror)),
|
|
Tool::Number => todo!(),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|