Grcov report - main.rs

1

// This file is part of hnefatafl-copenhagen.

2

//

3

// hnefatafl-copenhagen is free software: you can redistribute it and/or modify

4

// it under the terms of the GNU Affero General Public License as published by

5

// the Free Software Foundation, either version 3 of the License, or

6

// (at your option) any later version.

7

//

8

// hnefatafl-copenhagen is distributed in the hope that it will be useful,

9

// but WITHOUT ANY WARRANTY; without even the implied warranty of

10

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

11

// GNU Affero General Public License for more details.

12

//

13

// You should have received a copy of the GNU Affero General Public License

14

// along with this program.  If not, see <https://www.gnu.org/licenses/>.

15

16

// Don't open the terminal on Windows.

17

#![cfg_attr(all(windows, not(feature = "console")), windows_subsystem = "windows")]

18

#![deny(clippy::unwrap_used)]

19

20

mod archived_game_handle;

21

mod command_line;

22

mod dimensions;

23

mod enums;

24

mod new_game_settings;

25

mod user;

26

27

use std::{

28

    collections::{HashMap, HashSet, VecDeque},

29

    fmt::{self, Write as _},

30

    fs::{self, File},

31

    io::{BufRead, BufReader, Cursor, ErrorKind, Read, Write},

32

    net::{Shutdown, TcpStream, ToSocketAddrs},

33

    process::exit,

34

    str::{FromStr, SplitAsciiWhitespace},

35

    sync::mpsc,

36

    thread::{self, sleep},

37

    time::Duration,

38

};

39

40

use ::serde::{Deserialize, Serialize};

41

use chrono::{Local, Utc};

42

use clap::{CommandFactory, Parser};

43

use futures::{SinkExt, executor};

44

use hnefatafl_copenhagen::{

45

    COPYRIGHT, Id, SERVER_PORT, VERSION_ID,

46

    board::{Board, BoardSize},

47

    characters::Characters,

48

    draw::Draw,

49

    email::Email,

50

    game::{Game, LegalMoves, TimeUnix},

51

    glicko::{CONFIDENCE_INTERVAL_95, Rating},

52

    heat_map::{Heat, HeatMap},

53

    locale::Locale,

54

    play::{BOARD_LETTERS, Plae, Plays, Vertex},

55

    rating::Rated,

56

    role::Role,

57

    server_game::{ArchivedGame, ServerGameLight, ServerGamesLight},

58

    space::Space,

59

    status::Status,

60

    time::{TimeEnum, TimeSettings},

61

    tournament::{self, Tournament},

62

    tree::Tree,

63

    utils::{self, choose_ai, create_data_folder, data_file},

64

};

65

#[cfg(target_os = "linux")]

66

use iced::window::settings::PlatformSpecific;

67

use iced::{

68

    Color, Element, Event, Font, Pixels, Subscription, Task,

69

    alignment::{Horizontal, Vertical},

70

    color, event,

71

    futures::Stream,

72

    keyboard::{self, Key, key::Named},

73

    stream,

74

    theme::Palette,

75

    widget::{

76

        self, Column, Container, Row, Scrollable, button, checkbox, column, container,

77

        operation::{focus_next, focus_previous},

78

        pick_list, radio, row, scrollable, text, text_editor,

79

        text_input::Value,

80

        tooltip,

81

},

82

    window::{self, icon},

83

};

84

use image::ImageFormat;

85

use log::{debug, error, info, trace};

86

use rust_i18n::t;

87

use smol_str::ToSmolStr;

88

use socket2::{Domain, SockAddr, Socket, TcpKeepalive, Type};

89

90

use crate::{

91

    archived_game_handle::ArchivedGameHandle,

92

    command_line::Args,

93

    dimensions::Dimensions,

94

    enums::{Coordinates, JoinGame, LoggedIn, Message, Move, Screen, Size, SortBy, State, Theme},

95

    new_game_settings::NewGameSettings,

96

    user::User,

97

};

98

99

/// The Muted qualitative color scheme of [Tol]. A color scheme for the

100

/// color blind.

101

///

102

/// [Tol]: https://sronpersonalpages.nl/~pault/#sec:qualitative

103

pub const TOL: Palette = Palette {

104

    background: color!(0xDD, 0xDD, 0xDD), // PALE_GREY

105

    text: color!(0x00, 0x00, 0x00),       // BLACK

106

    primary: color!(0x88, 0xCC, 0xEE),    // CYAN

107

    success: color!(0x11, 0x77, 0x33),    // GREEN

108

    warning: color!(0xDD, 0xCC, 0x77),    // SAND

109

    danger: color!(0xCC, 0x66, 0x77),     // ROSE

110

};

111

112

const ALPHABET: [char; 26] = [

113

    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',

114

    't', 'u', 'v', 'w', 'x', 'y', 'z',

115

];

116

117

#[cfg(all(target_os = "linux", not(feature = "icon_2")))]

118

const APPLICATION_ID: &str = "hnefatafl-client";

119

120

#[cfg(all(target_os = "linux", feature = "icon_2"))]

121

const APPLICATION_ID: &str = "org.hnefatafl.hnefatafl_client";

122

123

const BOARD_LETTERS_LOWERCASE: [char; 13] = [

124

    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',

125

];

126

127

const HELMET: &[u8] = include_bytes!("helmet.png");

128

const ARCHIVED_GAMES_FILE: &str = "archived-games.postcard";

129

const USER_CONFIG_FILE: &str = "user.ron";

130

131

const PADDING: u16 = 10;

132

const PADDING_SMALL: u16 = 2;

133

const PADDING_MEDIUM: u16 = 4;

134

const SPACING: Pixels = Pixels(10.0);

135

const SPACING_B: Pixels = Pixels(20.0);

136

137

const SOUND_CAPTURE: &[u8] = include_bytes!("sound/capture.ogg");

138

const SOUND_GAME_OVER: &[u8] = include_bytes!("sound/game_over.ogg");

139

const SOUND_MOVE: &[u8] = include_bytes!("sound/move.ogg");

140

141

const TROPHY_SIZE: u32 = 32;

142

143

rust_i18n::i18n!();

144

145

