added undo/redo feature
This commit is contained in:
@@ -1,511 +1,15 @@
|
||||
use gdk4::cairo::{Context as CairoContext, Matrix, Rectangle};
|
||||
use gtk4::cairo::Error;
|
||||
use gtk4::glib::{MainContext, Propagation};
|
||||
use gtk4::{self as gtk, gdk::ffi::GDK_BUTTON_PRIMARY};
|
||||
use gtk4::{Application, DrawingArea, prelude::*};
|
||||
use rdraught::draughts::{DraughtsBoard, DraughtsGame, Move, Piece, Player};
|
||||
use rdraught::position::Position;
|
||||
use glib::ExitCode;
|
||||
use rdraught;
|
||||
use rdraught::draughts::DraughtsGame;
|
||||
use rdraught_ui;
|
||||
mod geo2d;
|
||||
use core::f64::consts::PI;
|
||||
use geo2d::Point;
|
||||
use rsvg::SvgHandle;
|
||||
use std::thread;
|
||||
const SQUARE_SIZE: f64 = 1.0;
|
||||
|
||||
mod final_dialog;
|
||||
mod greeting_dialog;
|
||||
mod rdraught_application;
|
||||
mod types;
|
||||
|
||||
use types::{SharedMutable, SharedMutableRef, new_shared_mut, new_shared_mut_ref};
|
||||
|
||||
const CROWN_RED: &[u8] = include_bytes!("crown_red.svg");
|
||||
const CROWN_WHITE: &[u8] = include_bytes!("crown_white.svg");
|
||||
|
||||
fn transform_point(p: &Point, m: &Matrix) -> Point {
|
||||
let (x, y) = m.transform_point(p.x(), p.y());
|
||||
Point::new(x, y)
|
||||
}
|
||||
|
||||
trait AugmentedRect {
|
||||
fn from_points(tl: Point, br: Point) -> Rectangle;
|
||||
fn center(&self) -> Point;
|
||||
fn tl(&self) -> Point;
|
||||
fn br(&self) -> Point;
|
||||
fn contains(&self, p: &Point) -> bool;
|
||||
}
|
||||
|
||||
impl AugmentedRect for Rectangle {
|
||||
fn center(&self) -> Point {
|
||||
Point::new(
|
||||
self.x() + self.width() / 2.0,
|
||||
self.y() + self.height() / 2.0,
|
||||
)
|
||||
}
|
||||
|
||||
fn tl(&self) -> Point {
|
||||
Point::new(self.x(), self.y())
|
||||
}
|
||||
|
||||
fn br(&self) -> Point {
|
||||
Point::new(self.x() + self.width(), self.y() + self.height())
|
||||
}
|
||||
|
||||
fn from_points(tl: Point, br: Point) -> Rectangle {
|
||||
Rectangle::new(tl.x(), tl.y(), br.x() - tl.x(), br.y() - tl.y())
|
||||
}
|
||||
|
||||
fn contains(&self, p: &Point) -> bool {
|
||||
self.x() < p.x()
|
||||
&& self.x() + self.width() > p.x()
|
||||
&& self.y() < p.y()
|
||||
&& self.y() + self.height() > p.y()
|
||||
}
|
||||
}
|
||||
|
||||
fn draw_piece(
|
||||
cr: &CairoContext,
|
||||
square: &Rectangle,
|
||||
piece: Piece,
|
||||
crown_red: &SvgHandle,
|
||||
crown_white: &SvgHandle,
|
||||
) -> Result<(), Error> {
|
||||
if let Piece::NoPiece = piece {
|
||||
Ok(())
|
||||
} else {
|
||||
cr.save()?;
|
||||
let center = square.center();
|
||||
let outer_radius = square.width() * 0.3;
|
||||
let vertical_scale_factor = 0.8;
|
||||
let matrix = {
|
||||
let mut m1 = Matrix::identity();
|
||||
m1.translate(0.0, -(center.y() - outer_radius));
|
||||
let mut m2 = Matrix::identity();
|
||||
m2.scale(1.0, vertical_scale_factor);
|
||||
let mut m3 = Matrix::identity();
|
||||
m3.translate(0.0, center.y() - outer_radius * vertical_scale_factor);
|
||||
Matrix::multiply(&Matrix::multiply(&m1, &m2), &m3)
|
||||
};
|
||||
cr.set_matrix(Matrix::multiply(&matrix, &cr.matrix()));
|
||||
cr.set_source_rgb(0.0, 0.0, 0.0);
|
||||
let thickness = outer_radius * 0.3;
|
||||
cr.arc(
|
||||
center.x(),
|
||||
center.y() + thickness / 2.0,
|
||||
outer_radius,
|
||||
0.0,
|
||||
2.0 * PI,
|
||||
);
|
||||
cr.rectangle(
|
||||
center.x() - outer_radius,
|
||||
center.y() - thickness / 2.0,
|
||||
outer_radius * 2.0,
|
||||
thickness,
|
||||
);
|
||||
cr.arc(
|
||||
center.x(),
|
||||
center.y() - thickness / 2.0,
|
||||
outer_radius,
|
||||
0.0,
|
||||
2.0 * PI,
|
||||
);
|
||||
cr.fill().unwrap();
|
||||
let (color, crowned) = match piece {
|
||||
Piece::NoPiece => return Ok(()),
|
||||
Piece::SimpleRedPawn => ((1.0, 0.0, 0.0), false),
|
||||
Piece::SimpleWhitePawn => ((1.0, 1.0, 1.0), false),
|
||||
Piece::CrownedRedPawn => ((1.0, 0.0, 0.0), true),
|
||||
Piece::CrownedWhitePawn => ((1.0, 1.0, 1.0), true),
|
||||
};
|
||||
let radius = square.width() * 0.275;
|
||||
cr.set_source_rgb(color.0, color.1, color.2);
|
||||
cr.arc(
|
||||
center.x(),
|
||||
center.y() - thickness / 2.0,
|
||||
radius,
|
||||
0.0,
|
||||
2.0 * PI,
|
||||
);
|
||||
cr.fill()?;
|
||||
cr.restore()?;
|
||||
if crowned {
|
||||
let renderer = match piece.player() {
|
||||
Some(Player::Red) => rsvg::CairoRenderer::new(crown_red),
|
||||
Some(Player::White) => rsvg::CairoRenderer::new(crown_white),
|
||||
None => panic!("This should never happen"),
|
||||
};
|
||||
let m4 = {
|
||||
let mut m1 = Matrix::identity();
|
||||
m1.translate(-center.x(), -(center.y() - thickness / 1.0));
|
||||
let mut m2 = Matrix::identity();
|
||||
m2.scale(0.5, 0.5);
|
||||
let mut m3 = Matrix::identity();
|
||||
m3.translate(center.x(), center.y() - thickness / 1.0);
|
||||
Matrix::multiply(&Matrix::multiply(&m1, &m2), &m3)
|
||||
};
|
||||
cr.set_matrix(Matrix::multiply(
|
||||
&Matrix::multiply(&matrix, &m4),
|
||||
&cr.matrix(),
|
||||
));
|
||||
renderer
|
||||
.render_document(
|
||||
cr,
|
||||
&cairo::Rectangle::new(
|
||||
square.tl().x(),
|
||||
square.tl().y(),
|
||||
square.width(),
|
||||
square.height(),
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn draw_score_bar(
|
||||
cr: &CairoContext,
|
||||
board: &Rectangle,
|
||||
draughts_game: &DraughtsGame,
|
||||
current_player: Player,
|
||||
) {
|
||||
fn modulate_score(relative_score: f64) -> f64 {
|
||||
let x = relative_score;
|
||||
f64::atan(8.0 * x - 4.0) / f64::atan(4.0) / 2.0 + 0.5
|
||||
}
|
||||
let score_bar = Rectangle::new(
|
||||
board.tl().x() - board.width() / 10.0,
|
||||
board.tl().y(),
|
||||
board.width() / 16.0,
|
||||
board.height(),
|
||||
);
|
||||
let score_percentage = modulate_score(draughts_game.relative_score(current_player) as f64);
|
||||
let tl = score_bar.tl();
|
||||
cr.save().unwrap();
|
||||
match current_player {
|
||||
Player::White => cr.set_source_rgb(1.0, 0.0, 0.0),
|
||||
Player::Red => cr.set_source_rgb(1.0, 1.0, 1.0),
|
||||
}
|
||||
cr.rectangle(
|
||||
score_bar.tl().x(),
|
||||
score_bar.tl().y(),
|
||||
score_bar.width(),
|
||||
score_bar.height() * (1.0 - score_percentage),
|
||||
);
|
||||
cr.fill().unwrap();
|
||||
match current_player {
|
||||
Player::White => cr.set_source_rgb(1.0, 1.0, 1.0),
|
||||
Player::Red => cr.set_source_rgb(1.0, 0.0, 0.0),
|
||||
}
|
||||
cr.rectangle(
|
||||
tl.x(),
|
||||
tl.y() + score_bar.height() * (1.0 - score_percentage),
|
||||
score_bar.width(),
|
||||
score_bar.height() * score_percentage,
|
||||
);
|
||||
cr.fill().unwrap();
|
||||
cr.restore().unwrap();
|
||||
}
|
||||
|
||||
fn create_game_window(application: &Application, current_player: Player) {
|
||||
// Create a new window.
|
||||
let window = gtk::ApplicationWindow::builder()
|
||||
.application(application)
|
||||
.title("Rdraught")
|
||||
.default_width(800)
|
||||
.default_height(800)
|
||||
.build();
|
||||
|
||||
// Create a DrawingArea widget where we will draw the chessboard.
|
||||
let drawing_area = DrawingArea::new();
|
||||
// Add the drawing area to the window.
|
||||
window.set_child(Some(&drawing_area));
|
||||
|
||||
let draughts_game = new_shared_mut_ref(DraughtsGame::default());
|
||||
let selected_piece: SharedMutable<Option<Position>> = new_shared_mut(None);
|
||||
let available_moves = new_shared_mut_ref(Vec::<Move>::new());
|
||||
// Get the allocation information for the widget.
|
||||
let board_width = SQUARE_SIZE * DraughtsBoard::rows() as f64;
|
||||
let board_height = SQUARE_SIZE * DraughtsBoard::columns() as f64;
|
||||
let board = Rectangle::from_points(Point::new(0.0, 0.0), Point::new(board_width, board_height));
|
||||
let board_with_bar = Rectangle::from_points(
|
||||
Point::new(-board_width / 10.0, 0.0),
|
||||
Point::new(board_width, board_height),
|
||||
);
|
||||
let board_clone = board;
|
||||
let crown_red_handle = {
|
||||
let stream = gio::MemoryInputStream::from_bytes(&glib::Bytes::from_static(CROWN_RED));
|
||||
|
||||
rsvg::Loader::new()
|
||||
.read_stream(
|
||||
&stream,
|
||||
None::<&gio::File>, // no base file as this document has no references
|
||||
None::<&gio::Cancellable>, // no cancellable
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
let crown_white_handle = {
|
||||
let stream = gio::MemoryInputStream::from_bytes(&glib::Bytes::from_static(CROWN_WHITE));
|
||||
|
||||
rsvg::Loader::new()
|
||||
.read_stream(
|
||||
&stream,
|
||||
None::<&gio::File>, // no base file as this document has no references
|
||||
None::<&gio::Cancellable>, // no cancellable
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
let xform = new_shared_mut_ref(Matrix::identity());
|
||||
// Set the "draw" function of the drawing area. This callback is called
|
||||
// whenever GTK needs to redraw this widget (for example, on first display or when resized).
|
||||
{
|
||||
let draughts_game = draughts_game.clone();
|
||||
let xform = xform.clone();
|
||||
let selected_piece = selected_piece.clone();
|
||||
let available_moves = available_moves.clone();
|
||||
drawing_area.set_draw_func(move |_widget, cr, width, height| {
|
||||
let screen = Rectangle::from_points(
|
||||
Point::new(0.0, 0.0),
|
||||
Point::new(width as f64, height as f64),
|
||||
);
|
||||
let f = f64::min(
|
||||
screen.width() / board_with_bar.width(),
|
||||
screen.height() / board_with_bar.height(),
|
||||
);
|
||||
let screen_center = screen.center();
|
||||
let board_center = board_with_bar.center();
|
||||
let mut xform = xform.borrow_mut();
|
||||
*xform = Matrix::multiply(
|
||||
&Matrix::multiply(
|
||||
&Matrix::new(1.0, 0.0, 0.0, 1.0, -board_center.x(), -board_center.y()),
|
||||
&Matrix::new(f, 0.0, 0.0, f, 0.0, 0.0),
|
||||
),
|
||||
&Matrix::new(1.0, 0.0, 0.0, 1.0, screen_center.x(), screen_center.y()),
|
||||
);
|
||||
cr.set_matrix(*xform);
|
||||
|
||||
// Loop over rows and columns to draw each chessboard cell.
|
||||
for row in 0..DraughtsBoard::rows() {
|
||||
for col in 0..DraughtsBoard::columns() {
|
||||
let position = match current_player {
|
||||
Player::White => Position::new((8 - row - 1) as u8, col as u8),
|
||||
Player::Red => Position::new(row as u8, col as u8),
|
||||
};
|
||||
let square = Rectangle::new(
|
||||
col as f64 * SQUARE_SIZE,
|
||||
row as f64 * SQUARE_SIZE,
|
||||
SQUARE_SIZE,
|
||||
SQUARE_SIZE,
|
||||
);
|
||||
cr.save().unwrap();
|
||||
// Alternate colors based on the sum of row and column indices.
|
||||
if (row + col) % 2 == 0 {
|
||||
cr.set_source_rgb(0.8, 0.8, 0.6);
|
||||
} else {
|
||||
cr.set_source_rgb(0.4, 0.4, 0.2);
|
||||
}
|
||||
|
||||
// Draw and fill the square.
|
||||
cr.rectangle(
|
||||
square.tl().x(),
|
||||
square.tl().y(),
|
||||
square.width(),
|
||||
square.height(),
|
||||
);
|
||||
cr.fill().unwrap();
|
||||
draw_piece(
|
||||
cr,
|
||||
&square,
|
||||
draughts_game.borrow().piece_at(position),
|
||||
&crown_red_handle,
|
||||
&crown_white_handle,
|
||||
)
|
||||
.unwrap();
|
||||
cr.restore().unwrap();
|
||||
}
|
||||
}
|
||||
if let Some(selected_position) = selected_piece.get() {
|
||||
let screen_position = match current_player {
|
||||
Player::White => {
|
||||
Position::new(8 - 1 - selected_position.row(), selected_position.col())
|
||||
}
|
||||
Player::Red => selected_position,
|
||||
};
|
||||
let square = Rectangle::new(
|
||||
screen_position.col() as f64 * SQUARE_SIZE,
|
||||
screen_position.row() as f64 * SQUARE_SIZE,
|
||||
SQUARE_SIZE,
|
||||
SQUARE_SIZE,
|
||||
);
|
||||
cr.save().unwrap();
|
||||
cr.new_path();
|
||||
cr.move_to(square.tl().x(), square.tl().y());
|
||||
cr.line_to(square.tl().x(), square.br().y());
|
||||
cr.line_to(square.br().x(), square.br().y());
|
||||
cr.line_to(square.br().x(), square.tl().y());
|
||||
cr.line_to(square.tl().x(), square.tl().y());
|
||||
cr.clip();
|
||||
cr.new_path();
|
||||
cr.set_source_rgb(0.0, 0.0, 1.0);
|
||||
cr.set_line_width((square.width() + square.height()) * 0.05);
|
||||
cr.move_to(square.tl().x(), square.tl().y());
|
||||
cr.line_to(square.tl().x(), square.br().y());
|
||||
cr.line_to(square.br().x(), square.br().y());
|
||||
cr.line_to(square.br().x(), square.tl().y());
|
||||
cr.line_to(square.tl().x(), square.tl().y());
|
||||
cr.stroke().unwrap();
|
||||
cr.restore().unwrap();
|
||||
}
|
||||
|
||||
let am = available_moves.borrow();
|
||||
if !am.is_empty() {
|
||||
for mv in am.iter() {
|
||||
let end_pos = mv.get_end_position();
|
||||
let screen_position = match current_player {
|
||||
Player::White => Position::new(8 - 1 - end_pos.row(), end_pos.col()),
|
||||
Player::Red => end_pos,
|
||||
};
|
||||
let square = Rectangle::new(
|
||||
screen_position.col() as f64 * SQUARE_SIZE,
|
||||
screen_position.row() as f64 * SQUARE_SIZE,
|
||||
SQUARE_SIZE,
|
||||
SQUARE_SIZE,
|
||||
);
|
||||
cr.save().unwrap();
|
||||
cr.new_path();
|
||||
cr.move_to(square.tl().x(), square.tl().y());
|
||||
cr.line_to(square.tl().x(), square.br().y());
|
||||
cr.line_to(square.br().x(), square.br().y());
|
||||
cr.line_to(square.br().x(), square.tl().y());
|
||||
cr.line_to(square.tl().x(), square.tl().y());
|
||||
cr.clip();
|
||||
cr.new_path();
|
||||
cr.set_source_rgb(0.0, 1.0, 0.0);
|
||||
cr.set_line_width((square.width() + square.height()) * 0.05);
|
||||
cr.move_to(square.tl().x(), square.tl().y());
|
||||
cr.line_to(square.tl().x(), square.br().y());
|
||||
cr.line_to(square.br().x(), square.br().y());
|
||||
cr.line_to(square.br().x(), square.tl().y());
|
||||
cr.line_to(square.tl().x(), square.tl().y());
|
||||
cr.stroke().unwrap();
|
||||
cr.restore().unwrap();
|
||||
}
|
||||
}
|
||||
draw_score_bar(cr, &board, &draughts_game.borrow(), current_player);
|
||||
});
|
||||
}
|
||||
let gesture = gtk::GestureClick::new();
|
||||
|
||||
// Set the gestures button to the right mouse button (=3)
|
||||
gesture.set_button(GDK_BUTTON_PRIMARY as u32);
|
||||
|
||||
// Assign your handler to an event of the gesture (e.g. the `pressed` event)
|
||||
{
|
||||
let drawing_area = drawing_area.clone();
|
||||
let available_moves = available_moves.clone();
|
||||
let window = window.clone();
|
||||
gesture.connect_pressed(move |gesture, _, x, y| {
|
||||
gesture.set_state(gtk::EventSequenceState::Claimed);
|
||||
if let Some(winner) = draughts_game.borrow().winner() {
|
||||
MainContext::default()
|
||||
.spawn_local(final_dialog::create_dialog(window.clone(), winner));
|
||||
} else {
|
||||
let xform = xform.borrow();
|
||||
let inverse = {
|
||||
let mut m = *xform;
|
||||
m.invert();
|
||||
m
|
||||
};
|
||||
let p = transform_point(&Point::new(x, y), &inverse);
|
||||
if board_clone.contains(&p) {
|
||||
let p = &p - &board_clone.tl();
|
||||
// println!("Point: {:?}", p);
|
||||
let position = match current_player {
|
||||
Player::White => Position::new(
|
||||
(8.0 - (p.y() / SQUARE_SIZE)) as u8,
|
||||
(p.x() / SQUARE_SIZE) as u8,
|
||||
),
|
||||
Player::Red => {
|
||||
Position::new((p.y() / SQUARE_SIZE) as u8, (p.x() / SQUARE_SIZE) as u8)
|
||||
}
|
||||
};
|
||||
// println!("Selected position: {:?}", position);
|
||||
let mut draughts_game = draughts_game.borrow_mut();
|
||||
let piece = draughts_game.piece_at(position);
|
||||
// println!("Selected piece: {:?}", piece);
|
||||
let mut am = available_moves.borrow_mut();
|
||||
let mut move_applied = false;
|
||||
if !am.is_empty() {
|
||||
for mv in am.iter() {
|
||||
if mv.get_end_position() == position {
|
||||
draughts_game.apply_move(mv).unwrap();
|
||||
let game_copy = draughts_game.clone();
|
||||
// thread::spawn(move || {
|
||||
// if let (Some(mv), analyzed_moves) = game_copy.get_best_move(10) {
|
||||
// println!(
|
||||
// "Next best move: {:?}, analyzed moves: {}",
|
||||
// mv, analyzed_moves
|
||||
// );
|
||||
// }
|
||||
// });
|
||||
move_applied = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if move_applied {
|
||||
selected_piece.set(None);
|
||||
am.clear();
|
||||
}
|
||||
}
|
||||
if !move_applied {
|
||||
match piece.player() {
|
||||
Some(Player::Red) => selected_piece.set(Some(position)),
|
||||
Some(Player::White) => selected_piece.set(Some(position)),
|
||||
None => selected_piece.set(None),
|
||||
}
|
||||
am.clear();
|
||||
if piece.player().is_none() {
|
||||
selected_piece.set(None)
|
||||
} else {
|
||||
selected_piece.set(Some(position));
|
||||
for mv in draughts_game.moves_for_piece(position) {
|
||||
am.push(mv);
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
selected_piece.set(None);
|
||||
}
|
||||
drawing_area.queue_draw();
|
||||
}
|
||||
});
|
||||
}
|
||||
// Assign the gesture to the treeview
|
||||
drawing_area.add_controller(gesture);
|
||||
window.present();
|
||||
}
|
||||
|
||||
fn on_activate(application: &Application) {
|
||||
// Initialize GTK before using any GTK functions.
|
||||
if gtk::init().is_err() {
|
||||
panic!("Failed to initialize GTK.");
|
||||
}
|
||||
|
||||
let current_player = new_shared_mut(Player::Red);
|
||||
let dialog = greeting_dialog::create(application, current_player.clone());
|
||||
let application = application.clone();
|
||||
dialog.connect_close_request(move |w| {
|
||||
application.remove_window(w);
|
||||
create_game_window(&application, current_player.get());
|
||||
Propagation::Proceed
|
||||
});
|
||||
}
|
||||
|
||||
fn main() {
|
||||
// Create a new application with the builder pattern
|
||||
let app = Application::builder()
|
||||
.application_id("net.woggioni.rdraught")
|
||||
.build();
|
||||
app.connect_activate(on_activate);
|
||||
// Run the application
|
||||
app.run();
|
||||
fn main() -> ExitCode {
|
||||
let game = DraughtsGame::default();
|
||||
rdraught_ui::run(game)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user