1014 lines
29 KiB
Rust
1014 lines
29 KiB
Rust
use std::{
|
|
fs::{read_dir, read_to_string},
|
|
mem::transmute,
|
|
ops::Rem,
|
|
};
|
|
|
|
use raylib::prelude::*;
|
|
|
|
use crate::{
|
|
blueprint::Blueprint,
|
|
draw_scaled_texture, draw_usize,
|
|
level::Level,
|
|
marble_engine::{
|
|
board::Board,
|
|
pos::Pos,
|
|
tile::{Direction, GateType, MathOp, MirrorType, PTile, Tile, WireType},
|
|
Machine,
|
|
},
|
|
simple_button, simple_option_button, slider,
|
|
solution::{Score, Solution},
|
|
text_input, texture_option_button, userdata_dir, Textures,
|
|
};
|
|
|
|
const HEADER_HEIGHT: i32 = 40;
|
|
const FOOTER_HEIGHT: i32 = 95;
|
|
const SIDEBAR_WIDTH: i32 = 200 + 32 * 2 + 5 * 4;
|
|
const MAX_ZOOM_IN: i32 = 3;
|
|
const BOARD_MARGIN: isize = 3;
|
|
|
|
#[derive(Debug)]
|
|
pub struct Editor {
|
|
source_board: Board,
|
|
level: Level,
|
|
machine: Machine,
|
|
sim_state: SimState,
|
|
view_offset: Vector2,
|
|
zoom: i32,
|
|
output_as_text: bool,
|
|
input_as_text: bool,
|
|
active_tool: Tool,
|
|
tool_math: MathOp,
|
|
tool_gate: GateType,
|
|
tool_arrow: Direction,
|
|
tool_mirror: MirrorType,
|
|
tool_wire: WireType,
|
|
input_text_selected: bool,
|
|
new_blueprint_name: String,
|
|
blueprint_name_selected: bool,
|
|
sim_speed: u8,
|
|
time_since_step: f32,
|
|
exit_state: ExitState,
|
|
exit_menu: bool,
|
|
complete_popup: Popup,
|
|
// fail_popup: Popup,
|
|
score: Option<Score>,
|
|
blueprints: Vec<Blueprint>,
|
|
selected_blueprint: usize,
|
|
blueprint_scroll: usize,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
enum Popup {
|
|
Start,
|
|
Visible,
|
|
Dismissed,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum Tool {
|
|
None,
|
|
Erase,
|
|
SetTile(Tile),
|
|
Digits(Option<Pos>),
|
|
Math,
|
|
Gate,
|
|
Wire,
|
|
Arrow,
|
|
Mirror,
|
|
SelectArea(Option<(Pos, Pos)>, bool),
|
|
Blueprint,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
enum SimState {
|
|
Editing,
|
|
Running,
|
|
Stepping,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub enum ExitState {
|
|
Dont,
|
|
ExitAndSave,
|
|
Save,
|
|
ExitNoSave,
|
|
}
|
|
|
|
impl Editor {
|
|
pub fn new(solution: Solution, level: Level) -> Self {
|
|
Self {
|
|
source_board: Board::parse(&solution.board),
|
|
machine: Machine::new_empty(level.inputs().to_owned(), 1),
|
|
sim_state: SimState::Editing,
|
|
view_offset: Vector2::zero(),
|
|
zoom: 1,
|
|
active_tool: Tool::None,
|
|
output_as_text: level.output_is_text(),
|
|
input_as_text: level.input_is_text(),
|
|
input_text_selected: false,
|
|
new_blueprint_name: String::new(),
|
|
blueprint_name_selected: false,
|
|
sim_speed: 8,
|
|
time_since_step: 0.,
|
|
tool_math: MathOp::Add,
|
|
tool_gate: GateType::Equal,
|
|
tool_arrow: Direction::Right,
|
|
tool_mirror: MirrorType::Forward,
|
|
tool_wire: WireType::Vertical,
|
|
level,
|
|
exit_state: ExitState::Dont,
|
|
exit_menu: false,
|
|
complete_popup: Popup::Start,
|
|
// fail_popup: Popup::Start,
|
|
score: solution.score,
|
|
blueprints: get_blueprints(),
|
|
selected_blueprint: usize::MAX,
|
|
blueprint_scroll: 0,
|
|
}
|
|
}
|
|
|
|
pub fn get_exit_state(&self) -> ExitState {
|
|
self.exit_state
|
|
}
|
|
|
|
pub fn level_id(&self) -> &str {
|
|
self.level.id()
|
|
}
|
|
|
|
pub fn source_board(&self) -> &Board {
|
|
&self.source_board
|
|
}
|
|
|
|
pub fn score(&self) -> Option<Score> {
|
|
self.score.clone()
|
|
}
|
|
|
|
fn pos_to_screen(&self, pos: Vector2) -> Vector2 {
|
|
pos * (16 << self.zoom) as f32 + self.view_offset
|
|
}
|
|
|
|
fn start_sim(&mut self) {
|
|
self.machine.reset();
|
|
self.machine.set_board(self.source_board.clone());
|
|
}
|
|
|
|
fn step_pressed(&mut self) {
|
|
match self.sim_state {
|
|
SimState::Editing => {
|
|
self.start_sim();
|
|
self.step();
|
|
}
|
|
SimState::Running => (),
|
|
SimState::Stepping => self.step(),
|
|
}
|
|
self.sim_state = SimState::Stepping;
|
|
}
|
|
|
|
fn step(&mut self) {
|
|
self.machine.step();
|
|
if self.complete_popup == Popup::Visible {
|
|
self.complete_popup = Popup::Dismissed;
|
|
}
|
|
if !self.level.outputs().is_empty()
|
|
&& self.level.outputs() == self.machine.output()
|
|
&& self.complete_popup == Popup::Start
|
|
{
|
|
self.complete_popup = Popup::Visible;
|
|
self.exit_state = ExitState::Save;
|
|
self.sim_state = SimState::Stepping;
|
|
self.score = Some(Score {
|
|
cycles: self.machine.step_count(),
|
|
tiles: self.source_board.count_tiles(),
|
|
area: 0,
|
|
});
|
|
}
|
|
}
|
|
|
|
fn rotate_tool(&mut self, shift: bool) {
|
|
match &self.active_tool {
|
|
Tool::Math => {
|
|
self.tool_math = match self.tool_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_gate = match self.tool_gate {
|
|
GateType::LessThan => GateType::GreaterThan,
|
|
GateType::GreaterThan => GateType::Equal,
|
|
GateType::Equal => GateType::NotEqual,
|
|
GateType::NotEqual => GateType::LessThan,
|
|
}
|
|
}
|
|
Tool::Arrow => {
|
|
self.tool_arrow = if shift {
|
|
self.tool_arrow.left()
|
|
} else {
|
|
self.tool_arrow.right()
|
|
}
|
|
}
|
|
Tool::Mirror => {
|
|
self.tool_mirror = match self.tool_mirror {
|
|
MirrorType::Forward => MirrorType::Back,
|
|
MirrorType::Back => MirrorType::Forward,
|
|
}
|
|
}
|
|
Tool::Wire => {
|
|
self.tool_wire = match self.tool_wire {
|
|
WireType::Vertical => WireType::Horizontal,
|
|
WireType::Horizontal => WireType::Cross,
|
|
WireType::Cross => WireType::Vertical,
|
|
}
|
|
}
|
|
Tool::None
|
|
| Tool::Erase
|
|
| Tool::SetTile(_)
|
|
| Tool::Digits(_)
|
|
| Tool::SelectArea(_, _)
|
|
| Tool::Blueprint => (),
|
|
}
|
|
}
|
|
|
|
pub fn center_view(&mut self, d: &RaylibHandle) {
|
|
let tile_size = (16 << self.zoom) as f32;
|
|
let tile_x = self.source_board.width() as f32 / 2. * tile_size;
|
|
let tile_y = self.source_board.height() as f32 / 2. * tile_size;
|
|
let screen_x = d.get_screen_width() as f32 / 2.;
|
|
let screen_y = d.get_screen_height() as f32 / 2.;
|
|
self.view_offset.x = (screen_x - tile_x).floor();
|
|
self.view_offset.y = (screen_y - tile_y).floor();
|
|
}
|
|
|
|
fn change_zoom_level(&mut self, d: &RaylibHandle, delta: i32) {
|
|
let tile_size = (16 << self.zoom) as f32;
|
|
let mouse_pos = d.get_mouse_position();
|
|
let tile_pos_of_mouse = (mouse_pos - self.view_offset) / tile_size;
|
|
self.zoom += delta;
|
|
let tile_size = (16 << self.zoom) as f32;
|
|
self.view_offset = mouse_pos - tile_pos_of_mouse * tile_size;
|
|
self.view_offset.x = self.view_offset.x.floor();
|
|
self.view_offset.y = self.view_offset.y.floor();
|
|
}
|
|
|
|
fn zoom_in(&mut self, d: &RaylibHandle) {
|
|
if self.zoom < MAX_ZOOM_IN {
|
|
self.change_zoom_level(d, 1);
|
|
}
|
|
}
|
|
|
|
fn zoom_out(&mut self, d: &RaylibHandle) {
|
|
if self.zoom > 0 {
|
|
self.change_zoom_level(d, -1);
|
|
}
|
|
}
|
|
|
|
fn save_blueprint(&mut self, selection: (Pos, Pos)) {
|
|
let min = selection.0.min(selection.1);
|
|
let max = selection.0.max(selection.1) + (1, 1).into();
|
|
let width = (max.x - min.x) as usize;
|
|
let height = (max.y - min.y) as usize;
|
|
let mut board = Board::new_empty(width, height);
|
|
for (target_x, x) in (min.x..=max.x).enumerate() {
|
|
for (target_y, y) in (min.y..=max.y).enumerate() {
|
|
if let Some(tile) = self.source_board.get(Pos { x, y }) {
|
|
board.set((target_x, target_y).into(), tile);
|
|
}
|
|
}
|
|
}
|
|
board.trim_size(0);
|
|
let mut blueprint = Blueprint::new(&board, self.blueprints.len());
|
|
if !self.new_blueprint_name.is_empty() {
|
|
blueprint.name = self.new_blueprint_name.clone();
|
|
}
|
|
blueprint.save();
|
|
self.blueprints.push(blueprint);
|
|
self.active_tool = Tool::Blueprint;
|
|
}
|
|
|
|
fn grow_board_and_update_view(&mut self, pos: &mut Pos) {
|
|
let tile_size = (16 << self.zoom) as f32;
|
|
let (x, y) = self.source_board.grow_to_include(*pos);
|
|
if x != 0 || y != 0 {
|
|
self.view_offset.x -= x as f32 * tile_size;
|
|
self.view_offset.y -= y as f32 * tile_size;
|
|
pos.x += x;
|
|
pos.y += y;
|
|
match &mut self.active_tool {
|
|
Tool::Digits(Some(pos)) => {
|
|
pos.x += x;
|
|
pos.y += y;
|
|
}
|
|
Tool::SelectArea(Some((start, end)), _) => {
|
|
start.x += x;
|
|
start.y += y;
|
|
end.x += x;
|
|
end.y += y;
|
|
}
|
|
_ => (),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn set_tile(&mut self, mut pos: Pos, tile: Tile) {
|
|
let tile_size = (16 << self.zoom) as f32;
|
|
pos.x -= BOARD_MARGIN;
|
|
pos.y -= BOARD_MARGIN;
|
|
self.grow_board_and_update_view(&mut pos);
|
|
pos.x += BOARD_MARGIN * 2;
|
|
pos.y += BOARD_MARGIN * 2;
|
|
self.grow_board_and_update_view(&mut pos);
|
|
pos.x -= BOARD_MARGIN;
|
|
pos.y -= BOARD_MARGIN;
|
|
self.source_board.set(pos, tile);
|
|
if tile.is_blank() {
|
|
let (x, y) = self.source_board.trim_size(BOARD_MARGIN as usize);
|
|
self.view_offset.x += x as f32 * tile_size;
|
|
self.view_offset.y += y as f32 * tile_size;
|
|
}
|
|
}
|
|
|
|
pub fn update(&mut self, rl: &RaylibHandle) {
|
|
if rl.is_key_pressed(KeyboardKey::KEY_ESCAPE) {
|
|
self.sim_state = SimState::Editing;
|
|
self.complete_popup = Popup::Start;
|
|
}
|
|
if self.sim_state == SimState::Running {
|
|
self.time_since_step += rl.get_frame_time();
|
|
if self.time_since_step > 1. / self.sim_speed as f32 {
|
|
self.time_since_step = 0.;
|
|
self.step();
|
|
}
|
|
}
|
|
if rl.is_key_pressed(KeyboardKey::KEY_SPACE) {
|
|
self.step_pressed()
|
|
}
|
|
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;
|
|
self.complete_popup = Popup::Start;
|
|
}
|
|
SimState::Stepping => self.sim_state = SimState::Running,
|
|
}
|
|
}
|
|
|
|
let mouse_pos = rl.get_mouse_position();
|
|
if self.active_tool != Tool::Blueprint
|
|
|| self.sim_state != SimState::Editing
|
|
|| mouse_pos.x > SIDEBAR_WIDTH as f32
|
|
{
|
|
if rl.get_mouse_wheel_move() > 0. {
|
|
self.zoom_in(rl);
|
|
}
|
|
if rl.get_mouse_wheel_move() < 0. {
|
|
self.zoom_out(rl);
|
|
}
|
|
}
|
|
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.center_view(rl);
|
|
}
|
|
|
|
if rl.is_key_pressed(KeyboardKey::KEY_R) {
|
|
self.rotate_tool(rl.is_key_down(KeyboardKey::KEY_LEFT_SHIFT));
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
pub fn draw(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
|
|
d.clear_background(Color::new(64, 64, 64, 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.,
|
|
d.get_screen_height() as f32 * 2.,
|
|
),
|
|
None,
|
|
tile_size,
|
|
1,
|
|
);
|
|
|
|
self.draw_board(d, textures);
|
|
self.board_overlay(d, textures);
|
|
self.draw_bottom_bar(d, textures);
|
|
self.draw_top_bar(d, textures);
|
|
|
|
if self.active_tool == Tool::Blueprint {
|
|
let sidebar_height = d.get_screen_height() - FOOTER_HEIGHT - HEADER_HEIGHT - 40;
|
|
d.draw_rectangle(
|
|
0,
|
|
HEADER_HEIGHT + 20,
|
|
SIDEBAR_WIDTH,
|
|
sidebar_height,
|
|
Color::new(32, 32, 32, 255),
|
|
);
|
|
d.draw_text("Blueprints", 10, HEADER_HEIGHT + 30, 20, Color::WHITE);
|
|
let mut y = HEADER_HEIGHT + 60;
|
|
let blueprints_shown = (sidebar_height as usize - 45) / 37;
|
|
let end = self
|
|
.blueprints
|
|
.len()
|
|
.min(blueprints_shown + self.blueprint_scroll);
|
|
for (i, b) in self.blueprints[self.blueprint_scroll..end]
|
|
.iter_mut()
|
|
.enumerate()
|
|
{
|
|
let i = i + self.blueprint_scroll;
|
|
if simple_button(d, 5, y, 32, 32) {
|
|
b.remove_file();
|
|
self.blueprints.remove(i);
|
|
break;
|
|
}
|
|
draw_scaled_texture(d, textures.get("rubbish"), 5, y, 2.);
|
|
let is_selected = self.selected_blueprint == i;
|
|
let mut text_selected = is_selected && self.blueprint_name_selected;
|
|
text_input(
|
|
d,
|
|
Rectangle::new(42., y as f32, 200., 32.),
|
|
&mut b.name,
|
|
&mut text_selected,
|
|
32,
|
|
is_selected,
|
|
);
|
|
if is_selected {
|
|
self.blueprint_name_selected = text_selected;
|
|
}
|
|
simple_option_button(d, 42 + 205, y, 32, 32, i, &mut self.selected_blueprint);
|
|
|
|
d.draw_texture_ex(
|
|
textures.get("blueprint"),
|
|
Vector2::new((42 + 205) as f32, y as f32),
|
|
0.,
|
|
2.,
|
|
Color::new(255, 255, 255, if is_selected { 255 } else { 150 }),
|
|
);
|
|
|
|
// d.draw_text(&b.name, 15, y+5, 20, Color::WHITE);
|
|
y += 37;
|
|
}
|
|
}
|
|
|
|
if self.complete_popup == Popup::Visible {
|
|
let width = 310;
|
|
let height = 165;
|
|
let x = d.get_screen_width() / 2 - width / 2;
|
|
let y = d.get_screen_height() / 2 - height / 2;
|
|
d.draw_rectangle(x, y, width, height, Color::DIMGRAY);
|
|
d.draw_text("Level Complete!", x + 10, y + 10, 30, Color::LIME);
|
|
if let Some(score) = &self.score {
|
|
d.draw_text("cycles", x + 15, y + 45, 20, Color::WHITE);
|
|
d.draw_rectangle(x + 10, y + 70, 90, 30, Color::DARKGREEN);
|
|
d.draw_text(
|
|
&format!("{}", score.cycles),
|
|
x + 15,
|
|
y + 75,
|
|
20,
|
|
Color::WHITE,
|
|
);
|
|
|
|
d.draw_text("tiles", x + 115, y + 45, 20, Color::WHITE);
|
|
d.draw_rectangle(x + 110, y + 70, 90, 30, Color::DARKGREEN);
|
|
d.draw_text(
|
|
&format!("{}", score.tiles),
|
|
x + 115,
|
|
y + 75,
|
|
20,
|
|
Color::WHITE,
|
|
);
|
|
|
|
d.draw_text("area", x + 215, y + 45, 20, Color::WHITE);
|
|
d.draw_rectangle(x + 210, y + 70, 90, 30, Color::DARKGREEN);
|
|
d.draw_text(
|
|
&format!("{}", score.area),
|
|
x + 215,
|
|
y + 75,
|
|
20,
|
|
Color::WHITE,
|
|
);
|
|
}
|
|
if simple_button(d, x + 10, y + 110, 140, 45) {
|
|
self.complete_popup = Popup::Dismissed;
|
|
}
|
|
d.draw_text("continue\nediting", x + 15, y + 115, 20, Color::WHITE);
|
|
|
|
if simple_button(d, x + width / 2 + 5, y + 110, 140, 45) {
|
|
self.exit_state = ExitState::ExitAndSave;
|
|
}
|
|
d.draw_text(
|
|
"return to\nlevel list",
|
|
x + width / 2 + 10,
|
|
y + 115,
|
|
20,
|
|
Color::WHITE,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn draw_top_bar(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
|
|
// background
|
|
d.draw_rectangle(
|
|
0,
|
|
0,
|
|
d.get_screen_width(),
|
|
HEADER_HEIGHT,
|
|
Color::new(32, 32, 32, 255),
|
|
);
|
|
|
|
if self.exit_menu {
|
|
if simple_button(d, 5, 5, 75, 30) {
|
|
self.exit_menu = false;
|
|
}
|
|
d.draw_text("cancel", 10, 10, 20, Color::WHITE);
|
|
if simple_button(d, 85, 5, 60, 30) {
|
|
self.exit_state = ExitState::ExitAndSave;
|
|
}
|
|
d.draw_text("save", 90, 10, 20, Color::WHITE);
|
|
if simple_button(d, 150, 5, 80, 30) {
|
|
self.exit_state = ExitState::ExitNoSave;
|
|
}
|
|
d.draw_text("revert", 155, 10, 20, Color::WHITE);
|
|
} else {
|
|
if simple_button(d, 5, 5, 75, 30) {
|
|
self.exit_menu = true;
|
|
}
|
|
d.draw_text("exit", 10, 10, 20, Color::WHITE);
|
|
if simple_button(d, 85, 5, 60, 30) {
|
|
self.exit_state = ExitState::Save;
|
|
}
|
|
d.draw_text("save", 90, 10, 20, Color::WHITE);
|
|
}
|
|
|
|
match self.sim_state {
|
|
SimState::Editing => {
|
|
if simple_button(d, 260, 4, 32, 32) {
|
|
self.start_sim();
|
|
self.sim_state = SimState::Running;
|
|
}
|
|
draw_scaled_texture(d, textures.get("play"), 260, 4, 2.);
|
|
}
|
|
SimState::Running => {
|
|
if simple_button(d, 260, 4, 32, 32) {
|
|
self.sim_state = SimState::Stepping;
|
|
}
|
|
draw_scaled_texture(d, textures.get("pause"), 260, 4, 2.);
|
|
if simple_button(d, 296, 4, 32, 32) {
|
|
self.sim_state = SimState::Editing;
|
|
self.complete_popup = Popup::Start;
|
|
}
|
|
draw_scaled_texture(d, textures.get("stop"), 296, 4, 2.);
|
|
}
|
|
SimState::Stepping => {
|
|
if simple_button(d, 260, 4, 32, 32) {
|
|
self.sim_state = SimState::Running;
|
|
}
|
|
draw_scaled_texture(d, textures.get("play"), 260, 4, 2.);
|
|
if simple_button(d, 296, 4, 32, 32) {
|
|
self.sim_state = SimState::Editing;
|
|
self.complete_popup = Popup::Start;
|
|
}
|
|
draw_scaled_texture(d, textures.get("stop"), 296, 4, 2.);
|
|
}
|
|
}
|
|
if simple_button(d, 332, 4, 32, 32) {
|
|
self.step_pressed();
|
|
}
|
|
draw_scaled_texture(d, textures.get("step"), 332, 4, 2.);
|
|
|
|
d.draw_text("speed", 368, 6, 10, Color::WHITE);
|
|
draw_usize(d, textures, self.sim_speed as usize, 398, 4, 2, 1);
|
|
slider(d, &mut self.sim_speed, 1, 33, 368, 24, 48, 12);
|
|
|
|
draw_usize(d, textures, self.machine.step_count(), 420, 4, 5, 2);
|
|
|
|
d.draw_text("input:", 523, 8, 10, Color::WHITE);
|
|
if simple_button(d, 520, 20, 35, 15) {
|
|
self.input_as_text = !self.input_as_text
|
|
}
|
|
let input_mode_text = if self.input_as_text { "text" } else { "bytes" };
|
|
d.draw_text(input_mode_text, 523, 23, 10, Color::WHITE);
|
|
|
|
let input_x = 560;
|
|
let width = d.get_screen_width();
|
|
if self.input_as_text {
|
|
let mut input_text = String::new();
|
|
for &byte in self.machine.input() {
|
|
if byte.is_ascii_graphic() || byte == b' ' {
|
|
input_text.push(byte as char);
|
|
} else {
|
|
input_text.push('\\');
|
|
}
|
|
}
|
|
if text_input(
|
|
d,
|
|
Rectangle::new(input_x as f32, 5., (width - input_x - 5) as f32, 30.),
|
|
&mut input_text,
|
|
&mut self.input_text_selected,
|
|
256,
|
|
self.level.is_sandbox(),
|
|
) {
|
|
self.machine.set_input(input_text.into_bytes());
|
|
}
|
|
} else {
|
|
let input_cell_width = 43;
|
|
let input_cells = (d.get_screen_width() - input_x) as usize / input_cell_width as usize;
|
|
|
|
let input_start = self.machine.input_index().saturating_sub(input_cells);
|
|
let input_end = input_start + input_cells;
|
|
for (box_index, index) in (input_start..input_end).enumerate() {
|
|
let x = input_x + input_cell_width * box_index as i32;
|
|
let byte = self.machine.input().get(index);
|
|
d.draw_rectangle(x, 5, input_cell_width - 5, 30, Color::DIMGRAY);
|
|
let color = if index < self.machine.input_index() {
|
|
d.draw_rectangle(x + 4, 25, input_cell_width - 13, 8, Color::LIME);
|
|
Color::LIGHTGREEN
|
|
} else {
|
|
Color::WHITE
|
|
};
|
|
if let Some(&byte) = byte {
|
|
let top_text = format!("{}", byte);
|
|
d.draw_text(&top_text, x + 2, 5, 20, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn draw_bottom_bar(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
|
|
let height = d.get_screen_height();
|
|
let footer_top = (height - FOOTER_HEIGHT) as f32;
|
|
// background
|
|
d.draw_rectangle(
|
|
0,
|
|
height - FOOTER_HEIGHT,
|
|
d.get_screen_width(),
|
|
FOOTER_HEIGHT,
|
|
Color::new(32, 32, 32, 255),
|
|
);
|
|
|
|
let mut hide_tile_tools = false;
|
|
if let Tool::SelectArea(Some(selection), _) = self.active_tool {
|
|
hide_tile_tools = true;
|
|
text_input(
|
|
d,
|
|
Rectangle::new(100., footer_top + 10., 240., 30.),
|
|
&mut self.new_blueprint_name,
|
|
&mut self.blueprint_name_selected,
|
|
32,
|
|
true,
|
|
);
|
|
if simple_button(d, 100, footer_top as i32 + 49, 40, 40) {
|
|
self.save_blueprint(selection);
|
|
}
|
|
draw_scaled_texture(d, textures.get("save"), 104, footer_top as i32 + 53, 2.);
|
|
if simple_button(d, 144, footer_top as i32 + 49, 40, 40) {
|
|
self.active_tool = Tool::SelectArea(None, false);
|
|
}
|
|
draw_scaled_texture(d, textures.get("cancel"), 148, footer_top as i32 + 53, 2.);
|
|
}
|
|
|
|
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_option_button(
|
|
d,
|
|
Vector2 {
|
|
x: 100. + col as f32 * bound_offset - if col < 0 { 10. } 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, -2), "eraser", Tool::Erase);
|
|
tool_button((1, -2), "selection", Tool::SelectArea(None, false));
|
|
|
|
tool_button((0, -1), "blueprint", Tool::Blueprint);
|
|
tool_button((1, -1), "transparent", Tool::None);
|
|
|
|
if !hide_tile_tools {
|
|
tool_button((0, 0), "block", Tool::SetTile(Tile::from_char('#')));
|
|
tool_button((0, 1), "bag_off", Tool::SetTile(Tile::from_char('B')));
|
|
tool_button((0, 2), "trigger_off", Tool::SetTile(Tile::from_char('*')));
|
|
tool_button((0, 3), "io_tile_off", Tool::SetTile(Tile::from_char('I')));
|
|
tool_button((0, 4), "flipper_off", Tool::SetTile(Tile::from_char('F')));
|
|
tool_button((0, 5), "digit_tool", Tool::Digits(None));
|
|
|
|
tool_button((1, 0), "marble", Tool::SetTile(Tile::from_char('o')));
|
|
tool_button(
|
|
(1, 1),
|
|
&Tile::Powerable(PTile::Wire(self.tool_wire), false).texture(),
|
|
Tool::Wire,
|
|
);
|
|
|
|
tool_button((1, 2), &Tile::Arrow(self.tool_arrow).texture(), Tool::Arrow);
|
|
tool_button(
|
|
(1, 3),
|
|
&Tile::Mirror(self.tool_mirror).texture(),
|
|
Tool::Mirror,
|
|
);
|
|
tool_button(
|
|
(1, 4),
|
|
&Tile::Powerable(PTile::Math(self.tool_math), false).texture(),
|
|
Tool::Math,
|
|
);
|
|
tool_button(
|
|
(1, 5),
|
|
&Tile::Powerable(PTile::Gate(self.tool_gate), false).texture(),
|
|
Tool::Gate,
|
|
);
|
|
}
|
|
|
|
let output_x = 370;
|
|
let output_cell_width = 43;
|
|
let output_cells = (d.get_screen_width() - output_x) as usize / output_cell_width as usize;
|
|
|
|
let y = footer_top as i32 + 5;
|
|
if simple_button(d, output_x, y + 70, 65, 15) {
|
|
self.output_as_text = !self.output_as_text
|
|
}
|
|
let output_mode_text = if self.output_as_text {
|
|
"show bytes"
|
|
} else {
|
|
"show text"
|
|
};
|
|
d.draw_text(output_mode_text, output_x + 5, y + 72, 10, Color::WHITE);
|
|
|
|
let output_start = self.machine.output().len().saturating_sub(output_cells);
|
|
let output_end = output_start + output_cells;
|
|
for (box_index, index) in (output_start..output_end).enumerate() {
|
|
let x = output_x + output_cell_width * box_index as i32;
|
|
|
|
let expected_byte = self.level.outputs().get(index);
|
|
let real_byte = self.machine.output().get(index);
|
|
|
|
let (top_color, bottom_color) =
|
|
if let (Some(&real_byte), Some(&expected_byte)) = (real_byte, expected_byte) {
|
|
if expected_byte == real_byte {
|
|
(Color::GREEN, Color::DARKGREEN)
|
|
} else {
|
|
(Color::RED, Color::DARKRED)
|
|
}
|
|
} else {
|
|
(Color::DARKGRAY, Color::DIMGRAY)
|
|
};
|
|
|
|
d.draw_rectangle(x, y, output_cell_width - 5, 30, top_color);
|
|
d.draw_rectangle(x, y + 35, output_cell_width - 5, 30, bottom_color);
|
|
if let Some(&expected_byte) = expected_byte {
|
|
let top_text = if self.output_as_text
|
|
&& (expected_byte.is_ascii_graphic() || expected_byte.is_ascii_whitespace())
|
|
{
|
|
format!("{:?}", expected_byte as char)
|
|
} else {
|
|
format!("{}", expected_byte)
|
|
};
|
|
d.draw_text(&top_text, x + 2, y + 5, 20, Color::WHITE);
|
|
}
|
|
if let Some(&real_byte) = real_byte {
|
|
let bottom_text = if self.output_as_text
|
|
&& (real_byte.is_ascii_graphic() || real_byte.is_ascii_whitespace())
|
|
{
|
|
format!("{:?}", real_byte as char)
|
|
} else {
|
|
format!("{}", real_byte)
|
|
};
|
|
d.draw_text(&bottom_text, x + 2, y + 40, 20, Color::WHITE);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn board_overlay(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
|
|
let footer_top = (d.get_screen_height() - FOOTER_HEIGHT) as f32;
|
|
let mouse_pos = d.get_mouse_position();
|
|
let scroll_delta = d.get_mouse_wheel_move();
|
|
let tile_scale = (1 << self.zoom) as f32;
|
|
let tile_size = 16 << self.zoom;
|
|
if self.sim_state == SimState::Editing {
|
|
if let Tool::Digits(Some(pos)) = &mut self.active_tool {
|
|
let tile_screen_pos = pos.to_vec() * tile_size as f32 + self.view_offset;
|
|
d.draw_texture_ex(
|
|
textures.get("selection"),
|
|
tile_screen_pos,
|
|
0.,
|
|
tile_scale,
|
|
Color::new(255, 180, 20, 255),
|
|
);
|
|
if d.is_key_pressed(KeyboardKey::KEY_LEFT) {
|
|
pos.x -= 1;
|
|
}
|
|
if d.is_key_pressed(KeyboardKey::KEY_RIGHT) {
|
|
pos.x += 1;
|
|
}
|
|
if d.is_key_pressed(KeyboardKey::KEY_UP) {
|
|
pos.y -= 1;
|
|
}
|
|
if d.is_key_pressed(KeyboardKey::KEY_DOWN) {
|
|
pos.y += 1;
|
|
}
|
|
let pos = *pos;
|
|
for n in 0..10 {
|
|
if d.is_key_pressed(unsafe { transmute::<u32, KeyboardKey>(b'0' as u32 + n) }) {
|
|
self.set_tile(pos, Tile::Digit(n as u8));
|
|
}
|
|
}
|
|
}
|
|
if mouse_pos.y < footer_top && mouse_pos.y > HEADER_HEIGHT as f32 {
|
|
let tile_pos = (mouse_pos - self.view_offset) / tile_size as f32;
|
|
let tile_pos = Vector2::new(tile_pos.x.floor(), tile_pos.y.floor());
|
|
|
|
let tile_screen_pos = self.pos_to_screen(tile_pos);
|
|
|
|
if self.active_tool != Tool::None {
|
|
let tex = match self.active_tool {
|
|
Tool::None => unreachable!(),
|
|
Tool::Erase => "selection".into(),
|
|
Tool::SetTile(t) => t.texture(),
|
|
Tool::Math => format!("{}_off", self.tool_math.texture_name()),
|
|
Tool::Gate => format!("{}_off", self.tool_gate.texture_name()),
|
|
Tool::Wire => format!("{}_off", self.tool_wire.texture_name()),
|
|
Tool::Arrow => self.tool_arrow.arrow_texture_name().into(),
|
|
Tool::Mirror => self.tool_mirror.texture_name().into(),
|
|
Tool::Digits(_) => "selection".into(),
|
|
Tool::SelectArea(_, false) => "area_full".into(),
|
|
Tool::SelectArea(_, true) => "transparent".into(),
|
|
Tool::Blueprint => "transparent".into(),
|
|
};
|
|
|
|
d.draw_texture_ex(
|
|
textures.get(&tex),
|
|
tile_screen_pos,
|
|
0.,
|
|
tile_scale,
|
|
Color::new(255, 255, 255, 100),
|
|
);
|
|
}
|
|
if d.is_mouse_button_pressed(MouseButton::MOUSE_BUTTON_LEFT) {
|
|
let pos = tile_pos.into();
|
|
match self.active_tool {
|
|
Tool::None => (),
|
|
Tool::Erase => (),
|
|
Tool::SetTile(tile) => self.set_tile(pos, tile),
|
|
Tool::Math => {
|
|
self.set_tile(pos, Tile::Powerable(PTile::Math(self.tool_math), false))
|
|
}
|
|
Tool::Gate => {
|
|
self.set_tile(pos, Tile::Powerable(PTile::Gate(self.tool_gate), false))
|
|
}
|
|
Tool::Wire => {
|
|
self.set_tile(pos, Tile::Powerable(PTile::Wire(self.tool_wire), false))
|
|
}
|
|
Tool::Arrow => self.set_tile(pos, Tile::Arrow(self.tool_arrow)),
|
|
Tool::Mirror => self.set_tile(pos, Tile::Mirror(self.tool_mirror)),
|
|
Tool::Digits(_pos) => {
|
|
self.active_tool = Tool::Digits(Some(pos));
|
|
if let Some(tile) = self.source_board.get_mut(pos) {
|
|
if let Tile::Digit(_) = tile {
|
|
} else {
|
|
*tile = Tile::Digit(0);
|
|
}
|
|
}
|
|
}
|
|
Tool::Blueprint => {
|
|
if mouse_pos.x > SIDEBAR_WIDTH as f32 {
|
|
if let Some(bp) = self.blueprints.get(self.selected_blueprint) {
|
|
let board = bp.get_board().unwrap().clone();
|
|
let mut pos = pos;
|
|
self.grow_board_and_update_view(&mut pos);
|
|
self.grow_board_and_update_view(
|
|
&mut (pos + (board.width() - 1, board.height() - 1).into()),
|
|
);
|
|
for x in 0..board.width() {
|
|
for y in 0..board.height() {
|
|
let p = (x, y).into();
|
|
if let Some(tile) = board.get(p) {
|
|
self.source_board.set(p + pos, tile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Tool::SelectArea(_, _) => (),
|
|
}
|
|
}
|
|
if d.is_mouse_button_down(MouseButton::MOUSE_BUTTON_LEFT)
|
|
&& self.active_tool == Tool::Erase
|
|
{
|
|
self.set_tile(tile_pos.into(), Tile::Blank)
|
|
}
|
|
if let Tool::SelectArea(selection, is_selecting) = &mut self.active_tool {
|
|
if d.is_mouse_button_down(MouseButton::MOUSE_BUTTON_LEFT) {
|
|
if *is_selecting {
|
|
if let Some((_start, end)) = selection {
|
|
*end = tile_pos.into();
|
|
} else {
|
|
*selection = Some((tile_pos.into(), tile_pos.into()));
|
|
}
|
|
} else {
|
|
*selection = Some((tile_pos.into(), tile_pos.into()));
|
|
*is_selecting = true;
|
|
}
|
|
} else if d.is_mouse_button_released(MouseButton::MOUSE_BUTTON_LEFT) {
|
|
*is_selecting = false;
|
|
}
|
|
}
|
|
if let Tool::Blueprint = self.active_tool {
|
|
if let Some(bp) = self.blueprints.get_mut(self.selected_blueprint) {
|
|
let view_offset = Vector2::new(
|
|
self.view_offset.x.rem(tile_size as f32),
|
|
self.view_offset.y.rem(tile_size as f32),
|
|
);
|
|
let mut offset = mouse_pos - view_offset;
|
|
offset.x -= offset.x.rem(tile_size as f32);
|
|
offset.y -= offset.y.rem(tile_size as f32);
|
|
offset += view_offset;
|
|
bp.convert_board().draw(d, textures, offset, self.zoom);
|
|
}
|
|
if mouse_pos.x < SIDEBAR_WIDTH as f32 {
|
|
if scroll_delta < 0.
|
|
&& self.blueprint_scroll < self.blueprints.len().saturating_sub(5)
|
|
{
|
|
self.blueprint_scroll += 1;
|
|
} else if scroll_delta > 0. && self.blueprint_scroll > 0 {
|
|
self.blueprint_scroll -= 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// draw selection
|
|
if let Tool::SelectArea(Some((start, end)), _) = self.active_tool {
|
|
let min = start.min(end);
|
|
let max = start.max(end);
|
|
let p_min = self.pos_to_screen(min.to_vec());
|
|
let p_max = self.pos_to_screen(max.to_vec());
|
|
let tex = textures.get("area_corner");
|
|
d.draw_texture_ex(tex, p_min, 0., tile_scale, Color::WHITE);
|
|
let one_xy = Vector2::new(tile_size as f32, tile_size as f32);
|
|
d.draw_texture_ex(tex, p_max + one_xy, 180., tile_scale, Color::WHITE);
|
|
let top_right = Vector2::new(p_max.x + tile_size as f32, p_min.y);
|
|
d.draw_texture_ex(tex, top_right, 90., tile_scale, Color::WHITE);
|
|
let bot_left = Vector2::new(p_min.x, p_max.y + tile_size as f32);
|
|
d.draw_texture_ex(tex, bot_left, -90., tile_scale, Color::WHITE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq for Tool {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
match (self, other) {
|
|
(Self::SetTile(l0), Self::SetTile(r0)) => l0 == r0,
|
|
(Self::Digits(_), Self::Digits(_)) => true,
|
|
(Self::SelectArea(_, _), Self::SelectArea(_, _)) => true,
|
|
_ => ::core::mem::discriminant(self) == ::core::mem::discriminant(other),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_blueprints() -> Vec<Blueprint> {
|
|
let mut blueprints = Vec::<Blueprint>::new();
|
|
let Ok(dir) = read_dir(userdata_dir().join("blueprints")) else {
|
|
return blueprints;
|
|
};
|
|
for d in dir.flatten() {
|
|
let l = read_to_string(d.path())
|
|
.ok()
|
|
.as_deref()
|
|
.and_then(|s| serde_json::from_str(s).ok());
|
|
if let Some(level) = l {
|
|
blueprints.push(level);
|
|
}
|
|
}
|
|
blueprints.sort_by(|a, b| a.name.cmp(&b.name));
|
|
blueprints
|
|
}
|