API tools faq
paste
Advertisement
paranid5

Sapper (Rust version)

paranid5
Jun 25th, 2020
357
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Rust 65.30 KB | None | 0 0
raw download clone embed print report
  1. extern crate libc;
  2. extern crate rand;
  3. use std::{io, fs};
  4. use rand::Rng;
  5. use std::io::{Write, Read};
  6.  
  7. struct Result
  8. (
  9.     String,  // name
  10.     u32,     // games
  11.     u32,     // victory
  12.     f64,     // percent
  13.     u32,     // izzy
  14.     u32,     // hard
  15.     u32      // doom_guy
  16. );
  17.  
  18. fn save(save: &Vec<Result>)
  19. {
  20.     fs::remove_file("results.bin").expect("could not remove file");
  21.     let mut file = std::fs::File::create("results.bin").expect("23. opening file while saving");
  22.     file.write_all(((save.len()).to_string()).as_bytes()).expect("28. game saving err");
  23.     file.write_all("/".as_bytes()).expect("27. file space err");
  24.     for q in 0..save.len()
  25.     {
  26.         file.write_all(save[q].0.as_bytes()).expect("26. name saving err");
  27.         file.write_all("/".as_bytes()).expect("27. file space err");
  28.         file.write_all(((save[q].1).to_string()).as_bytes()).expect("28. game saving err");
  29.         file.write_all("/".as_bytes()).expect("29. file space err");
  30.         file.write_all(((save[q].2).to_string()).as_bytes()).expect("31. victories saving err");
  31.         file.write_all("/".as_bytes()).expect("32. file space err");
  32.         file.write_all(((save[q].3).to_string()).as_bytes()).expect("33. percent saving err");
  33.         file.write_all("/".as_bytes()).expect("34. file space err");
  34.         file.write_all(((save[q].4).to_string()).as_bytes()).expect("35. izzy saving err");
  35.         file.write_all("/".as_bytes()).expect("36. file space err");
  36.         file.write_all(((save[q].5).to_string()).as_bytes()).expect("37. hard saving err");
  37.         file.write_all("/".as_bytes()).expect("38. file space err");
  38.         file.write_all(((save[q].6).to_string()).as_bytes()).expect("39. doom_guy saving err");
  39.         file.write_all("/".as_bytes()).expect("40. file space err");
  40.     }
  41. }
  42.  
  43. fn print_desk(desk_gr: &Vec<Vec<char>>, x: u32, y: u32)
  44. {
  45.     print!("  ");
  46.     for i in 1..y + 1
  47.     {
  48.         print!(" {}", i % 10);
  49.     }
  50.     print!("\n");
  51.     for i in 0..x as usize
  52.     {
  53.         print!("  ");
  54.         for _q in 1..y + 1
  55.         {
  56.             print!(" _");
  57.         }
  58.         print!("\n");
  59.         print!("%{}", (i + 1) % 10);
  60.         for q in 0..y as usize
  61.         {
  62.             print!("|{}", desk_gr[i][q]);
  63.         }
  64.         print!("|\n");
  65.     }
  66.     print!("  ");
  67.     for _q in 1..y + 1
  68.     {
  69.         print!(" _");
  70.     }
  71.     print!("\n");
  72. }
  73.  
  74. fn open_cl(num: u32) -> char
  75. {
  76.     return match num
  77.     {
  78.         0 => '0',
  79.         1 => '1',
  80.         2 => '2',
  81.         3 => '3',
  82.         4 => '4',
  83.         5 => '5',
  84.         6 => '6',
  85.         7 => '7',
  86.         _ => '8',
  87.     }
  88. }
  89.  
  90. fn to_hu(_xm: &String) -> i32
  91. {
  92.     let mut xm = 0;
  93.     let mut correct = true;
  94.     if     &_xm[1..2] == "1" || &_xm[1..2] == "2" || &_xm[1..2] == "3"
  95.         || &_xm[1..2] == "4" || &_xm[1..2] == "5" || &_xm[1..2] == "6"
  96.         || &_xm[1..2] == "7" || &_xm[1..2] == "8" || &_xm[1..2] == "9"
  97.     {
  98.         match &_xm[0..1]
  99.         {
  100.             "1" => xm = 10,
  101.             "2" => xm = 20,
  102.             "3" => xm = 30,
  103.              _  => {
  104.                  println!("Ввод не корректен");
  105.                  correct = false
  106.              }
  107.         }
  108.         if correct
  109.         {
  110.             match &_xm[1..2]
  111.             {
  112.                 "0" => xm += 0,
  113.                 "1" => xm += 1,
  114.                 "2" => xm += 2,
  115.                 "3" => xm += 3,
  116.                 "4" => xm += 4,
  117.                 "5" => xm += 5,
  118.                 "6" => xm += 6,
  119.                 "7" => xm += 7,
  120.                 "8" => xm += 8,
  121.                 "9" => xm += 9,
  122.                  _  => {
  123.                     println!("Ввод не корректен");
  124.                     correct = false
  125.                 },
  126.             }
  127.         }
  128.         if correct && &_xm[2..3] != "0"
  129.         {
  130.             println!("Ввод не корректен");
  131.             correct = false
  132.         }
  133.     }
  134.     else if &_xm[1..2] == "0"
  135.     {
  136.         match &_xm[0..1]
  137.         {
  138.             "0" => xm += 0,
  139.             "1" => xm += 1,
  140.             "2" => xm += 2,
  141.             "3" => xm += 3,
  142.             "4" => xm += 4,
  143.             "5" => xm += 5,
  144.             "6" => xm += 6,
  145.             "7" => xm += 7,
  146.             "8" => xm += 8,
  147.             "9" => xm += 9,
  148.             _  => {
  149.                 println!("Ввод не корректен");
  150.                 correct = false
  151.             },
  152.         }
  153.     }
  154.     else
  155.     {
  156.         println!("Ввод не корректен");
  157.         correct = false
  158.     }
  159.     return match correct
  160.     {
  161.         true => xm,
  162.         _    => -1,
  163.     }
  164. }
  165.  
  166. unsafe fn game (game_type: u32) -> bool
  167. {
  168.     let mut mines: u32 = 0;                            // amount of mines
  169.     let mut x:     u32 = 4;                            // custom
  170.     let mut y:     u32 = 4;                            // custom
  171.     let mut count: u32 = 0;                            // amount of mines
  172.     let mut desk_gr: Vec<Vec<char>> = vec![vec![]]; // output
  173.     let mut bomb_num: Vec<Vec<u32>> = vec![vec![]]; // numbers near mines
  174.     let mut position: Vec<u32> = vec![];             // numbers of mines
  175.     if game_type != 1
  176.     {
  177.         let mut resize_gr: Vec<char> = vec![];
  178.         let mut resize_b: Vec<u32> = vec![];
  179.         resize_gr.resize(game_type as usize, ' ');
  180.         resize_b.resize(game_type as usize, 0);
  181.         desk_gr.resize(game_type as usize, resize_gr);
  182.         bomb_num.resize(game_type as usize, resize_b);
  183.         match game_type
  184.         {
  185.             8  => print_desk(&desk_gr, 8, 8),
  186.             16 => print_desk(&desk_gr, 16, 16),
  187.             _  => print_desk(&desk_gr, 32, 32),
  188.         }
  189.    
  190.         position.resize((game_type * 2) as usize, 0);
  191.         while count != game_type * 2
  192.         {
  193.             let mut test = false;
  194.             let place = rand::thread_rng().gen_range(0, game_type); // mine position
  195.             for i in 0..count as usize
  196.             {
  197.                 if place == position[i]
  198.                 {
  199.                     test = true;
  200.                     break;
  201.                 }
  202.             }
  203.             if !test
  204.             {
  205.                 count += 1;
  206.                 position[(count - 1) as usize] = place;
  207.             }
  208.         } // we've created mines
  209.         let mut xc: u32 = 0;
  210.         let mut yc: u32 = 0;
  211.         for q in 0..count as usize
  212.         {
  213.             xc = position[q] / game_type;         // string with mine
  214.             yc = position[q] - (game_type * xc); // column with mine
  215.                                                   // we've defined location of mine
  216.             if xc > 0
  217.             {
  218.                 bomb_num[(xc - 1) as usize][yc as usize] += 1;
  219.             }
  220.             if xc < game_type - 1
  221.             {
  222.                 bomb_num[(xc + 1) as usize][yc as usize] += 1;
  223.             }
  224.             if yc > 0
  225.             {
  226.                 bomb_num[xc as usize][(yc - 1) as usize] += 1;
  227.             }
  228.             if yc < game_type - 1
  229.             {
  230.                 bomb_num[xc as usize][(yc + 1) as usize] += 1;
  231.             }
  232.             if xc > 0 && yc > 0
  233.             {
  234.                 bomb_num[(xc - 1) as usize][(yc - 1) as usize] += 1;
  235.             }
  236.             if xc < game_type - 1 && yc > 0
  237.             {
  238.                 bomb_num[(xc + 1) as usize][(yc - 1) as usize] += 1;
  239.             }
  240.             if xc > 0 && yc < game_type - 1
  241.             {
  242.                 bomb_num[(xc - 1) as usize][(yc + 1) as usize] += 1;
  243.             }
  244.             if xc < game_type - 1 && yc < game_type - 1
  245.             {
  246.                 bomb_num[(xc + 1) as usize][(yc + 1) as usize] += 1;
  247.             }
  248.         } // numbers of mines are established
  249.     }
  250.     else
  251.     {
  252.         let mut _x = String::new();
  253.         let mut _y = String::new();
  254.         println!("Задайте размер доски.");
  255.         while x < 3 || x > 50
  256.         {
  257.             print!("Кол-во строк (не больше 50, минимум 3): ");
  258.             io::stdin().read_line(&mut _x).expect("185. wrong input");
  259.             x = _x.trim().parse().expect("186. not number");
  260.             if x < 3 || x > 50
  261.             {
  262.                 println!("Ввод не корректен");
  263.             }
  264.         }
  265.         while y < 3 || y > 50
  266.         {
  267.             print!("Кол-во столбцов (не больше 50, минимум 3): ");
  268.             io::stdin().read_line(&mut _x).expect("195. wrong input");
  269.             y = _y.trim().parse().expect("196. not number");
  270.             if y < 3 || y > 50
  271.             {
  272.                 println!("Ввод не корректен");
  273.             }
  274.         }
  275.         let mut column: Vec<char> = vec![];
  276.         let mut bomb:   Vec<u32>  = vec![];
  277.         column.resize(y as usize,' ');
  278.         bomb.resize(y as usize,0);
  279.         desk_gr.resize(x as usize, column); // set size
  280.         bomb_num.resize(x as usize, bomb);  // set size
  281.         print_desk(&desk_gr, x, y);
  282.         while (mines as f64) > ((y * x) as f64 / 100.0 * 95f64) || ((y * x) as f64 / 100.0 * 5f64) > (mines as f64)
  283.         {
  284.             mines = 0;
  285.             let mut _mines = String::new();
  286.             print!("Задайте кол-во мин (минимум 5%% от площади доски и максимум 95%%): ");
  287.             io::stdin().read_line(&mut _mines).expect("214. wrong input");
  288.             mines = _mines.trim().parse().expect("215. not number");
  289.             if  (mines as f64) > ((y * x) as f64 / 100.0 * 95f64) || ((y * x) as f64 / 100.0 * 5f64) > (mines as f64)
  290.             {
  291.                 println!("Ввод не корректен");
  292.             }
  293.         }
  294.         count = 0;
  295.         position.resize(mines as usize, 0);
  296.         while count != mines
  297.         {
  298.             let mut test = false;                                                  // new mine checking
  299.             let place     = rand::thread_rng().gen_range(0, x * y); // mine position
  300.             for i in 0..count as usize
  301.             {
  302.                 if place == position[i]
  303.                 {
  304.                     test = true;
  305.                     break;
  306.                 }
  307.             }
  308.             if !test
  309.             {
  310.                 count += 1;
  311.                 position[(count - 1) as usize] = place;
  312.             }
  313.         } // set mines
  314.         let mut xc: u32 = 0;
  315.         let mut yc: u32 = 0;
  316.         for q in 0..count
  317.         {
  318.             xc = position[q as usize] / y;      // string with mine
  319.             yc = position[q as usize] - y * xc; // column with mine
  320.             // we've defined location of mine
  321.             if xc > 0
  322.             {
  323.                 bomb_num[(xc - 1) as usize][yc as usize] += 1;
  324.             }
  325.             if xc < x - 1
  326.             {
  327.                 bomb_num[(xc + 1) as usize][yc as usize] += 1;
  328.             }
  329.             if yc > 0
  330.             {
  331.                 bomb_num[xc as usize][(yc - 1) as usize] += 1;
  332.             }
  333.             if yc < y - 1
  334.             {
  335.                 bomb_num[xc as usize][(yc + 1) as usize] += 1;
  336.             }
  337.             if xc > 0 && yc > 0
  338.             {
  339.                 bomb_num[(xc - 1) as usize][(yc - 1) as usize] += 1;
  340.             }
  341.             if xc < x - 1 && yc > 0
  342.             {
  343.                 bomb_num[(xc + 1) as usize][(yc - 1) as usize] += 1;
  344.             }
  345.             if xc > 0 && yc < y - 1
  346.             {
  347.                 bomb_num[(xc - 1) as usize][(yc + 1) as usize] += 1;
  348.             }
  349.             if xc < x - 1 && yc < y - 1
  350.             {
  351.                 bomb_num[(xc + 1) as usize][(yc + 1) as usize] += 1;
  352.             }
  353.         } // numbers of mines are established
  354.     }
  355.     let mut xh:    u32    = 0;     // string of move location
  356.     let mut yh:    u32    = 0;     // column of move location
  357.     let mut mv:    u32    = 0;     // move choice
  358.     let mut lose:  bool   = false; // game status
  359.     let mut space: u32    = 0;     // locations without mines
  360.     match game_type
  361.     {
  362.         1 => space = game_type * game_type - game_type * 2,
  363.         _ => space = x * y - mines,
  364.     }
  365.     let mut _mv =    String::new();                                                // input move choice
  366.     let mut _xm =    String::new();                                                // string of new flag
  367.     let mut _ym =    String::new();                                                // column of new flag
  368.     let mut _xd =    String::new();                                                // string of destroyable flag
  369.     let mut _yd =    String::new();                                                // column of destroyable flag
  370.     let mut _xh =    String::new();                                                // string of move location
  371.     let mut _yh =    String::new();                                                // column of move location
  372.     let mut _yes_f = String::from("YES");                                       // confirmation of flag placing
  373.     let mut _yes_d = String::from("YES");                                       // confirmation of flag destroying
  374.     let mut _yes_m = String::new();                                                // confirmation of making move
  375.     let start: libc::time64_t = libc::time(0 as *mut libc::time64_t); // game start
  376.     while !lose && space != 0
  377.     {
  378.         while mv < 1 || mv > 3
  379.         {
  380.             println!("1. Поставить метку\n2. Убрать метку\n3. Сделать ход");
  381.             print!("Выберите цифру: ");
  382.             io::stdin().read_line(&mut _mv).expect("309. read string");
  383.             if &_mv[0..1] != "1" && &_mv[0..1] != "2" && &_mv[0..1] != "3" || &_mv[1..2] != "0"
  384.             {
  385.                 println!("Ввод не корректен");
  386.             }
  387.         }
  388.         match &_mv[0..1]
  389.         {
  390.             "1" => mv = 1,
  391.             "2" => mv = 2,
  392.              _  => mv = 3,
  393.         }
  394.         match mv
  395.         {
  396.             1 =>
  397.             while &_yes_f[..] == "YES"
  398.             {
  399.                 print!("Если у вас есть предположение о месте мин, то можете поставить + на это место.\
  400.                 Если хотите это сделать, то введите YES, иначе что-то другое: ");
  401.                 io::stdin().read_line(&mut _yes_f).expect("405. read string");
  402.                 if &_yes_f[..] == "YES"
  403.                 {
  404.                     let mut xm: u32 = 0;  // flag string
  405.                     let mut ym: u32 = 0;  // flag column
  406.                     let mut xt: i32 = -1; // input test
  407.                     let mut yt: i32 = -1; // input test
  408.                     println!("Введите координаты мины.");
  409.                     while xt == -1
  410.                     {
  411.                         xm = 0;
  412.                         print!("Введите номер строки: ");
  413.                         io::stdin().read_line(&mut _xm).expect("415 read string");
  414.                         xt = to_hu(&_xm);
  415.                     }
  416.                     xm = xt as u32;
  417.                     while yt == -1
  418.                     {
  419.                         ym = 0;
  420.                         print!("Введите номер столбца: ");
  421.                         io::stdin().read_line(&mut _ym).expect("423 read string");
  422.                         yt = to_hu(&_ym);
  423.                     }
  424.                     ym = yt as u32;
  425.                     if game_type != 1 && (xm > game_type || xm < 1) && (ym > game_type || ym < 1)
  426.                     {
  427.                             println!("Вы вышли за рамки доски");
  428.                     }
  429.                     else if (xm > x || xm < 1) && (ym > y || ym < 1)
  430.                     {
  431.                         println!("Вы вышли за рамки доски");
  432.                     }
  433.                     if desk_gr[(xm - 1) as usize][(ym - 1) as usize] != ' '
  434.                     {
  435.                         println!("Сомневаюсь, что вы хотите поставить сюда метку...");
  436.                     }
  437.                     desk_gr[(xm - 1) as usize][(ym - 1) as usize] = '+';
  438.                     match game_type
  439.                     {
  440.                         8  => print_desk(&desk_gr, 8, 8),
  441.                         16 => print_desk(&desk_gr, 16, 16),
  442.                         32 => print_desk(&desk_gr, 32, 32),
  443.                         _  => print_desk(&desk_gr, x, y),
  444.                     }
  445.                 }
  446.             }
  447.             2 =>
  448.             while &_yes_d[..] == "YES"
  449.             {
  450.                 print!("Вы можете убрать метку на мину.\
  451.                 Если хотите это сделать, то введите YES, иначе что-то другое: ");
  452.                 io::stdin().read_line(&mut _yes_d).expect("405. read string");
  453.                 if &_yes_d[..] == "YES"
  454.                 {
  455.                     let mut xm: u32 = 0;  // flag string
  456.                     let mut ym: u32 = 0;  // flag column
  457.                     let mut xt: i32 = -1; // input test
  458.                     let mut yt: i32 = -1; // input test
  459.                     println!("Введите координаты мины.");
  460.                     while xt == -1
  461.                     {
  462.                         xm = 0;
  463.                         print!("Введите номер строки: ");
  464.                         io::stdin().read_line(&mut _xm).expect("415 read string");
  465.                         xt = to_hu(&_xm);
  466.                     }
  467.                     xm = xt as u32;
  468.                     while yt == -1
  469.                     {
  470.                         ym = 0;
  471.                         print!("Введите номер столбца: ");
  472.                         io::stdin().read_line(&mut _ym).expect("423 read string");
  473.                         yt = to_hu(&_ym);
  474.                     }
  475.                     ym = yt as u32;
  476.                     if game_type != 1 && (xm > game_type || xm < 1) && (ym > game_type || ym < 1)
  477.                     {
  478.                         println!("Вы вышли за рамки доски");
  479.                     }
  480.                     else if (xm > x || xm < 1) && (ym > y || ym < 1)
  481.                     {
  482.                         println!("Вы вышли за рамки доски");
  483.                     }
  484.                     if desk_gr[(xm - 1) as usize][(ym - 1) as usize] != '+'
  485.                     {
  486.                         println!("Здесь нет метки...");
  487.                     }
  488.                     desk_gr[(xm - 1) as usize][(ym - 1) as usize] = ' ';
  489.                     match game_type
  490.                     {
  491.                         8  => print_desk(&desk_gr, 8, 8),
  492.                         16 => print_desk(&desk_gr, 16, 16),
  493.                         32 => print_desk(&desk_gr, 32, 32),
  494.                         _  => print_desk(&desk_gr, x, y),
  495.                     }
  496.                 }
  497.             }
  498.             _ =>
  499.             {
  500.                 print!("Вы уверены, что хотите совершить ход? \
  501.                Если да, то введите YES, иначе что-то другое: ");
  502.                 io::stdin().read_line(&mut _yes_m).expect("504. read string");
  503.                 if &_yes_m == "YES"
  504.                 {
  505.                     let mut xt:     i32  = -1;     // input test
  506.                     let mut yt:     i32  = -1;     // input test
  507.                     let mut beyond: bool = true;   // out of borders
  508.                     while beyond
  509.                     {
  510.                         println!("Введите координаты мины");
  511.                         while xt == -1
  512.                         {
  513.                             print!("Введите номер строки: ");
  514.                             io::stdin().read_line(&mut _xh).expect("517. read string");
  515.                             xt = to_hu(&_xh);
  516.                         }
  517.                         xh = xt as u32;
  518.                         while yt == -1
  519.                         {
  520.                             print!("Введите номер столбца: ");
  521.                             io::stdin().read_line(&mut _yh).expect("523. read string");
  522.                             yt = to_hu(&_yh);
  523.                         }
  524.                         yh = yt as u32;
  525.                         beyond = false;
  526.                         if game_type != 1 && (xh > game_type || xh < 1) && (yh > game_type || yh < 1)
  527.                         {
  528.                             println!("Вы вышли за рамки доски");
  529.                             beyond = true;
  530.                         }
  531.                         else if (xh > x || xh < 1) && (yh > y || yh < 1)
  532.                         {
  533.                             println!("Вы вышли за рамки доски");
  534.                             beyond = true;
  535.                         }
  536.                     }
  537.                     for c in 0..count as usize // checking for
  538.                     {
  539.                         if game_type != 1
  540.                         {
  541.                             if (xh - 1) * game_type + yh - 1 == position[c] // lose
  542.                             {
  543.                                 for o in 0.. count as usize // fill with mines
  544.                                 {
  545.                                     desk_gr[(position[o] / game_type) as usize]
  546.                                         [(position[o] - (position[o] / game_type) * game_type) as usize] = 'x';
  547.                                 }
  548.                                 match game_type
  549.                                 {
  550.                                     8  => print_desk(&desk_gr, 8, 8),
  551.                                     16 => print_desk(&desk_gr, 16, 16),
  552.                                     _  => print_desk(&desk_gr, 32, 32),
  553.                                 }
  554.                                 println!("Вы взорвались :(");
  555.                                 lose = true;
  556.                             }
  557.                         }
  558.                         else if (xh - 1) * y + yh - 1 == position[c] // lose
  559.                         {
  560.                             for o in 0..count as usize  // fill with mines
  561.                             {
  562.                                 desk_gr[(position[o] / y) as usize]
  563.                                     [(position[o] - (position[o] / y) * y) as usize] = 'x';
  564.                             }
  565.                             print_desk(&desk_gr, x, y);
  566.                             println!("Вы взорвались :(");
  567.                             lose = true;
  568.                         }
  569.                     }
  570.                     if !lose && desk_gr[(xh - 1) as usize][(yh - 1) as usize] != ' '
  571.                     {
  572.                         println!("Эта клетка уже открыта");
  573.                     }
  574.                     else if !lose && desk_gr[(xh - 1) as usize][(yh - 1) as usize] == ' '  // not lose
  575.                     {
  576.                         let mut i:      u32 = 0; // to move in array
  577.                         let mut amount: u32 = 0; // amount of cells we've opened when open 1 cell
  578.                         if bomb_num[(xh - 1) as usize][(yh - 1) as usize] == 0 // cells opening
  579.                         {
  580.                             let mut eternal: Vec<(u32, u32)> = vec![]; // strings and columns with 0
  581.                             eternal.push((xh - 1, yh - 1));
  582.                             for i in 0..eternal.len()
  583.                             {
  584.                                 desk_gr[(eternal[i].0) as usize][eternal[i].1 as usize] = '0';
  585.                                 amount += 1;
  586.                                 if eternal[i].0 > 0
  587.                                 {
  588.                                     if bomb_num[(eternal[i].0 - 1) as usize][(eternal[i].1) as usize] == 0
  589.                                     {
  590.                                         let mut potato = false; // check for 0
  591.                                         for c in 0..eternal.len()
  592.                                         {
  593.                                             if eternal[c].0 == eternal[i].0 - 1 && eternal[c].1 == eternal[i].1
  594.                                             {
  595.                                                 potato = true;
  596.                                                 break;
  597.                                             }
  598.                                         }
  599.                                         if !potato
  600.                                         {
  601.                                             eternal.push((eternal[i].0 - 1, eternal[i].1));
  602.                                         }
  603.                                     }
  604.                                     else if desk_gr[(eternal[i].0 - 1) as usize][(eternal[i].1) as usize] == ' '
  605.                                     {
  606.                                         desk_gr[((eternal[i].0) - 1) as usize][(eternal[i].1) as usize] =
  607.                                             open_cl(bomb_num[((eternal[i].0) - 1) as usize][(eternal[i].1) as usize]);
  608.                                         amount += 1;
  609.                                     }
  610.                                 }
  611.                                 if game_type != 1
  612.                                 {
  613.                                     if eternal[i].0 < game_type - 1
  614.                                     {
  615.                                         if bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1) as usize] == 0
  616.                                         {
  617.                                             let mut potato = false; // check for 0
  618.                                             for c in 0..eternal.len()
  619.                                             {
  620.                                                 if eternal[c].0 == eternal[i].0 + 1 && eternal[c].1 == eternal[i].1
  621.                                                 {
  622.                                                     potato = true;
  623.                                                     break;
  624.                                                 }
  625.                                             }
  626.                                             if !potato
  627.                                             {
  628.                                                 eternal.push((eternal[i].0 + 1, eternal[i].1));
  629.                                             }
  630.                                         }
  631.                                         else if desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1) as usize] == ' '
  632.                                         {
  633.                                             desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1) as usize] =
  634.                                                 open_cl(bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1) as usize]);
  635.                                             amount += 1;
  636.                                         }
  637.                                     }
  638.                                 }
  639.                                 else
  640.                                 {
  641.                                     if eternal[i].0 < x - 1
  642.                                     {
  643.                                         if bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1) as usize] == 0
  644.                                         {
  645.                                             let mut potato = false;
  646.                                             for c in 0..eternal.len()
  647.                                             {
  648.                                                 if eternal[c].0 == eternal[i].0 + 1 && eternal[c].1 == eternal[i].1
  649.                                                 {
  650.                                                     potato = true;
  651.                                                     break;
  652.                                                 }
  653.                                             }
  654.                                             if !potato
  655.                                             {
  656.                                                 eternal.push((eternal[i].0 + 1, eternal[i].1));
  657.                                             }
  658.                                         }
  659.                                         else if desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1) as usize] == ' '
  660.                                         {
  661.                                             desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1) as usize] =
  662.                                                 open_cl(bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1) as usize]);
  663.                                             amount += 1;
  664.                                         }
  665.                                     }
  666.                                 }
  667.                                 if eternal[i].1 > 0
  668.                                 {
  669.                                     if bomb_num[(eternal[i].0) as usize][(eternal[i].1 - 1) as usize] == 0
  670.                                     {
  671.                                         let mut potato = false;
  672.                                         for c in 0..eternal.len()
  673.                                         {
  674.                                             if eternal[c].0 == eternal[i].0 && eternal[c].1 == eternal[i].1 - 1
  675.                                             {
  676.                                                 potato = true;
  677.                                                 break;
  678.                                             }
  679.                                         }
  680.                                         if !potato
  681.                                         {
  682.                                             eternal.push((eternal[i].0 , eternal[i].1 - 1));
  683.                                         }
  684.                                     }
  685.                                     else if desk_gr[(eternal[i].0) as usize][(eternal[i].1 - 1) as usize] == ' '
  686.                                     {
  687.                                         desk_gr[(eternal[i].0) as usize][(eternal[i].1 - 1) as usize] =
  688.                                             open_cl(bomb_num[(eternal[i].0) as usize][(eternal[i].1 - 1) as usize]);
  689.                                         amount += 1;
  690.                                     }
  691.                                 }
  692.                                 if game_type != 1
  693.                                 {
  694.                                     if eternal[i].0 < game_type - 1
  695.                                     {
  696.                                         if bomb_num[(eternal[i].0) as usize][(eternal[i].1 + 1) as usize] == 0
  697.                                         {
  698.                                             let mut potato = false; // check for 0
  699.                                             for c in 0..eternal.len()
  700.                                             {
  701.                                                 if eternal[c].0 == eternal[i].0 && eternal[c].1 == eternal[i].1 + 1
  702.                                                 {
  703.                                                     potato = true;
  704.                                                     break;
  705.                                                 }
  706.                                             }
  707.                                             if !potato
  708.                                             {
  709.                                                 eternal.push((eternal[i].0 , eternal[i].1 + 1));
  710.                                             }
  711.                                         }
  712.                                         else if desk_gr[(eternal[i].0) as usize][(eternal[i].1 + 1) as usize] == ' '
  713.                                         {
  714.                                             desk_gr[(eternal[i].0) as usize][(eternal[i].1 + 1) as usize] =
  715.                                                 open_cl(bomb_num[(eternal[i].0) as usize][(eternal[i].1 + 1) as usize]);
  716.                                             amount += 1;
  717.                                         }
  718.                                     }
  719.                                 }
  720.                                 else
  721.                                 {
  722.                                     if eternal[i].1 < y - 1
  723.                                     {
  724.                                         if bomb_num[(eternal[i].0) as usize][(eternal[i].1 + 1) as usize] == 0
  725.                                         {
  726.                                             let mut potato = false;
  727.                                             for c in 0..eternal.len()
  728.                                             {
  729.                                                 if eternal[c].0 == eternal[i].0 && eternal[c].1 == eternal[i].1 + 1
  730.                                                 {
  731.                                                     potato = true;
  732.                                                     break;
  733.                                                 }
  734.                                             }
  735.                                             if !potato
  736.                                             {
  737.                                                 eternal.push((eternal[i].0 , eternal[i].1 + 1));
  738.                                             }
  739.                                         }
  740.                                         else if desk_gr[(eternal[i].0) as usize][(eternal[i].1 + 1) as usize] == ' '
  741.                                         {
  742.                                             desk_gr[(eternal[i].0) as usize][(eternal[i].1 + 1) as usize] =
  743.                                                 open_cl(bomb_num[(eternal[i].0) as usize][(eternal[i].1 + 1) as usize]);
  744.                                             amount += 1;
  745.                                         }
  746.                                     }
  747.                                 }
  748.                                 if eternal[i].0 > 0 && eternal[i].1 > 0
  749.                                 {
  750.                                     if bomb_num[(eternal[i].0 - 1) as usize][(eternal[i].1 - 1) as usize] == 0
  751.                                     {
  752.                                         let mut potato = false;
  753.                                         for c in 0..eternal.len()
  754.                                         {
  755.                                             if eternal[c].0 == eternal[i].0 - 1 && eternal[c].1 == eternal[i].1 - 1
  756.                                             {
  757.                                                 potato = true;
  758.                                                 break;
  759.                                             }
  760.                                         }
  761.                                         if !potato
  762.                                         {
  763.                                             eternal.push((eternal[i].0 - 1, eternal[i].1 - 1));
  764.                                         }
  765.                                     }
  766.                                     else if desk_gr[(eternal[i].0 - 1) as usize][(eternal[i].1 - 1) as usize] == ' '
  767.                                     {
  768.                                         desk_gr[(eternal[i].0 - 1) as usize][(eternal[i].1 - 1) as usize] =
  769.                                             open_cl(bomb_num[(eternal[i].0 - 1) as usize][(eternal[i].1 - 1) as usize]);
  770.                                         amount += 1;
  771.                                     }
  772.                                 }
  773.                                 if game_type != 1
  774.                                 {
  775.                                     if eternal[i].0 < game_type - 1 && eternal[i].1 > 0
  776.                                     {
  777.                                         if bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1 - 1) as usize] == 0
  778.                                         {
  779.                                             let mut potato = false; // check for 0
  780.                                             for c in 0..eternal.len()
  781.                                             {
  782.                                                 if eternal[c].0 == eternal[i].0 + 1 && eternal[c].1 == eternal[i].1 - 1
  783.                                                 {
  784.                                                     potato = true;
  785.                                                     break;
  786.                                                 }
  787.                                             }
  788.                                             if !potato
  789.                                             {
  790.                                                 eternal.push((eternal[i].0 + 1, eternal[i].1 - 1));
  791.                                             }
  792.                                         }
  793.                                         else if desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1 - 1) as usize] == ' '
  794.                                         {
  795.                                             desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1 - 1) as usize] =
  796.                                                 open_cl(bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1 - 1) as usize]);
  797.                                             amount += 1;
  798.                                         }
  799.                                     }
  800.                                 }
  801.                                 else
  802.                                 {
  803.                                     if eternal[i].0 < x - 1 && eternal[i].1 > 0
  804.                                     {
  805.                                         if bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1 - 1) as usize] == 0
  806.                                         {
  807.                                             let mut potato = false;
  808.                                             for c in 0..eternal.len()
  809.                                             {
  810.                                                 if eternal[c].0 == eternal[i].0 + 1 && eternal[c].1 == eternal[i].1 - 1
  811.                                                 {
  812.                                                     potato = true;
  813.                                                     break;
  814.                                                 }
  815.                                             }
  816.                                             if !potato
  817.                                             {
  818.                                                 eternal.push((eternal[i].0 + 1, eternal[i].1 - 1));
  819.                                             }
  820.                                         }
  821.                                         else if desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1 - 1) as usize] == ' '
  822.                                         {
  823.                                             desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1 - 1) as usize] =
  824.                                                 open_cl(bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1 - 1) as usize]);
  825.                                             amount += 1;
  826.                                         }
  827.                                     }
  828.                                 }
  829.                                 if game_type != 1
  830.                                 {
  831.                                     if eternal[i].0 > 0 && eternal[i].1 < game_type - 1
  832.                                     {
  833.                                         if bomb_num[(eternal[i].0 - 1) as usize][(eternal[i].1 + 1) as usize] == 0
  834.                                         {
  835.                                             let mut potato = false; // check for 0
  836.                                             for c in 0..eternal.len()
  837.                                             {
  838.                                                 if eternal[c].0 == eternal[i].0 - 1 && eternal[c].1 == eternal[i].1 + 1
  839.                                                 {
  840.                                                     potato = true;
  841.                                                     break;
  842.                                                 }
  843.                                             }
  844.                                             if !potato
  845.                                             {
  846.                                                 eternal.push((eternal[i].0 - 1, eternal[i].1 + 1));
  847.                                             }
  848.                                         }
  849.                                         else if desk_gr[(eternal[i].0 - 1) as usize][(eternal[i].1 + 1) as usize] == ' '
  850.                                         {
  851.                                             desk_gr[(eternal[i].0 - 1) as usize][(eternal[i].1 + 1) as usize] =
  852.                                                 open_cl(bomb_num[(eternal[i].0 - 1) as usize][(eternal[i].1 + 1) as usize]);
  853.                                             amount += 1;
  854.                                         }
  855.                                     }
  856.                                 }
  857.                                 else
  858.                                 {
  859.                                     if eternal[i].0 > 0 && eternal[i].1 < y - 1
  860.                                     {
  861.                                         if bomb_num[(eternal[i].0 - 1) as usize][(eternal[i].1 + 1) as usize] == 0
  862.                                         {
  863.                                             let mut potato = false;
  864.                                             for c in 0..eternal.len()
  865.                                             {
  866.                                                 if eternal[c].0 == eternal[i].0 - 1 && eternal[c].1 == eternal[i].1 + 1
  867.                                                 {
  868.                                                     potato = true;
  869.                                                     break;
  870.                                                 }
  871.                                             }
  872.                                             if !potato
  873.                                             {
  874.                                                 eternal.push((eternal[i].0 - 1, eternal[i].1 + 1));
  875.                                             }
  876.                                         }
  877.                                         else if desk_gr[(eternal[i].0 - 1) as usize][(eternal[i].1 + 1) as usize] == ' '
  878.                                         {
  879.                                             desk_gr[(eternal[i].0 - 1) as usize][(eternal[i].1 + 1) as usize] =
  880.                                                 open_cl(bomb_num[(eternal[i].0 - 1) as usize][(eternal[i].1 + 1) as usize]);
  881.                                             amount += 1;
  882.                                         }
  883.                                     }
  884.                                 }
  885.                                 if game_type != 1
  886.                                 {
  887.                                     if eternal[i].0 < game_type - 1 && eternal[i].1 < game_type - 1
  888.                                     {
  889.                                         if bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1 + 1) as usize] == 0
  890.                                         {
  891.                                             let mut potato = false; // check for 0
  892.                                             for c in 0..eternal.len()
  893.                                             {
  894.                                                 if eternal[c].0 == eternal[i].0 + 1 && eternal[c].1 == eternal[i].1 + 1
  895.                                                 {
  896.                                                     potato = true;
  897.                                                     break;
  898.                                                 }
  899.                                             }
  900.                                             if !potato
  901.                                             {
  902.                                                 eternal.push((eternal[i].0 + 1, eternal[i].1 + 1));
  903.                                             }
  904.                                         }
  905.                                         else if desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1 + 1) as usize] == ' '
  906.                                         {
  907.                                             desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1 + 1) as usize] =
  908.                                                 open_cl(bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1 + 1) as usize]);
  909.                                             amount += 1;
  910.                                         }
  911.                                     }
  912.                                 }
  913.                                 else
  914.                                 {
  915.                                     if eternal[i].0 < x - 1 && eternal[i].1 < y - 1
  916.                                     {
  917.                                         if bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1 + 1) as usize] == 0
  918.                                         {
  919.                                             let mut potato = false;
  920.                                             for c in 0..eternal.len()
  921.                                             {
  922.                                                 if eternal[c].0 == eternal[i].0 + 1 && eternal[c].1 == eternal[i].1 + 1
  923.                                                 {
  924.                                                     potato = true;
  925.                                                     break;
  926.                                                 }
  927.                                             }
  928.                                             if !potato
  929.                                             {
  930.                                                 eternal.push((eternal[i].0 + 1, eternal[i].1 + 1));
  931.                                             }
  932.                                         }
  933.                                         else if desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1 + 1) as usize] == ' '
  934.                                         {
  935.                                             desk_gr[(eternal[i].0 + 1) as usize][(eternal[i].1 + 1) as usize] =
  936.                                                 open_cl(bomb_num[(eternal[i].0 + 1) as usize][(eternal[i].1 + 1) as usize]);
  937.                                             amount += 1;
  938.                                         }
  939.                                     }
  940.                                 }
  941.                             }
  942.                         }
  943.                         else
  944.                         {
  945.                             desk_gr[(xh - 1) as usize][(yh - 1) as usize] =
  946.                                 open_cl(bomb_num[(xh - 1) as usize][(yh - 1) as usize]);
  947.                         }
  948.                         match game_type
  949.                         {
  950.                             8  => print_desk(&desk_gr, 8, 8),
  951.                             16 => print_desk(&desk_gr, 16, 16),
  952.                             32 => print_desk(&desk_gr, 32, 32),
  953.                             _  => print_desk(&desk_gr, x, y),
  954.                         }
  955.                         space -= amount;
  956.                     }
  957.                 }
  958.             },
  959.         }
  960.     }
  961.     if !lose
  962.     {
  963.         println!("ВЫ ВЫЖИЛИ!");
  964.     }
  965.     let finish: libc::time64_t  = libc::time(0 as *mut libc::time64_t);
  966.     println!("Ваше время: {} секунд", finish - start);
  967.     return lose;
  968. }
  969.  
  970. unsafe fn main() {
  971.     let mut list: Vec<Result> = vec![];
  972.     let fin = std::fs::File::open("results.bin");
  973.     match fin
  974.     {
  975.         Err(std::fs::File::open("results.bin")) => {
  976.             // If file does not exist, than we'll create it
  977.             let mut file = std::fs::File::create("results.bin").expect("create failed");
  978.         },
  979.         Ok(std::fs::File::open("results.bin"))  => {
  980.             /*
  981.             We know the amount of players, so we know how many times we'll
  982.             read data from string. To understand that we've read something
  983.             we are reading symbol by symbol and check it. If symbol is
  984.             equal to '/' then it's a field of structure.
  985.             */
  986.             let mut file = std::fs::File::open("results.bin").unwrap();
  987.             let mut contents = String::new();
  988.             file.read_to_string(&mut contents).unwrap();
  989.             let mut end_s: usize = 0;
  990.             while &contents[end_s - 1..end_s] != "/"
  991.             {
  992.                 end_s += 1;
  993.             }
  994.             let mut size: usize = contents[0..end_s].parse().expect("convert string");
  995.             list.resize_with(size,("", 0, 0, 0.0, 0, 0));
  996.             let mut start: usize = 0;
  997.             let mut finish: usize = 1;
  998.             for i in 0..list.len()
  999.             {
  1000.                 let mut guy = Result("".to_string(), 0, 0, 0.0, 0, 0, 0);
  1001.                 while &contents[finish - 1..finish] != "/"
  1002.                 {
  1003.                     finish += 1;
  1004.                 }
  1005.                 guy.0 = contents[start..finish - 1].to_string();
  1006.                 start = finish;
  1007.                 finish += 1;
  1008.                 while &contents[finish - 1..finish] != "/"
  1009.                 {
  1010.                     finish += 1;
  1011.                 }
  1012.                 guy.1 = contents[start..finish - 1].parse().expect("convert error");
  1013.                 start = finish;
  1014.                 finish += 1;
  1015.                 while &contents[finish - 1..finish] != "/"
  1016.                 {
  1017.                     finish += 1;
  1018.                 }
  1019.                 guy.2 = contents[start..finish - 1].parse().expect("convert error");
  1020.                 start = finish;
  1021.                 finish += 1;
  1022.                 while &contents[finish - 1..finish] != "/"
  1023.                 {
  1024.                     finish += 1;
  1025.                 }
  1026.                 guy.3 = contents[start..finish - 1].parse().expect("convert error");
  1027.                 start = finish;
  1028.                 finish += 1;
  1029.                 while &contents[finish - 1..finish] != "/"
  1030.                 {
  1031.                     finish += 1;
  1032.                 }
  1033.                 guy.4 = contents[start..finish - 1].parse().expect("convert error");
  1034.                 start = finish;
  1035.                 finish += 1;
  1036.                 while &contents[finish - 1..finish] != "/"
  1037.                 {
  1038.                     finish += 1;
  1039.                 }
  1040.                 guy.5 = contents[start..finish - 1].parse().expect("convert error");
  1041.                 start = finish;
  1042.                 finish += 1;
  1043.                 while &contents[finish - 1..finish] != "/"
  1044.                 {
  1045.                     finish += 1;
  1046.                 }
  1047.                 guy.6 = contents[start..finish - 1].parse().expect("convert error");
  1048.                 start = finish;
  1049.                 finish += 1;
  1050.                 list.push(guy);
  1051.             }
  1052.         },
  1053.     }
  1054.     let mut choice: u32      = 0;
  1055.     let mut gm_ch:  u32      = 0;
  1056.     let mut res_ch: u32      = 0;
  1057.     let mut _choice: String  = String::new();
  1058.     let mut _game_ch: String = String::new();
  1059.     let mut _res_ch: String  = String::new();
  1060.     let mut _away: String    = String::new();
  1061.     let mut _fix_ex: String  = String::new();
  1062.     let mut g8sch:  bool     = false;
  1063.     let mut g16sch: bool     = false;
  1064.     let mut g32sch: bool     = false;
  1065.     let mut gcssch: bool     = false;
  1066.     while choice != 3
  1067.     {
  1068.         g8sch  = false;
  1069.         g16sch = false;
  1070.         g32sch = false;
  1071.         while choice < 1 || choice > 3
  1072.         {
  1073.             loop
  1074.             {
  1075.                 println!("ххххх_САПЁР_ххххх");
  1076.                 println!("1.Играть\n2.Рекорды\n3.Выход");
  1077.                 println!("Введите ЦИФРУ ОТ 1 ДО 3, чтобы выполнить действие: ");
  1078.                 io::stdin().read_line(&mut _choice).expect("read string");
  1079.                 let test = _choice.trim().parse();
  1080.                 match test
  1081.                 {
  1082.                     Err(test) => {
  1083.                         println!("Некорректный ввод");
  1084.                     },
  1085.                     _ => {
  1086.                         break;
  1087.                     },
  1088.                 }
  1089.             }
  1090.             choice = _choice.trim().parse().expect("convert error");
  1091.         }
  1092.         let mut player = Result("".to_string(), 0, 0, 0.0, 0, 0, 0);
  1093.         match choice
  1094.         {
  1095.             1 => {
  1096.                 print!("Введите ваш ник");
  1097.                 let mut name = String::new();
  1098.                 io::stdin().read_line(&mut name).expect("read string");
  1099.                 player.0 = name;
  1100.                 while gm_ch < 1 || gm_ch > 4
  1101.                 {
  1102.                     loop
  1103.                     {
  1104.                         print!("Выберите уровень сложности: \
  1105.                        1.Просто(доска 8x8, 16 мин); \
  1106.                        2.Не так просто(доска 16x16, 32 мины);\
  1107.                        3.ХАРДКОР(доска 32x32, 64 мины); \
  1108.                        4.Своя игра (ВВЕСТИ ЦИФРУ): ");
  1109.                         io::stdin().read_line(&mut _game_ch).expect("read string");
  1110.                         let test = _game_ch.trim().parse();
  1111.                         match test
  1112.                         {
  1113.                             Err(test) => {
  1114.                                 println!("Некорректный ввод");
  1115.                             },
  1116.                             _ => {
  1117.                                 break;
  1118.                             },
  1119.                         }
  1120.                     }
  1121.                     gm_ch = _game_ch.trim().parse().expect("convert error");
  1122.                     match gm_ch
  1123.                     {
  1124.                         1 => {
  1125.                             for e in 0..list.len()
  1126.                             {
  1127.                                 if list[e].0 == player.0 // name
  1128.                                 {
  1129.                                     g8sch = true;
  1130.                                     if game(8)
  1131.                                     {
  1132.                                         list[e].2 += 1;                                          // victory
  1133.                                         list[e].4 += 1;                                          // izzy
  1134.                                     }
  1135.                                     list[e].1 += 1;                                              // games
  1136.                                     list[e].3 = (list[e].2 as f64 / (list[e].1 as f64 / 100.0)); // percent
  1137.                                     break;
  1138.                                 }
  1139.                             }
  1140.                             if !g8sch
  1141.                             {
  1142.                                 player.2 = 0;
  1143.                                 player.4 = 0;
  1144.                                 player.5 = 0;
  1145.                                 player.6 = 0;
  1146.                                 if game(8)
  1147.                                 {
  1148.                                     player.2 = 1;                                           // victory
  1149.                                     player.4 = 1;                                           // izzy
  1150.                                 }
  1151.                                 player.1 = 1;                                               // games
  1152.                                 player.3 = (list[e].2 as f64 / (list[e].1 as f64 / 100.0)); // percent
  1153.                                 list.push(player);
  1154.                             }
  1155.                         },
  1156.                         2 => {
  1157.                             for e in 0..list.len()
  1158.                             {
  1159.                                 if list[e].0 == player.0 // name
  1160.                                 {
  1161.                                     g16sch = true;
  1162.                                     if game(16)
  1163.                                     {
  1164.                                         list[e].2 += 1;                                          // victory
  1165.                                         list[e].5 += 1;                                          // hard
  1166.                                     }
  1167.                                     list[e].1 += 1;                                              // games
  1168.                                     list[e].3 = (list[e].2 as f64 / (list[e].1 as f64 / 100.0)); // percent
  1169.                                     break;
  1170.                                 }
  1171.                             }
  1172.                             if !g16sch
  1173.                             {
  1174.                                 player.2 = 0;
  1175.                                 player.4 = 0;
  1176.                                 player.5 = 0;
  1177.                                 player.6 = 0;
  1178.                                 if game(16)
  1179.                                 {
  1180.                                     player.2 = 1;                                           // victory
  1181.                                     player.5 = 1;                                           // hard
  1182.                                 }
  1183.                                 player.1 = 1;                                               // games
  1184.                                 player.3 = (list[e].2 as f64 / (list[e].1 as f64 / 100.0)); // percent
  1185.                                 list.push(player);
  1186.                             }
  1187.                         }
  1188.                         3 => {
  1189.                             for e in 0..list.len()
  1190.                             {
  1191.                                 if list[e].0 == player.0 // name
  1192.                                 {
  1193.                                     g32sch = true;
  1194.                                     if game(32)
  1195.                                     {
  1196.                                         list[e].2 += 1;                                          // victory
  1197.                                         list[e].6 += 1;                                          // hard
  1198.                                     }
  1199.                                     list[e].1 += 1;                                              // games
  1200.                                     list[e].3 = (list[e].2 as f64 / (list[e].1 as f64 / 100.0)); // percent
  1201.                                     break;
  1202.                                 }
  1203.                             }
  1204.                             if !g32sch
  1205.                             {
  1206.                                 player.2 = 0;
  1207.                                 player.4 = 0;
  1208.                                 player.5 = 0;
  1209.                                 player.6 = 0;
  1210.                                 if game(32)
  1211.                                 {
  1212.                                     player.2 = 1;                                           // victory
  1213.                                     player.6 = 1;                                           // doom
  1214.                                 }
  1215.                                 player.1 = 1;                                               // games
  1216.                                 player.3 = (list[e].2 as f64 / (list[e].1 as f64 / 100.0)); // percent
  1217.                                 list.push(player);
  1218.                             }
  1219.                         }
  1220.                         _ => {
  1221.                             for e in 0..list.len()
  1222.                             {
  1223.                                 if list[e].0 == player.0 // name
  1224.                                 {
  1225.                                     gcssch = true;
  1226.                                     if game(1)
  1227.                                     {
  1228.                                         list[e].2 += 1;                                          // victory
  1229.                                     }
  1230.                                     list[e].1 += 1;                                              // games
  1231.                                     list[e].3 = (list[e].2 as f64 / (list[e].1 as f64 / 100.0)); // percent
  1232.                                     break;
  1233.                                 }
  1234.                             }
  1235.                             if !gcssch
  1236.                             {
  1237.                                 player.2 = 0;
  1238.                                 player.4 = 0;
  1239.                                 player.5 = 0;
  1240.                                 player.6 = 0;
  1241.                                 if game(1)
  1242.                                 {
  1243.                                     player.2 = 1;                                           // victory
  1244.                                 }
  1245.                                 player.1 = 1;                                               // games
  1246.                                 player.3 = (list[e].2 as f64 / (list[e].1 as f64 / 100.0)); // percent
  1247.                                 list.push(player);
  1248.                             }
  1249.                         }
  1250.                     }
  1251.                     save(&list);
  1252.                 }
  1253.             },
  1254.             2 => {
  1255.                 while res_ch != 6
  1256.                 {
  1257.                     println!("Результаты");
  1258.                     while res_ch > 6
  1259.                     {
  1260.                         println!("1.Сыграно игр\n\
  1261.                        2.Побед на сложности 'легко'\n\
  1262.                        3.Побед на сложности 'не так легко'\n\
  1263.                        4.Побед на сложности 'ХАРДКОР'\n\
  1264.                        5.Процент побед.\n\
  1265.                        6.Выход");
  1266.                         print!("Выберите ЦИФРУ действия: ");
  1267.                         io::stdin().read_line(&mut _res_ch).expect("read string");
  1268.                         res_ch = _res_ch.trim().parse().expect("convert");
  1269.                         if res_ch > 6
  1270.                         {
  1271.                             println!("Ввод не корректен");
  1272.                         }
  1273.                     }
  1274.                     match res_ch
  1275.                     {
  1276.                         1 => {
  1277.                             if list.is_empty()
  1278.                             {
  1279.                                 println!("Ещё никто не играл");
  1280.                             }
  1281.                             else
  1282.                             {
  1283.                                 list.sort();
  1284.                                 list.reverse();
  1285.                                 for i in 0..list.len()
  1286.                                 {
  1287.                                     println!("{} : {}", list[i].0, list[i].2);
  1288.                                 }
  1289.                             }
  1290.                         },
  1291.                         2 => {
  1292.                             if list.is_empty()
  1293.                             {
  1294.                                 println!("Ещё никто не играл");
  1295.                             }
  1296.                             else
  1297.                             {
  1298.                                 list.sort();
  1299.                                 list.reverse();
  1300.                                 for i in 0..list.len()
  1301.                                 {
  1302.                                     println!("{} : {}", list[i].0, list[i].4);
  1303.                                 }
  1304.                             }
  1305.                         },
  1306.                         3 => {
  1307.                             if list.is_empty()
  1308.                             {
  1309.                                 println!("Ещё никто не играл");
  1310.                             }
  1311.                             else
  1312.                             {
  1313.                                 list.sort();
  1314.                                 list.reverse();
  1315.                                 for i in 0..list.len()
  1316.                                 {
  1317.                                     println!("{} : {}", list[i].0, list[i].5);
  1318.                                 }
  1319.                             }
  1320.                         },
  1321.                         4 => {
  1322.                             if list.is_empty()
  1323.                             {
  1324.                                 println!("Ещё никто не играл");
  1325.                             }
  1326.                             else
  1327.                             {
  1328.                                 list.sort();
  1329.                                 list.reverse();
  1330.                                 for i in 0..list.len()
  1331.                                 {
  1332.                                     println!("{} : {}", list[i].0, list[i].6);
  1333.                                 }
  1334.                             }
  1335.                         },
  1336.                         5 => {
  1337.                             if list.is_empty()
  1338.                             {
  1339.                                 println!("Ещё никто не играл");
  1340.                             }
  1341.                             else
  1342.                             {
  1343.                                 list.sort();
  1344.                                 list.reverse();
  1345.                                 for i in 0..list.len()
  1346.                                 {
  1347.                                     println!("{} : {}", list[i].0, list[i].3);
  1348.                                 }
  1349.                             }
  1350.                         },
  1351.                         _ => {
  1352.                             println!("Вы точно хотите выйти? \
  1353.                            Введите YES, если да или что-то другое, если нет.");
  1354.                             io::stdin().read_line(&mut _fix_ex).expect("read string");
  1355.                             if _fix_ex != "YES".to_string()
  1356.                             {
  1357.                                 res_ch = 0;
  1358.                             }
  1359.                         }
  1360.                     }
  1361.                 }
  1362.                
  1363.             }
  1364.             _ => {
  1365.                 println!("Вы точно хотите выйти? \
  1366.                          Введите YES, если да или что-то другое, если нет.");
  1367.                 io::stdin().read_line(&mut _away).expect("read string");
  1368.                 if _away != "YES".to_string()
  1369.                 {
  1370.                     choice = 0;
  1371.                 }
  1372.             }
  1373.         }
  1374.     }    
  1375. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!