SHARE
TWEET

Rust chessboard flip size working

loloof64 Nov 26th, 2018 115 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. use std::cell::RefCell;
  2. use std::rc::Rc;
  3. use gtk::prelude::*;
  4. use gdk::prelude::*;
  5. use gtk::DrawingArea;
  6. use cairo::Context;
  7. use cairo::enums::{FontSlant, FontWeight};
  8. use shakmaty::Role;
  9. use chess_position_trainer::graphic::PieceImages;
  10. use chess_position_trainer::logic::chessgame::ChessGame;
  11.  
  12. #[derive(Clone)]
  13. pub struct ChessBoard
  14. {
  15.     drawing_area: DrawingArea,
  16.     reversed: bool,
  17.     logic: ChessGame,
  18.     cells_size: u32,
  19. }
  20.  
  21. impl ChessBoard
  22. {
  23.     pub fn new_from_default(cells_size: u32) -> Option<Rc<RefCell<ChessBoard>>>
  24.     {
  25.         ChessBoard::get_chessboard(
  26.             cells_size,
  27.             "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
  28.         )
  29.     }
  30.  
  31.     pub fn new_from_fen(cells_size: u32, initial_position: &str) -> Option<Rc<RefCell<ChessBoard>>>
  32.     {
  33.         ChessBoard::get_chessboard(
  34.             cells_size,
  35.             initial_position,
  36.         )
  37.     }
  38.  
  39.     pub fn reverse(&mut self)
  40.     {
  41.         self.reversed = ! self.reversed;
  42.         self.drawing_area.queue_draw();
  43.     }
  44.  
  45.     pub fn get_drawing_area(&self) -> &DrawingArea
  46.     {
  47.         &self.drawing_area
  48.     }
  49.  
  50.    
  51.  
  52.     fn get_chessboard(cells_size: u32, initial_position: &str) -> Option<Rc<RefCell<ChessBoard>>>
  53.     {
  54.         let drawing_area = DrawingArea::new();
  55.  
  56.         let logic = ChessGame::new_from_fen(initial_position);
  57.  
  58.         match logic {
  59.             Some(game_logic) => {
  60.                 let chess_board = ChessBoard {
  61.                     drawing_area,
  62.                     reversed: false,
  63.                     logic: game_logic,
  64.                     cells_size,
  65.                 };
  66.  
  67.                 let chess_board_ref = Rc::new(RefCell::new(chess_board));
  68.  
  69.                 let chess_board_ref_2 = chess_board_ref.clone();
  70.                 chess_board_ref.borrow().drawing_area.connect_draw(move |_drawing_area, cr|{
  71.                     chess_board_ref_2.borrow().paint(cr);
  72.                     Inhibit(false)
  73.                 });
  74.  
  75.                 Some(chess_board_ref)
  76.             },
  77.             _ => None
  78.         }
  79.     }
  80.  
  81.     fn paint(&self, cr: &Context){
  82.         self.draw_background(cr);
  83.         self.draw_cells(cr);
  84.         self.draw_pieces(cr);
  85.         self.draw_coordinates(cr);
  86.         self.draw_player_turn(cr);
  87.     }
  88.  
  89.     fn draw_background(&self, cr: &Context)
  90.     {
  91.         let green_color = [60.0/255.0, 204.0/255.0, 100.0/255.0];
  92.         cr.set_source_rgb(
  93.             green_color[0],
  94.             green_color[1],
  95.             green_color[2],
  96.         );
  97.         cr.paint();
  98.     }
  99.  
  100.     fn draw_cells(&self, cr: &Context)
  101.     {
  102.         (0..8).for_each(|rank| {
  103.             (0..8).for_each(|file| {
  104.                 let white_cell_color = [255.0/255.0, 255.0/255.0, 179.0/255.0];
  105.                 let black_cell_color = [153.0/255.0, 102.0/255.0, 51.0/255.0];
  106.  
  107.                 let is_white_cell = (file + rank) % 2 == 0;
  108.                 let cell_color = if is_white_cell {white_cell_color} else {black_cell_color};
  109.  
  110.                 let rect_x = (self.cells_size as f64) * (0.5 + (file as f64));
  111.                 let rect_y = (self.cells_size as f64) * (0.5 + (rank as f64));
  112.                 let rect_size = self.cells_size as f64;
  113.  
  114.                 cr.rectangle(
  115.                     rect_x,
  116.                     rect_y,
  117.                     rect_size,
  118.                     rect_size,
  119.                 );
  120.                 cr.set_source_rgb(
  121.                     cell_color[0],
  122.                     cell_color[1],
  123.                     cell_color[2],
  124.                 );
  125.                 cr.fill();
  126.             });
  127.         });
  128.     }
  129.  
  130.     fn draw_pieces(&self, cr: &Context)
  131.     {
  132.         (0..8).for_each(|rank| {
  133.             (0..8).for_each(|file| {
  134.                 let real_file = if self.reversed { 7-file } else { file };
  135.                 let real_rank = if self.reversed { 7-rank } else { rank };
  136.  
  137.                 let piece_size = (self.cells_size as f64 * 0.8) as i32;
  138.  
  139.                 if let Some(piece) = self.logic.piece_at_cell(real_file, real_rank) {
  140.                     let image = match piece.role {
  141.                         Role::Pawn => {
  142.                             if piece.color.is_white()
  143.                             {
  144.                                 PieceImages::get_white_pawn(piece_size)
  145.                             }
  146.                             else
  147.                             {
  148.                                 PieceImages::get_black_pawn(piece_size)
  149.                             }
  150.                         },
  151.                         Role::Knight => {
  152.                             if piece.color.is_white()
  153.                             {
  154.                                 PieceImages::get_white_knight(piece_size)
  155.                             }
  156.                             else
  157.                             {
  158.                                 PieceImages::get_black_knight(piece_size)
  159.                             }
  160.                         },
  161.                         Role::Bishop => {
  162.                             if piece.color.is_white()
  163.                             {
  164.                                 PieceImages::get_white_bishop(piece_size)
  165.                             }
  166.                             else
  167.                             {
  168.                                 PieceImages::get_black_bishop(piece_size)
  169.                             }
  170.                         },
  171.                         Role::Rook => {
  172.                             if piece.color.is_white()
  173.                             {
  174.                                 PieceImages::get_white_rook(piece_size)
  175.                             }
  176.                             else
  177.                             {
  178.                                 PieceImages::get_black_rook(piece_size)
  179.                             }
  180.                         },
  181.                         Role::Queen => {
  182.                             if piece.color.is_white()
  183.                             {
  184.                                 PieceImages::get_white_queen(piece_size)
  185.                             }
  186.                             else
  187.                             {
  188.                                 PieceImages::get_black_queen(piece_size)
  189.                             }
  190.                         },
  191.                         Role::King => {
  192.                             if piece.color.is_white()
  193.                             {
  194.                                 PieceImages::get_white_king(piece_size)
  195.                             }
  196.                             else
  197.                             {
  198.                                 PieceImages::get_black_king(piece_size)
  199.                             }
  200.                         },
  201.                     };
  202.  
  203.                     let location_x = (self.cells_size as f64) * (file as f64 + 0.5 + 0.1);
  204.                     let location_y = (self.cells_size as f64) * ((7.0-rank as f64) + 0.5 + 0.1);
  205.                     cr.set_source_pixbuf(
  206.                         &image,
  207.                         location_x,
  208.                         location_y
  209.                     );
  210.                     cr.paint();  
  211.                 }
  212.             });
  213.         });
  214.     }
  215.  
  216.     fn draw_coordinates(&self, cr: &Context)
  217.     {
  218.         let files = ["A", "B", "C", "D", "E", "F", "G", "H"];
  219.         let ranks = ["8", "7", "6", "5", "4", "3", "2", "1"];
  220.  
  221.         cr.set_source_rgb(0.2, 0.4, 1.0);
  222.         cr.select_font_face(
  223.             "Sans Serif",
  224.             FontSlant::Normal,
  225.             FontWeight::Bold
  226.         );
  227.         cr.set_font_size((self.cells_size as f64) * 0.38);
  228.        
  229.         (0..8).for_each(|file_index| {
  230.             let real_file_index = if self.reversed { 7 - file_index } else { file_index };
  231.  
  232.             let letter = files[real_file_index];
  233.             let letter_x = (self.cells_size as f64) * (0.9 + (real_file_index as f64));
  234.             let letter_y_top = (self.cells_size as f64) * 0.4;
  235.             let letter_y_bottom = (self.cells_size as f64) * 8.9;
  236.  
  237.             cr.move_to(letter_x, letter_y_top);
  238.             cr.show_text(letter);
  239.  
  240.             cr.move_to(letter_x, letter_y_bottom);
  241.             cr.show_text(letter);
  242.         });
  243.  
  244.         (0..8).for_each(|rank_index| {
  245.             let real_rank_index = if self.reversed { 7 - rank_index } else { rank_index };
  246.  
  247.             let letter = ranks[real_rank_index];
  248.             let letter_y = (self.cells_size as f64) * (1.2 + (real_rank_index as f64));
  249.             let letter_x_left = (self.cells_size as f64) * 0.1;
  250.             let letter_x_right = (self.cells_size as f64) * 8.6;
  251.  
  252.             cr.move_to(letter_x_left, letter_y);
  253.             cr.show_text(letter);
  254.  
  255.             cr.move_to(letter_x_right, letter_y);
  256.             cr.show_text(letter);
  257.         });
  258.     }
  259.  
  260.     fn draw_player_turn(&self, cr: &Context)
  261.     {
  262.         let color = if self.logic.is_white_turn() { [1.0, 1.0, 1.0] } else { [0.0, 0.0, 0.0] };
  263.         let center = (self.cells_size as f64) * 8.75;
  264.         let radius = (self.cells_size as f64) * 0.25;
  265.         cr.arc(center, center, radius, 0.0, 2.0 * std::f64::consts::PI);
  266.         cr.set_source_rgb(
  267.             color[0],
  268.             color[1],
  269.             color[2],
  270.         );
  271.         cr.fill();
  272.     }
  273. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top