fn i18n_buttons() -> HashMap<String, String> {

146

    let mut strings = HashMap::new();

147

148

    strings.insert("Login".to_string(), t!("Login").to_string());

149

    strings.insert(

150

        "Create Account".to_string(),

151

        t!("Create Account").to_string(),

152

);

153

    strings.insert(

154

        "Reset Password".to_string(),

155

        t!("Reset Password").to_string(),

156

);

157

    strings.insert("Leave".to_string(), t!("Leave").to_string());

158

    strings.insert("Quit".to_string(), t!("Quit").to_string());

159

    strings.insert("Dark".to_string(), t!("Dark").to_string());

160

    strings.insert("Light".to_string(), t!("Light").to_string());

161

    strings.insert("Create Game".to_string(), t!("Create Game").to_string());

162

    strings.insert("Users".to_string(), t!("Users").to_string());

163

    strings.insert(

164

        "Account Settings".to_string(),

165

        t!("Account Settings").to_string(),

166

);

167

    strings.insert("Rules".to_string(), t!("Rules").to_string());

168

    strings.insert("Reset Email".to_string(), t!("Reset Email").to_string());

169

    strings.insert(

170

        "Change Password".to_string(),

171

        t!("Change Password").to_string(),

172

);

173

    strings.insert(

174

        "Delete Account".to_string(),

175

        t!("Delete Account").to_string(),

176

);

177

    strings.insert(

178

        "REALLY DELETE ACCOUNT".to_string(),

179

        t!("REALLY DELETE ACCOUNT").to_string(),

180

);

181

    strings.insert("New Game".to_string(), t!("New Game").to_string());

182

    strings.insert("Accept".to_string(), t!("Accept").to_string());

183

    strings.insert("Decline".to_string(), t!("Decline").to_string());

184

    strings.insert("Watch".to_string(), t!("Watch").to_string());

185

    strings.insert("Join".to_string(), t!("Join").to_string());

186

    strings.insert("Resume".to_string(), t!("Resume").to_string());

187

    strings.insert("Resign".to_string(), t!("Resign").to_string());

188

    strings.insert("Request Draw".to_string(), t!("Request Draw").to_string());

189

    strings.insert("Accept Draw".to_string(), t!("Accept Draw").to_string());

190

    strings.insert("Review Game".to_string(), t!("Review Game").to_string());

191

    strings.insert(

192

        "Get Archived Games".to_string(),

193

        t!("Get Archived Games").to_string(),

194

);

195

    strings.insert("Heat Map".to_string(), t!("Heat Map").to_string());

196

    strings.insert("Join Discord".to_string(), t!("Join Discord").to_string());

197

    strings.insert("Cancel".to_string(), t!("Cancel").to_string());

198

    strings.insert("Tournament".to_string(), t!("Tournament").to_string());

199

    strings.insert(

200

        "Join Tournament".to_string(),

201

        t!("Join Tournament").to_string(),

202

);

203

    strings.insert(

204

        "Leave Tournament".to_string(),

205

        t!("Leave Tournament").to_string(),

206

);

207

208

    strings

209

210

211

fn init_client() -> Client {

212

    let user_config_file_postcard = data_file(ARCHIVED_GAMES_FILE);

213

    let user_config_file_ron = data_file(USER_CONFIG_FILE);

214

    let mut error = Vec::new();

215

216

    let mut client: Client = match &fs::read_to_string(&user_config_file_ron) {

217

        Ok(string) => match ron::from_str(string) {

218

            Ok(client) => client,

219

            Err(err) => {

220

                error.push(format!(

221

                    "Error parsing the ron file {}: {err}",

222

                    user_config_file_ron.display()

223

));

224

                Client::default()

225

226

},

227

        Err(err) => {

228

            if err.kind() == ErrorKind::NotFound {

229

                error.push(format!(

230

                    "Unable to find User Configuration file: {}",

231

                    user_config_file_ron.display()

232

));

233

                Client::default()

234

            } else {

235

                error.push(format!(

236

                    "Error opening the file {}: {err}",

237

                    user_config_file_ron.display()

238

));

239

                Client::default()

240

241

242

};

243

244

    rust_i18n::set_locale(&client.locale_selected.txt());

245

    client.strings = i18n_buttons();

246

    client.text_input.clone_from(&client.username);

247

248

    let archived_games: Vec<ArchivedGame> = match &fs::read(&user_config_file_postcard) {

249

        Ok(bytes) => match postcard::from_bytes(bytes) {

250

            Ok(client) => client,

251

            Err(err) => {

252

                error.push(format!(

253

                    "Error parsing the postcard file {}: {err}",

254

                    user_config_file_postcard.display()

255

));

256

                Vec::new()

257

258

},

259

        Err(err) => {

260

            if err.kind() == ErrorKind::NotFound {

261

                error.push(format!(

262

                    "{}: {}",

263

                    t!("Unable to find Archived Games file"),

264

                    user_config_file_postcard.display()

265

));

266

                Vec::new()

267

            } else {

268

                error.push(format!(

269

                    "{} {}: {err}",

270

                    t!("Error opening the file"),

271

                    user_config_file_postcard.display()

272

));

273

                Vec::new()

274

275

276

};

277

278

    client.archived_games = archived_games;

279

    client.error_persistent = error;

280

281

    let args = Args::parse();

282

    if args.ascii {

283

        client.chars.ascii();

284

285

286

    let mut letters = HashMap::new();

287

    for ch in BOARD_LETTERS_LOWERCASE {

288

        letters.insert(ch, false);

289

290

291

    client

292

293

294

fn main() -> anyhow::Result<()> {

295

    let args = Args::parse();

296

    utils::init_logger("hnefatafl_client", args.debug, false);

297

298

    if args.man {

299

        let mut buffer: Vec<u8> = Vec::default();

300

        let cmd = Args::command().name("hnefatafl-client").long_version(None);

301

        let man = clap_mangen::Man::new(cmd).date("2025-06-23");

302

303

        man.render(&mut buffer)?;

304

        write!(buffer, "{COPYRIGHT}")?;

305

306

        std::fs::write("hnefatafl-client.1", buffer)?;

307

        return Ok(());

308

309

310

    create_data_folder()?;

311

312

    let mut application = iced::application(init_client, Client::update, Client::view)

313

        .title("Hnefatafl Copenhagen")

314

        .subscription(Client::subscriptions)

315

        .window(window::Settings {

316

            #[cfg(target_os = "linux")]

317

            platform_specific: PlatformSpecific {

318

                application_id: APPLICATION_ID.to_string(),

319

                ..PlatformSpecific::default()

320

},

321

            icon: Some(icon::from_file_data(HELMET, Some(ImageFormat::Png))?),

322

            ..window::Settings::default()

323

})

324

        .theme(Client::theme);

325

326

    // For screenshots.

327

    if args.tiny_window {

328

        application = application.window_size(iced::Size {

329

            width: 868.0,

330

            height: 541.0,

331

});

332

333

334

    if args.social_preview {

335

        application = application.window_size(iced::Size {

336

            width: 1148.0,

337

            height: 481.0,

338

});

339

340

341

    application.run()?;

342

    Ok(())

343

344

345

fn estimate_score() -> impl Stream<Item = Message> {

346

    let args = Args::parse();

347

348

    stream::channel(

349

        100,

350

        move |mut sender: iced::futures::channel::mpsc::Sender<Message>| async move {

351

            let (tx, rx) = mpsc::channel();

352

353

            if let Err(error) = sender.send(Message::EstimateScoreConnected(tx)).await {

354

                error!("failed to send channel: {error}");

355

                exit(1);

356

357

358

            thread::spawn(move || {

359

                let mut ai = match choose_ai(&args.ai, args.seconds, args.depth, true) {

360

                    Ok(ai) => ai,

361

                    Err(error) => {

362

                        error!("{error}");

363

                        exit(1);

364

365

};

366

367

                for tree in &rx {

368

                    let mut game = Game::from(&tree);

369

                    let generate_move = ai.generate_move(&mut game).expect("the game is ongoing");

370

371

                    if let Err(error) = executor::block_on(

372

                        sender.send(Message::EstimateScoreDisplay((tree.here(), generate_move))),

373

) {

374

                        error!("failed to send channel: {error}");

375

                        exit(1);

376

377

378

});

379

},

380

381

382

383

fn handle_error<T, E: fmt::Display>(result: Result<T, E>) -> T {

384

    match result {

385

        Ok(value) => value,

386

        Err(error) => {

387

            error!("{error}");

388

            exit(1)

389

390

391

392

393

fn open_url(url: &str) {

394

    if let Err(error) = webbrowser::open(url) {

395

        error!("{error}");

396

397

398

399

#[allow(clippy::too_many_lines)]

400

fn pass_messages() -> impl Stream<Item = Message> {

401

    stream::channel(

402

        100,

403

        move |mut sender: iced::futures::channel::mpsc::Sender<Message>| async move {

404

            let mut args = Args::parse();

405

            args.host.push_str(SERVER_PORT);

406

            let address_string = args.host;

407

408

            thread::spawn(move || {

409

                'start_over: loop {

410

                    let (tx, rx) = mpsc::channel();

411

412

                    if let Err(error) =

413

                        executor::block_on(sender.send(Message::StreamConnected(tx.clone())))

414

415

                        error!("failed to send channel: {error}");

416

                        exit(1);

417

418

419

                    loop {

420

                        let message = match rx.recv() {

421

                            Ok(message) => message,

422

                            Err(error) => {

423

                                error!("rx: {error}");

424

425

                                if let Err(error) = executor::block_on(sender.send(Message::Exit)) {

426

                                    error!("{error}");

427

428

429

                                return;

430

431

};

432

                        let message_trim = message.trim();

433

434

                        if message_trim == "tcp_connect" {

435

                            break;

436

437

438

439

                    let mut is_ipv6 = false;

440

                    let mut socket_address = None;

441

                    let socket_addresses =

442

                        address_string.to_socket_addrs().unwrap_or_else(|error| {

443

                            panic!("The socket address resolves to no IPs: {error})")

444

});

445

446

                    for address in socket_addresses.clone() {

447

                        if address.is_ipv6() {

448

                            socket_address = Some(address);

449

                            is_ipv6 = true;

450

                            break;

451

452

453

454

                    if !is_ipv6 {

455

                        for address in socket_addresses {

456

                            if address.is_ipv4() {

457

                                socket_address = Some(address);

458

                                break;

459

460

461

462

463

                    let socket_address = socket_address.unwrap_or_else(|| {

464

                        panic!("There is no IPv4 address for the host: {address_string}")

465

});

466

467

                    let address: SockAddr = socket_address.into();

468

                    let keepalive = TcpKeepalive::new()

469

                        .with_time(Duration::from_secs(30))

470

                        .with_interval(Duration::from_secs(30))

471

                        .with_retries(3);

472

473

                    let domain_type = if is_ipv6 { Domain::IPV6 } else { Domain::IPV4 };

474

                    let socket = handle_error(Socket::new(domain_type, Type::STREAM, None));

475

                    handle_error(socket.set_tcp_keepalive(&keepalive));

476

477

                    if let Err(error) = socket.connect(&address) {

478

                        error!("socket.connect {address_string}: {error}");

479

                        handle_error(executor::block_on(sender.send(Message::TcpDisconnect)));

480

                        handle_error(executor::block_on(sender.send(Message::ServerShutdown)));

481

482

                        continue 'start_over;

483

484

485

                    info!("connected to {socket_address} ...");

486

487

                    let mut tcp_stream: TcpStream = socket.into();

488

                    let mut reader = BufReader::new(handle_error(tcp_stream.try_clone()));

489

490

                    let mut sender_clone = sender.clone();

491

                    thread::spawn(move || {

492

                        for message in rx {

493

                            let message_trim = message.trim();

494

495

                            if message_trim == "ping" {

496

                                trace!("<- {message_trim}");

497

                            } else {

498

                                debug!("<- {message_trim}");

499

500

501

                            if message_trim == "quit" {

502

                                if cfg!(not(target_os = "redox")) {

503

                                    tcp_stream

504

                                        .shutdown(Shutdown::Both)

505

                                        .expect("shutdown call failed");

506

507

508

                                return;

509

510

511

                            handle_error(tcp_stream.write_all(message.as_bytes()));

512

513

514

                        for _ in 0..2 {

515

                            if let Err(error) =

516

                                executor::block_on(sender_clone.send(Message::LeaveSoft))

517

518

                                error!("{error}");

519

520

521

522

                        if let Err(error) =

523

                            executor::block_on(sender_clone.send(Message::ServerShutdown))

524

525

                            error!("{error}");

526

527

});

528

529

                    let mut buffer = String::new();

530

                    handle_error(executor::block_on(

531

                        sender.send(Message::ConnectedTo(address_string.clone())),

532

));

533

534

                    if cfg!(target_os = "redox") {

535

                        sleep(Duration::from_secs(1));

536

537

538

                    loop {

539

                        let bytes = handle_error(reader.read_line(&mut buffer));

540

                        if bytes > 0 {

541

                            let buffer_trim = buffer.trim();

542

                            let buffer_trim_vec: Vec<_> =

543

                                buffer_trim.split_ascii_whitespace().collect();

544

545

                            if buffer_trim_vec[1] == "display_users"

546

                                || buffer_trim_vec[1] == "display_games"

547

                                || buffer_trim_vec[1] == "ping"

548

549

                                trace!("-> {buffer_trim}");

550

                            } else {

551

                                debug!("-> {buffer_trim}");

552

553

554

                            handle_error(executor::block_on(

555

                                sender.send(Message::TextReceived(buffer.clone())),

556

));

557

558

                            if buffer_trim_vec[1] == "archived_games" {

559

                                let length = handle_error(buffer_trim_vec[2].parse());

560

                                let mut buf = vec![0; length];

561

                                handle_error(reader.read_exact(&mut buf));

562

                                let archived_games: Vec<ArchivedGame> =

563

                                    handle_error(postcard::from_bytes(&buf));

564

565

                                handle_error(executor::block_on(

566

                                    sender.send(Message::ArchivedGames(archived_games)),

567

));

568

569

570

                            buffer.clear();

571

                        } else {

572

                            info!("the TCP stream has closed");

573

                            continue 'start_over;

574

575

576

577

});

578

},

579

580

581

582

fn text_collect(text: SplitAsciiWhitespace<'_>) -> String {

583

    let text: Vec<&str> = text.collect();

584

    text.join(" ")

585

586

587

#[allow(clippy::struct_excessive_bools)]

588

#[derive(Debug, Default, Deserialize, Serialize)]

589

struct Client {

590

    #[serde(skip)]

591

    admin: bool,

592

    #[serde(skip)]

593

    attacker: String,

594

    #[serde(default)]

595

    archived_games: Vec<ArchivedGame>,

596

    #[serde(skip)]

597

    archived_games_filtered: Option<Vec<ArchivedGame>>,

598

    #[serde(skip)]

599

    archived_game_selected: Option<ArchivedGame>,

600

    #[serde(skip)]

601

    archived_game_handle: Option<ArchivedGameHandle>,

602

    #[serde(default)]

603

    coordinates: Coordinates,

604

    #[serde(skip)]

605

    defender: String,

606

    #[serde(skip)]

607

    delete_account: bool,

608

    #[serde(skip)]

609

    estimate_score: bool,

610

    #[serde(skip)]

611

    estimate_score_tx: Option<mpsc::Sender<Tree>>,

612

    #[serde(skip)]

613

    captures: HashSet<Vertex>,

614

    #[serde(skip)]

615

    counter: u64,

616

    #[serde(skip)]

617

    chars: Characters,

618

    #[serde(skip)]

619

    challenger: bool,

620

    #[serde(skip)]

621

    connected_tcp: bool,

622

    #[serde(skip)]

623

    connected_to: String,

624

    #[serde(skip)]

625

    content: text_editor::Content,

626

    #[serde(skip)]

627

    email: Option<Email>,

628

    #[serde(skip)]

629

    emails_bcc: Vec<String>,

630

    #[serde(skip)]

631

    error: Option<String>,

632

    #[serde(skip)]

633

    error_email: Option<String>,

634

    #[serde(skip)]

635

    error_persistent: Vec<String>,

636

    #[serde(skip)]

637

    game: Option<Game>,

638

    #[serde(skip)]

639

    game_id: Id,

640

    #[serde(skip)]

641

    games_light: ServerGamesLight,

642

    #[serde(skip)]

643

    game_settings: NewGameSettings,

644

    #[serde(skip)]

645

    heat_map: Option<HeatMap>,

646

    #[serde(skip)]

647

    heat_map_display: bool,

648

    #[serde(default)]

649

    locale_selected: Locale,

650

    #[serde(skip)]

651

    message: String,

652

    #[serde(default)]

653

    my_games_only: bool,

654

    #[serde(skip)]

655

    my_turn: bool,

656

    #[serde(skip)]

657

    now: i64,

658

    #[serde(skip)]

659

    now_diff: i64,

660

    #[serde(default)]

661

    password: String,

662

    #[serde(skip)]

663

    password_ends_with_whitespace: bool,

664

    #[serde(default)]

665

    password_save: bool,

666

    #[serde(default)]

667

    password_show: bool,

668

    #[serde(skip)]

669

    play_from: Option<Vertex>,

670

    #[serde(skip)]

671

    play_from_previous: Option<Vertex>,

672

    #[serde(skip)]

673

    play_to_previous: Option<Vertex>,

674

    #[serde(skip)]

675

    press_letters: HashSet<char>,

676

    #[serde(skip)]

677

    press_numbers: [bool; 13],

678

    #[serde(skip)]

679

    request_draw: bool,

680

    #[serde(skip)]

681

    screen: Screen,

682

    #[serde(skip)]

683

    screen_size: Size,

684

    #[serde(default)]

685

    sound_muted: bool,

686

    #[serde(skip)]

687

    spectators: Vec<String>,

688

    #[serde(skip)]

689

    status: Status,

690

    #[serde(skip)]

691

    texts: VecDeque<String>,

692

    #[serde(skip)]

693

    texts_game: VecDeque<String>,

694

    #[serde(skip)]

695

    text_input: String,

696

    #[serde(default)]

697

    theme: Theme,

698

    #[serde(skip)]

699

    time_attacker: TimeSettings,

700

    #[serde(skip)]

701

    time_defender: TimeSettings,

702

    #[serde(skip)]

703

    tournament: Option<Tournament>,

704

    #[serde(skip)]

705

    tx: Option<mpsc::Sender<String>>,

706

    #[serde(default)]

707

    username: String,

708

    #[serde(skip)]

709

    users: HashMap<String, User>,

710

    #[serde(skip)]

711

    users_sort_by: SortBy,

712

    #[serde(skip)]

713

    strings: HashMap<String, String>,

714

715

716

impl<'a> Client {

717

    fn add_infinity(&self, column: Column<'a, Message>) -> Column<'a, Message> {

718

        let infinity = radio(

719

            format!("{} (9)", TimeEnum::Infinity),

720

            TimeEnum::Infinity,

721

            self.game_settings.time,

722

            Message::Time,

723

);

724

725

        let row = row![infinity].padding(PADDING).spacing(SPACING);

726

        column.push(row)

727

728

729

    fn archived_game_reset(&mut self) {

730

        self.archived_game_handle = None;

731

        self.archived_game_selected = None;

732

733

734

    #[must_use]

735

    fn board(&self) -> Row<'_, Message> {

736

        let (board, heat_map) = self.board_and_heatmap();

737

        let board_size = board.size();

738

        let board_size_usize: usize = board_size.into();

739

        let d = Dimensions::new(board_size, &self.screen_size);

740

        let letters: Vec<_> = BOARD_LETTERS[..board_size_usize].chars().collect();

741

        let mut game_display = Row::new().spacing(2);

742

        let possible_moves = self.possible_moves();

743

744

        let coordinates: bool = self.coordinates.into();

745

        if coordinates {

746

            game_display =

747

                game_display.push(self.numbers(d.letter_size, d.spacing, board_size_usize));

748

749

750

        for (x, letter) in letters.iter().enumerate() {

751

            let mut column = Column::new().spacing(2).align_x(Horizontal::Center);

752

753

            if coordinates {

754

                column = self.letter(*letter, column, d.letter_size);

755

756

757

            for y in 0..board_size_usize {

758

                let vertex = Vertex {

759

                    size: board.size(),

760

x,

761

y,

762

};

763

764

                let mut txt = match board.get(&vertex) {

765

                    Space::Attacker => text(&self.chars.attacker),

766

                    Space::Defender => text(&self.chars.defender),

767

                    Space::Empty => {

768

                        if let Some(arrow) = self.draw_arrow(y, x) {

769

                            text(arrow)

770

                        } else if self.captures.contains(&vertex) {

771

                            text(&self.chars.captured)

772

                        } else if vertex.on_restricted_square() {

773

                            text(&self.chars.restricted_square)

774

                        } else {

775

                            text(" ")

776

777

778

                    Space::King => text(&self.chars.king),

779

};

780

781

                if let Some((heat_map_from, heat_map_to)) = &heat_map

782

                    && possible_moves.is_some()

783

784

                    if let Some(vertex_from) = self.play_from.as_ref() {

785

                        let space = board.get(vertex_from);

786

                        let turn = Role::from(space);

787

                        if let Some(heat_map_to) = heat_map_to.get(&(turn, *vertex_from)) {

788

                            let heat = heat_map_to[y * board_size_usize + x];

789

790

                            if heat == Heat::UnRanked {

791

                                txt = txt.color(Color::from_rgba(0.0, 0.0, 0.0, heat.into()));

792

                            } else {

793

                                let txt_char = match space {

794

                                    Space::Attacker => &self.chars.attacker,

795

                                    Space::Defender => &self.chars.defender,

796

                                    Space::Empty => "",

797

                                    Space::King => &self.chars.king,

798

};

799

800

                                txt = text(txt_char).color(Color::from_rgba(

801

                                    0.0,

802

                                    0.0,

803

                                    0.0,

804

                                    heat.into(),

805

));

806

807

808

                    } else {

809

                        let heat = heat_map_from[y * board_size_usize + x];

810

                        txt = txt.color(Color::from_rgba(0.0, 0.0, 0.0, heat.into()));

811

812

813

814

                txt = txt.font(Font::MONOSPACE).center().size(d.piece_size);

815

                let mut button = button(txt)

816

                    .width(d.board_dimension)

817

                    .height(d.board_dimension);

818

819

                match self.board_move(&vertex, possible_moves.as_ref()) {

820

                    Move::From => button = button.on_press(Message::PlayMoveFrom(vertex)),

821

                    Move::To => button = button.on_press(Message::PlayMoveTo(vertex)),

822

                    Move::Revert => button = button.on_press(Message::PlayMoveRevert),

823

                    Move::None => {}

824

825

826

                column = column.push(button);

827

828

829

            if coordinates {

830

                column = self.letter(*letter, column, d.letter_size);

831

832

833

            game_display = game_display.push(column);

834

835

836

        if coordinates {

837

            game_display =

838

                game_display.push(self.numbers(d.letter_size, d.spacing, board_size_usize));

839

840

841

        game_display

842

843

844

    fn board_move(&self, vertex: &Vertex, possible_moves: Option<&LegalMoves>) -> Move {

845

        if let Some(legal_moves) = possible_moves {

846

            if let Some(vertex_from) = self.play_from.as_ref() {

847

                if let Some(vertexes) = legal_moves.moves.get(vertex_from) {

848

                    if vertex == vertex_from {

849

                        Move::Revert

850

                    } else if vertexes.contains(vertex) {

851

                        Move::To

852

                    } else {

853

                        Move::None

854

855

                } else {

856

                    Move::None

857

858

            } else if legal_moves.moves.contains_key(vertex) {

859

                Move::From

860

            } else {

861

                Move::None

862

863

        } else {

864

            Move::None

865

866

867

868

    #[allow(clippy::type_complexity)]

869

    fn board_and_heatmap(

870

        &self,

871

    ) -> (

872

        Board,

873

        Option<(Vec<Heat>, HashMap<(Role, Vertex), Vec<Heat>>)>,

874

) {

875

        if let Some(game_handle) = &self.archived_game_handle {

876

            let node = game_handle.boards.here();

877

878

            if self.heat_map_display

879

                && let Some(heat_map) = &self.heat_map

880

881

                (node.board.clone(), Some(heat_map.draw(node.turn)))

882

            } else {

883

                (node.board.clone(), None)

884

885

        } else {

886

            let game = self.game.as_ref().expect("we should be in a game");

887

888

            (game.board.clone(), None)

889

890

891

892

    fn game_state(&self, game_id: u128) -> State {

893

        if let Some(game) = self.games_light.0.get(&game_id) {

894

            if game.challenge_accepted {

895

                return State::Spectator;

896

897

898

            if game.attacker.is_none() || game.defender.is_none() {

899

                if let Some(attacker) = &game.attacker

900

                    && &self.username == attacker

901

902

                    return State::CreatorOnly;

903

904

905

                if let Some(defender) = &game.defender

906

                    && &self.username == defender

907

908

                    return State::CreatorOnly;

909

910

911

912

            if let (Some(attacker), Some(defender)) = (&game.attacker, &game.defender)

913

                && (&self.username == attacker || &self.username == defender)

914

915

                if let Some(challenger) = &game.challenger.0 {

916

                    if &self.username != challenger {

917

                        return State::Creator;

918

919

                } else {

920

                    return State::Challenger;

921

922

923

924

925

        State::Spectator

926

927

928

    fn clear_letters_except(&mut self, letter: char) {

929

        for l in BOARD_LETTERS_LOWERCASE {

930

            if l != letter {

931

                self.press_letters.remove(&l);

932

933

934

935

936

    fn clear_numbers_except(&mut self, number: usize) {

937

        let (board, _) = self.board_and_heatmap();

938

        let board_size = board.size().into();

939

940

        for i in 0..board_size {

941

            let i = board_size - i;

942

            if i != number {

943

                self.press_numbers[i - 1] = false;

944

945

946

947

948

    fn create_account(&mut self) {

949

        if !self.connected_tcp {

950

            self.send("tcp_connect\n");

951

            self.connected_tcp = true;

952

953

954

        if self.screen == Screen::Login {

955

            if !self.text_input.trim().is_empty() {

956

                let username = self.text_input.clone();

957

                self.send(&format!(

958

                    "{VERSION_ID} create_account {username} {}\n",

959

                    self.password,

960

));

961

                self.username = username;

962

963

            self.text_input.clear();

964

            self.archived_game_reset();

965

            handle_error(self.save_client_ron());

966

967

968

969

    fn delete_account(&mut self) {

970

        if self.delete_account {

971

            self.send("delete_account\n");

972

            self.screen = Screen::Login;

973

        } else {

974

            self.delete_account = true;

975

976

977

978

    fn display_tournament(&self) -> Column<'_, Message> {

979

        let Some(tournament) = &self.tournament else {

980

            return Column::new();

981

};

982

983

        let tournament_string = "Tournament";

984

        let row_1 = text(tournament_string);

985

        let row_2 = text("-".repeat(tournament_string.len())).font(Font::MONOSPACE);

986

        let column_1 = column![row_1, row_2];

987

988

        let players_len = tournament.players.len();

989

990

        if players_len == 0 {

991

            return Column::new();

992

993

994

        let Some(tree) = &tournament.tree else {

995

            return Column::new();

996

};

997

998

        let mut column_2 = Column::new().spacing(SPACING);

999

1000

        for (i, round) in tree.rounds.iter().enumerate() {

1001

            let title = format!("{} {}", t!("Round"), i + 1);

1002

            let title_len = title.len();

1003

            let column_title = column![

1004

                text(title),

1005

                text("-".repeat(title_len)).font(Font::MONOSPACE)

1006

];

1007

1008

            let mut add_column = column![column_title];

1009

            let round_length = round.len();

1010

            for (i, status) in round.iter().enumerate() {

1011

                let brace = if round_length == 1 {

1012

""

1013

                } else if i % 2 == 0 {

1014

                    "┐"

1015

                } else {

1016

                    "┘"

1017

};

1018

1019

                let mut row = match &status {

1020

                    tournament::Status::Lost(player) => {

1021

                        let name = player.to_string();

1022

                        let len = 22 - name.len();

1023

                        row![

1024

                            text(name).font(Font::MONOSPACE),

1025

                            text("─".repeat(len)).style(text::danger),

1026

                            text(brace).style(text::danger),

1027

1028

1029

                    tournament::Status::None | tournament::Status::Waiting => {

1030

                        row![text("─".repeat(22)), text(brace)]

1031

1032

                    tournament::Status::Playing(player) => {

1033

                        let name = player.to_string();

1034

                        let len = 22 - name.len();

1035

                        row![

1036

                            text(name).font(Font::MONOSPACE),

1037

                            text("─".repeat(len)),

1038

                            text(brace),

1039

1040

1041

                    tournament::Status::Ready(player) => {

1042

                        let name = player.to_string();

1043

                        let len = 22 - name.len();

1044

                        row![

1045

                            text(name).font(Font::MONOSPACE),

1046

                            text("─".repeat(len)).style(text::warning),

1047

                            text(brace).style(text::warning),

1048

1049

1050

                    tournament::Status::Won(player) => {

1051

                        let name = player.to_string();

1052

                        let len = 22 - name.len();

1053

                        row![

1054

                            text(name).font(Font::MONOSPACE),

1055

                            text("─".repeat(len)).style(text::success),

1056

                            text(brace).style(text::success),

1057

1058

1059

};

1060

1061

                if round_length == 1 {

1062

                    row = row.push(text("🏆").size(TROPHY_SIZE));

1063

1064

1065

                add_column = add_column.push(row);

1066

1067

            column_2 = column_2.push(add_column);

1068

1069

1070

        column![column_1, column_2]

1071

1072

1073

    fn draw(&mut self) {

1074

        let game = self.game.as_ref().expect("you should have a game by now");

1075

        self.send(&format!("request_draw {} {}\n", self.game_id, game.turn));

1076

1077

1078

    fn draw_arrow(&self, y: usize, x: usize) -> Option<&str> {

1079

        if let (Some(from), Some(to)) = (&self.play_from_previous, &self.play_to_previous) {

1080

            if (y, x) == (from.y, from.x) {

1081

                let x_diff = from.x as i128 - to.x as i128;

1082

                let y_diff = from.y as i128 - to.y as i128;

1083

                let mut arrow = " ";

1084

1085

                if y_diff < 0 {

1086

                    arrow = &self.chars.arrow_down;

1087

                } else if y_diff > 0 {

1088

                    arrow = &self.chars.arrow_up;

1089

                } else if x_diff < 0 {

1090

                    arrow = &self.chars.arrow_right;

1091

                } else if x_diff > 0 {

1092

                    arrow = &self.chars.arrow_left;

1093

1094

1095

                Some(arrow)

1096

            } else {

1097

                None

1098

1099

        } else {

1100

            None

1101

1102

1103

1104

    fn estimate_score(&mut self) {

1105

        if !self.estimate_score {

1106

            info!("start running score estimator...");

1107

1108

            let handle = self

1109

                .archived_game_handle

1110

                .as_ref()

1111

                .expect("we should have a game handle now");

1112

1113

            self.estimate_score = true;

1114

            self.send_estimate_score(handle.boards.clone());

1115

1116

1117

1118

    fn game_new(&mut self) {

1119

        self.game_settings = NewGameSettings::default();

1120

        self.screen = Screen::GameNew;

1121

1122

1123

    fn game_submit(&mut self) {

1124

        let Some(role) = self.game_settings.role_selected else {

1125

            error!("No role selected.");

1126

            unreachable!();

1127

};

1128

1129

        let Some(time_settings) = self.game_settings.time else {

1130

            error!("No time settings selected.");

1131

            unreachable!();

1132

};

1133

        self.game_settings.timed = time_settings.into();

1134

1135

        // <- new_game (attacker | defender) (rated | unrated) (TIME_MINUTES | _) (ADD_SECONDS_AFTER_EACH_MOVE | _) board_size

1136

        // -> game id rated attacker defender un-timed _ _ board_size challenger challenge_accepted spectators

1137

        self.send(&format!(

1138

            "new_game {role} {} {:?} {}\n",

1139

            self.game_settings.rated, self.game_settings.timed, self.game_settings.board_size

1140

));

1141

1142

        self.screen = Screen::Games;

1143

1144

1145

    fn press_letter(&mut self, letter: char) {

1146

        self.clear_letters_except(letter);

1147

        self.press_letters.insert(letter);

1148

1149

1150

    fn press_letter_and_number(&mut self) {

1151

        let mut number = None;

1152

        let mut letter = None;

1153

1154

        for i in 0..13 {

1155

            if self.press_numbers[i] {

1156

                number = Some(i);

1157

                break;

1158

1159

1160

        for (i, l) in BOARD_LETTERS_LOWERCASE.iter().enumerate() {

1161

            if self.press_letters.contains(l) {

1162

                letter = Some(i);

1163

                break;

1164

1165

1166

1167

        let size = if let Some(game) = self.game.as_ref() {

1168

            Some(game.board.size())

1169

        } else {

1170

            self.archived_game_handle

1171

                .as_ref()

1172

                .map(|game| game.game.board_size)

1173

};

1174

1175

        if let (Some(size), Some(number), Some(letter)) = (size, number, letter) {

1176

            let board_usize: usize = size.into();

1177

            let vertex = Vertex {

1178

                size,

1179

                x: letter,

1180

                y: board_usize - number - 1,

1181

};

1182

            let possible_moves = self.possible_moves();

1183

1184

            match self.board_move(&vertex, possible_moves.as_ref()) {

1185

                Move::From => self.play_from = Some(vertex),

1186

                Move::To => self.play_to(vertex),

1187

                Move::Revert => self.play_from = None,

1188

                Move::None => {}

1189

1190

1191

            for i in 0..13 {

1192

                self.press_numbers[i] = false;

1193

1194

            self.press_letters.clear();

1195

1196

1197

1198

    fn join_game_press(&mut self, i: usize, shift: bool) {

1199

        let mut server_games: Vec<&ServerGameLight> = self.games_light.0.values().collect();

1200

1201

        server_games.sort_by(|a, b| b.id.cmp(&a.id));

1202

1203

        if let Some(game) = server_games.get(i) {

1204

            match self.join_game(game) {

1205

                JoinGame::Cancel => self.send(&format!("decline_game {} switch\n", game.id)),

1206

                JoinGame::Join => self.join(game.id),

1207

                JoinGame::None => match self.game_state(game.id) {

1208

                    State::Challenger | State::Spectator => {}

1209

                    State::Creator => {

1210

                        if shift {

1211

                            self.send(&format!("decline_game {}\n", game.id));

1212

                        } else {

1213

                            self.send(&format!("join_game {}\n", game.id));

1214

1215

1216

                    State::CreatorOnly => self.send(&format!("leave_game {}\n", game.id)),

1217

},

1218

                JoinGame::Resume => self.resume(game.id),

1219

                JoinGame::Watch => self.watch(game.id),

1220

1221

1222

1223

1224

    fn join_game(&self, game: &ServerGameLight) -> JoinGame {

1225

        if game.challenge_accepted {

1226

            if Some(&self.username) == game.attacker.as_ref()

1227

                || Some(&self.username) == game.defender.as_ref()

1228

1229

                JoinGame::Resume

1230

            } else {

1231

                JoinGame::Watch

1232

1233

        } else if game.attacker.is_some()

1234

            && game.defender.is_some()

1235

            && Some(&self.username) == game.challenger.0.as_ref()

1236

1237

            JoinGame::Cancel

1238

        } else if (game.attacker.is_none() || game.defender.is_none())

1239

            && !(Some(&self.username) == game.attacker.as_ref()

1240

                || Some(&self.username) == game.defender.as_ref())

1241

1242

            JoinGame::Join

1243

        } else {

1244

            JoinGame::None

1245

1246

1247

1248

    fn join(&mut self, id: u128) {

1249

        self.game_id = id;

1250

        self.send(&format!("join_game_pending {id}\n"));

1251

1252

        let game = self.games_light.0.get(&id).expect("the game must exist");

1253

1254

        self.game_settings.role_selected = if game.attacker.is_some() {

1255

            Some(Role::Defender)

1256

        } else {

1257

            Some(Role::Attacker)

1258

};

1259

1260

1261

    fn resume(&mut self, id: u128) {

1262

        self.game_id = id;

1263

        self.send(&format!("resume_game {id}\n"));

1264

1265

1266

    fn watch(&mut self, id: u128) {

1267

        self.game_id = id;

1268

        self.send(&format!("watch_game {id}\n"));

1269

1270

1271

    fn login(&mut self) {

1272

        if !self.connected_tcp {

1273

            self.send("tcp_connect\n");

1274

            self.connected_tcp = true;

1275

1276

1277

        if self.text_input.trim().is_empty() {

1278

            let username = format!("user-{:x}", rand::random::<u16>());

1279

1280

            self.send(&format!(

1281

                "{VERSION_ID} create_account {username} {}\n",

1282

                self.password

1283

));

1284

            self.username = username;

1285

        } else {

1286

            let username = self.text_input.clone();

1287

1288

            self.send(&format!(

1289

                "{VERSION_ID} login {username} {}\n",

1290

                self.password

1291

));

1292

            self.username = username;

1293

1294

1295

        self.texts.clear();

1296

        self.text_input.clear();

1297

        self.archived_game_reset();

1298

        handle_error(self.save_client_ron());

1299

1300

1301

    fn play_to(&mut self, to: Vertex) {

1302

        let from = self

1303

            .play_from

1304

            .expect("you have to have a from to get to to");

1305

1306

        let mut turn = Role::Roleless;

1307

        if let Some(game) = &self.game {

1308

            turn = game.turn;

1309

1310

1311

        self.handle_play(None, &from.to_string(), &to.to_string());

1312

1313

        if self.archived_game_handle.is_none() {

1314

            self.send(&format!(

1315

                "game {} play {} {from} {to}\n",

1316

                self.game_id, turn

1317

));

1318

1319

            let game = self.game.as_ref().expect("you should have a game by now");

1320

            if game.status == Status::Ongoing {

1321

                match game.turn {

1322

                    Role::Attacker => {

1323

                        if let TimeSettings::Timed(time) = &mut self.time_defender {

1324

                            time.milliseconds_left += time.add_seconds * 1_000;

1325

1326

1327

                    Role::Roleless => {}

1328

                    Role::Defender => {

1329

                        if let TimeSettings::Timed(time) = &mut self.time_attacker {

1330

                            time.milliseconds_left += time.add_seconds * 1_000;

1331

1332

1333

1334

1335

1336

            self.my_turn = false;

1337

1338

1339

        self.play_from_previous = self.play_from;

1340

        self.play_to_previous = Some(to);

1341

        self.play_from = None;

1342

1343

1344

    fn possible_moves(&self) -> Option<LegalMoves> {

1345

        let mut possible_moves = None;

1346

1347

        if self.my_turn {

1348

            if let Some(game) = self.game.as_ref() {

1349

                possible_moves = Some(game.all_legal_moves());

1350

1351

        } else if let Some(handle) = &self.archived_game_handle {

1352

            let game = Game::from(&handle.boards);

1353

            possible_moves = Some(game.all_legal_moves());

1354

1355

1356

        possible_moves

1357

1358

1359

    fn change_theme(&mut self, theme: Theme) {

1360

        self.theme = theme;

1361

        handle_error(self.save_client_ron());

1362

1363

1364

    fn coordinates(&mut self) {

1365

        self.coordinates = !self.coordinates;

1366

        handle_error(self.save_client_ron());

1367

1368

1369

    // Fixme: get the real status when exploring the game tree.

1370

    #[allow(clippy::too_many_lines)]

1371

    fn display_game(&self) -> Element<'_, Message> {

1372

        let mut attacker_rating = String::new();

1373

        let mut defender_rating = String::new();

1374

1375

        let (game_id, attacker, attacker_time, defender, defender_time, board, play, status, texts) =

1376

            if let Some(game_handle) = &self.archived_game_handle {

1377

                attacker_rating = game_handle.game.attacker_rating.to_string_rounded();

1378

                defender_rating = game_handle.game.defender_rating.to_string_rounded();

1379

1380

                let status = if game_handle.play == game_handle.game.plays.len() - 1 {

1381

                    &game_handle.game.status

1382

                } else {

1383

                    &Status::Ongoing

1384

};

1385

1386

1387

                    &game_handle.game.id,

1388

                    &game_handle.game.attacker,

1389

                    game_handle

1390

                        .game

1391

                        .plays

1392

                        .time_left(Role::Attacker, game_handle.play),

1393

                    &game_handle.game.defender,

1394

                    game_handle

1395

                        .game

1396

                        .plays

1397

                        .time_left(Role::Defender, game_handle.play),

1398

                    &game_handle.boards.here().board,

1399

                    game_handle.play,

1400

                    status,

1401

                    &game_handle.game.texts,

1402

1403

            } else {

1404

                for user in self.users.values() {

1405

                    if self.attacker == user.name {

1406

                        attacker_rating = user.rating.to_string_rounded();

1407

1408

                    if self.defender == user.name {

1409

                        defender_rating = user.rating.to_string_rounded();

1410

1411

1412

1413

                let game = self.game.as_ref().expect("we should be in a game");

1414

1415

1416

                    &self.game_id,

1417

                    &self.attacker,

1418

                    self.time_attacker.time_left(),

1419

                    &self.defender,

1420

                    self.time_defender.time_left(),

1421

                    &game.board,

1422

                    game.previous_boards.0.len() - 1,

1423

                    &self.status,

1424

                    &self.texts_game,

1425

1426

};

1427

1428

        for user in self.users.values() {

1429

            if self.attacker == user.name {

1430

                attacker_rating = user.rating.to_string_rounded();

1431

1432

            if self.defender == user.name {

1433

                defender_rating = user.rating.to_string_rounded();

1434

1435

1436

1437

        let captured = board.captured();

1438

        let attacker = container(

1439

            column![

1440

                row![

1441

                    text(attacker),

1442

                    text(attacker_rating).center(),

1443

                    text(captured.defender(&self.chars).clone()).font(Font::MONOSPACE),

1444

1445

                .spacing(SPACING),

1446

                row![

1447

                    text(attacker_time).size(35).center(),

1448

                    text(&self.chars.dagger).size(35).center(),

1449

1450

                .spacing(SPACING),

1451

1452

            .spacing(SPACING),

1453

1454

        .padding(PADDING)

1455

        .style(container::bordered_box);

1456

1457

        let defender = container(

1458

            column![

1459

                row![

1460

                    text(defender),

1461

                    text(defender_rating).center(),

1462

                    text(captured.attacker(&self.chars).clone()).font(Font::MONOSPACE),

1463

1464

                .spacing(SPACING),

1465

                row![

1466

                    text(defender_time).size(35).center(),

1467

                    text(&self.chars.shield).size(35.0).center(),

1468

1469

                .spacing(SPACING),

1470

1471

            .spacing(SPACING),

1472

1473

        .padding(PADDING)

1474

        .style(container::bordered_box);

1475

1476

        let mut watching = false;

1477

1478

        let sub_second = self.now_diff % 1_000;

1479

        let seconds = self.now_diff / 1_000;

1480

1481

        let mut user_area = column![text!("#{game_id} {}", &self.username)].spacing(SPACING);

1482

1483

        let is_rated = match self.game_settings.rated {

1484

            Rated::No => t!("no"),

1485

            Rated::Yes => t!("yes"),

1486

};

1487

1488

        user_area = user_area.push(text!("{}: {play} {}: {is_rated}", t!("move"), t!("rated")));

1489

1490

        match self.screen_size {

1491

            Size::Large | Size::Medium | Size::Small | Size::Tiny => {

1492

                user_area = user_area.push(column![attacker, defender].spacing(SPACING));

1493

1494

            Size::Giant | Size::TinyWide => {

1495

                user_area = user_area.push(row![attacker, defender].spacing(SPACING));

1496

1497

1498

1499

        let mut spectators = Column::new();

1500

        for spectator in &self.spectators {

1501

            if self.username.as_str() == spectator.as_str() {

1502

                watching = true;

1503

1504

1505

            let mut spectator = spectator.clone();

1506

            if let Some(user) = self.users.get(&spectator) {

1507

                let _ok = write!(spectator, " ({})", user.rating.to_string_rounded());

1508

1509

            spectators = spectators.push(text(spectator));

1510

1511

1512

        let resign =

1513

            button(text!("{} (p)", self.strings["Resign"].as_str())).on_press(Message::PlayResign);

1514

1515

        let request_draw = button(text!("{} (q)", self.strings["Request Draw"].as_str()))

1516

            .on_press(Message::PlayDraw);

1517

1518

        if !watching {

1519

            if self.my_turn {

1520

                match self.screen_size {

1521

                    Size::Tiny | Size::Small => {

1522

                        user_area = user_area.push(

1523

                            column![

1524

                                row![resign].spacing(SPACING),

1525

                                row![request_draw].spacing(SPACING),

1526

1527

                            .spacing(SPACING),

1528

);

1529

1530

                    Size::TinyWide | Size::Medium | Size::Large | Size::Giant => {

1531

                        user_area = user_area.push(row![resign, request_draw].spacing(SPACING));

1532

1533

1534

            } else {

1535

                let row = if self.request_draw {

1536

                    column![

1537

                        row![

1538

                            button(text(self.strings["Accept Draw"].as_str()))

1539

                                .on_press(Message::PlayDrawDecision(Draw::Accept)),

1540

1541

                        .spacing(SPACING)

1542

1543

                } else {

1544

                    Column::new()

1545

};

1546

                user_area = user_area.push(row.spacing(SPACING));

1547

1548

1549

1550

        let coordinates_muted = row![

1551

            checkbox(self.coordinates.into()).on_toggle(Message::Coordinates),

1552

            text!("{} (n)", t!("Coordinates")),

1553

            checkbox(self.sound_muted).on_toggle(Message::SoundMuted),

1554

            text!("{} (o)", t!("Muted"))

1555

1556

        .spacing(SPACING);

1557

1558

        user_area = user_area.push(coordinates_muted);

1559

1560

        let leave =

1561

            button(text!("{} (Esc)", self.strings["Leave"].as_str())).on_press(Message::Leave);

1562

1563

        match status {

1564

            Status::AttackerWins => {

1565

                user_area = user_area.push(text(t!("Attacker wins!")));

1566

1567

            Status::Draw => {

1568

                user_area = user_area.push(text(t!("It's a draw.")));

1569

1570

            Status::Ongoing => {}

1571

            Status::DefenderWins => {

1572

                user_area = user_area.push(text(t!("Defender wins!")));

1573

1574

1575

1576

        if let Some(handle) = &self.archived_game_handle {

1577

            let mut heat_map = checkbox(self.heat_map_display).size(32);

1578

            if self.heat_map.is_some() {

1579

                heat_map = heat_map.on_toggle(Message::HeatMap);

1580

1581

1582

            let mut heat_map_button =

1583

                button(text!("{} (p) (q)", self.strings["Heat Map"].as_str()));

1584

1585

            if !self.estimate_score && *status == Status::Ongoing {

1586

                heat_map_button = heat_map_button.on_press(Message::EstimateScore);

1587

1588

1589

            user_area = user_area.push(row![heat_map, heat_map_button].spacing(SPACING));

1590

1591

            let child_number = text(handle.boards.next_child);

1592

            let child_right = button(

1593

                text(&self.chars.double_arrow_right)

1594

                    .center()

1595

                    .font(Font::MONOSPACE),

1596

1597

            .on_press(Message::ReviewGameChildNext);

1598

1599

            user_area = user_area.push(

1600

                row![

1601

                    leave,

1602

                    child_right,

1603

                    container(child_number)

1604

                        .style(container::bordered_box)

1605

                        .padding(PADDING_MEDIUM),

1606

1607

                .spacing(SPACING),

1608

);

1609

1610

            let mut left_all = button(text(&self.chars.double_arrow_left_full));

1611

            let mut left = button(text(&self.chars.double_arrow_left));

1612

1613

            if handle.play > 0 {

1614

                left_all = left_all.on_press(Message::ReviewGameBackwardAll);

1615

                left = left.on_press(Message::ReviewGameBackward);

1616

1617

1618

            let mut right = button(text(&self.chars.double_arrow_right));

1619

            let mut right_all = button(text(&self.chars.double_arrow_right_full));

1620

1621

            if handle.boards.has_children() {

1622

                right = right.on_press(Message::ReviewGameForward);

1623

                right_all = right_all.on_press(Message::ReviewGameForwardAll);

1624

1625

1626

            user_area = user_area.push(row![left_all, left, right, right_all].spacing(SPACING));

1627

        } else {

1628

            user_area = user_area.push(leave);

1629

1630

            let spectator = text!(

1631

                "{} ({}) {}: {seconds:01}.{sub_second:03} s",

1632

                &self.chars.people,

1633

                self.spectators.len(),

1634

                t!("lag"),

1635

);

1636

1637

            if self.spectators.is_empty() {

1638

                user_area = user_area.push(spectator);

1639

            } else {

1640

                user_area = user_area.push(tooltip(

1641

                    spectator,

1642

                    container(spectators)

1643

                        .style(container::bordered_box)

1644

                        .padding(PADDING),

1645

                    tooltip::Position::Bottom,

1646

));

1647

1648

1649

1650

        if self.archived_game_handle.is_some() {

1651

            user_area = user_area.push(self.texting(texts, false));

1652

        } else {

1653

            user_area = user_area.push(self.texting(texts, true));

1654

1655

1656

        let user_area = container(user_area)

1657

            .padding(PADDING)

1658

            .style(container::bordered_box);

1659

1660

        let board = container(self.board())

1661

            .style(container::bordered_box)

1662

            .padding(PADDING);

1663

1664

        row![board, user_area].spacing(SPACING).into()

1665

1666

1667

    fn leave(&mut self) {

1668

        match self.screen {

1669

            Screen::AccountSettings

1670

            | Screen::EmailEveryone

1671

            | Screen::GameNew

1672

            | Screen::Users

1673

            | Screen::Tournament => {

1674

                self.screen = Screen::Games;

1675

                self.text_input = String::new();

1676

1677

            Screen::Game => {

1678

                self.screen = Screen::Games;

1679

                self.my_turn = false;

1680

                self.request_draw = false;

1681

1682

                if self.spectators.contains(&self.username) {

1683

                    self.send(&format!("leave_game {}\n", self.game_id));

1684

1685

                self.spectators = Vec::new();

1686

1687

            Screen::Games => {

1688

                self.send("quit\n");

1689

                self.admin = false;

1690

                self.connected_tcp = false;

1691

                self.text_input = self.username.clone();

1692

                self.screen = Screen::Login;

1693

1694

            Screen::GameReview => {

1695

                self.heat_map = None;

1696

                self.heat_map_display = false;

1697

                self.screen = Screen::Login;

1698

1699

            Screen::Login => {}

1700

1701

1702

1703

    fn my_games_only(&mut self) {

1704

        let selected = !self.my_games_only;

1705

        if selected {

1706

            self.archived_games_filtered = Some(

1707

                self.archived_games

1708

                    .iter()

1709

                    .filter(|game| game.attacker == self.username || game.defender == self.username)

1710

                    .cloned()

1711

                    .collect(),

1712

);

1713

        } else {

1714

            self.archived_games_filtered = None;

1715

1716

1717

        self.my_games_only = selected;

1718

        handle_error(self.save_client_ron());

1719

1720

1721

    #[allow(clippy::too_many_lines)]

1722

    #[allow(clippy::collapsible_match)]

1723

    pub(crate) fn subscriptions(&self) -> Subscription<Message> {

1724

        let subscription_1 = if let Some(game) = &self.game {

1725

            if let TimeUnix::Time(_) = game.time {

1726

                iced::time::every(iced::time::Duration::from_millis(100))

1727

                    .map(|_instant| Message::Tick)

1728

            } else {

1729

                Subscription::none()

1730

1731

        } else {

1732

            Subscription::none()

1733

};

1734

1735

        let subscription_2 = Subscription::run(pass_messages);

1736

        let subscription_3 = Subscription::run(estimate_score);

1737

1738

        let subscription_4 = event::listen_with(|event, _status, _id| match event {

1739

            Event::Window(iced::window::Event::Resized(size)) => {

1740

                Some(Message::WindowResized((size.width, size.height)))

1741

1742

            Event::Keyboard(event) => match event {

1743

                keyboard::Event::KeyPressed {

1744

                    key: Key::Character(ch),

1745

                    modifiers,

1746

..

1747

                } => {

1748

                    let shift = modifiers.shift();

1749

1750

                    if modifiers.control() || modifiers.command() {

1751

                        if *ch == *Value::new("a").to_smolstr() {

1752

                            Some(Message::PressA(shift))

1753

                        } else if *ch == *Value::new("b").to_smolstr() {

1754

                            Some(Message::PressB(shift))

1755

                        } else if *ch == *Value::new("c").to_smolstr() {

1756

                            Some(Message::PressC(shift))

1757

                        } else if *ch == *Value::new("d").to_smolstr() {

1758

                            Some(Message::PressD(shift))

1759

                        } else if *ch == *Value::new("e").to_smolstr() {

1760

                            Some(Message::PressE(shift))

1761

                        } else if *ch == *Value::new("f").to_smolstr() {

1762

                            Some(Message::PressF(shift))

1763

                        } else if *ch == *Value::new("g").to_smolstr() {

1764

                            Some(Message::PressG(shift))

1765

                        } else if *ch == *Value::new("h").to_smolstr() {

1766

                            Some(Message::PressH(shift))

1767

                        } else if *ch == *Value::new("i").to_smolstr() {

1768

                            Some(Message::PressI(shift))

1769

                        } else if *ch == *Value::new("j").to_smolstr() {

1770

                            Some(Message::PressJ(shift))

1771

                        } else if *ch == *Value::new("k").to_smolstr() {

1772

                            Some(Message::PressK(shift))

1773

                        } else if *ch == *Value::new("l").to_smolstr() {

1774

                            Some(Message::PressL(shift))

1775

                        } else if *ch == *Value::new("m").to_smolstr() {

1776

                            Some(Message::PressM(shift))

1777

                        } else if *ch == *Value::new("n").to_smolstr() {

1778

                            Some(Message::PressN(shift))

1779

                        } else if *ch == *Value::new("o").to_smolstr() {

1780

                            Some(Message::PressO(shift))

1781

                        } else if *ch == *Value::new("p").to_smolstr() {

1782

                            Some(Message::PressP(shift))

1783

                        } else if *ch == *Value::new("q").to_smolstr() {

1784

                            Some(Message::PressQ(shift))

1785

                        } else if *ch == *Value::new("r").to_smolstr() {

1786

                            Some(Message::PressR(shift))

1787

                        } else if *ch == *Value::new("s").to_smolstr() {

1788

                            Some(Message::PressS(shift))

1789

                        } else if *ch == *Value::new("t").to_smolstr() {

1790

                            Some(Message::PressT(shift))

1791

                        } else if *ch == *Value::new("u").to_smolstr() {

1792

                            Some(Message::PressU(shift))

1793

                        } else if *ch == *Value::new("v").to_smolstr() {

1794

                            Some(Message::PressV(shift))

1795

                        } else if *ch == *Value::new("w").to_smolstr() {

1796

                            Some(Message::PressW(shift))

1797

                        } else if *ch == *Value::new("x").to_smolstr() {

1798

                            Some(Message::PressX(shift))

1799

                        } else if *ch == *Value::new("y").to_smolstr() {

1800

                            Some(Message::PressY(shift))

1801

                        } else if *ch == *Value::new("z").to_smolstr() {

1802

                            Some(Message::PressZ(shift))

1803

                        } else if *ch == *Value::new("1").to_smolstr() {

1804

                            Some(Message::Press1)

1805

                        } else if *ch == *Value::new("2").to_smolstr() {

1806

                            Some(Message::Press2)

1807

                        } else if *ch == *Value::new("3").to_smolstr() {

1808

                            Some(Message::Press3)

1809

                        } else if *ch == *Value::new("4").to_smolstr() {

1810

                            Some(Message::Press4)

1811

                        } else if *ch == *Value::new("5").to_smolstr() {

1812

                            Some(Message::Press5)

1813

                        } else if *ch == *Value::new("6").to_smolstr() {

1814

                            Some(Message::Press6)

1815

                        } else if *ch == *Value::new("7").to_smolstr() {

1816

                            Some(Message::Press7)

1817

                        } else if *ch == *Value::new("8").to_smolstr() {

1818

                            Some(Message::Press8)

1819

                        } else if *ch == *Value::new("9").to_smolstr() {

1820

                            Some(Message::Press9)

1821

                        } else if *ch == *Value::new("0").to_smolstr() {

1822

                            Some(Message::Press0)

1823

                        } else {

1824

                            None

1825

1826

                    } else {

1827

                        None

1828

1829

1830

                keyboard::Event::KeyPressed {

1831

                    key: Key::Named(named),

1832

                    modifiers,

1833

..

1834

                } => {

1835

                    if named == Named::Enter {

1836

                        Some(Message::PressEnter)

1837

                    } else if modifiers.shift() && named == Named::Tab {

1838

                        Some(Message::FocusPrevious)

1839

                    } else if named == Named::Tab {

1840

                        Some(Message::FocusNext)

1841

                    } else if named == Named::ArrowUp {

1842

                        Some(Message::ReviewGameBackwardAll)

1843

                    } else if named == Named::ArrowLeft {

1844

                        Some(Message::ReviewGameBackward)

1845

                    } else if named == Named::ArrowRight && modifiers.shift() {

1846

                        Some(Message::ReviewGameChildNext)

1847

                    } else if named == Named::ArrowRight {

1848

                        Some(Message::ReviewGameForward)

1849

                    } else if named == Named::ArrowDown {

1850

                        Some(Message::ReviewGameForwardAll)

1851

                    } else if named == Named::Escape {

1852

                        Some(Message::Leave)

1853

                    } else {

1854

                        None

1855

1856

1857

                _ => None,

1858

},

1859

            _ => None,

1860

});

1861

1862

        Subscription::batch(vec![

1863

            subscription_1,

1864

            subscription_2,

1865

            subscription_3,

1866

            subscription_4,

1867

])

1868

1869

1870

    fn texting(

1871

        &'a self,

1872

        messages: &'a VecDeque<String>,

1873

        enable_texting: bool,

1874

    ) -> Container<'a, Message> {

1875

        let text_input = if enable_texting {

1876

            iced::widget::text_input(&format!("{}…", t!("message")), &self.text_input)

1877

                .on_input(Message::TextChanged)

1878

                .on_paste(Message::TextChanged)

1879

                .on_submit(Message::TextSend)

1880

        } else {

1881

            iced::widget::text_input(&format!("{}…", t!("message")), "")

1882

};

1883

1884

        let mut text_box = column![text_input].spacing(SPACING);

1885

1886

        let mut texting = Column::new();

1887

        for message in messages {

1888

            texting = texting.push(text(message));

1889

1890

        text_box = text_box.push(scrollable(texting));

1891

1892

        container(text_box)

1893

            .padding(PADDING)

1894

            .style(container::bordered_box)

1895

1896

1897

    pub fn theme(&self) -> iced::Theme {

1898

        match self.theme {

1899

            Theme::Dark => iced::Theme::SolarizedDark,

1900

            Theme::Light => iced::Theme::SolarizedLight,

1901

            Theme::Tol => iced::Theme::custom("Tol", TOL),

1902

1903

1904

1905

    #[allow(clippy::too_many_lines)]

1906

    pub fn update(&mut self, message: Message) -> Task<Message> {

1907

        self.error = None;

1908

1909

        match message {

1910

            Message::AccountSettings => self.screen = Screen::AccountSettings,

1911

            Message::ArchivedGames(mut archived_games) => {

1912

                archived_games.reverse();

1913

                self.archived_games = archived_games;

1914

                self.archived_games_filtered = None;

1915

                handle_error(self.save_client_postcard());

1916

1917

            Message::ArchivedGamesGet => self.send("archived_games\n"),

1918

            Message::ArchivedGameSelected(game) => self.archived_game_selected = Some(game),

1919

            Message::CancelGame(id) => self.send(&format!("leave_game {id}\n")),

1920

            Message::ChangeTheme(theme) => self.change_theme(theme),

1921

            Message::BoardSizeSelected(size) => self.game_settings.board_size = size,

1922

            Message::ConnectedTo(address) => self.connected_to = address,

1923

            Message::Coordinates(_coordinates) => self.coordinates(),

1924

            Message::DeleteAccount => self.delete_account(),

1925

            Message::EmailEveryone => {

1926

                self.screen = Screen::EmailEveryone;

1927

                self.send("emails_bcc\n");

1928

1929

            Message::EmailReset => self.reset_email(),

1930

            Message::EstimateScore => self.estimate_score(),

1931

            Message::EstimateScoreConnected(tx) => self.estimate_score_tx = Some(tx),

1932

            Message::EstimateScoreDisplay((node, generate_move)) => {

1933

                info!("finish running score estimator...");

1934

1935

                if let Some(handle) = self.archived_game_handle.as_ref()

1936

                    && handle.boards.here() == node

1937

1938

                    info!("{generate_move}");

1939

                    debug!("{}", generate_move.heat_map);

1940

                    self.heat_map = Some(generate_move.heat_map);

1941

1942

1943

                self.estimate_score = false;

1944

1945

            Message::Exit => return iced::exit(),

1946

            Message::FocusNext => return focus_next(),

1947

            Message::FocusPrevious => return focus_previous(),

1948

            Message::GameCancel(id) => self.send(&format!("decline_game {id} switch\n")),

1949

            Message::GameAccept(id) => self.send(&format!("join_game {id}\n")),

1950

            Message::GameDecline(id) => self.send(&format!("decline_game {id}\n")),

1951

            Message::GameJoin(id) => self.join(id),

1952

            Message::GameWatch(id) => self.watch(id),

1953

            Message::HeatMap(_display) => self.heat_map_display = !self.heat_map_display,

1954

            Message::Leave => {

1955

                if self.screen == Screen::Login {

1956

                    return iced::exit();

1957

1958

1959

                self.leave();

1960

1961

            Message::LeaveSoft => self.leave(),

1962

            Message::LocaleSelected(locale) => {

1963

                rust_i18n::set_locale(&locale.txt());

1964

1965

                let string_keys: Vec<_> = self.strings.keys().cloned().collect();

1966

                for string in string_keys {

1967

                    self.strings.insert(string.clone(), t!(string).to_string());

1968

1969

1970

                self.locale_selected = locale;

1971

                handle_error(self.save_client_ron());

1972

1973

            Message::MyGamesOnly(_selected) => {

1974

                self.my_games_only();

1975

1976

            Message::OpenUrl(string) => open_url(&string),

1977

            Message::GameNew => self.game_new(),

1978

            Message::GameResume(id) => self.resume(id),

1979

            Message::GameSubmit => self.game_submit(),

1980

            Message::PasswordChanged(password) => {

1981

                let (password, ends_with_whitespace) = utils::split_whitespace_password(&password);

1982

                self.password_ends_with_whitespace = ends_with_whitespace;

1983

                if password.len() <= 32 {

1984

                    self.password = password;

1985

1986

1987

            Message::PasswordSave(_save) => self.toggle_save_password(),

1988

            Message::PasswordShow(_show) => self.toggle_show_password(),

1989

            Message::PlayDraw => self.draw(),

1990

            Message::PlayDrawDecision(draw) => {

1991

                self.send(&format!("draw {} {draw}\n", self.game_id));

1992

1993

            Message::PlayMoveFrom(vertex) => self.play_from = Some(vertex),

1994

            Message::PlayMoveTo(to) => self.play_to(to),

1995

            Message::PlayMoveRevert => self.play_from = None,

1996

            Message::PlayResign => self.resign(),

1997

            Message::PressEnter => match self.screen {

1998

                Screen::AccountSettings

1999

                | Screen::EmailEveryone

2000

                | Screen::Game

2001

                | Screen::Games

2002

                | Screen::GameReview

2003

                | Screen::Tournament

2004

                | Screen::Users => {}

2005

                Screen::GameNew => self.game_submit(),

2006

                Screen::Login => self.login(),

2007

},

2008

            Message::PressA(shift) => match self.screen {

2009

                Screen::AccountSettings

2010

                | Screen::EmailEveryone

2011

                | Screen::GameNew

2012

                | Screen::Tournament

2013

                | Screen::Users => {}

2014

                Screen::Game | Screen::GameReview => {

2015

                    self.press_letter('a');

2016

                    self.press_letter_and_number();

2017

2018

                Screen::Games => self.join_game_press(0, shift),

2019

                Screen::Login => self.change_theme(Theme::Tol),

2020

},

2021

            Message::PressB(shift) => match self.screen {

2022

                Screen::AccountSettings

2023

                | Screen::EmailEveryone

2024

                | Screen::GameNew

2025

                | Screen::Login

2026

                | Screen::Tournament

2027

                | Screen::Users => {}

2028

                Screen::Game | Screen::GameReview => {

2029

                    self.press_letter('b');

2030

                    self.press_letter_and_number();

2031

2032

                Screen::Games => self.join_game_press(1, shift),

2033

},

2034

            Message::PressC(shift) => match self.screen {

2035

                Screen::AccountSettings

2036

                | Screen::EmailEveryone

2037

                | Screen::GameNew

2038

                | Screen::Login

2039

                | Screen::Tournament

2040

                | Screen::Users => {}

2041

                Screen::Game | Screen::GameReview => {

2042

                    self.press_letter('c');

2043

                    self.press_letter_and_number();

2044

2045

                Screen::Games => self.join_game_press(2, shift),

2046

},

2047

            Message::PressD(shift) => match self.screen {

2048

                Screen::AccountSettings

2049

                | Screen::EmailEveryone

2050

                | Screen::GameNew

2051

                | Screen::Login

2052

                | Screen::Tournament

2053

                | Screen::Users => {}

2054

                Screen::Game | Screen::GameReview => {

2055

                    self.press_letter('d');

2056

                    self.press_letter_and_number();

2057

2058

                Screen::Games => self.join_game_press(3, shift),

2059

},

2060

            Message::PressE(shift) => match self.screen {

2061

                Screen::AccountSettings

2062

                | Screen::EmailEveryone

2063

                | Screen::GameNew

2064

                | Screen::Login

2065

                | Screen::Tournament

2066

                | Screen::Users => {}

2067

                Screen::Game | Screen::GameReview => {

2068

                    self.press_letter('e');

2069

                    self.press_letter_and_number();

2070

2071

                Screen::Games => self.join_game_press(4, shift),

2072

},

2073

            Message::PressF(shift) => match self.screen {

2074

                Screen::AccountSettings

2075

                | Screen::EmailEveryone

2076

                | Screen::GameNew

2077

                | Screen::Login

2078

                | Screen::Tournament

2079

                | Screen::Users => {}

2080

                Screen::Game | Screen::GameReview => {

2081

                    self.press_letter('f');

2082

                    self.press_letter_and_number();

2083

2084

                Screen::Games => self.join_game_press(5, shift),

2085

},

2086

            Message::PressG(shift) => match self.screen {

2087

                Screen::AccountSettings

2088

                | Screen::EmailEveryone

2089

                | Screen::GameNew

2090

                | Screen::Login

2091

                | Screen::Tournament

2092

                | Screen::Users => {}

2093

                Screen::Game | Screen::GameReview => {

2094

                    self.press_letter('g');

2095

                    self.press_letter_and_number();

2096

2097

                Screen::Games => self.join_game_press(6, shift),

2098

},

2099

            Message::PressH(shift) => match self.screen {

2100

                Screen::AccountSettings

2101

                | Screen::EmailEveryone

2102

                | Screen::GameNew

2103

                | Screen::Login

2104

                | Screen::Tournament

2105

                | Screen::Users => {}

2106

                Screen::Game | Screen::GameReview => {

2107

                    self.press_letter('h');

2108

                    self.press_letter_and_number();

2109

2110

                Screen::Games => self.join_game_press(7, shift),

2111

},

2112

            Message::PressI(shift) => match self.screen {

2113

                Screen::AccountSettings

2114

                | Screen::EmailEveryone

2115

                | Screen::GameNew

2116

                | Screen::Login

2117

                | Screen::Tournament

2118

                | Screen::Users => {}

2119

                Screen::Game | Screen::GameReview => {

2120

                    self.press_letter('i');

2121

                    self.press_letter_and_number();

2122

2123

                Screen::Games => self.join_game_press(8, shift),

2124

},

2125

            Message::PressJ(shift) => match self.screen {

2126

                Screen::AccountSettings

2127

                | Screen::EmailEveryone

2128

                | Screen::GameNew

2129

                | Screen::Login

2130

                | Screen::Tournament

2131

                | Screen::Users => {}

2132

                Screen::Game | Screen::GameReview => {

2133

                    self.press_letter('j');

2134

                    self.press_letter_and_number();

2135

2136

                Screen::Games => self.join_game_press(9, shift),

2137

},

2138

            Message::PressK(shift) => match self.screen {

2139

                Screen::AccountSettings

2140

                | Screen::EmailEveryone

2141

                | Screen::GameNew

2142

                | Screen::Login

2143

                | Screen::Tournament

2144

                | Screen::Users => {}

2145

                Screen::Game | Screen::GameReview => {

2146

                    self.press_letter('k');

2147

                    self.press_letter_and_number();

2148

2149

                Screen::Games => self.join_game_press(10, shift),

2150

},

2151

            Message::PressL(shift) => match self.screen {

2152

                Screen::AccountSettings

2153

                | Screen::EmailEveryone

2154

                | Screen::GameNew

2155

                | Screen::Login

2156

                | Screen::Tournament

2157

                | Screen::Users => {}

2158

                Screen::Game | Screen::GameReview => {

2159

                    self.press_letter('l');

2160

                    self.press_letter_and_number();

2161

2162

                Screen::Games => self.join_game_press(11, shift),

2163

},

2164

            Message::PressM(shift) => match self.screen {

2165

                Screen::AccountSettings

2166

                | Screen::EmailEveryone

2167

                | Screen::GameNew

2168

                | Screen::Login

2169

                | Screen::Tournament

2170

                | Screen::Users => {}

2171

                Screen::Game | Screen::GameReview => {

2172

                    self.press_letter('m');

2173

                    self.press_letter_and_number();

2174

2175

                Screen::Games => self.join_game_press(12, shift),

2176

},

2177

            Message::PressN(shift) => match self.screen {

2178

                Screen::AccountSettings

2179

                | Screen::EmailEveryone

2180

                | Screen::GameNew

2181

                | Screen::Login

2182

                | Screen::Tournament

2183

                | Screen::Users => {}

2184

                Screen::Game | Screen::GameReview => self.coordinates(),

2185

                Screen::Games => self.join_game_press(13, shift),

2186

},

2187

            Message::PressO(shift) => match self.screen {

2188

                Screen::AccountSettings

2189

                | Screen::EmailEveryone

2190

                | Screen::GameNew

2191

                | Screen::Login

2192

                | Screen::Tournament

2193

                | Screen::Users => {}

2194

                Screen::Game | Screen::GameReview => self.sound_muted(),

2195

                Screen::Games => self.join_game_press(14, shift),

2196

},

2197

            Message::PressP(shift) => match self.screen {

2198

                Screen::AccountSettings

2199

                | Screen::EmailEveryone

2200

                | Screen::GameNew

2201

                | Screen::Login

2202

                | Screen::Tournament

2203

                | Screen::Users => {}

2204

                Screen::Game => self.resign(),

2205

                Screen::Games => self.join_game_press(1, shift),

2206

                Screen::GameReview => self.estimate_score(),

2207

},

2208

            Message::PressQ(shift) => match self.screen {

2209

                Screen::AccountSettings

2210

                | Screen::EmailEveryone

2211

                | Screen::GameNew

2212

                | Screen::Login

2213

                | Screen::Tournament

2214

                | Screen::Users => {}

2215

                Screen::Game => self.draw(),

2216

                Screen::Games => self.join_game_press(16, shift),

2217

                Screen::GameReview => self.heat_map_display = !self.heat_map_display,

2218

},

2219

            Message::PressR(shift) => match self.screen {

2220

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Game => self.draw(),

2221

                Screen::GameNew

2222

                | Screen::GameReview

2223

                | Screen::Login

2224

                | Screen::Tournament

2225

                | Screen::Users => {}

2226

                Screen::Games => self.join_game_press(17, shift),

2227

},

2228

            Message::PressS(shift) => match self.screen {

2229

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Game => self.draw(),

2230

                Screen::GameNew

2231

                | Screen::GameReview

2232

                | Screen::Login

2233

                | Screen::Tournament

2234

                | Screen::Users => {}

2235

                Screen::Games => self.join_game_press(18, shift),

2236

},

2237

            Message::PressT(shift) => match self.screen {

2238

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Game => self.draw(),

2239

                Screen::GameNew

2240

                | Screen::GameReview

2241

                | Screen::Login

2242

                | Screen::Tournament

2243

                | Screen::Users => {}

2244

                Screen::Games => self.join_game_press(19, shift),

2245

},

2246

            Message::PressU(shift) => match self.screen {

2247

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Game => self.draw(),

2248

                Screen::GameNew

2249

                | Screen::GameReview

2250

                | Screen::Login

2251

                | Screen::Tournament

2252

                | Screen::Users => {}

2253

                Screen::Games => self.join_game_press(20, shift),

2254

},

2255

            Message::PressV(shift) => match self.screen {

2256

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Game => self.draw(),

2257

                Screen::GameNew

2258

                | Screen::GameReview

2259

                | Screen::Login

2260

                | Screen::Tournament

2261

                | Screen::Users => {}

2262

                Screen::Games => self.join_game_press(21, shift),

2263

},

2264

            Message::PressW(shift) => match self.screen {

2265

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Game => self.draw(),

2266

                Screen::GameNew

2267

                | Screen::GameReview

2268

                | Screen::Login

2269

                | Screen::Tournament

2270

                | Screen::Users => {}

2271

                Screen::Games => self.join_game_press(22, shift),

2272

},

2273

            Message::PressX(shift) => match self.screen {

2274

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Game => self.draw(),

2275

                Screen::GameNew

2276

                | Screen::GameReview

2277

                | Screen::Login

2278

                | Screen::Tournament

2279

                | Screen::Users => {}

2280

                Screen::Games => self.join_game_press(23, shift),

2281

},

2282

            Message::PressY(shift) => match self.screen {

2283

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Game => self.draw(),

2284

                Screen::GameNew

2285

                | Screen::GameReview

2286

                | Screen::Login

2287

                | Screen::Tournament

2288

                | Screen::Users => {}

2289

                Screen::Games => self.join_game_press(24, shift),

2290

},

2291

            Message::PressZ(shift) => match self.screen {

2292

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Game => self.draw(),

2293

                Screen::GameNew

2294

                | Screen::GameReview

2295

                | Screen::Login

2296

                | Screen::Tournament

2297

                | Screen::Users => {}

2298

                Screen::Games => self.join_game_press(25, shift),

2299

},

2300

            Message::Press1 => match self.screen {

2301

                Screen::AccountSettings | Screen::Login => self.reset_email(),

2302

                Screen::EmailEveryone | Screen::Tournament | Screen::Users => {}

2303

                Screen::Games => self.send("archived_games\n"),

2304

                Screen::GameNew => self.game_settings.role_selected = Some(Role::Attacker),

2305

                Screen::Game | Screen::GameReview => {

2306

                    if !(self.press_numbers[0]

2307

                        || self.press_numbers[10]

2308

                        || self.press_numbers[11]

2309

                        || self.press_numbers[12])

2310

2311

                        self.clear_numbers_except(0);

2312

                        self.press_numbers[0] = true;

2313

                    } else if self.press_numbers[0] {

2314

                        self.clear_numbers_except(10);

2315

                        self.press_numbers[10] = true;

2316

                    } else {

2317

                        self.clear_numbers_except(11);

2318

                        self.press_numbers[10] = false;

2319

2320

2321

                    self.press_letter_and_number();

2322

2323

},

2324

            Message::Press2 => match self.screen {

2325

                Screen::AccountSettings => {

2326

                    self.send(&format!("change_password {}\n", self.password));

2327

2328

                Screen::EmailEveryone | Screen::Tournament | Screen::Users => {}

2329

                Screen::Games => self.my_games_only(),

2330

                Screen::GameNew => self.game_settings.role_selected = Some(Role::Defender),

2331

                Screen::Game | Screen::GameReview => {

2332

                    let (board, _) = self.board_and_heatmap();

2333

                    match board.size() {

2334

                        BoardSize::_11 => {

2335

                            self.clear_numbers_except(2);

2336

                            self.press_numbers[1] = !self.press_numbers[1];

2337

                            self.press_letter_and_number();

2338

2339

                        BoardSize::_13 => {

2340

                            if !self.press_numbers[0]

2341

                                && !self.press_numbers[1]

2342

                                && !self.press_numbers[11]

2343

2344

                                self.clear_numbers_except(2);

2345

                                self.press_numbers[1] = true;

2346

                            } else if self.press_numbers[1] {

2347

                                self.press_numbers[1] = false;

2348

                            } else if self.press_numbers[11] {

2349

                                self.press_numbers[11] = false;

2350

                            } else {

2351

                                self.press_numbers[0] = false;

2352

                                self.press_numbers[11] = true;

2353

2354

2355

2356

2357

                    self.press_letter_and_number();

2358

2359

                Screen::Login => self.toggle_save_password(),

2360

},

2361

            Message::Press3 => match self.screen {

2362

                Screen::AccountSettings => self.toggle_show_password(),

2363

                Screen::EmailEveryone | Screen::Tournament | Screen::Users => {}

2364

                Screen::Games => self.game_new(),

2365

                Screen::GameNew => self.game_settings.board_size = BoardSize::_11,

2366

                Screen::Login => self.my_games_only(),

2367

                Screen::Game | Screen::GameReview => {

2368

                    let (board, _) = self.board_and_heatmap();

2369

                    match board.size() {

2370

                        BoardSize::_11 => {

2371

                            self.clear_numbers_except(3);

2372

                            self.press_numbers[2] = !self.press_numbers[2];

2373

                            self.press_letter_and_number();

2374

2375

                        BoardSize::_13 => {

2376

                            if !self.press_numbers[0]

2377

                                && !self.press_numbers[2]

2378

                                && !self.press_numbers[12]

2379

2380

                                self.clear_numbers_except(3);

2381

                                self.press_numbers[2] = true;

2382

                            } else if self.press_numbers[2] {

2383

                                self.press_numbers[2] = false;

2384

                            } else if self.press_numbers[12] {

2385

                                self.press_numbers[12] = false;

2386

                            } else {

2387

                                self.press_numbers[0] = false;

2388

                                self.press_numbers[12] = true;

2389

2390

2391

2392

2393

                    self.press_letter_and_number();

2394

2395

},

2396

            Message::Press4 => match self.screen {

2397

                Screen::AccountSettings => self.delete_account(),

2398

                Screen::EmailEveryone | Screen::Tournament | Screen::Users => {}

2399

                Screen::Games => self.screen = Screen::Users,

2400

                Screen::GameNew => self.game_settings.board_size = BoardSize::_13,

2401

                Screen::Login => self.create_account(),

2402

                Screen::Game | Screen::GameReview => {

2403

                    self.clear_numbers_except(4);

2404

                    self.press_numbers[3] = !self.press_numbers[3];

2405

                    self.press_letter_and_number();

2406

2407

},

2408

            Message::Press5 => match self.screen {

2409

                Screen::AccountSettings

2410

                | Screen::EmailEveryone

2411

                | Screen::Tournament

2412

                | Screen::Users => {}

2413

                Screen::Games => self.screen = Screen::AccountSettings,

2414

                Screen::GameNew => self.game_settings.time = Some(TimeEnum::Rapid),

2415

                Screen::Login => self.reset_password(),

2416

                Screen::Game | Screen::GameReview => {

2417

                    self.clear_numbers_except(5);

2418

                    self.press_numbers[4] = !self.press_numbers[4];

2419

                    self.press_letter_and_number();

2420

2421

},

2422

            Message::Press6 => match self.screen {

2423

                Screen::AccountSettings

2424

                | Screen::EmailEveryone

2425

                | Screen::Tournament

2426

                | Screen::Users => {}

2427

                Screen::GameNew => self.game_settings.time = Some(TimeEnum::Classical),

2428

                Screen::Games => open_url("https://hnefatafl.org/rules.html"),

2429

                Screen::Login => self.review_game(),

2430

                Screen::Game | Screen::GameReview => {

2431

                    if self.screen == Screen::Game || self.screen == Screen::GameReview {

2432

                        self.clear_numbers_except(6);

2433

                        self.press_numbers[5] = !self.press_numbers[5];

2434

                        self.press_letter_and_number();

2435

2436

2437

},

2438

            Message::Press7 => match self.screen {

2439

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Tournament => {}

2440

                Screen::Games | Screen::Users => self.users_sort_by = SortBy::Rating,

2441

                Screen::GameNew => self.game_settings.time = Some(TimeEnum::Long),

2442

                Screen::Login => self.change_theme(Theme::Dark),

2443

                Screen::Game | Screen::GameReview => {

2444

                    self.clear_numbers_except(7);

2445

                    self.press_numbers[6] = !self.press_numbers[6];

2446

                    self.press_letter_and_number();

2447

2448

},

2449

            Message::Press8 => match self.screen {

2450

                Screen::AccountSettings | Screen::EmailEveryone | Screen::Tournament => {}

2451

                Screen::Games | Screen::Users => self.users_sort_by = SortBy::Name,

2452

                Screen::GameNew => self.game_settings.time = Some(TimeEnum::VeryLong),

2453

                Screen::Login => self.change_theme(Theme::Light),

2454

                Screen::Game | Screen::GameReview => {

2455

                    self.clear_numbers_except(8);

2456

                    self.press_numbers[7] = !self.press_numbers[7];

2457

                    self.press_letter_and_number();

2458

2459

},

2460

            Message::Press9 => match self.screen {

2461

                Screen::AccountSettings

2462

                | Screen::EmailEveryone

2463

                | Screen::Games

2464

                | Screen::Tournament

2465

                | Screen::Users => {}

2466

                Screen::GameNew => self.game_settings.time = Some(TimeEnum::Infinity),

2467

                Screen::Login => open_url("https://discord.gg/h56CAHEBXd"),

2468

                Screen::Game | Screen::GameReview => {

2469

                    self.clear_numbers_except(9);

2470

                    self.press_numbers[8] = !self.press_numbers[8];

2471

                    self.press_letter_and_number();

2472

2473

},

2474

            Message::Press0 => match self.screen {

2475

                Screen::AccountSettings

2476

                | Screen::EmailEveryone

2477

                | Screen::Games

2478

                | Screen::Tournament

2479

                | Screen::Users => {}

2480

                Screen::GameNew => self.game_settings.rated = !self.game_settings.rated,

2481

                Screen::Login => open_url("https://hnefatafl.org"),

2482

                Screen::Game | Screen::GameReview => {

2483

                    self.clear_numbers_except(10);

2484

                    self.press_numbers[9] = !self.press_numbers[9];

2485

                    self.press_letter_and_number();

2486

2487

},

2488

            Message::ServerShutdown => {

2489

                self.error_persistent

2490

                    .push(t!("The server was shut down.").to_string());

2491

2492

            Message::SoundMuted(_muted) => self.sound_muted(),

2493

            Message::StreamConnected(tx) => self.tx = Some(tx),

2494

            Message::TcpDisconnect => self.connected_tcp = false,

2495

            Message::Tournament => self.screen = Screen::Tournament,

2496

            Message::TournamentJoin => self.send("join_tournament\n"),

2497

            Message::TournamentLeave => self.send("leave_tournament\n"),

2498

            Message::TournamentStart => self.send("tournament_start\n"),

2499

            Message::RatedSelected(rated) => self.game_settings.rated = rated.into(),

2500

            Message::ResetPassword => self.reset_password(),

2501

            Message::ReviewGame => self.review_game(),

2502

            Message::ReviewGameBackward => {

2503

                if let Some(handle) = &mut self.archived_game_handle {

2504

                    handle.play = handle.play.saturating_sub(1);

2505

                    handle.boards.backward();

2506

                    self.reset_markers();

2507

2508

2509

            Message::ReviewGameBackwardAll => {

2510

                if let Some(handle) = &mut self.archived_game_handle {

2511

                    handle.play = 0;

2512

                    handle.boards.backward_all();

2513

                    self.reset_markers();

2514

2515

2516

            Message::ReviewGameChildNext => {

2517

                if let Some(handle) = &mut self.archived_game_handle {

2518

                    handle.boards.next_child();

2519

                    self.reset_markers();

2520

2521

2522

            Message::ReviewGameForward => {

2523

                if let Some(handle) = &mut self.archived_game_handle

2524

                    && handle.boards.has_children()

2525

2526

                    handle.play += 1;

2527

                    handle.boards.forward();

2528

                    self.reset_markers();

2529

2530

2531

            Message::ReviewGameForwardAll => {

2532

                if let Some(handle) = &mut self.archived_game_handle {

2533

                    let count = handle.boards.forward_all();

2534

                    handle.play += count;

2535

                    self.reset_markers();

2536

2537

2538

            Message::RoleSelected(role) => self.game_settings.role_selected = Some(role),

2539

            Message::TextChanged(string) => {

2540

                if self.screen == Screen::Login {

2541

                    let string: Vec<_> = string.split_whitespace().collect();

2542

                    if let Some(string) = string.first() {

2543

                        if string.len() <= 16 {

2544

                            self.text_input = string.to_ascii_lowercase();

2545

                            self.username = self.text_input.clone();

2546

2547

                    } else {

2548

                        self.text_input = String::new();

2549

2550

                } else {

2551

                    self.text_input = string;

2552

2553

2554

            Message::TextEdit(action) => {

2555

                self.content.perform(action);

2556

2557

            Message::TextReceived(string) => {

2558

                let mut text = string.split_ascii_whitespace();

2559

                match text.next() {

2560

                    Some("=") => {

2561

                        let text_next = text.next();

2562

                        match text_next {

2563

                            Some(

2564

                                "archived_games"

2565

                                | "challenge_requested"

2566

                                | "change_password"

2567

                                | "decline_game"

2568

                                | "email_reset"

2569

                                | "game"

2570

                                | "request_draw",

2571

                            ) => {}

2572

                            Some("admin") => self.admin = true,

2573

                            Some("display_games") => {

2574

                                self.games_light.0.clear();

2575

                                let games: Vec<&str> = text.collect();

2576

                                for chunks in games.chunks_exact(12) {

2577

                                    let game = ServerGameLight::try_from(chunks)

2578

                                        .expect("the value should be a valid ServerGameLight");

2579

2580

                                    self.games_light.0.insert(game.id, game);

2581

2582

2583

                                if let Some(game) = self.games_light.0.get(&self.game_id) {

2584

                                    self.spectators = game.spectators.keys().cloned().collect();

2585

                                    self.spectators.sort();

2586

2587

2588

                            Some("display_users") => {

2589

                                let users: Vec<&str> = text.collect();

2590

                                self.users.clear();

2591

                                for user_wins_losses_rating in users.chunks_exact(6) {

2592

                                    let rating = user_wins_losses_rating[4];

2593

                                    let (mut rating, mut deviation) =

2594

                                        rating.split_once("±").unwrap_or_else(|| {

2595

                                            error!("The ratings has this form: {rating}");

2596

                                            unreachable!();

2597

});

2598

2599

                                    rating = rating.trim();

2600

                                    deviation = deviation.trim();

2601

2602

                                    let (Ok(rating), Ok(deviation)) =

2603

                                        (rating.parse::<f64>(), deviation.parse::<f64>())

2604

                                    else {

2605

                                        error!(

2606

                                            "The ratings has this form: ({rating}, {deviation})"

2607

);

2608

                                        unreachable!();

2609

};

2610

2611

                                    let logged_in = if "logged_in" == user_wins_losses_rating[5] {

2612

                                        LoggedIn::Yes

2613

                                    } else {

2614

                                        LoggedIn::No

2615

};

2616

2617

                                    self.users.insert(

2618

                                        user_wins_losses_rating[0].to_string(),

2619

                                        User {

2620

                                            name: user_wins_losses_rating[0].to_string(),

2621

                                            wins: user_wins_losses_rating[1].to_string(),

2622

                                            losses: user_wins_losses_rating[2].to_string(),

2623

                                            draws: user_wins_losses_rating[3].to_string(),

2624

                                            rating: Rating {

2625

                                                rating,

2626

                                                rd: deviation / CONFIDENCE_INTERVAL_95,

2627

},

2628

                                            logged_in,

2629

},

2630

);

2631

2632

2633

                            Some("draw") => {

2634

                                self.request_draw = false;

2635

                                if let Some("accept") = text.next() {

2636

                                    self.my_turn = false;

2637

                                    self.status = Status::Draw;

2638

2639

                                    if let Some(game) = &mut self.game {

2640

                                        game.turn = Role::Roleless;

2641

2642

2643

2644

                            Some("email") => {

2645

                                if let (Some(address), Some(verified)) = (text.next(), text.next())

2646

2647

                                    self.email = Some(Email {

2648

                                        username: String::new(),

2649

                                        address: address.to_string(),

2650

                                        code: None,

2651

                                        verified: handle_error(verified.parse()),

2652

});

2653

2654

2655

                            Some("emails_bcc") => {

2656

                                self.emails_bcc = text.map(ToString::to_string).collect();

2657

2658

                            Some("email_code") => {

2659

                                if let Some(email) = &mut self.email {

2660

                                    email.verified = true;

2661

2662

                                self.error_email = None;

2663

2664

                            Some("game_over") => {

2665

                                self.my_turn = false;

2666

                                if let Some(game) = &mut self.game {

2667

                                    game.turn = Role::Roleless;

2668

2669

2670

                                text.next();

2671

                                match text.next() {

2672

                                    Some("attacker_wins") => self.status = Status::AttackerWins,

2673

                                    Some("defender_wins") => self.status = Status::DefenderWins,

2674

                                    _ => error!("(1) unexpected text: {}", string.trim()),

2675

2676

2677

                                if !self.sound_muted {

2678

                                    thread::spawn(move || {

2679

                                        let mut stream =

2680

                                            rodio::OutputStreamBuilder::open_default_stream()?;

2681

2682

                                        let cursor = Cursor::new(SOUND_GAME_OVER);

2683

                                        let sound = rodio::play(stream.mixer(), cursor)?;

2684

                                        sound.set_volume(1.0);

2685

                                        sound.sleep_until_end();

2686

2687

                                        stream.log_on_drop(false);

2688

                                        Ok::<(), anyhow::Error>(())

2689

});

2690

2691

2692

                            // = join_game david abby rated fischer 900_000 10

2693

                            Some("join_game" | "resume_game" | "watch_game") => {

2694

                                self.screen = Screen::Game;

2695

                                self.status = Status::Ongoing;

2696

                                self.captures = HashSet::new();

2697

                                self.play_from = None;

2698

                                self.play_from_previous = None;

2699

                                self.play_to_previous = None;

2700

                                self.texts_game = VecDeque::new();

2701

                                self.archived_game_handle = None;

2702

2703

                                let attacker =

2704

                                    text.next().expect("the attacker should be supplied");

2705

                                let defender =

2706

                                    text.next().expect("the defender should be supplied");

2707

2708

                                self.attacker = attacker.to_string();

2709

                                self.defender = defender.to_string();

2710

2711

                                let rated = text

2712

                                    .next()

2713

                                    .expect("there should be rated or unrated supplied");

2714

                                let rated = Rated::from_str(rated).expect("rated should be valid");

2715

2716

                                self.game_settings.rated = rated;

2717

2718

                                let timed = text

2719

                                    .next()

2720

                                    .expect("there should be a time setting supplied");

2721

                                let minutes =

2722

                                    text.next().expect("there should be a minutes supplied");

2723

                                let add_seconds =

2724

                                    text.next().expect("there should be a add_seconds supplied");

2725

2726

                                let timed = TimeSettings::try_from(vec![

2727

                                    "time_settings",

2728

                                    timed,

2729

                                    minutes,

2730

                                    add_seconds,

2731

])

2732

                                .expect("there should be a valid time settings");

2733

2734

                                let board_size =

2735

                                    text.next().expect("there should be a valid board size");

2736

                                let board_size = BoardSize::from_str(board_size)

2737

                                    .expect("there should be a valid board size");

2738

2739

                                let board = Board::new(board_size);

2740

2741

                                let mut game = Game {

2742

                                    attacker_time: timed.clone(),

2743

                                    defender_time: timed.clone(),

2744

                                    plays: Plays::new(&timed),

2745

                                    board,

2746

                                    ..Game::default()

2747

};

2748

2749

                                self.time_attacker = timed.clone();

2750

                                self.time_defender = timed;

2751

2752

                                if let Some(game_serialized) = text.next() {

2753

                                    let game_deserialized = ron::from_str(game_serialized)

2754

                                        .expect("we should be able to deserialize the game");

2755

2756

                                    game = game_deserialized;

2757

2758

                                    self.time_attacker = game.attacker_time.clone();

2759

                                    self.time_defender = game.defender_time.clone();

2760

2761

                                    match game.turn {

2762

                                        Role::Attacker => {

2763

                                            if let (

2764

                                                TimeSettings::Timed(time),

2765

                                                TimeUnix::Time(time_ago),

2766

                                            ) = (&mut self.time_attacker, &game.time)

2767

2768

                                                let now = Local::now().to_utc().timestamp_millis();

2769

                                                time.milliseconds_left -= now - time_ago;

2770

                                                if time.milliseconds_left < 0 {

2771

                                                    time.milliseconds_left = 0;

2772

2773

2774

2775

                                        Role::Roleless => {}

2776

                                        Role::Defender => {

2777

                                            if let (

2778

                                                TimeSettings::Timed(time),

2779

                                                TimeUnix::Time(time_ago),

2780

                                            ) = (&mut self.time_defender, &game.time)

2781

2782

                                                let now = Local::now().to_utc().timestamp_millis();

2783

                                                time.milliseconds_left -= now - time_ago;

2784

                                                if time.milliseconds_left < 0 {

2785

                                                    time.milliseconds_left = 0;

2786

2787

2788

2789

2790

2791

2792

                                let texts: Vec<&str> = text.collect();

2793

                                let texts = texts.join(" ");

2794

                                if !texts.is_empty() {

2795

                                    let texts = ron::from_str(&texts)

2796

                                        .expect("we should be able to deserialize the text");

2797

2798

                                    self.texts_game = texts;

2799

2800

2801

                                if (self.username == attacker && game.turn == Role::Attacker)

2802

                                    || (self.username == defender && game.turn == Role::Defender)

2803

2804

                                    self.my_turn = true;

2805

2806

2807

                                self.game = Some(game);

2808

2809

                            Some("join_game_pending") => {

2810

                                let id = text.next().expect("there should be an id supplied");

2811

                                let id = id.parse().expect("id should be a valid u128");

2812

2813

                                self.game_id = id;

2814

                                self.challenger = true;

2815

2816

                            Some("leave_game") => self.game_id = 0,

2817

                            Some("login") => self.screen = Screen::Games,

2818

                            Some("message") => {

2819

                                let message =

2820

                                    text.collect::<Vec<&str>>().join(" ").replace("\\n", "\n");

2821

                                self.message = message;

2822

2823

                            Some("new_game") => {

2824

                                // = new_game game 15 none david rated fischer 900_000 10

2825

                                if Some("game") == text.next() {

2826

                                    let game_id = text.next().expect("the game id should be next");

2827

                                    let game_id =

2828

                                        game_id.parse().expect("the game_id should be a usize");

2829

2830

                                    self.game_id = game_id;

2831

                                    self.challenger = false;

2832

2833

2834

                            Some("ping") => {

2835

                                let after = Utc::now().timestamp_millis();

2836

                                self.now_diff = after - self.now;

2837

2838

                            Some("text") => self.texts.push_front(text_collect(text)),

2839

                            Some("text_game") => self.texts_game.push_front(text_collect(text)),

2840

                            Some("tournament_status") => {

2841

                                if let Some(tournament) = text.next() {

2842

                                    let tournament: Option<Tournament> = ron::from_str(tournament)

2843

                                        .expect("This is a valid tournament.");

2844

2845

                                    self.tournament = tournament;

2846

2847

2848

                            _ => error!("(2) unexpected text: {}", string.trim()),

2849

2850

2851

                    Some("?") => {

2852

                        let text_next = text.next();

2853

                        match text_next {

2854

                            Some("create_account") => {

2855

                                self.error = Some(t!("Account already exists.").to_string());

2856

2857

                            // Fixme: translate.

2858

                            Some("email") => {

2859

                                let text: Vec<_> = text.collect();

2860

                                let text = text.join(" ");

2861

                                self.error_email = Some(text);

2862

2863

                            Some("email_code") => {

2864

                                self.error_email = Some(t!("invalid email code").to_string());

2865

2866

                            Some("login") => {

2867

                                let text_next = text.next();

2868

                                match text_next {

2869

                                    Some("multiple_possible_errors") => {

2870

                                        self.error = Some(t!(

2871

                                            "Login password is wrong (try lowercase), account doesn't exist, or you're already logged in."

2872

                                        ).to_string());

2873

2874

                                    Some("reset_password") => {

2875

                                        self.error = Some(t!(

2876

                                            "Sent a password reset email if a verified email exists for this account and the last password reset happened more than a day ago.",

2877

                                        ).to_string());

2878

2879

                                    Some("wrong_version") => {

2880

                                        self.error = Some(t!(

2881

                                            "Wrong version, update your hnefatafl-copenhagen package.",

2882

                                        ).to_string());

2883

2884

                                    _ => {

2885

                                        let text: Vec<_> = text.collect();

2886

                                        let text = text.join(" ");

2887

                                        self.error = Some(text);

2888

2889

2890

2891

                            _ => error!("(3) unexpected text: {}", string.trim()),

2892

2893

2894

                    Some("game") => {

2895

                        // Plays the move then sends the result back.

2896

                        let id = text.next().expect("there should be a game id");

2897

                        let id = id

2898

                            .parse::<Id>()

2899

                            .expect("the game_id should be a valid usize");

2900

2901

                        self.game_id = id;

2902

2903

                        // game 0 generate_move attacker

2904

                        let text_word = text.next();

2905

                        if text_word == Some("generate_move") {

2906

                            self.request_draw = false;

2907

                            self.my_turn = true;

2908

                        // game 0 play attacker a3 a4

2909

                        } else if text_word == Some("play") {

2910

                            let role = text.next().expect("this should be a role string");

2911

                            let role = Role::from_str(role).expect("this should be a role");

2912

                            let from = text.next().expect("this should be from");

2913

2914

                            if from == "resigns" {

2915

                                return Task::none();

2916

2917

2918

                            let to = text.next().expect("this should be to");

2919

2920

                            if let (Ok(from), Ok(to)) =

2921

                                (Vertex::from_str(from), Vertex::from_str(to))

2922

2923

                                self.play_from_previous = Some(from);

2924

                                self.play_to_previous = Some(to);

2925

2926

2927

                            self.handle_play(Some(&role.to_string()), from, to);

2928

                            let game = self.game.as_ref().expect("you should have a game by now");

2929

2930

                            if game.status == Status::Ongoing {

2931

                                match game.turn {

2932

                                    Role::Attacker => {

2933

                                        if let TimeSettings::Timed(time) = &mut self.time_defender {

2934

                                            time.milliseconds_left += time.add_seconds * 1_000;

2935

2936

2937

                                    Role::Roleless => {}

2938

                                    Role::Defender => {

2939

                                        if let TimeSettings::Timed(time) = &mut self.time_attacker {

2940

                                            time.milliseconds_left += time.add_seconds * 1_000;

2941

2942

2943

2944

2945

2946

2947

                    Some("request_draw") => {

2948

                        let id = text.next().expect("there should be a game id");

2949

                        let id = id

2950

                            .parse::<Id>()

2951

                            .expect("the game_id should be a valid usize");

2952

2953

                        if id == self.game_id {

2954

                            self.request_draw = true;

2955

2956

2957

                    _ => error!("(4) unexpected text: {}", string.trim()),

2958

2959

2960

            Message::TextSend => {

2961

                match self.screen {

2962

                    Screen::AccountSettings => {

2963

                        self.send(&format!("change_password {}\n", self.password));

2964

2965

                    Screen::EmailEveryone => {

2966

                        // subject == self.text_input

2967

                        let email = self.content.text().replace('\n', "\\n");

2968

                        self.send(&format!("email_everyone {} {email}\n", self.text_input));

2969

2970

                    Screen::Game => {

2971

                        if !self.text_input.trim().is_empty() {

2972

                            self.text_input.push('\n');

2973

                            self.send(&format!("text_game {} {}", self.game_id, self.text_input));

2974

2975

2976

                    Screen::Games => {

2977

                        if !self.text_input.trim().is_empty() {

2978

                            self.text_input.push('\n');

2979

                            self.send(&format!("text {}", self.text_input));

2980

2981

2982

                    Screen::Tournament => {

2983

                        if !self.text_input.trim().is_empty() {

2984

                            self.text_input.push('\n');

2985

                            self.send(&format!("tournament_date {}", self.text_input));

2986

2987

2988

                    Screen::GameNew | Screen::GameReview | Screen::Login | Screen::Users => {}

2989

2990

2991

                self.text_input.clear();

2992

2993

            Message::TextSendEmail => {

2994

                self.error_email = None;

2995

2996

                self.send(&format!("email {}\n", self.text_input));

2997

                self.text_input.clear();

2998

2999

            Message::TextSendEmailCode => {

3000

                self.error_email = None;

3001

3002

                self.send(&format!("email_code {}\n", self.text_input));

3003

3004

            Message::TextSendCreateAccount => self.create_account(),

3005

            Message::TextSendLogin => self.login(),

3006

            Message::Tick => {

3007

                self.counter = self.counter.wrapping_add(1);

3008

                if self.counter.is_multiple_of(25) {

3009

                    self.now = Utc::now().timestamp_millis();

3010

                    self.send("ping\n");

3011

3012

3013

                if let Some(game) = &mut self.game {

3014

                    match game.turn {

3015

                        Role::Attacker => {

3016

                            if let TimeSettings::Timed(time) = &mut self.time_attacker {

3017

                                time.milliseconds_left -= 100;

3018

                                if time.milliseconds_left < 0 {

3019

                                    time.milliseconds_left = 0;

3020

3021

3022

3023

                        Role::Roleless => {}

3024

                        Role::Defender => {

3025

                            if let TimeSettings::Timed(time) = &mut self.time_defender {

3026

                                time.milliseconds_left -= 100;

3027

                                if time.milliseconds_left < 0 {

3028

                                    time.milliseconds_left = 0;

3029

3030

3031

3032

3033

3034

3035

            Message::Time(time) => self.game_settings.time = Some(time),

3036

            Message::TournamentDelete => self.send("tournament_delete\n"),

3037

            Message::TournamentTreeDelete => self.send("tournament_tree_delete\n"),

3038

            Message::Users => self.screen = Screen::Users,

3039

            Message::UsersSortedBy(sort_by) => self.users_sort_by = sort_by,

3040

            Message::WindowResized((width, height)) => {

3041

                if width >= 1_500.0 && height >= 1_000.0 {

3042

                    self.screen_size = Size::Giant;

3043

                } else if width >= 1_300.0 && height >= 1_000.0 {

3044

                    self.screen_size = Size::Large;

3045

                } else if width >= 1_200.0 && height >= 850.0 {

3046

                    self.screen_size = Size::Medium;

3047

                } else if width >= 1_000.0 && height >= 750.0 {

3048

                    self.screen_size = Size::Small;

3049

                } else if width >= 1_100.0 {

3050

                    self.screen_size = Size::TinyWide;

3051

                } else {

3052

                    self.screen_size = Size::Tiny;

3053

3054

3055

3056

3057

        Task::none()

3058

3059

3060

    #[must_use]

3061

    fn users_sorted(&self) -> Vec<User> {

3062

        let mut users: Vec<_> = self.users.values().cloned().collect();

3063

3064

        match self.users_sort_by {

3065

            SortBy::Name => {

3066

                users.sort_by(|a, b| {

3067

                    b.rating

3068

                        .rating

3069

                        .partial_cmp(&a.rating.rating)

3070

                        .expect("The number should be comparable.")

3071

});

3072

                users.sort_by(|a, b| a.name.cmp(&b.name));

3073

3074

            SortBy::Rating => {

3075

                users.sort_by(|a, b| a.name.cmp(&b.name));

3076

                users.sort_by(|a, b| {

3077

                    b.rating

3078

                        .rating

3079

                        .partial_cmp(&a.rating.rating)

3080

                        .expect("The number should be comparable.")

3081

});

3082

3083

3084

3085

        users

3086

3087

3088

    #[allow(clippy::too_many_lines)]

3089

    #[must_use]

3090

    fn games(&self) -> Scrollable<'_, Message> {

3091

        let mut game_ids = Column::new().spacing(SPACING_B);

3092

        let mut attackers = Column::new().spacing(SPACING_B);

3093

        let mut defenders = Column::new().spacing(SPACING_B);

3094

        let mut ratings = Column::new().spacing(SPACING_B);

3095

        let mut timings = Column::new().spacing(SPACING_B);

3096

        let mut sizes = Column::new().spacing(SPACING_B);

3097

        let mut buttons = Column::new().spacing(SPACING);

3098

3099

        let mut server_games: Vec<&ServerGameLight> = self.games_light.0.values().collect();

3100

        server_games.sort_by(|a, b| b.id.cmp(&a.id));

3101

3102

        for (i, game) in server_games.iter().enumerate() {

3103

            if self.my_games_only {

3104

                let mut includes_username = false;

3105

                if let Some(attacker) = &game.attacker

3106

                    && attacker == &self.username

3107

3108

                    includes_username = true;

3109

3110

3111

                if let Some(defender) = &game.defender

3112

                    && defender == &self.username

3113

3114

                    includes_username = true;

3115

3116

3117

                if !includes_username {

3118

                    continue;

3119

3120

3121

3122

            let id = game.id;

3123

            game_ids = game_ids.push(text(id));

3124

3125

            attackers = if let Some(attacker) = &game.attacker {

3126

                attackers.push(text(attacker))

3127

            } else {

3128

                attackers.push(text(t!("none")))

3129

};

3130

            defenders = if let Some(defender) = &game.defender {

3131

                defenders.push(text(defender))

3132

            } else {

3133

                defenders.push(text(t!("none")))

3134

};

3135

3136

            let rating: bool = game.rated.into();

3137

            let rating = if rating { t!("yes") } else { t!("no") };

3138

            ratings = ratings.push(text(rating));

3139

3140

            timings = timings.push(text(game.timed.to_string()));

3141

            sizes = sizes.push(text(game.board_size.to_string()));

3142

3143

            let mut buttons_row = Row::new().spacing(SPACING);

3144

3145

            let i = if let Some(i) = ALPHABET.get(i) {

3146

                format!(" ({i})")

3147

            } else {

3148

                String::new()

3149

};

3150

3151

            match self.join_game(game) {

3152

                JoinGame::Cancel => {

3153

                    buttons_row = buttons_row.push(

3154

                        button(text!("{}{i}", self.strings["Cancel"].as_str()))

3155

                            .on_press(Message::GameCancel(id)),

3156

);

3157

3158

                JoinGame::Join => {

3159

                    buttons_row = buttons_row.push(

3160

                        button(text!("{}{i}", self.strings["Join"].as_str()))

3161

                            .on_press(Message::GameJoin(id)),

3162

);

3163

3164

                JoinGame::None => {}

3165

                JoinGame::Resume => {

3166

                    buttons_row = buttons_row.push(

3167

                        button(text!("{}{i}", self.strings["Resume"].as_str()))

3168

                            .on_press(Message::GameResume(id)),

3169

);

3170

3171

                JoinGame::Watch => {

3172

                    buttons_row = buttons_row.push(

3173

                        button(text!("{}{i}", self.strings["Watch"].as_str()))

3174

                            .on_press(Message::GameWatch(id)),

3175

);

3176

3177

3178

3179

            match self.game_state(id) {

3180

                State::Challenger | State::Spectator => {}

3181

                State::Creator => {

3182

                    buttons_row = buttons_row.push(

3183

                        button(text!("{}{i}", self.strings["Accept"].as_str()))

3184

                            .on_press(Message::GameAccept(id)),

3185

);

3186

                    buttons_row = buttons_row.push(

3187

                        button(text!(

3188

                            "{}{}",

3189

                            self.strings["Decline"].as_str(),

3190

                            i.to_ascii_uppercase()

3191

))

3192

                        .on_press(Message::GameDecline(id)),

3193

);

3194

3195

                State::CreatorOnly => {

3196

                    buttons_row = buttons_row.push(

3197

                        button(text!("{}{i}", self.strings["Cancel"].as_str()))

3198

                            .on_press(Message::CancelGame(id)),

3199

);

3200

3201

3202

            buttons = buttons.push(buttons_row);

3203

3204

3205

        let game_id = t!("ID");

3206

        let game_ids = column![

3207

            text(game_id.to_string()),

3208

            text("-".repeat(game_id.chars().count())).font(Font::MONOSPACE),

3209

            game_ids

3210

3211

        .padding(PADDING);

3212

        let attacker = t!("attacker");

3213

        let attackers = column![

3214

            text(attacker.to_string()),

3215

            text("-".repeat(attacker.chars().count())).font(Font::MONOSPACE),

3216

            attackers

3217

3218

        .padding(PADDING);

3219

        let defender = t!("defender");

3220

        let defenders = column![

3221

            text(defender.to_string()),

3222

            text("-".repeat(defender.chars().count())).font(Font::MONOSPACE),

3223

            defenders

3224

3225

        .padding(PADDING);

3226

        let rated = t!("rated");

3227

        let ratings = column![

3228

            text(rated.to_string()),

3229

            text("-".repeat(rated.chars().count())).font(Font::MONOSPACE),

3230

            ratings

3231

3232

        .padding(PADDING);

3233

        let timed = t!("timed");

3234

        let timings = column![

3235

            text(timed.to_string()),

3236

            text("-".repeat(timed.chars().count())).font(Font::MONOSPACE),

3237

            timings

3238

3239

        .padding(PADDING);

3240

        let size = t!("size");

3241

        let sizes = column![

3242

            text(size.to_string()),

3243

            text("-".repeat(size.chars().count())).font(Font::MONOSPACE),

3244

            sizes

3245

3246

        .padding(PADDING);

3247

        let buttons = column![text(""), text(""), buttons].padding(PADDING);

3248

3249

        scrollable(row![

3250

            game_ids, attackers, defenders, ratings, timings, sizes, buttons

3251

])

3252

3253

3254

    fn handle_play(&mut self, role: Option<&str>, from: &str, to: &str) {

3255

        self.captures = HashSet::new();

3256

3257

        let mut game_handle = None;

3258

        if let Some(handle) = &mut self.archived_game_handle {

3259

            game_handle = Some(Game::from(&handle.boards));

3260

3261

3262

        let game = if let Some(game) = &mut game_handle {

3263

            game

3264

        } else {

3265

            self.game.as_mut().expect("you should have a game by now")

3266

};

3267

3268

        let role = if let Some(role) = role {

3269

            Role::from_str(role).expect("there should be a valid role")

3270

        } else {

3271

            game.turn

3272

};

3273

3274

        let play = Plae::try_from(vec!["play", &role.to_string(), from, to])

3275

            .expect("This is a valid plae.");

3276

        let captures = game.play(&play).expect("This should be a legal play.");

3277

        for vertex in captures.0 {

3278

            self.captures.insert(vertex);

3279

3280

3281

        if let Some(handle) = &mut self.archived_game_handle {

3282

            handle.boards.insert(&game.board);

3283

            handle.play += 1;

3284

3285

3286

        if self.sound_muted {

3287

            return;

3288

3289

3290

        let capture = !self.captures.is_empty();

3291

3292

        thread::spawn(move || {

3293

            let mut stream = rodio::OutputStreamBuilder::open_default_stream()?;

3294

            let cursor = if capture {

3295

                Cursor::new(SOUND_CAPTURE)

3296

            } else {

3297

                Cursor::new(SOUND_MOVE)

3298

};

3299

            let sound = rodio::play(stream.mixer(), cursor)?;

3300

            sound.set_volume(1.0);

3301

            sound.sleep_until_end();

3302

3303

            stream.log_on_drop(false);

3304

            Ok::<(), anyhow::Error>(())

3305

});

3306

3307

3308

    fn resign(&mut self) {

3309

        let game = self.game.as_ref().expect("you should have a game by now");

3310

3311

        self.send(&format!(

3312

            "game {} play {} resigns _\n",

3313

            self.game_id, game.turn

3314

));

3315

3316

3317

    fn sound_muted(&mut self) {

3318

        self.sound_muted = !self.sound_muted;

3319

        handle_error(self.save_client_ron());

3320

3321

3322

    #[must_use]

3323

    fn users(&self, logged_in: &LoggedIn) -> Scrollable<'_, Message> {

3324

        let mut ratings = Column::new();

3325

        let mut usernames = Column::new();

3326

        let mut wins = Column::new();

3327

        let mut losses = Column::new();

3328

        let mut draws = Column::new();

3329

        let mut win_percents = Column::new();

3330

3331

        for user in self.users_sorted() {

3332

            if *logged_in == user.logged_in || *logged_in == LoggedIn::None {

3333

                let wins_number = f64::from_str(&user.wins).expect("This is a f64.");

3334

                let mut win_percentage = wins_number

3335

                    / (wins_number + f64::from_str(&user.losses).expect("This is a f64."));

3336

3337

                win_percentage *= 100.0;

3338

                win_percentage = win_percentage.round_ties_even();

3339

3340

                ratings = ratings.push(text(user.rating.to_string_rounded()));

3341

                usernames = usernames.push(text(user.name));

3342

                wins = wins.push(text(user.wins));

3343

                losses = losses.push(text(user.losses));

3344

                draws = draws.push(text(user.draws));

3345

                win_percents = win_percents.push(text!("{}", win_percentage));

3346

3347

3348

3349

        let rating = t!("rating");

3350

        let mut button_1 = button(text("(7)").size(10)).padding(PADDING_SMALL);

3351

3352

        if self.users_sort_by != SortBy::Rating {

3353

            button_1 = button_1.on_press(Message::UsersSortedBy(SortBy::Rating));

3354

3355

3356

        let ratings = column![

3357

            row![text(rating.to_string()), button_1,].spacing(SPACING),

3358

            text("-".repeat(rating.chars().count())).font(Font::MONOSPACE),

3359

            ratings

3360

3361

        .padding(PADDING);

3362

3363

        let username = t!("username");

3364

        let mut button_2 = button(text("(8)").size(10)).padding(PADDING_SMALL);

3365

3366

        if self.users_sort_by != SortBy::Name {

3367

            button_2 = button_2.on_press(Message::UsersSortedBy(SortBy::Name));

3368

3369

3370

        let usernames = column![

3371

            row![text(username.to_string()), button_2,].spacing(SPACING),

3372

            text("-".repeat(username.chars().count())).font(Font::MONOSPACE),

3373

            usernames

3374

3375

        .padding(PADDING);

3376

3377

        let win = t!("wins");

3378

        let wins = column![

3379

            text(win.to_string()),

3380

            text("-".repeat(win.chars().count())).font(Font::MONOSPACE),

3381

            wins

3382

3383

        .padding(PADDING);

3384

3385

        let loss = t!("losses");

3386

        let losses = column![

3387

            text(loss.to_string()),

3388

            text("-".repeat(loss.chars().count())).font(Font::MONOSPACE),

3389

            losses

3390

3391

        .padding(PADDING);

3392

3393

        let draw = t!("draws");

3394

        let draws = column![

3395

            text(draw.to_string()),

3396

            text("-".repeat(draw.chars().count())).font(Font::MONOSPACE),

3397

            draws

3398

3399

        .padding(PADDING);

3400

3401

        let win_percent = format!("{} %", t!("wins"));

3402

        let hyphens_count = win_percent.chars().count();

3403

        let win_percents = column![

3404

            text(win_percent),

3405

            text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3406

            win_percents

3407

3408

        .padding(PADDING);

3409

3410

        scrollable(row![ratings, usernames, wins, losses, draws, win_percents]).spacing(SPACING)

3411

3412

3413

    #[must_use]

3414

    fn user_area(&self, in_game: bool) -> Container<'_, Message> {

3415

        let texts = if in_game {

3416

            &self.texts_game

3417

        } else {

3418

            &self.texts

3419

};

3420

3421

        let games = self.games();

3422

        let texting = self.texting(texts, true).padding(PADDING);

3423

        let users = self.users(&LoggedIn::Yes);

3424

3425

        let user_area = scrollable(column![games, users, texting]);

3426

        container(user_area)

3427

            .padding(PADDING)

3428

            .style(container::bordered_box)

3429

3430

3431

    fn reset_password(&mut self) {

3432

        if !self.connected_tcp {

3433

            self.send("tcp_connect\n");

3434

            self.connected_tcp = true;

3435

3436

3437

        if self.screen == Screen::Login {

3438

            self.send(&format!(

3439

                "{VERSION_ID} reset_password {}\n",

3440

                self.text_input

3441

));

3442

3443

3444

3445

    #[must_use]

3446

    #[allow(clippy::too_many_lines)]

3447

    pub fn view(&self) -> Element<'_, Message> {

3448

        match self.screen {

3449

            Screen::AccountSettings => {

3450

                let mut rating = String::new();

3451

                let mut wins = String::new();

3452

                let mut draws = String::new();

3453

                let mut losses = String::new();

3454

3455

                for user in self.users.values() {

3456

                    if self.username == user.name {

3457

                        rating = user.rating.to_string_rounded();

3458

                        wins.clone_from(&user.wins);

3459

                        losses.clone_from(&user.losses);

3460

                        draws.clone_from(&user.draws);

3461

3462

3463

3464

                let mut columns = column![

3465

                    text!(

3466

                        "{} {} {} TCP",

3467

                        t!("connected to"),

3468

                        &self.connected_to,

3469

                        t!("via")

3470

),

3471

                    text!("{}: {}", t!("username"), &self.username),

3472

                    text!("{}: {rating}", t!("rating")),

3473

                    text!("{}: {wins}", t!("wins")),

3474

                    text!("{}: {losses}", t!("losses")),

3475

                    text!("{}: {draws}", t!("draws")),

3476

3477

                .padding(PADDING)

3478

                .spacing(SPACING);

3479

3480

                if let Some(email) = &self.email {

3481

                    let mut row = Row::new();

3482

                    if email.verified {

3483

                        row = row.push(text!(

3484

                            "{}: [{}] {} ",

3485

                            t!("email address"),

3486

                            t!("verified"),

3487

                            email.address,

3488

));

3489

                        columns = columns.push(row);

3490

                    } else {

3491

                        row = row.push(text!(

3492

                            "{}: [{}] {} ",

3493

                            t!("email address"),

3494

                            t!("unverified"),

3495

                            email.address,

3496

));

3497

                        columns = columns.push(row);

3498

3499

                        let mut row = Row::new();

3500

                        row = row.push(text!("{}: ", t!("email code")));

3501

                        row = row.push(

3502

                            widget::text_input("", &self.text_input)

3503

                                .on_input(Message::TextChanged)

3504

                                .on_paste(Message::TextChanged)

3505

                                .on_submit(Message::TextSendEmailCode),

3506

);

3507

                        columns = columns.push(row);

3508

3509

                } else {

3510

                    let mut row = Row::new();

3511

                    row = row.push(text!("{}: ", t!("email address")));

3512

                    row = row.push(

3513

                        widget::text_input("", &self.text_input)

3514

                            .on_input(Message::TextChanged)

3515

                            .on_paste(Message::TextChanged)

3516

                            .on_submit(Message::TextSendEmail),

3517

);

3518

3519

                    columns = columns.push(row);

3520

                    columns = columns.push(row![text!("{}: ", t!("email code"))]);

3521

3522

3523

                columns = columns.push(row![

3524

                    button(text!("{} (1)", self.strings["Reset Email"].as_str()))

3525

                        .on_press(Message::EmailReset)

3526

]);

3527

3528

                if let Some(error) = &self.error_email {

3529

                    columns = columns.push(row![text!("error: {error}").style(text::danger)]);

3530

3531

3532

                let mut change_password_button =

3533

                    button(text!("{} (2)", self.strings["Change Password"].as_str()));

3534

3535

                if !self.password_ends_with_whitespace {

3536

                    change_password_button = change_password_button.on_press(Message::TextSend);

3537

3538

3539

                columns = columns.push(

3540

                    row![

3541

                        change_password_button,

3542

                        widget::text_input("", &self.password)

3543

                            .secure(!self.password_show)

3544

                            .on_input(Message::PasswordChanged)

3545

                            .on_paste(Message::PasswordChanged),

3546

3547

                    .spacing(SPACING),

3548

);

3549

3550

                columns = columns.push(

3551

                    row![

3552

                        checkbox(self.password_show).on_toggle(Message::PasswordShow),

3553

                        text!("{} (3)", t!("show password")),

3554

3555

                    .spacing(SPACING),

3556

);

3557

3558

                if self.delete_account {

3559

                    columns = columns.push(

3560

                        button(text!(

3561

                            "{} (4)",

3562

                            self.strings["REALLY DELETE ACCOUNT"].as_str()

3563

))

3564

                        .on_press(Message::DeleteAccount),

3565

);

3566

                } else {

3567

                    columns = columns.push(

3568

                        button(text!("{} (4)", self.strings["Delete Account"].as_str()))

3569

                            .on_press(Message::DeleteAccount),

3570

);

3571

3572

3573

                columns = columns.push(

3574

                    button(text!("{} (Esc)", self.strings["Leave"].as_str()))

3575

                        .on_press(Message::Leave),

3576

);

3577

3578

                columns.into()

3579

3580

            Screen::EmailEveryone => {

3581

                let subject = row![

3582

                    text("Subject: "),

3583

                    widget::text_input("", &self.text_input)

3584

                        .on_input(Message::TextChanged)

3585

                        .on_paste(Message::TextChanged)

3586

                        .on_submit(Message::TextSend),

3587

];

3588

3589

                let editor = text_editor(&self.content)

3590

                    .placeholder("Dear User, …")

3591

                    .on_action(Message::TextEdit);

3592

3593

                let send_emails = button("Send Emails").on_press(Message::TextSend);

3594

                let leave = button(text!("{} (Esc)", self.strings["Leave"].as_str()))

3595

                    .on_press(Message::Leave);

3596

                let mut column = column![

3597

                    subject,

3598

                    text("From: Hnefatafl Org <no-reply@hnefatafl.org>"),

3599

                    text("Content-Type: text/plain; charset=utf-8"),

3600

                    text("Content-Transfer-Encoding: 7bit"),

3601

                    text!("Date: {}", Utc::now().to_rfc2822()),

3602

                    text("Body:"),

3603

                    editor,

3604

                    send_emails,

3605

                    leave,

3606

                    text("Bcc:")

3607

3608

                .spacing(SPACING)

3609

                .padding(PADDING);

3610

3611

                for email in &self.emails_bcc {

3612

                    column = column.push(text(email));

3613

3614

3615

                scrollable(column).spacing(SPACING).into()

3616

3617

            Screen::Game | Screen::GameReview => self.display_game(),

3618

            Screen::GameNew => {

3619

                let attacker = radio(

3620

                    format!("{} (1)", t!("attacker")),

3621

                    Role::Attacker,

3622

                    self.game_settings.role_selected,

3623

                    Message::RoleSelected,

3624

);

3625

3626

                let defender = radio(

3627

                    format!("{} (2)", t!("defender")),

3628

                    Role::Defender,

3629

                    self.game_settings.role_selected,

3630

                    Message::RoleSelected,

3631

);

3632

3633

                let rated = row![

3634

                    text!("{} (0):", t!("rated")),

3635

                    checkbox(self.game_settings.rated.into()).on_toggle(Message::RatedSelected)

3636

3637

                .padding(PADDING)

3638

                .spacing(SPACING);

3639

3640

                let mut new_game = button(text!("{} (Enter)", self.strings["New Game"].as_str()));

3641

                if self.game_settings.role_selected.is_some() && self.game_settings.time.is_some() {

3642

                    new_game = new_game.on_press(Message::GameSubmit);

3643

3644

3645

                let leave = button(text!("{} (Esc)", self.strings["Leave"].as_str()))

3646

                    .on_press(Message::Leave);

3647

3648

                let size_11x11 = radio(

3649

                    "11x11 (3)",

3650

                    BoardSize::_11,

3651

                    Some(self.game_settings.board_size),

3652

                    Message::BoardSizeSelected,

3653

);

3654

3655

                let size_13x13 = radio(

3656

                    "13x13 (4)",

3657

                    BoardSize::_13,

3658

                    Some(self.game_settings.board_size),

3659

                    Message::BoardSizeSelected,

3660

);

3661

3662

                let row_1 = row![text!("{}:", t!("role")), attacker, defender]

3663

                    .padding(PADDING)

3664

                    .spacing(SPACING);

3665

3666

                let row_2 = row![text!("{}:", t!("board size")), size_11x11, size_13x13]

3667

                    .padding(PADDING)

3668

                    .spacing(SPACING);

3669

3670

                let rapid = radio(

3671

                    format!("{} (5)", TimeEnum::Rapid),

3672

                    TimeEnum::Rapid,

3673

                    self.game_settings.time,

3674

                    Message::Time,

3675

);

3676

3677

                let classical = radio(

3678

                    format!("{} (6)", TimeEnum::Classical),

3679

                    TimeEnum::Classical,

3680

                    self.game_settings.time,

3681

                    Message::Time,

3682

);

3683

3684

                let long = radio(

3685

                    format!("{} (7)", TimeEnum::Long),

3686

                    TimeEnum::Long,

3687

                    self.game_settings.time,

3688

                    Message::Time,

3689

);

3690

3691

                let very_long = radio(

3692

                    format!("{} (8)", TimeEnum::VeryLong),

3693

                    TimeEnum::VeryLong,

3694

                    self.game_settings.time,

3695

                    Message::Time,

3696

);

3697

3698

                let row_3 = row![text!("{}:", t!("time"))]

3699

                    .padding(PADDING)

3700

                    .spacing(SPACING);

3701

3702

                let row_4 = row![rapid, classical].padding(PADDING).spacing(SPACING);

3703

                let row_5 = row![long, very_long].padding(PADDING).spacing(SPACING);

3704

3705

                let mut column = column![rated, row_1, row_2, row_3, row_4, row_5];

3706

                column = self.add_infinity(column);

3707

3708

                let row_6 = row![new_game, leave].padding(PADDING).spacing(SPACING);

3709

                column.push(row_6).into()

3710

3711

            Screen::Games => {

3712

                let mut column = Column::new().padding(PADDING).spacing(SPACING);

3713

3714

                if !self.message.is_empty() {

3715

                    column = column.push(text(self.message.clone()));

3716

3717

3718

                if self.admin {

3719

                    column = column.push(button("Email Everyone").on_press(Message::EmailEveryone));

3720

3721

3722

                let username =

3723

                    row![text!("{}: {}", t!("username"), &self.username)].spacing(SPACING);

3724

3725

                let username = container(username)

3726

                    .padding(PADDING / 2)

3727

                    .style(container::bordered_box);

3728

3729

                let tournament = button(text!("{} (0)", self.strings["Tournament"].as_str()))

3730

                    .on_press(Message::Tournament);

3731

3732

                let my_games_text = text!("{} (2)", t!("My Games Only")).center();

3733

                let my_games = checkbox(self.my_games_only)

3734

                    .on_toggle(Message::MyGamesOnly)

3735

                    .size(32);

3736

3737

                let get_archived_games =

3738

                    button(text!("{} (1)", self.strings["Get Archived Games"].as_str()))

3739

                        .on_press(Message::ArchivedGamesGet);

3740

3741

                let username = row![

3742

                    username,

3743

                    tournament,

3744

                    get_archived_games,

3745

                    my_games,

3746

                    my_games_text

3747

3748

                .spacing(SPACING);

3749

3750

                let create_game = button(text!("{} (3)", self.strings["Create Game"].as_str()))

3751

                    .on_press(Message::GameNew);

3752

3753

                let users = button(text!("{} (4)", self.strings["Users"].as_str()))

3754

                    .on_press(Message::Users);

3755

3756

                let account_setting =

3757

                    button(text!("{} (5)", self.strings["Account Settings"].as_str()))

3758

                        .on_press(Message::AccountSettings);

3759

3760

                let website = button(text!("{} (6)", self.strings["Rules"].as_str())).on_press(

3761

                    Message::OpenUrl("https://hnefatafl.org/rules.html".to_string()),

3762

);

3763

3764

                let quit = button(text!("{} (Esc)", self.strings["Leave"].as_str()))

3765

                    .on_press(Message::Leave);

3766

3767

                let top = row![create_game, users, account_setting, website, quit].spacing(SPACING);

3768

                let user_area = self.user_area(false);

3769

3770

                column = column.push(username);

3771

                column = column.push(top);

3772

                column = column.push(user_area);

3773

                column.into()

3774

3775

            Screen::Login => {

3776

                let username = row![

3777

                    text!("{}:", t!("username")).size(20),

3778

                    widget::text_input("", &self.text_input)

3779

                        .on_input(Message::TextChanged)

3780

                        .on_paste(Message::TextChanged),

3781

3782

                .spacing(SPACING);

3783

3784

                let username = container(username)

3785

                    .padding(PADDING)

3786

                    .style(container::bordered_box);

3787

3788

                let password = row![

3789

                    text!("{}:", t!("password")).size(20),

3790

                    widget::text_input("", &self.password)

3791

                        .secure(!self.password_show)

3792

                        .on_input(Message::PasswordChanged)

3793

                        .on_paste(Message::PasswordChanged),

3794

3795

                .spacing(SPACING);

3796

3797

                let password = container(password)

3798

                    .padding(PADDING)

3799

                    .style(container::bordered_box);

3800

3801

                let show_password_text = text!("{} (1)", t!("show password"));

3802

                let show_password = checkbox(self.password_show).on_toggle(Message::PasswordShow);

3803

3804

                let save_password_text = text!("{} (2)", t!("save password"));

3805

                let save_password = checkbox(self.password_save).on_toggle(Message::PasswordSave);

3806

3807

                let mut login = button(text!("{} (Enter)", self.strings["Login"].as_str()));

3808

                if !self.password_ends_with_whitespace {

3809

                    login = login.on_press(Message::TextSendLogin);

3810

3811

3812

                let mut create_account =

3813

                    button(text!("{} (4)", self.strings["Create Account"].as_str()));

3814

                if !self.text_input.is_empty() && !self.password_ends_with_whitespace {

3815

                    create_account = create_account.on_press(Message::TextSendCreateAccount);

3816

3817

3818

                let mut reset_password =

3819

                    button(text!("{} (5)", self.strings["Reset Password"].as_str()));

3820

                if !self.text_input.is_empty() {

3821

                    reset_password = reset_password.on_press(Message::ResetPassword);

3822

3823

3824

                let mut error = text("");

3825

                if let Some(error_) = &self.error {

3826

                    error = text(error_).style(text::danger);

3827

3828

3829

                let mut error_persistent = Column::new();

3830

                for error in &self.error_persistent {

3831

                    error_persistent = error_persistent.push(text(error).style(text::danger));

3832

3833

3834

                let mut review_game = button(text!("{} (6)", self.strings["Review Game"].as_str()));

3835

                if self.archived_game_selected.is_some() {

3836

                    review_game = review_game.on_press(Message::ReviewGame);

3837

3838

3839

                let archived_games = if let Some(archived_games) = &self.archived_games_filtered {

3840

                    archived_games.clone()

3841

                } else {

3842

                    self.archived_games.clone()

3843

};

3844

3845

                let my_games_text = text!("{} (3)", t!("My Games Only"));

3846

                let my_games = checkbox(self.my_games_only).on_toggle(Message::MyGamesOnly);

3847

3848

                let buttons_1 =

3849

                    row![login, create_account, reset_password, review_game,].spacing(SPACING);

3850

3851

                let review_game_pick = pick_list(

3852

                    archived_games,

3853

                    self.archived_game_selected.clone(),

3854

                    Message::ArchivedGameSelected,

3855

3856

                .placeholder(t!("Archived Games"));

3857

3858

                let review_game_pick = row![review_game_pick].spacing(SPACING);

3859

3860

                let locale = [

3861

                    Locale::English,

3862

                    Locale::Chinese,

3863

                    Locale::Spanish,

3864

                    Locale::Arabic,

3865

                    Locale::Indonesian,

3866

                    Locale::PortugueseBr,

3867

                    Locale::PortuguesePt,

3868

                    Locale::French,

3869

                    Locale::Japanese,

3870

                    Locale::Russian,

3871

                    Locale::German,

3872

                    Locale::Icelandic,

3873

                    Locale::IcelandicRunic,

3874

                    Locale::Swedish,

3875

                    Locale::Korean,

3876

];

3877

3878

                let locale = row![

3879

                    text!("{}: ", t!("locale")).size(20),

3880

                    pick_list(locale, Some(self.locale_selected), Message::LocaleSelected),

3881

];

3882

3883

                let mut buttons_2 = if self.theme == Theme::Light {

3884

                    row![

3885

                        button(text!("{} (7)", self.strings["Dark"].as_str()))

3886

                            .on_press(Message::ChangeTheme(Theme::Dark)),

3887

                        button(text!("{} (8)", self.strings["Light"].as_str())),

3888

                        button(text("Tol (a)")).on_press(Message::ChangeTheme(Theme::Tol)),

3889

3890

                    .spacing(SPACING)

3891

                } else if self.theme == Theme::Dark {

3892

                    row![

3893

                        button(text!("{} (7)", self.strings["Dark"].as_str())),

3894

                        button(text!("{} (8)", self.strings["Light"].as_str()))

3895

                            .on_press(Message::ChangeTheme(Theme::Light)),

3896

                        button(text("Tol (a)")).on_press(Message::ChangeTheme(Theme::Tol)),

3897

3898

                    .spacing(SPACING)

3899

                } else {

3900

                    row![

3901

                        button(text!("{} (7)", self.strings["Dark"].as_str()))

3902

                            .on_press(Message::ChangeTheme(Theme::Dark)),

3903

                        button(text!("{} (8)", self.strings["Light"].as_str()))

3904

                            .on_press(Message::ChangeTheme(Theme::Light)),

3905

                        button(text("Tol (a)")),

3906

3907

                    .spacing(SPACING)

3908

};

3909

3910

                let discord = button(text!("{} (9)", self.strings["Join Discord"].as_str()))

3911

                    .on_press(Message::OpenUrl(

3912

                        "https://discord.gg/h56CAHEBXd".to_string(),

3913

));

3914

3915

                let website = button("https://hnefatafl.org (0)")

3916

                    .on_press(Message::OpenUrl("https://hnefatafl.org".to_string()));

3917

3918

                let quit = button(text!("{} (Esc)", self.strings["Quit"].as_str()))

3919

                    .on_press(Message::Leave);

3920

3921

                buttons_2 = buttons_2.push(discord);

3922

                buttons_2 = buttons_2.push(website);

3923

                buttons_2 = buttons_2.push(quit);

3924

3925

                let help_text = container(text!(

3926

                    "Tab: {}, Shift + Tab: {}",

3927

                    self.chars.arrow_right,

3928

                    self.chars.arrow_left

3929

))

3930

                .padding(PADDING)

3931

                .style(container::bordered_box);

3932

3933

                let help_text_2 = text(t!(

3934

                    "You must hold down the control (Ctrl) or command (⌘) key when pressing a lettered or numbered hotkey."

3935

));

3936

3937

                let help_text_3 = text(t!(

3938

                    "You can play on the board by pressing control (Ctrl) or command (⌘) and a letter then a number or vice versa."

3939

));

3940

3941

                let help_text_4 = text(t!("You have a week to move, then you lose the game."));

3942

3943

                column![

3944

                    username,

3945

                    password,

3946

                    row![

3947

                        show_password,

3948

                        show_password_text,

3949

                        save_password,

3950

                        save_password_text,

3951

                        my_games,

3952

                        my_games_text,

3953

3954

                    .spacing(SPACING),

3955

                    buttons_1,

3956

                    review_game_pick,

3957

                    locale,

3958

                    buttons_2,

3959

                    help_text,

3960

                    help_text_2,

3961

                    help_text_3,

3962

                    help_text_4,

3963

                    error,

3964

                    error_persistent

3965

3966

                .padding(PADDING)

3967

                .spacing(SPACING)

3968

                .into()

3969

3970

            Screen::Tournament => {

3971

                let mut column = Column::new().padding(PADDING).spacing(SPACING);

3972

3973

                if self.admin {

3974

                    let input = iced::widget::text_input("????-??-??", &self.text_input)

3975

                        .on_input(Message::TextChanged)

3976

                        .on_paste(Message::TextChanged)

3977

                        .on_submit(Message::TextSend);

3978

3979

                    let mut delete_button = button("Delete Tournament");

3980

3981

                    if self.tournament.is_some() {

3982

                        delete_button = delete_button.on_press(Message::TournamentDelete);

3983

3984

3985

                    let row = row![input, delete_button].spacing(SPACING);

3986

3987

                    column = column.push(row);

3988

3989

3990

                let Some(tournament) = &self.tournament else {

3991

                    column = column.push(text(t!("There is no tournament.")));

3992

                    column = column.push(

3993

                        button(text!("{} (Esc)", self.strings["Leave"].as_str()))

3994

                            .on_press(Message::Leave),

3995

);

3996

3997

                    return column.into();

3998

};

3999

4000

                let mut date = Row::new().spacing(SPACING);

4001

                let start_date = t!("Tournament Start Date");

4002

                date = date.push(text!("{start_date}: {}", tournament.date.to_rfc2822()));

4003

4004

                let mut button_1 =

4005

                    button(text!("{} (1)", self.strings["Join Tournament"].as_str()));

4006

4007

                let mut button_2 =

4008

                    button(text!("{} (2)", self.strings["Leave Tournament"].as_str()));

4009

4010

                if tournament.players.contains(&self.username) {

4011

                    button_2 = button_2.on_press(Message::TournamentLeave);

4012

                } else {

4013

                    button_1 = button_1.on_press(Message::TournamentJoin);

4014

4015

4016

                let buttons = row![

4017

                    button_1,

4018

                    button_2,

4019

                    button(text!("{} (Esc)", self.strings["Leave"].as_str()))

4020

                        .on_press(Message::Leave),

4021

4022

                .spacing(SPACING);

4023

4024

                let title = t!("Players");

4025

                let dashes = text("-".repeat(title.len())).font(Font::MONOSPACE);

4026

                let title = text(title);

4027

                let title = column![title, dashes];

4028

4029

                let mut players = Column::new();

4030

                let mut player_names: Vec<_> = tournament.players.iter().collect();

4031

                player_names.sort();

4032

4033

                for player in &player_names {

4034

                    players = players.push(text(*player));

4035

4036

4037

                column = column.push(date);

4038

                column = column.push(buttons);

4039

                column = column.push(title);

4040

                column = column.push(players);

4041

4042

                if self.admin {

4043

                    let mut delete_button = button("Delete Tournament Tree");

4044

4045

                    if let Some(tournament) = &self.tournament

4046

                        && tournament.tree.is_some()

4047

4048

                        delete_button = delete_button.on_press(Message::TournamentTreeDelete);

4049

4050

4051

                    let mut start_tournament = button("Start Tournament");

4052

                    if self.tournament.is_none() {

4053

                        start_tournament = start_tournament.on_press(Message::TournamentStart);

4054

4055

4056

                    column = column.push(row![start_tournament, delete_button].spacing(SPACING));

4057

4058

4059

                column = column.push(self.display_tournament());

4060

                scrollable(column).spacing(SPACING).into()

4061

4062

            Screen::Users => row![

4063

                self.users(&LoggedIn::None),

4064

                button(text!("{} (Esc)", self.strings["Leave"].as_str())).on_press(Message::Leave)

4065

4066

            .padding(PADDING)

4067

            .spacing(SPACING)

4068

            .into(),

4069

4070

4071

4072

    fn reset_email(&mut self) {

4073

        self.email = None;

4074

        self.send("email_reset\n");

4075

4076

4077

    fn reset_markers(&mut self) {

4078

        self.captures = HashSet::new();

4079

        self.play_from = None;

4080

        self.play_from_previous = None;

4081

        self.play_to_previous = None;

4082

4083

4084

    fn review_game(&mut self) {

4085

        if let Some(archived_game) = &self.archived_game_selected {

4086

            self.archived_game_handle = Some(ArchivedGameHandle::new(archived_game));

4087

            self.screen = Screen::GameReview;

4088

4089

            self.captures = HashSet::new();

4090

            self.reset_markers();

4091

4092

4093

4094

    fn save_client_postcard(&self) -> anyhow::Result<()> {

4095

        let postcard_bytes = postcard::to_allocvec(&self.archived_games)?;

4096

        if !postcard_bytes.is_empty() {

4097

            let mut file = File::create(data_file(ARCHIVED_GAMES_FILE))?;

4098

            file.write_all(&postcard_bytes)?;

4099

4100

4101

        Ok(())

4102

4103

4104

    fn save_client_ron(&self) -> anyhow::Result<()> {

4105

        let password = if self.password_save {

4106

            self.password.clone()

4107

        } else {

4108

            String::new()

4109

};

4110

4111

        let client = Client {

4112

            archived_games: Vec::new(),

4113

            coordinates: self.coordinates,

4114

            locale_selected: self.locale_selected,

4115

            my_games_only: self.my_games_only,

4116

            password,

4117

            password_save: self.password_save,

4118

            password_show: self.password_show,

4119

            sound_muted: self.sound_muted,

4120

            theme: self.theme,

4121

            username: self.username.clone(),

4122

            ..Client::default()

4123

};

4124

4125

        let ron_string = ron::ser::to_string_pretty(&client, ron::ser::PrettyConfig::new())?;

4126

        if !ron_string.is_empty() {

4127

            let mut file = File::create(data_file(USER_CONFIG_FILE))?;

4128

            file.write_all(ron_string.as_bytes())?;

4129

4130

4131

        Ok(())

4132

4133

4134

    fn send(&mut self, string: &str) {

4135

        if let Err(error) = self

4136

.tx

4137

            .as_mut()

4138

            .unwrap_or_else(|| {

4139

                error!("Error sending {string:?}: you should have a tx available by now");

4140

                unreachable!();

4141

})

4142

            .send(string.to_string())

4143

4144

            error!("{error}: {string}");

4145

            exit(1);

4146

4147

4148

4149

    fn send_estimate_score(&mut self, tree: Tree) {

4150

        handle_error(

4151

            self.estimate_score_tx

4152

                .as_mut()

4153

                .unwrap_or_else(|| {

4154

                    error!("Error sending {tree:?}: you should have a tx available by now");

4155

                    unreachable!();

4156

})

4157

                .send(tree),

4158

);

4159

4160

4161

    fn toggle_save_password(&mut self) {

4162

        self.password_save = !self.password_save;

4163

        handle_error(self.save_client_ron());

4164

4165

4166

    fn toggle_show_password(&mut self) {

4167

        self.password_show = !self.password_show;

4168

        handle_error(self.save_client_ron());

4169

4170

4171

    fn letter(

4172

        &self,

4173

        letter: char,

4174

        column: Column<'a, Message>,

4175

        letter_size: u32,

4176

    ) -> Column<'a, Message> {

4177

        let mut text = text(letter).size(letter_size);

4178

        if self.press_letters.contains(&letter.to_ascii_lowercase()) {

4179

            text = text.style(text::success);

4180

4181

4182

        column.push(text)

4183

4184

4185

    fn numbers(&self, letter_size: u32, spacing: u32, board_size: usize) -> Column<'a, Message> {

4186

        let mut column = column![text(" ").size(letter_size)].spacing(spacing);

4187

4188

        for i in 0..board_size {

4189

            let i = board_size - i;

4190

            let mut text = text!("{i:2}").size(letter_size).align_y(Vertical::Center);

4191

            if self.press_numbers[i - 1] {

4192

                text = text.style(text::success);

4193

4194

            column = column.push(text);

4195

4196

4197

        column

4198

4199