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

// SPDX-License-Identifier: AGPL-3.0-or-later

17

// SPDX-FileCopyrightText: 2025 David Campbell <david@hnefatafl.org>

18

19

// Don't open the terminal on Windows.

20

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

21

#![deny(clippy::unwrap_used)]

22

23

mod archived_game_handle;

24

mod command_line;

25

mod dimensions;

26

mod enums;

27

mod new_game_settings;

28

mod tabs;

29

mod user;

30

mod volume;

31

32

use std::{

33

    collections::{HashMap, HashSet, VecDeque},

34

    fmt::{self, Write as _},

35

    fs::{self, File},

36

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

37

    net::{Shutdown, TcpStream, ToSocketAddrs},

38

    process::exit,

39

    str::{FromStr, SplitAsciiWhitespace},

40

    sync::mpsc,

41

    thread::{self, sleep},

42

    time::Duration,

43

};

44

45

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

46

use clap::{CommandFactory, Parser};

47

use hnefatafl_copenhagen::{

48

    COPYRIGHT, Id, SERVER_PORT, VERSION_ID,

49

    accounts::{Account, Accounts},

50

    board::{Board, BoardSize},

51

    characters::Characters,

52

    draw::Draw,

53

    email::Email,

54

    game::{Game, LegalMoves, TimeUnix},

55

    heat_map::{Heat, HeatMap},

56

    locale::Locale,

57

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

58

    rating::Rated,

59

    role::Role,

60

    server_game::{ArchivedGame, Challenger, ServerGameLight, ServerGamesLight},

61

    space::Space,

62

    status::Status,

63

    tcp_keep_alive,

64

    time::{TimeEnum, TimeSettings},

65

    tournament::Tournament,

66

    tree::Tree,

67

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

68

};

69

#[cfg(target_os = "linux")]

70

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

71

use iced::{

72

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

73

    alignment::{Horizontal, Vertical},

74

    color, event,

75

    futures::{SinkExt, Stream, executor},

76

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

77

    stream,

78

    theme::Palette,

79

    widget::{

80

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

81

        operation::{focus_next, focus_previous},

82

        pick_list, radio, row, scrollable, slider, text, text_editor, tooltip,

83

},

84

    window::{self, icon},

85

};

86

use iced_aw::{

87

    ICED_AW_FONT_BYTES, Tabs, date_picker::Date, helpers::date_picker, number_input,

88

    widget::LabeledFrame,

89

};

90

use image::ImageFormat;

91

use jiff::Timestamp;

92

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

93

use rust_i18n::t;

94

use smol_str::ToSmolStr;

95

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

96

use sys_locale::{get_locale, get_locales};

97

98

use crate::{

99

    archived_game_handle::ArchivedGameHandle,

100

    command_line::Args,

101

    dimensions::Dimensions,

102

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

103

    new_game_settings::NewGameSettings,

104

    tabs::TabId,

105

    user::User,

106

    volume::{MAX_VOLUME, Volume},

107

};

108

109

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

110

/// color blind.

111

///

112

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

113

pub const TOL: Palette = Palette {

114

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

115

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

116

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

117

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

118

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

119

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

120

};

121

122

const ALPHABET: [char; 26] = [

123

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

124

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

125

];

126

127

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

128

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

129

130

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

131

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

132

133

const BOARD_LETTERS_LOWERCASE: [char; 13] = [

134

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

135

];

136

137

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

138

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

139

140

const MAX_RATING: f64 = 100_000.0;

141

const PADDING: u16 = 8;

142

const PADDING_SMALL: u16 = 2;

143

const PADDING_MEDIUM: u16 = 4;

144

const SPACING: Pixels = Pixels(8.0);

145

const SPACING_B: Pixels = Pixels(20.0);

146

147

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

148

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

149

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

150

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

151

152

/// In milliseconds.

153

const TICK: i64 = 100;

154

const TICK_U: u64 = 100;

155

156

rust_i18n::i18n!();

157

158

#[allow(clippy::too_many_lines)]

159

fn init_client() -> Client {

160

    let archived_games_file = data_file(ARCHIVED_GAMES_FILE);

161

    let user_file = data_file(USER_CONFIG_FILE);

162

    let mut error = Vec::new();

163

164

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

165

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

166

            Ok(client) => client,

167

            Err(err) => {

168

                error.push(format!(

169

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

170

                    user_file.display()

171

));

172

                Client::default()

173

174

},

175

        Err(err) => {

176

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

177

                error.push(format!(

178

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

179

                    user_file.display()

180

));

181

                Client::default()

182

            } else {

183

                error.push(format!(

184

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

185

                    user_file.display()

186

));

187

                Client::default()

188

189

190

};

191

192

    client.tournament_date = Date::today();

193

194

    if let Some(locale) = &client.locale_selected {

195

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

196

    } else {

197

        let mut locale_1 = None;

198

199

        if get_locales().count() > 0 {

200

            for locale_2 in get_locales() {

201

                if let Ok(locale) = locale_2.as_str().try_into() {

202

                    locale_1 = Some(locale);

203

                    break;

204

205

206

207

208

        if locale_1.is_none() {

209

            let locale_2 = get_locale().unwrap_or_else(|| String::from("en-US"));

210

211

            if let Ok(locale) = locale_2.as_str().try_into() {

212

                locale_1 = Some(locale);

213

            } else {

214

                locale_1 = Some(Locale::English);

215

216

217

218

        if let Some(locale) = locale_1 {

219

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

220

            client.locale_selected = Some(locale);

221

            client

222

                .save_client_ron()

223

                .expect("saving user file should work");

224

225

226

227

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

228

229

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

230

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

231

            Ok(client) => client,

232

            Err(err) => {

233

                error.push(format!(

234

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

235

                    archived_games_file.display()

236

));

237

                Vec::new()

238

239

},

240

        Err(err) => {

241

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

242

                error.push(format!(

243

                    "{}: {}",

244

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

245

                    archived_games_file.display()

246

));

247

                Vec::new()

248

            } else {

249

                error.push(format!(

250

                    "{} {}: {err}",

251

                    t!("Error opening the file"),

252

                    archived_games_file.display()

253

));

254

                Vec::new()

255

256

257

};

258

259

    client.archived_games = archived_games;

260

    client.error_persistent = error;

261

262

    let args = Args::parse();

263

    if args.ascii {

264

        client.chars.ascii();

265

266

267

    let mut letters = HashMap::new();

268

    for ch in BOARD_LETTERS_LOWERCASE {

269

        letters.insert(ch, false);

270

271

272

    if client.rating_maximum == 0.0 {

273

        client.rating_max();

274

275

    if client.rating_minimum == 0.0 {

276

        client.rating_min();

277

278

    client.games_filtered();

279

280

    client

281

282

283

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

284

    let args = Args::parse();

285

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

286

287

    if args.man {

288

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

289

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

290

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

291

292

        man.render(&mut buffer)?;

293

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

294

295

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

296

        return Ok(());

297

298

299

    create_data_folder()?;

300

301

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

302

        .title("Hnefatafl Copenhagen")

303

        .subscription(Client::subscriptions)

304

        .window(window::Settings {

305

            #[cfg(target_os = "linux")]

306

            platform_specific: PlatformSpecific {

307

                application_id: APPLICATION_ID.to_string(),

308

                ..PlatformSpecific::default()

309

},

310

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

311

            ..window::Settings::default()

312

})

313

        .font(ICED_AW_FONT_BYTES)

314

        .theme(Client::theme);

315

316

    // For screenshots.

317

    if args.tiny_window {

318

        application = application.window_size(iced::Size {

319

            width: 868.0,

320

            height: 541.0,

321

});

322

323

324

    if args.social_preview {

325

        application = application.window_size(iced::Size {

326

            width: 1148.0,

327

            height: 481.0,

328

});

329

330

331

    application.run()?;

332

    Ok(())

333

334

335

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

336

    let args = Args::parse();

337

338

    stream::channel(

339

        100,

340

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

341

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

342

343

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

344

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

345

                exit(1);

346

347

348

            thread::spawn(move || {

349

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

350

                    Ok(ai) => ai,

351

                    Err(error) => {

352

                        error!("{error}");

353

                        exit(1);

354

355

};

356

357

                for tree in &rx {

358

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

359

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

360

361

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

362

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

363

) {

364

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

365

                        exit(1);

366

367

368

});

369

},

370

371

372

373

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

374

    match result {

375

        Ok(value) => value,

376

        Err(error) => {

377

            error!("{error}");

378

            exit(1)

379

380

381

382

383

fn open_url(url: &str) {

384

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

385

        error!("{error}");

386

387

388

389

#[allow(clippy::too_many_lines)]

390

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

391

    stream::channel(

392

        100,

393

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

394

            let mut args = Args::parse();

395

            args.host.push_str(SERVER_PORT);

396

            let address_string = args.host;

397

398

            thread::spawn(move || {

399

                'start_over: loop {

400

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

401

402

                    if let Err(error) =

403

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

404

405

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

406

                        exit(1);

407

408

409

                    loop {

410

                        let message = match rx.recv() {

411

                            Ok(message) => message,

412

                            Err(error) => {

413

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

414

415

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

416

                                    error!("{error}");

417

418

419

                                return;

420

421

};

422

                        let message_trim = message.trim();

423

424

                        if message_trim == "tcp_connect" {

425

                            break;

426

427

428

429

                    let mut is_ipv6 = false;

430

                    let mut socket_address = None;

431

                    let socket_addresses = match address_string.to_socket_addrs() {

432

                        Ok(socket_addresses) => socket_addresses,

433

                        Err(error) => {

434

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

435

436

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

437

                            handle_error(executor::block_on(

438

                                sender.send(Message::TcpConnectFailed),

439

));

440

441

                            continue 'start_over;

442

443

};

444

445

                    for address in socket_addresses.clone() {

446

                        if address.is_ipv6() {

447

                            socket_address = Some(address);

448

                            is_ipv6 = true;

449

                            break;

450

451

452

453

                    if !is_ipv6 {

454

                        for address in socket_addresses {

455

                            if address.is_ipv4() {

456

                                socket_address = Some(address);

457

                                break;

458

459

460

461

462

                    let Some(socket_address) = socket_address else {

463

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

464

465

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

466

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

467

468

                        continue 'start_over;

469

};

470

471

                    let address: SockAddr = socket_address.into();

472

                    let keep_alive = tcp_keep_alive();

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(&keep_alive));

476

477

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

478

                        if error.kind() == ErrorKind::NetworkUnreachable {

479

                            handle_error(executor::block_on(

480

                                sender.send(Message::TcpConnectFailed),

481

));

482

                        } else {

483

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

484

485

486

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

487

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

488

489

                        continue 'start_over;

490

491

492

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

493

494

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

495

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

496

497

                    let mut sender_clone = sender.clone();

498

                    thread::spawn(move || {

499

                        for message in rx {

500

                            let message_trim = message.trim();

501

502

                            if message_trim == "ping" {

503

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

504

                            } else {

505

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

506

507

508

                            if message_trim == "quit" {

509

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

510

                                    tcp_stream

511

                                        .shutdown(Shutdown::Both)

512

                                        .expect("shutdown call failed");

513

514

515

                                return;

516

517

518

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

519

520

521

                        for _ in 0..2 {

522

                            if let Err(error) =

523

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

524

525

                                error!("{error}");

526

527

528

529

                        if let Err(error) =

530

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

531

532

                            error!("{error}");

533

534

});

535

536

                    let mut buffer = String::new();

537

                    handle_error(executor::block_on(

538

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

539

));

540

541

                    if cfg!(target_os = "redox") {

542

                        sleep(Duration::from_secs(1));

543

544

545

                    loop {

546

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

547

                        if bytes > 0 {

548

                            let buffer_trim = buffer.trim();

549

                            let buffer_trim_vec: Vec<_> =

550

                                buffer_trim.split_ascii_whitespace().collect();

551

552

                            if buffer_trim_vec[1] == "display_users"

553

                                || buffer_trim_vec[1] == "display_games"

554

                                || buffer_trim_vec[1] == "ping"

555

556

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

557

                            } else {

558

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

559

560

561

                            handle_error(executor::block_on(

562

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

563

));

564

565

                            if buffer_trim_vec[1] == "archived_games" {

566

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

567

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

568

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

569

                                let archived_games: Vec<ArchivedGame> =

570

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

571

572

                                handle_error(executor::block_on(

573

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

574

));

575

576

577

                            buffer.clear();

578

                        } else {

579

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

580

                            continue 'start_over;

581

582

583

584

});

585

},

586

587

588

589

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

590

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

591

    text.join(" ")

592

593

594

#[allow(clippy::struct_excessive_bools)]

595

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

596

struct Client {

597

    #[serde(skip)]

598

    accounts: Accounts,

599

    #[serde(skip)]

600

    active_tab: TabId,

601

    #[serde(skip)]

602

    admin: bool,

603

    #[serde(skip)]

604

    admin_tournament: bool,

605

    #[serde(skip)]

606

    attacker: String,

607

    #[serde(default)]

608

    archived_games: Vec<ArchivedGame>,

609

    #[serde(skip)]

610

    archived_games_filtered: Option<Vec<ArchivedGame>>,

611

    #[serde(skip)]

612

    archived_game_selected: Option<ArchivedGame>,

613

    #[serde(skip)]

614

    archived_game_handle: Option<ArchivedGameHandle>,

615

    #[serde(default)]

616

    coordinates: Coordinates,

617

    #[serde(skip)]

618

    defender: String,

619

    #[serde(skip)]

620

    delete_account: bool,

621

    #[serde(skip)]

622

    estimate_score: bool,

623

    #[serde(skip)]

624

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

625

    #[serde(skip)]

626

    captures: HashSet<Vertex>,

627

    #[serde(skip)]

628

    counter: u64,

629

    #[serde(skip)]

630

    chars: Characters,

631

    #[serde(skip)]

632

    challenger: bool,

633

    #[serde(skip)]

634

    connected_tcp: bool,

635

    #[serde(skip)]

636

    connected_to: String,

637

    #[serde(skip)]

638

    content: text_editor::Content,

639

    #[serde(skip)]

640

    email: Option<Email>,

641

    #[serde(skip)]

642

    email_input: String,

643

    #[serde(skip)]

644

    emails_bcc: Vec<String>,

645

    #[serde(skip)]

646

    error: Option<String>,

647

    #[serde(skip)]

648

    error_email: Option<String>,

649

    #[serde(skip)]

650

    error_persistent: Vec<String>,

651

    #[serde(skip)]

652

    game: Option<Game>,

653

    #[serde(skip)]

654

    game_id: Id,

655

    #[serde(skip)]

656

    games_light: ServerGamesLight,

657

    #[serde(skip)]

658

    games_light_vec: Vec<ServerGameLight>,

659

    #[serde(skip)]

660

    game_settings: NewGameSettings,

661

    #[serde(skip)]

662

    heat_map: Option<HeatMap>,

663

    #[serde(skip)]

664

    heat_map_display: bool,

665

    #[serde(default)]

666

    locale_selected: Option<Locale>,

667

    #[serde(default)]

668

    my_games_only: bool,

669

    #[serde(skip)]

670

    my_turn: bool,

671

    #[serde(skip)]

672

    now: i64,

673

    #[serde(skip)]

674

    now_diff: i64,

675

    #[serde(default)]

676

    password: String,

677

    #[serde(skip)]

678

    password_ends_with_whitespace: bool,

679

    #[serde(default)]

680

    password_save: bool,

681

    #[serde(default)]

682

    password_show: bool,

683

    #[serde(skip)]

684

    play_from: Option<Vertex>,

685

    #[serde(skip)]

686

    play_from_previous: Option<Vertex>,

687

    #[serde(skip)]

688

    play_to_previous: Option<Vertex>,

689

    #[serde(skip)]

690

    press_letters: HashSet<char>,

691

    #[serde(skip)]

692

    press_numbers: [bool; 13],

693

    #[serde(default)]

694

    rating_minimum: f64,

695

    #[serde(default)]

696

    rating_maximum: f64,

697

    #[serde(skip)]

698

    request_draw: bool,

699

    #[serde(skip)]

700

    screen: Screen,

701

    #[serde(skip)]

702

    screen_size: Size,

703

    #[serde(default)]

704

    sound_muted: bool,

705

    #[serde(skip)]

706

    spectators: Vec<String>,

707

    #[serde(skip)]

708

    status: Status,

709

    #[serde(skip)]

710

    texts: VecDeque<String>,

711

    #[serde(skip)]

712

    texts_game: VecDeque<String>,

713

    #[serde(skip)]

714

    text_input: String,

715

    #[serde(default)]

716

    theme: Theme,

717

    #[serde(skip)]

718

    time_attacker: TimeSettings,

719

    #[serde(skip)]

720

    time_defender: TimeSettings,

721

    #[serde(skip)]

722

    tournament: Option<Tournament>,

723

    #[serde(skip)]

724

    tournament_date: Date,

725

    #[serde(skip)]

726

    tournament_date_show_picker: bool,

727

    #[serde(skip)]

728

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

729

    #[serde(default)]

730

    username: String,

731

    #[serde(skip)]

732

    users: HashMap<String, User>,

733

    #[serde(skip)]

734

    users_sort_by: SortBy,

735

    #[serde(default)]

736

    volume: Volume,

737

738

739

impl<'a> Client {

740

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

741

        let mut columns = column![

742

            text!(

743

                "{} {} {} TCP",

744

                t!("connected to"),

745

                &self.connected_to,

746

                t!("via")

747

),

748

            text!("{}: {}", t!("username"), &self.username),

749

750

        .padding(PADDING)

751

        .spacing(SPACING);

752

753

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

754

            let mut row = Row::new();

755

            if email.verified {

756

                row = row.push(text!(

757

                    "{} [{}]: {} ",

758

                    t!("email address"),

759

                    t!("verified"),

760

                    email.address,

761

));

762

                columns = columns.push(row);

763

            } else {

764

                row = row.push(text!(

765

                    "{} [{}]: {} ",

766

                    t!("email address"),

767

                    t!("unverified"),

768

                    email.address,

769

));

770

                columns = columns.push(row);

771

772

                let mut row = Row::new();

773

                row = row.push(text!("{}: ", t!("email code")));

774

                row = row.push(

775

                    widget::text_input("", &self.email_input)

776

                        .on_input(Message::EmailChanged)

777

                        .on_paste(Message::EmailChanged)

778

                        .on_submit(Message::TextSendEmailCode),

779

);

780

                columns = columns.push(row);

781

782

        } else {

783

            let mut row = Row::new();

784

            row = row.push(text!("{}: ", t!("email address")));

785

            row = row.push(

786

                widget::text_input("", &self.email_input)

787

                    .on_input(Message::EmailChanged)

788

                    .on_paste(Message::EmailChanged)

789

                    .on_submit(Message::TextSendEmail),

790

);

791

792

            columns = columns.push(row);

793

            columns = columns.push(row![text!("{}: ", t!("email code"))]);

794

795

796

        columns = columns.push(row![

797

            button(text!("{} (6)", t!("Reset Email"))).on_press(Message::EmailReset)

798

]);

799

800

        if let Some(error) = &self.error_email {

801

            columns = columns.push(row![text!("error: {error}").style(text::danger)]);

802

803

804

        let mut change_password_button = button(text!("{} (7)", t!("Change Password")));

805

806

        if !self.password_ends_with_whitespace {

807

            change_password_button = change_password_button.on_press(Message::TextSend);

808

809

810

        columns = columns.push(

811

            row![

812

                change_password_button,

813

                widget::text_input("", &self.password)

814

                    .secure(!self.password_show)

815

                    .on_input(Message::PasswordChanged)

816

                    .on_paste(Message::PasswordChanged),

817

818

            .spacing(SPACING),

819

);

820

821

        columns = columns.push(

822

            row![

823

                checkbox(self.password_show).on_toggle(Message::PasswordShow),

824

                text!("{} (8)", t!("show password")),

825

826

            .spacing(SPACING),

827

);

828

829

        if self.delete_account {

830

            columns = columns.push(

831

                button(text!("{} (9)", t!("REALLY DELETE ACCOUNT")))

832

                    .on_press(Message::DeleteAccount),

833

);

834

        } else {

835

            columns = columns.push(

836

                button(text!("{} (9)", t!("Delete Account"))).on_press(Message::DeleteAccount),

837

);

838

839

840

        columns = columns.push(button(text!("{} (Esc)", t!("Quit"))).on_press(Message::Leave));

841

842

        columns

843

844

845

    fn archived_game_reset(&mut self) {

846

        self.archived_game_handle = None;

847

        self.archived_game_selected = None;

848

849

850

    #[must_use]

851

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

852

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

853

        let board_size = board.size();

854

        let board_size_usize: usize = board_size.into();

855

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

856

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

857

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

858

        let possible_moves = self.possible_moves();

859

860

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

861

        if coordinates {

862

            game_display =

863

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

864

865

866

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

867

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

868

869

            if coordinates {

870

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

871

872

873

            for y in 0..board_size_usize {

874

                let vertex = Vertex {

875

                    size: board.size(),

876

x,

877

y,

878

};

879

880

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

881

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

882

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

883

                    Space::Empty => {

884

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

885

                            text(arrow)

886

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

887

                            text(&self.chars.captured)

888

                        } else if vertex.on_restricted_square() {

889

                            text(&self.chars.restricted_square)

890

                        } else {

891

                            text(" ")

892

893

894

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

895

};

896

897

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

898

                    && possible_moves.is_some()

899

900

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

901

                        let space = board.get(vertex_from);

902

                        let turn = Role::from(space);

903

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

904

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

905

906

                            if heat == Heat::UnRanked {

907

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

908

                            } else {

909

                                let txt_char = match space {

910

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

911

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

912

                                    Space::Empty => "",

913

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

914

};

915

916

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

917

                                    0.0,

918

                                    0.0,

919

                                    0.0,

920

                                    heat.into(),

921

));

922

923

924

                    } else {

925

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

926

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

927

928

929

930

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

931

                let mut button = button(txt)

932

                    .width(d.board_dimension)

933

                    .height(d.board_dimension);

934

935

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

936

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

937

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

938

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

939

                    Move::None => {}

940

941

942

                column = column.push(button);

943

944

945

            if coordinates {

946

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

947

948

949

            game_display = game_display.push(column);

950

951

952

        if coordinates {

953

            game_display =

954

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

955

956

957

        game_display

958

959

960

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

961

        if let Some(legal_moves) = possible_moves {

962

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

963

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

964

                    if vertex == vertex_from {

965

                        Move::Revert

966

                    } else if vertexes.contains(vertex) {

967

                        Move::To

968

                    } else {

969

                        Move::None

970

971

                } else {

972

                    Move::None

973

974

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

975

                Move::From

976

            } else {

977

                Move::None

978

979

        } else {

980

            Move::None

981

982

983

984

    #[allow(clippy::type_complexity)]

985

    fn board_and_heatmap(

986

        &self,

987

    ) -> (

988

        Board,

989

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

990

) {

991

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

992

            let node = game_handle.boards.here();

993

994

            if self.heat_map_display

995

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

996

997

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

998

            } else {

999

                (node.board.clone(), None)

1000

1001

        } else {

1002

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

1003

1004

            (game.board.clone(), None)

1005

1006

1007

1008

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

1009

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

1010

            if game.challenge_accepted {

1011

                return State::Spectator;

1012

1013

1014

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

1015

                if let Some(attacker) = &game.attacker

1016

                    && &self.username == attacker

1017

1018

                    return State::CreatorOnly;

1019

1020

1021

                if let Some(defender) = &game.defender

1022

                    && &self.username == defender

1023

1024

                    return State::CreatorOnly;

1025

1026

1027

1028

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

1029

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

1030

1031

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

1032

                    if &self.username != challenger {

1033

                        return State::Creator;

1034

1035

                } else {

1036

                    return State::Challenger;

1037

1038

1039

1040

1041

        State::Spectator

1042

1043

1044

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

1045

        for l in BOARD_LETTERS_LOWERCASE {

1046

            if l != letter {

1047

                self.press_letters.remove(&l);

1048

1049

1050

1051

1052

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

1053

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

1054

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

1055

1056

        for i in 0..board_size {

1057

            let i = board_size - i;

1058

            if i != number {

1059

                self.press_numbers[i - 1] = false;

1060

1061

1062

1063

1064

    fn create_account(&mut self) {

1065

        if !self.connected_tcp {

1066

            self.send("tcp_connect\n");

1067

            self.connected_tcp = true;

1068

1069

1070

        if self.screen == Screen::Login {

1071

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

1072

                let username = self.text_input.clone();

1073

                self.send(&format!(

1074

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

1075

                    self.password,

1076

));

1077

                self.username = username;

1078

1079

            self.text_input.clear();

1080

            self.archived_game_reset();

1081

            handle_error(self.save_client_ron());

1082

1083

1084

1085

    fn delete_account(&mut self) {

1086

        if self.delete_account {

1087

            self.send("delete_account\n");

1088

            self.leave();

1089

            self.delete_account = false;

1090

        } else {

1091

            self.delete_account = true;

1092

1093

1094

1095

    #[allow(clippy::too_many_lines)]

1096

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

1097

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

1098

            return Column::new();

1099

};

1100

1101

        let tournament_string = t!("Tournament");

1102

        let row_1 = text(tournament_string.to_string());

1103

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

1104

        let column_1 = column![row_1, row_2];

1105

1106

        let players_len = tournament.players.len();

1107

1108

        if players_len == 0 {

1109

            return Column::new();

1110

1111

1112

        let mut column_rounds = Column::new();

1113

1114

        if let Some(round) = &tournament.groups {

1115

            let mut column_round = Column::new();

1116

1117

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

1118

                let round_title = if tournament.tournament_games.is_empty() && i + 1 == round.len()

1119

1120

                    let winner = t!("Winner");

1121

                    let row_1 = text(winner.to_string());

1122

                    let row_2 = text!("{}", "-".repeat(winner.len())).font(Font::MONOSPACE);

1123

1124

                    column![row_1, row_2]

1125

                } else {

1126

                    let round = t!("Round");

1127

                    let row_1 = text!("{} {}", round.to_string(), i + 1);

1128

                    let row_2 = text!(

1129

                        "{}-{}",

1130

                        "-".repeat(round.len()),

1131

                        "-".repeat((i + 1).to_string().len())

1132

1133

                    .font(Font::MONOSPACE);

1134

1135

                    column![row_1, row_2]

1136

};

1137

1138

                column_round = column_round.push(round_title);

1139

1140

                let mut column_groups = Column::new();

1141

1142

                for (j, players) in group.iter().enumerate() {

1143

                    if let Ok(players) = players.lock() {

1144

                        if players.records.iter().last().is_none() {

1145

                            continue;

1146

1147

1148

                        let mut games_count = 0;

1149

                        let mut column_group = Column::new();

1150

1151

                        if j > 0 {

1152

                            column_group = column_group.push(text("---").font(Font::MONOSPACE));

1153

1154

1155

                        let mut column_group_vec = Vec::new();

1156

1157

                        for (player, record) in &players.records {

1158

                            games_count += record.games_count();

1159

1160

                            if tournament.tournament_games.is_empty() && i + 1 == round.len() {

1161

                                column_group_vec.push(

1162

                                    text!("{:16} {:10}", player, record.rating.to_string_rounded())

1163

                                        .font(Font::MONOSPACE),

1164

);

1165

                            } else {

1166

                                column_group_vec.push(

1167

                                    text!(

1168

                                        "{:16} {:10} {}: {}, {}: {}, {}: {}",

1169

                                        player,

1170

                                        record.rating.to_string_rounded(),

1171

                                        t!("wins"),

1172

                                        record.wins,

1173

                                        t!("losses"),

1174

                                        record.losses,

1175

                                        t!("draws"),

1176

                                        record.draws,

1177

1178

                                    .font(Font::MONOSPACE),

1179

);

1180

1181

1182

1183

                        // If round finished:

1184

                        if games_count / 2 == players.total_games {

1185

                            column_group_vec.clear();

1186

1187

                            let mut records: Vec<_> = players

1188

                                .records

1189

                                .iter()

1190

                                .map(|(name, record)| (name, record.clone()))

1191

                                .collect();

1192

1193

                            records.sort_by(|(_, record_1), (_, record_2)| {

1194

                                record_2.draws.cmp(&record_1.draws)

1195

});

1196

                            records.sort_by(|(_, record_1), (_, record_2)| {

1197

                                record_2.wins.cmp(&record_1.wins)

1198

});

1199

1200

                            if let Some((_, record_1)) = records.first() {

1201

                                column_group_vec.clear();

1202

                                for (name_2, record_2) in &records {

1203

                                    if record_1.wins == record_2.wins

1204

                                        && record_1.losses == record_2.losses

1205

                                        && record_1.draws == record_2.draws

1206

1207

                                        column_group_vec.push(

1208

                                            text!(

1209

                                                "{:16} {:10} {}: {}, {}: {}, {}: {}",

1210

                                                name_2,

1211

                                                record_2.rating.to_string_rounded(),

1212

                                                t!("wins"),

1213

                                                record_2.wins,

1214

                                                t!("losses"),

1215

                                                record_2.losses,

1216

                                                t!("draws"),

1217

                                                record_2.draws,

1218

1219

                                            .font(Font::MONOSPACE)

1220

                                            .style(text::success),

1221

);

1222

                                    } else {

1223

                                        column_group_vec.push(

1224

                                            text!(

1225

                                                "{:16} {:10} {}: {}, {}: {}, {}: {}",

1226

                                                name_2,

1227

                                                record_2.rating.to_string_rounded(),

1228

                                                t!("wins"),

1229

                                                record_2.wins,

1230

                                                t!("losses"),

1231

                                                record_2.losses,

1232

                                                t!("draws"),

1233

                                                record_2.draws,

1234

1235

                                            .font(Font::MONOSPACE)

1236

                                            .style(text::danger),

1237

);

1238

1239

1240

1241

1242

1243

                        for player in column_group_vec {

1244

                            column_group = column_group.push(player);

1245

1246

1247

                        column_groups = column_groups.push(column_group);

1248

1249

1250

                column_round = column_round.push(column_groups);

1251

1252

            column_rounds = column_rounds.push(column_round.spacing(SPACING));

1253

1254

1255

        column![column_1, column_rounds.spacing(SPACING)].spacing(SPACING)

1256

1257

1258

    fn draw(&mut self) {

1259

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

1260

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

1261

1262

1263

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

1264

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

1265

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

1266

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

1267

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

1268

                let mut arrow = " ";

1269

1270

                if y_diff < 0 {

1271

                    arrow = &self.chars.arrow_down;

1272

                } else if y_diff > 0 {

1273

                    arrow = &self.chars.arrow_up;

1274

                } else if x_diff < 0 {

1275

                    arrow = &self.chars.arrow_right;

1276

                } else if x_diff > 0 {

1277

                    arrow = &self.chars.arrow_left;

1278

1279

1280

                Some(arrow)

1281

            } else {

1282

                None

1283

1284

        } else {

1285

            None

1286

1287

1288

1289

    fn estimate_score(&mut self) {

1290

        if !self.estimate_score {

1291

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

1292

1293

            let handle = self

1294

                .archived_game_handle

1295

                .as_ref()

1296

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

1297

1298

            self.estimate_score = true;

1299

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

1300

1301

1302

1303

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

1304

        let attacker = radio(

1305

            format!("{} (7)", t!("attacker")),

1306

            Role::Attacker,

1307

            self.game_settings.role_selected,

1308

            Message::RoleSelected,

1309

);

1310

1311

        let defender = radio(

1312

            format!("{} (8)", t!("defender")),

1313

            Role::Defender,

1314

            self.game_settings.role_selected,

1315

            Message::RoleSelected,

1316

);

1317

1318

        let rated = LabeledFrame::new(

1319

            text(t!("rated")),

1320

            row![

1321

                text!("(6)"),

1322

                checkbox(self.game_settings.rated.into()).on_toggle(Message::RatedSelected)

1323

1324

            .padding(PADDING)

1325

            .spacing(SPACING),

1326

);

1327

1328

        let mut new_game = button(text!("{} (Enter)", t!("New Game")));

1329

        if self.game_settings.role_selected.is_some() && self.game_settings.time.is_some() {

1330

            new_game = new_game.on_press(Message::GameSubmit);

1331

1332

1333

        let leave = button(text!("{} (Esc)", t!("Quit"))).on_press(Message::Leave);

1334

1335

        let size_11x11 = radio(

1336

            "11x11 (9)",

1337

            BoardSize::_11,

1338

            Some(self.game_settings.board_size),

1339

            Message::BoardSizeSelected,

1340

);

1341

1342

        let size_13x13 = radio(

1343

            "13x13 (0)",

1344

            BoardSize::_13,

1345

            Some(self.game_settings.board_size),

1346

            Message::BoardSizeSelected,

1347

);

1348

1349

        let row_role = LabeledFrame::new(

1350

            text(t!("role")),

1351

            row![attacker, defender].padding(PADDING).spacing(SPACING),

1352

);

1353

1354

        let row_board_size = LabeledFrame::new(

1355

            text(t!("board size")),

1356

            row![size_11x11, size_13x13]

1357

                .padding(PADDING)

1358

                .spacing(SPACING),

1359

);

1360

1361

        let rapid = radio(

1362

            format!("{} (a)", TimeEnum::Rapid),

1363

            TimeEnum::Rapid,

1364

            self.game_settings.time,

1365

            Message::Time,

1366

);

1367

1368

        let classical = radio(

1369

            format!("{} (b)", TimeEnum::Classical),

1370

            TimeEnum::Classical,

1371

            self.game_settings.time,

1372

            Message::Time,

1373

);

1374

1375

        let long = radio(

1376

            format!("{} (c)", TimeEnum::Long),

1377

            TimeEnum::Long,

1378

            self.game_settings.time,

1379

            Message::Time,

1380

);

1381

1382

        let very_long = radio(

1383

            format!("{} (d)", TimeEnum::VeryLong),

1384

            TimeEnum::VeryLong,

1385

            self.game_settings.time,

1386

            Message::Time,

1387

);

1388

1389

        let infinity = radio(

1390

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

1391

            TimeEnum::Infinity,

1392

            self.game_settings.time,

1393

            Message::Time,

1394

);

1395

1396

        let row_1 = row![rapid, classical].spacing(SPACING);

1397

        let row_2 = row![long, very_long].spacing(SPACING);

1398

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

1399

1400

        let row_time = LabeledFrame::new(

1401

            text(t!("time")),

1402

            column![row_1, row_2, row_3].padding(PADDING).spacing(3),

1403

);

1404

1405

        let leave = row![new_game, leave].padding(PADDING).spacing(SPACING);

1406

1407

        column![rated, row_role, row_board_size, row_time, leave]

1408

1409

1410

    fn games_filtered(&mut self) {

1411

        let filtered_games = self.archived_games.iter().filter(|game| {

1412

            let max_rating = f64::max(game.attacker_rating.rating, game.defender_rating.rating);

1413

            let min_rating = f64::min(game.attacker_rating.rating, game.defender_rating.rating);

1414

1415

            min_rating >= self.rating_minimum && max_rating <= self.rating_maximum

1416

});

1417

1418

        if self.my_games_only {

1419

            self.archived_games_filtered = Some(

1420

                filtered_games

1421

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

1422

                    .cloned()

1423

                    .collect(),

1424

);

1425

        } else {

1426

            self.archived_games_filtered = Some(filtered_games.cloned().collect());

1427

1428

1429

1430

    fn game_submit(&mut self) {

1431

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

1432

            error!("No role selected.");

1433

            unreachable!();

1434

};

1435

1436

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

1437

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

1438

            unreachable!();

1439

};

1440

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

1441

1442

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

1443

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

1444

        self.send(&format!(

1445

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

1446

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

1447

));

1448

1449

        self.screen = Screen::Games;

1450

1451

1452

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

1453

        self.clear_letters_except(letter);

1454

        self.press_letters.insert(letter);

1455

1456

1457

    fn press_letter_and_number(&mut self) {

1458

        let mut number = None;

1459

        let mut letter = None;

1460

1461

        for i in 0..13 {

1462

            if self.press_numbers[i] {

1463

                number = Some(i);

1464

                break;

1465

1466

1467

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

1468

            if self.press_letters.contains(l) {

1469

                letter = Some(i);

1470

                break;

1471

1472

1473

1474

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

1475

            Some(game.board.size())

1476

        } else {

1477

            self.archived_game_handle

1478

                .as_ref()

1479

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

1480

};

1481

1482

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

1483

            let board_usize: usize = size.into();

1484

            let vertex = Vertex {

1485

                size,

1486

                x: letter,

1487

                y: board_usize - number - 1,

1488

};

1489

            let possible_moves = self.possible_moves();

1490

1491

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

1492

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

1493

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

1494

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

1495

                Move::None => {}

1496

1497

1498

            for i in 0..13 {

1499

                self.press_numbers[i] = false;

1500

1501

            self.press_letters.clear();

1502

1503

1504

1505

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

1506

        if let Some(game) = self.games_light_vec.get(i) {

1507

            match self.join_game(game) {

1508

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

1509

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

1510

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

1511

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

1512

                    State::Creator => {

1513

                        if shift {

1514

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

1515

                        } else {

1516

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

1517

1518

1519

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

1520

},

1521

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

1522

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

1523

1524

1525

1526

1527

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

1528

        if game.challenge_accepted {

1529

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

1530

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

1531

1532

                JoinGame::Resume

1533

            } else if game.challenge_accepted {

1534

                JoinGame::Watch

1535

            } else {

1536

                JoinGame::None

1537

1538

        } else if game.attacker.is_some()

1539

            && game.defender.is_some()

1540

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

1541

1542

            JoinGame::Cancel

1543

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

1544

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

1545

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

1546

1547

            JoinGame::Join

1548

        } else {

1549

            JoinGame::None

1550

1551

1552

1553

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

1554

        self.game_id = id;

1555

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

1556

1557

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

1558

1559

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

1560

            Some(Role::Defender)

1561

        } else {

1562

            Some(Role::Attacker)

1563

};

1564

1565

1566

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

1567

        self.game_id = id;

1568

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

1569

1570

1571

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

1572

        self.game_id = id;

1573

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

1574

1575

1576

    fn login(&mut self) {

1577

        if !self.connected_tcp {

1578

            self.send("tcp_connect\n");

1579

            self.connected_tcp = true;

1580

1581

1582

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

1583

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

1584

1585

            self.send(&format!(

1586

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

1587

                self.password

1588

));

1589

            self.username = username;

1590

        } else {

1591

            let username = self.text_input.clone();

1592

1593

            self.send(&format!(

1594

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

1595

                self.password

1596

));

1597

            self.username = username;

1598

1599

1600

        self.texts.clear();

1601

        self.text_input.clear();

1602

        self.archived_game_reset();

1603

        handle_error(self.save_client_ron());

1604

1605

1606

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

1607

        let from = self

1608

            .play_from

1609

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

1610

1611

        let mut turn = Role::Roleless;

1612

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

1613

            turn = game.turn;

1614

1615

1616

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

1617

1618

        if self.archived_game_handle.is_none() {

1619

            self.send(&format!(

1620

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

1621

                self.game_id, turn

1622

));

1623

1624

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

1625

            if game.status == Status::Ongoing {

1626

                match game.turn {

1627

                    Role::Attacker => {

1628

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

1629

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

1630

1631

1632

                    Role::Roleless => {}

1633

                    Role::Defender => {

1634

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

1635

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

1636

1637

1638

1639

1640

1641

            self.my_turn = false;

1642

1643

1644

        self.play_from_previous = self.play_from;

1645

        self.play_to_previous = Some(to);

1646

        self.play_from = None;

1647

1648

1649

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

1650

        let mut possible_moves = None;

1651

1652

        if self.my_turn {

1653

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

1654

                possible_moves = Some(game.all_legal_moves());

1655

1656

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

1657

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

1658

            possible_moves = Some(game.all_legal_moves());

1659

1660

1661

        possible_moves

1662

1663

1664

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

1665

        self.theme = theme;

1666

        handle_error(self.save_client_ron());

1667

1668

1669

    fn coordinates(&mut self) {

1670

        self.coordinates = !self.coordinates;

1671

        handle_error(self.save_client_ron());

1672

1673

1674

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

1675

    #[allow(clippy::too_many_lines)]

1676

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

1677

        let mut attacker_rating = String::new();

1678

        let mut defender_rating = String::new();

1679

1680

        let (

1681

            game_id,

1682

            attacker_string,

1683

            attacker_time,

1684

            defender_string,

1685

            defender_time,

1686

            board,

1687

            play,

1688

            status,

1689

            texts,

1690

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

1691

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

1692

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

1693

1694

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

1695

                &game_handle.game.status

1696

            } else {

1697

                &Status::Ongoing

1698

};

1699

1700

1701

                &game_handle.game.id,

1702

                &game_handle.game.attacker,

1703

                game_handle

1704

                    .game

1705

                    .plays

1706

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

1707

                &game_handle.game.defender,

1708

                game_handle

1709

                    .game

1710

                    .plays

1711

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

1712

                &game_handle.boards.here().board,

1713

                game_handle.play,

1714

                status,

1715

                &game_handle.game.texts,

1716

1717

        } else {

1718

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

1719

                attacker_rating = user.rating.to_string_rounded();

1720

1721

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

1722

                defender_rating = user.rating.to_string_rounded();

1723

1724

1725

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

1726

1727

1728

                &self.game_id,

1729

                &self.attacker,

1730

                self.time_attacker.time_left(),

1731

                &self.defender,

1732

                self.time_defender.time_left(),

1733

                &game.board,

1734

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

1735

                &self.status,

1736

                &self.texts_game,

1737

1738

};

1739

1740

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

1741

            attacker_rating = user.rating.to_string_rounded();

1742

1743

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

1744

            defender_rating = user.rating.to_string_rounded();

1745

1746

1747

        let captured = board.captured();

1748

1749

        let mut row_1 = row![

1750

            text(attacker_string),

1751

            text(attacker_rating).center(),

1752

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

1753

];

1754

1755

        if !self.spectators.contains(attacker_string) {

1756

            row_1 = row_1.push(text(&self.chars.warning).style(text::danger));

1757

1758

1759

        let attacker = container(

1760

            column![

1761

                row_1.spacing(SPACING),

1762

                row![

1763

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

1764

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

1765

1766

                .spacing(SPACING),

1767

1768

            .spacing(SPACING),

1769

1770

        .padding(PADDING)

1771

        .style(container::bordered_box);

1772

1773

        let mut row_2 = row![

1774

            text(defender_string),

1775

            text(defender_rating).center(),

1776

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

1777

];

1778

1779

        if !self.spectators.contains(defender_string) {

1780

            row_2 = row_2.push(text(&self.chars.warning).style(text::danger));

1781

1782

1783

        let defender = container(

1784

            column![

1785

                row_2.spacing(SPACING),

1786

                row![

1787

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

1788

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

1789

1790

                .spacing(SPACING),

1791

1792

            .spacing(SPACING),

1793

1794

        .padding(PADDING)

1795

        .style(container::bordered_box);

1796

1797

        let mut watching = false;

1798

1799

        let sub_second = self.now_diff % 1_000;

1800

        let seconds = self.now_diff / 1_000;

1801

1802

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

1803

1804

        let is_rated = match self.game_settings.rated {

1805

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

1806

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

1807

};

1808

1809

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

1810

1811

        match self.screen_size {

1812

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

1813

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

1814

1815

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

1816

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

1817

1818

1819

1820

        if self.username.as_str() != attacker_string && self.username.as_str() != defender_string {

1821

            watching = true;

1822

1823

1824

        let mut spectators = Column::new();

1825

        let mut players_length = 0;

1826

        for spectator in &self.spectators {

1827

            if spectator == attacker_string || spectator == defender_string {

1828

                players_length += 1;

1829

                continue;

1830

1831

1832

            let mut spectator = spectator.clone();

1833

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

1834

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

1835

1836

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

1837

1838

1839

        let resign = button(text!("{} (p)", t!("Resign"))).on_press(Message::PlayResign);

1840

        let request_draw = button(text!("{} (q)", t!("Request Draw"))).on_press(Message::PlayDraw);

1841

1842

        if !watching {

1843

            if self.my_turn {

1844

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

1845

            } else {

1846

                let row = if self.request_draw {

1847

                    column![

1848

                        row![

1849

                            button(text!("{} (r)", t!("Accept Draw")))

1850

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

1851

1852

                        .spacing(SPACING)

1853

1854

                } else {

1855

                    Column::new()

1856

};

1857

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

1858

1859

1860

1861

        let coordinates_muted = row![

1862

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

1863

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

1864

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

1865

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

1866

1867

        .spacing(SPACING);

1868

        user_area = user_area.push(coordinates_muted);

1869

1870

        let volume = row![

1871

            text!("{} (- +)", t!("Volume")),

1872

            slider(0..=MAX_VOLUME, self.volume.0, Message::VolumeChanged),

1873

1874

        .spacing(SPACING);

1875

        user_area = user_area.push(volume);

1876

1877

        let leave = button(text!("{} (Esc)", t!("Leave"))).on_press(Message::Leave);

1878

1879

        match status {

1880

            Status::AttackerWins => {

1881

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

1882

1883

            Status::Draw => {

1884

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

1885

1886

            Status::Ongoing => {}

1887

            Status::DefenderWins => {

1888

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

1889

1890

1891

1892

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

1893

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

1894

            if self.heat_map.is_some() {

1895

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

1896

1897

1898

            let mut heat_map_button = button(text!("{} (p) (q)", t!("Heat Map")));

1899

1900

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

1901

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

1902

1903

1904

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

1905

1906

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

1907

            let child_right = button(

1908

                text(&self.chars.double_arrow_right)

1909

                    .center()

1910

                    .font(Font::MONOSPACE),

1911

1912

            .on_press(Message::ReviewGameChildNext);

1913

1914

            user_area = user_area.push(

1915

                row![

1916

                    leave,

1917

                    child_right,

1918

                    container(child_number)

1919

                        .style(container::bordered_box)

1920

                        .padding(PADDING_MEDIUM),

1921

1922

                .spacing(SPACING),

1923

);

1924

1925

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

1926

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

1927

1928

            if handle.play > 0 {

1929

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

1930

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

1931

1932

1933

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

1934

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

1935

1936

            if handle.boards.has_children() {

1937

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

1938

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

1939

1940

1941

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

1942

        } else {

1943

            user_area = user_area.push(leave);

1944

1945

            let spectator = text!(

1946

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

1947

                &self.chars.people,

1948

                self.spectators.len() - players_length,

1949

                t!("lag"),

1950

);

1951

1952

            if self.spectators.is_empty() {

1953

                user_area = user_area.push(spectator);

1954

            } else {

1955

                user_area = user_area.push(tooltip(

1956

                    spectator,

1957

                    container(spectators)

1958

                        .style(container::bordered_box)

1959

                        .padding(PADDING),

1960

                    tooltip::Position::Bottom,

1961

));

1962

1963

1964

1965

        if self.archived_game_handle.is_some() {

1966

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

1967

        } else {

1968

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

1969

1970

1971

        let user_area = container(user_area)

1972

            .padding(PADDING)

1973

            .style(container::bordered_box);

1974

1975

        let board = container(self.board())

1976

            .style(container::bordered_box)

1977

            .padding(PADDING);

1978

1979

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

1980

1981

1982

    fn leave(&mut self) {

1983

        match self.screen {

1984

            Screen::EmailEveryone => {

1985

                self.screen = Screen::Games;

1986

                self.text_input = String::new();

1987

1988

            Screen::Game => {

1989

                self.screen = Screen::Games;

1990

                self.my_turn = false;

1991

                self.request_draw = false;

1992

1993

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

1994

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

1995

1996

                self.spectators = Vec::new();

1997

1998

            Screen::Games => {

1999

                self.send("quit\n");

2000

                self.admin = false;

2001

                self.admin_tournament = false;

2002

                self.connected_tcp = false;

2003

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

2004

                self.screen = Screen::Login;

2005

                self.email = None;

2006

2007

            Screen::GameReview => {

2008

                self.heat_map = None;

2009

                self.heat_map_display = false;

2010

                self.screen = Screen::Login;

2011

2012

            Screen::Login => {}

2013

2014

2015

2016

    fn my_games_only(&mut self) {

2017

        self.my_games_only = !self.my_games_only;

2018

        self.games_filtered();

2019

        handle_error(self.save_client_ron());

2020

2021

2022

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

2023

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

2024

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

2025

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

2026

                    .map(|_instant| Message::Tick)

2027

            } else {

2028

                Subscription::none()

2029

2030

        } else {

2031

            Subscription::none()

2032

};

2033

2034

        let subscription_2 = Subscription::run(pass_messages);

2035

        let subscription_3 = Subscription::run(estimate_score);

2036

2037

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

2038

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

2039

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

2040

2041

            Event::Keyboard(keyboard::Event::KeyPressed { key, modifiers, .. }) => {

2042

                let shift = modifiers.shift();

2043

2044

                match key {

2045

                    Key::Character(ch) if modifiers.control() || modifiers.command() => match ch {

2046

                        ch if *ch == *"a".to_smolstr() => Some(Message::PressA(shift)),

2047

                        ch if *ch == *"b".to_smolstr() => Some(Message::PressB(shift)),

2048

                        // Fixme: ctrl + shift + "c" is copy.

2049

                        ch if *ch == *"c".to_smolstr() && !shift => Some(Message::PressC(shift)),

2050

                        ch if *ch == *"d".to_smolstr() => Some(Message::PressD(shift)),

2051

                        ch if *ch == *"e".to_smolstr() => Some(Message::PressE(shift)),

2052

                        ch if *ch == *"f".to_smolstr() => Some(Message::PressF(shift)),

2053

                        ch if *ch == *"g".to_smolstr() => Some(Message::PressG(shift)),

2054

                        ch if *ch == *"h".to_smolstr() => Some(Message::PressH(shift)),

2055

                        ch if *ch == *"i".to_smolstr() => Some(Message::PressI(shift)),

2056

                        ch if *ch == *"j".to_smolstr() => Some(Message::PressJ(shift)),

2057

                        ch if *ch == *"k".to_smolstr() => Some(Message::PressK(shift)),

2058

                        ch if *ch == *"l".to_smolstr() => Some(Message::PressL(shift)),

2059

                        ch if *ch == *"m".to_smolstr() => Some(Message::PressM(shift)),

2060

                        ch if *ch == *"n".to_smolstr() => Some(Message::PressN(shift)),

2061

                        ch if *ch == *"o".to_smolstr() => Some(Message::PressO(shift)),

2062

                        ch if *ch == *"p".to_smolstr() => Some(Message::PressP(shift)),

2063

                        ch if *ch == *"q".to_smolstr() => Some(Message::PressQ(shift)),

2064

                        ch if *ch == *"r".to_smolstr() => Some(Message::PressR(shift)),

2065

                        ch if *ch == *"s".to_smolstr() => Some(Message::PressS(shift)),

2066

                        ch if *ch == *"t".to_smolstr() => Some(Message::PressT(shift)),

2067

                        ch if *ch == *"u".to_smolstr() => Some(Message::PressU(shift)),

2068

                        // Fixme: ctrl + shift + "v" is paste.

2069

                        ch if *ch == *"v".to_smolstr() && !shift => Some(Message::PressV(shift)),

2070

                        ch if *ch == *"w".to_smolstr() => Some(Message::PressW(shift)),

2071

                        ch if *ch == *"x".to_smolstr() => Some(Message::PressX(shift)),

2072

                        ch if *ch == *"y".to_smolstr() => Some(Message::PressY(shift)),

2073

                        ch if *ch == *"z".to_smolstr() => Some(Message::PressZ(shift)),

2074

                        ch if *ch == *"1".to_smolstr() => Some(Message::Press1),

2075

                        ch if *ch == *"2".to_smolstr() => Some(Message::Press2),

2076

                        ch if *ch == *"3".to_smolstr() => Some(Message::Press3),

2077

                        ch if *ch == *"4".to_smolstr() => Some(Message::Press4),

2078

                        ch if *ch == *"5".to_smolstr() => Some(Message::Press5),

2079

                        ch if *ch == *"6".to_smolstr() => Some(Message::Press6),

2080

                        ch if *ch == *"7".to_smolstr() => Some(Message::Press7),

2081

                        ch if *ch == *"8".to_smolstr() => Some(Message::Press8),

2082

                        ch if *ch == *"9".to_smolstr() => Some(Message::Press9),

2083

                        ch if *ch == *"0".to_smolstr() => Some(Message::Press0),

2084

                        ch if *ch == *"-".to_smolstr() => Some(Message::PressMinus),

2085

                        ch if (*ch == *"=".to_smolstr() && shift) || *ch == *"+".to_smolstr() => {

2086

                            Some(Message::PressPlus)

2087

2088

                        _ => None,

2089

},

2090

                    Key::Named(name) => match name {

2091

                        Named::Enter => Some(Message::PressEnter),

2092

                        Named::Tab if shift => Some(Message::FocusPrevious),

2093

                        Named::Tab => Some(Message::FocusNext),

2094

                        Named::ArrowUp => Some(Message::ReviewGameBackwardAll),

2095

                        Named::ArrowLeft => Some(Message::ReviewGameBackward),

2096

                        Named::ArrowRight if shift => Some(Message::ReviewGameChildNext),

2097

                        Named::ArrowRight => Some(Message::ReviewGameForward),

2098

                        Named::ArrowDown => Some(Message::ReviewGameForwardAll),

2099

                        Named::Escape => Some(Message::Leave),

2100

                        _ => None,

2101

},

2102

                    _ => None,

2103

2104

2105

            _ => None,

2106

});

2107

2108

        Subscription::batch(vec![

2109

            subscription_1,

2110

            subscription_2,

2111

            subscription_3,

2112

            subscription_4,

2113

])

2114

2115

2116

    fn texting(

2117

        &'a self,

2118

        messages: &'a VecDeque<String>,

2119

        enable_texting: bool,

2120

    ) -> Container<'a, Message> {

2121

        let text_input = if enable_texting {

2122

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

2123

                .on_input(Message::TextChanged)

2124

                .on_paste(Message::TextChanged)

2125

                .on_submit(Message::TextSend)

2126

        } else {

2127

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

2128

};

2129

2130

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

2131

2132

        let mut texting = Column::new();

2133

        for message in messages {

2134

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

2135

2136

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

2137

2138

        container(text_box)

2139

            .padding(PADDING)

2140

            .style(container::bordered_box)

2141

2142

2143

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

2144

        match self.theme {

2145

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

2146

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

2147

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

2148

2149

2150

2151

    #[allow(clippy::too_many_lines)]

2152

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

2153

        self.error = None;

2154

2155

        match message {

2156

            Message::ArchivedGames(mut archived_games) => {

2157

                archived_games.reverse();

2158

                self.archived_games = archived_games;

2159

                self.archived_games_filtered = None;

2160

                handle_error(self.save_client_postcard());

2161

2162

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

2163

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

2164

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

2165

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

2166

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

2167

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

2168

            Message::DateCancel => self.tournament_date_show_picker = false,

2169

            Message::DateChoose => self.tournament_date_show_picker = true,

2170

            Message::DateSubmit(date) => {

2171

                self.send(&format!("tournament_date {date}T00:00:00Z\n"));

2172

                self.tournament_date = date;

2173

                self.tournament_date_show_picker = false;

2174

2175

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

2176

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

2177

            Message::EmailChanged(email) => self.email_input = email,

2178

            Message::EmailEveryone => {

2179

                self.screen = Screen::EmailEveryone;

2180

                self.send("emails_bcc\n");

2181

2182

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

2183

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

2184

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

2185

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

2186

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

2187

2188

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

2189

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

2190

2191

                    info!("{generate_move}");

2192

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

2193

                    self.heat_map = Some(generate_move.heat_map);

2194

2195

2196

                self.estimate_score = false;

2197

2198

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

2199

            Message::FocusNext => return focus_next(),

2200

            Message::FocusPrevious => return focus_previous(),

2201

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

2202

            Message::GameAccept(id) => {

2203

                self.game_id = id;

2204

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

2205

2206

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

2207

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

2208

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

2209

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

2210

            Message::Leave => {

2211

                if self.screen == Screen::Login {

2212

                    return iced::exit();

2213

2214

2215

                self.leave();

2216

2217

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

2218

            Message::LocaleSelected(locale) => {

2219

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

2220

                self.locale_selected = Some(locale);

2221

                handle_error(self.save_client_ron());

2222

2223

            Message::MyGamesOnly(_selected) => {

2224

                self.my_games_only();

2225

2226

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

2227

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

2228

            Message::GameSubmit => {

2229

                self.game_submit();

2230

                self.active_tab = TabId::Games;

2231

2232

            Message::PasswordChanged(password) => {

2233

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

2234

                self.password_ends_with_whitespace = ends_with_whitespace;

2235

                if password.len() <= 32 {

2236

                    self.password = password;

2237

2238

2239

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

2240

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

2241

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

2242

            Message::PlayDrawDecision(draw) => {

2243

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

2244

2245

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

2246

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

2247

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

2248

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

2249

            Message::PressEnter => match self.screen {

2250

                Screen::Games if self.active_tab == TabId::GameNew => self.game_submit(),

2251

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

2252

                Screen::EmailEveryone | Screen::Game | Screen::Games | Screen::GameReview => {}

2253

},

2254

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

2255

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

2256

                    self.press_letter('a');

2257

                    self.press_letter_and_number();

2258

2259

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

2260

                Screen::Games if self.active_tab == TabId::GameNew => {

2261

                    self.game_settings.time = Some(TimeEnum::Rapid);

2262

2263

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

2264

                Screen::EmailEveryone | Screen::Games => {}

2265

},

2266

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

2267

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

2268

                    self.press_letter('b');

2269

                    self.press_letter_and_number();

2270

2271

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

2272

                Screen::Games if self.active_tab == TabId::GameNew => {

2273

                    self.game_settings.time = Some(TimeEnum::Classical);

2274

2275

                Screen::EmailEveryone | Screen::Games => {}

2276

                Screen::Login => {

2277

                    self.rating_min();

2278

                    self.games_filtered();

2279

                    handle_error(self.save_client_ron());

2280

2281

},

2282

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

2283

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

2284

                    self.press_letter('c');

2285

                    self.press_letter_and_number();

2286

2287

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

2288

                Screen::Games if self.active_tab == TabId::GameNew => {

2289

                    self.game_settings.time = Some(TimeEnum::Long);

2290

2291

                Screen::EmailEveryone | Screen::Games => {}

2292

                Screen::Login => {

2293

                    self.rating_max();

2294

                    self.games_filtered();

2295

                    handle_error(self.save_client_ron());

2296

2297

},

2298

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

2299

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

2300

                    self.press_letter('d');

2301

                    self.press_letter_and_number();

2302

2303

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

2304

                Screen::Games if self.active_tab == TabId::GameNew => {

2305

                    self.game_settings.time = Some(TimeEnum::VeryLong);

2306

2307

                Screen::EmailEveryone | Screen::Games | Screen::Login => {}

2308

},

2309

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

2310

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

2311

                    self.press_letter('e');

2312

                    self.press_letter_and_number();

2313

2314

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

2315

                Screen::Games if self.active_tab == TabId::GameNew => {

2316

                    self.game_settings.time = Some(TimeEnum::Infinity);

2317

2318

                Screen::EmailEveryone | Screen::Games | Screen::Login => {}

2319

},

2320

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

2321

                Screen::EmailEveryone | Screen::Login => {}

2322

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

2323

                    self.press_letter('f');

2324

                    self.press_letter_and_number();

2325

2326

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

2327

},

2328

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

2329

                Screen::EmailEveryone | Screen::Login => {}

2330

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

2331

                    self.press_letter('g');

2332

                    self.press_letter_and_number();

2333

2334

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

2335

},

2336

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

2337

                Screen::EmailEveryone | Screen::Login => {}

2338

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

2339

                    self.press_letter('h');

2340

                    self.press_letter_and_number();

2341

2342

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

2343

},

2344

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

2345

                Screen::EmailEveryone | Screen::Login => {}

2346

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

2347

                    self.press_letter('i');

2348

                    self.press_letter_and_number();

2349

2350

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

2351

},

2352

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

2353

                Screen::EmailEveryone | Screen::Login => {}

2354

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

2355

                    self.press_letter('j');

2356

                    self.press_letter_and_number();

2357

2358

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

2359

},

2360

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

2361

                Screen::EmailEveryone | Screen::Login => {}

2362

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

2363

                    self.press_letter('k');

2364

                    self.press_letter_and_number();

2365

2366

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

2367

},

2368

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

2369

                Screen::EmailEveryone | Screen::Login => {}

2370

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

2371

                    self.press_letter('l');

2372

                    self.press_letter_and_number();

2373

2374

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

2375

},

2376

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

2377

                Screen::EmailEveryone | Screen::Login => {}

2378

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

2379

                    self.press_letter('m');

2380

                    self.press_letter_and_number();

2381

2382

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

2383

},

2384

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

2385

                Screen::EmailEveryone | Screen::Login => {}

2386

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

2387

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

2388

},

2389

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

2390

                Screen::EmailEveryone | Screen::Login => {}

2391

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

2392

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

2393

},

2394

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

2395

                Screen::EmailEveryone | Screen::Login => {}

2396

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

2397

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

2398

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

2399

},

2400

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

2401

                Screen::EmailEveryone | Screen::Login => {}

2402

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

2403

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

2404

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

2405

},

2406

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

2407

                Screen::EmailEveryone | Screen::GameReview | Screen::Login => {}

2408

                Screen::Game => {

2409

                    if self.request_draw {

2410

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

2411

2412

2413

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

2414

},

2415

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

2416

                Screen::EmailEveryone | Screen::Game | Screen::GameReview | Screen::Login => {}

2417

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

2418

},

2419

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

2420

                Screen::EmailEveryone | Screen::Game | Screen::GameReview | Screen::Login => {}

2421

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

2422

},

2423

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

2424

                Screen::EmailEveryone | Screen::Game | Screen::GameReview | Screen::Login => {}

2425

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

2426

},

2427

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

2428

                Screen::EmailEveryone | Screen::Game | Screen::GameReview | Screen::Login => {}

2429

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

2430

},

2431

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

2432

                Screen::EmailEveryone | Screen::Game | Screen::GameReview | Screen::Login => {}

2433

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

2434

},

2435

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

2436

                Screen::EmailEveryone | Screen::Game | Screen::GameReview | Screen::Login => {}

2437

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

2438

},

2439

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

2440

                Screen::EmailEveryone | Screen::Game | Screen::GameReview | Screen::Login => {}

2441

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

2442

},

2443

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

2444

                Screen::EmailEveryone | Screen::Game | Screen::GameReview | Screen::Login => {}

2445

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

2446

},

2447

            Message::Press1 => match self.screen {

2448

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

2449

                Screen::EmailEveryone => {}

2450

                Screen::Games => self.active_tab = TabId::Games,

2451

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

2452

                    if !(self.press_numbers[0]

2453

                        || self.press_numbers[10]

2454

                        || self.press_numbers[11]

2455

                        || self.press_numbers[12])

2456

2457

                        self.clear_numbers_except(0);

2458

                        self.press_numbers[0] = true;

2459

                    } else if self.press_numbers[0] {

2460

                        self.clear_numbers_except(10);

2461

                        self.press_numbers[10] = true;

2462

                    } else {

2463

                        self.clear_numbers_except(11);

2464

                        self.press_numbers[10] = false;

2465

2466

2467

                    self.press_letter_and_number();

2468

2469

},

2470

            Message::Press2 => match self.screen {

2471

                Screen::EmailEveryone => {}

2472

                Screen::Games => self.active_tab = TabId::GameNew,

2473

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

2474

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

2475

                    match board.size() {

2476

                        BoardSize::_11 => {

2477

                            self.clear_numbers_except(2);

2478

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

2479

                            self.press_letter_and_number();

2480

2481

                        BoardSize::_13 => {

2482

                            if !self.press_numbers[0]

2483

                                && !self.press_numbers[1]

2484

                                && !self.press_numbers[11]

2485

2486

                                self.clear_numbers_except(2);

2487

                                self.press_numbers[1] = true;

2488

                            } else if self.press_numbers[1] {

2489

                                self.press_numbers[1] = false;

2490

                            } else if self.press_numbers[11] {

2491

                                self.press_numbers[11] = false;

2492

                            } else {

2493

                                self.press_numbers[0] = false;

2494

                                self.press_numbers[11] = true;

2495

2496

2497

2498

2499

                    self.press_letter_and_number();

2500

2501

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

2502

},

2503

            Message::Press3 => match self.screen {

2504

                Screen::EmailEveryone => {}

2505

                Screen::Games => self.active_tab = TabId::Tournament,

2506

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

2507

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

2508

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

2509

                    match board.size() {

2510

                        BoardSize::_11 => {

2511

                            self.clear_numbers_except(3);

2512

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

2513

                            self.press_letter_and_number();

2514

2515

                        BoardSize::_13 => {

2516

                            if !self.press_numbers[0]

2517

                                && !self.press_numbers[2]

2518

                                && !self.press_numbers[12]

2519

2520

                                self.clear_numbers_except(3);

2521

                                self.press_numbers[2] = true;

2522

                            } else if self.press_numbers[2] {

2523

                                self.press_numbers[2] = false;

2524

                            } else if self.press_numbers[12] {

2525

                                self.press_numbers[12] = false;

2526

                            } else {

2527

                                self.press_numbers[0] = false;

2528

                                self.press_numbers[12] = true;

2529

2530

2531

2532

2533

                    self.press_letter_and_number();

2534

2535

},

2536

            Message::Press4 => match self.screen {

2537

                Screen::EmailEveryone => {}

2538

                Screen::Games => self.active_tab = TabId::AccountSettings,

2539

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

2540

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

2541

                    self.clear_numbers_except(4);

2542

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

2543

                    self.press_letter_and_number();

2544

2545

},

2546

            Message::Press5 => match self.screen {

2547

                Screen::EmailEveryone => {}

2548

                Screen::Games => self.active_tab = TabId::Users,

2549

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

2550

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

2551

                    self.clear_numbers_except(5);

2552

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

2553

                    self.press_letter_and_number();

2554

2555

},

2556

            Message::Press6 => match self.screen {

2557

                Screen::EmailEveryone => {}

2558

                Screen::Games => match self.active_tab {

2559

                    TabId::AccountSettings => self.reset_email(),

2560

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

2561

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

2562

                    TabId::Tournament => open_url("https://hnefatafl.org/tournaments.html"),

2563

                    TabId::Users => {}

2564

},

2565

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

2566

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

2567

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

2568

                        self.clear_numbers_except(6);

2569

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

2570

                        self.press_letter_and_number();

2571

2572

2573

},

2574

            Message::Press7 => match self.screen {

2575

                Screen::EmailEveryone => {}

2576

                Screen::Games => match self.active_tab {

2577

                    TabId::AccountSettings => {

2578

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

2579

2580

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

2581

                    TabId::Games | TabId::Users => {}

2582

                    TabId::Tournament => self.send("join_tournament\n"),

2583

},

2584

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

2585

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

2586

                    self.clear_numbers_except(7);

2587

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

2588

                    self.press_letter_and_number();

2589

2590

},

2591

            Message::Press8 => match self.screen {

2592

                Screen::EmailEveryone => {}

2593

                Screen::Games => match self.active_tab {

2594

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

2595

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

2596

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

2597

                    TabId::Tournament => self.send("leave_tournament\n"),

2598

                    TabId::Users => {}

2599

},

2600

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

2601

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

2602

                    self.clear_numbers_except(8);

2603

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

2604

                    self.press_letter_and_number();

2605

2606

},

2607

            Message::Press9 => match self.screen {

2608

                Screen::EmailEveryone => {}

2609

                Screen::Games => match self.active_tab {

2610

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

2611

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

2612

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

2613

                    TabId::Tournament => {}

2614

},

2615

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

2616

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

2617

                    self.clear_numbers_except(9);

2618

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

2619

                    self.press_letter_and_number();

2620

2621

},

2622

            Message::Press0 => match self.screen {

2623

                Screen::EmailEveryone => {}

2624

                Screen::Games => match self.active_tab {

2625

                    TabId::AccountSettings | TabId::Tournament => {}

2626

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

2627

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

2628

},

2629

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

2630

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

2631

                    self.clear_numbers_except(10);

2632

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

2633

                    self.press_letter_and_number();

2634

2635

},

2636

            Message::PressMinus => match self.screen {

2637

                Screen::EmailEveryone | Screen::Games | Screen::Login => {}

2638

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

2639

                    self.volume.0 = self.volume.0.saturating_sub(1);

2640

2641

},

2642

            Message::PressPlus => match self.screen {

2643

                Screen::EmailEveryone | Screen::Games | Screen::Login => {}

2644

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

2645

                    self.volume.0 = self.volume.0.saturating_add(1);

2646

2647

},

2648

            Message::RatingMaximum => {

2649

                self.rating_max();

2650

                self.games_filtered();

2651

                handle_error(self.save_client_ron());

2652

2653

            Message::RatingMaximumChanged(rating) => {

2654

                self.rating_maximum = rating;

2655

                self.games_filtered();

2656

                handle_error(self.save_client_ron());

2657

2658

            Message::RatingMinimum => {

2659

                self.rating_min();

2660

                self.games_filtered();

2661

                handle_error(self.save_client_ron());

2662

2663

            Message::RatingMinimumChanged(rating) => {

2664

                self.rating_minimum = rating;

2665

                self.games_filtered();

2666

                handle_error(self.save_client_ron());

2667

2668

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

2669

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

2670

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

2671

            Message::ReviewGameBackward => {

2672

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

2673

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

2674

                    handle.boards.backward();

2675

                    self.reset_markers();

2676

2677

2678

            Message::ReviewGameBackwardAll => {

2679

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

2680

                    handle.play = 0;

2681

                    handle.boards.backward_all();

2682

                    self.reset_markers();

2683

2684

2685

            Message::ReviewGameChildNext => {

2686

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

2687

                    handle.boards.next_child();

2688

                    self.reset_markers();

2689

2690

2691

            Message::ReviewGameForward => {

2692

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

2693

                    && handle.boards.has_children()

2694

2695

                    handle.play += 1;

2696

                    handle.boards.forward();

2697

                    self.reset_markers();

2698

2699

2700

            Message::ReviewGameForwardAll => {

2701

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

2702

                    let count = handle.boards.forward_all();

2703

                    handle.play += count;

2704

                    self.reset_markers();

2705

2706

2707

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

2708

            Message::ServerShutdown => {

2709

                self.error_persistent

2710

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

2711

2712

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

2713

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

2714

            Message::TcpConnectFailed => {

2715

                self.error_persistent

2716

                    .push(t!("The TCP connection failed.").to_string());

2717

2718

            Message::TabSelected(tab) => self.active_tab = tab,

2719

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

2720

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

2721

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

2722

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

2723

            Message::TextChanged(string) => {

2724

                if self.screen == Screen::Login {

2725

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

2726

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

2727

                        if string.len() <= 16 {

2728

                            self.text_input = string.to_ascii_lowercase();

2729

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

2730

2731

                    } else {

2732

                        self.text_input = String::new();

2733

2734

                } else {

2735

                    self.text_input = string;

2736

2737

2738

            Message::TextEdit(action) => {

2739

                self.content.perform(action);

2740

2741

            Message::TextReceived(string) => {

2742

                let mut text = string.split_ascii_whitespace();

2743

                match text.next() {

2744

                    Some("=") => {

2745

                        let text_next = text.next();

2746

                        match text_next {

2747

                            Some(

2748

                                "archived_games"

2749

                                | "challenge_requested"

2750

                                | "change_password"

2751

                                | "decline_game"

2752

                                | "email_reset"

2753

                                | "game"

2754

                                | "request_draw",

2755

                            ) => {}

2756

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

2757

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

2758

                            Some("display_games") => {

2759

                                self.games_light.0.clear();

2760

                                self.games_light_vec.clear();

2761

2762

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

2763

2764

                                let (chunks, []) = games.as_chunks::<12>() else {

2765

                                    panic!("chunks is an exact multiple of 12");

2766

};

2767

2768

                                for chunks in chunks {

2769

                                    let game = ServerGameLight::try_from(chunks)

2770

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

2771

2772

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

2773

                                    self.games_light_vec.push(game);

2774

2775

2776

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

2777

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

2778

                                    self.spectators.sort();

2779

2780

2781

                            Some("display_users") => {

2782

                                self.users.clear();

2783

2784

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

2785

2786

                                let (chunks, []) = users.as_chunks::<6>() else {

2787

                                    panic!("chunks is an exact multiple of 6");

2788

};

2789

2790

                                for user in chunks {

2791

                                    let user: User = user.into();

2792

                                    self.users.insert(user.name.clone(), user);

2793

2794

2795

                            Some("display_users_admin") => {

2796

                                let accounts: Accounts = ron::from_str(

2797

                                    text.next().expect("there should be a nex value"),

2798

2799

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

2800

2801

                                self.accounts = accounts;

2802

2803

                            Some("draw") => {

2804

                                self.request_draw = false;

2805

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

2806

                                    self.my_turn = false;

2807

                                    self.status = Status::Draw;

2808

2809

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

2810

                                        game.turn = Role::Roleless;

2811

2812

2813

                                    if !self.sound_muted {

2814

                                        let volume = self.volume.volume();

2815

                                        thread::spawn(move || {

2816

                                            let mut stream =

2817

                                                rodio::DeviceSinkBuilder::open_default_sink()?;

2818

2819

                                            let cursor = Cursor::new(SOUND_GAME_OVER);

2820

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

2821

                                            sound.set_volume(volume);

2822

                                            sound.sleep_until_end();

2823

2824

                                            stream.log_on_drop(false);

2825

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

2826

});

2827

2828

2829

2830

                            Some("email") => {

2831

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

2832

2833

                                    self.email = Some(Email {

2834

                                        username: String::new(),

2835

                                        address: address.to_string(),

2836

                                        code: None,

2837

                                        verified: handle_error(verified.parse()),

2838

});

2839

2840

2841

                            Some("emails_bcc") => {

2842

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

2843

2844

                            Some("email_code") => {

2845

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

2846

                                    email.verified = true;

2847

2848

                                self.error_email = None;

2849

2850

                            Some("game_over") => {

2851

                                self.my_turn = false;

2852

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

2853

                                    game.turn = Role::Roleless;

2854

2855

2856

                                text.next();

2857

                                match text.next() {

2858

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

2859

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

2860

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

2861

2862

2863

                                if !self.sound_muted {

2864

                                    let volume = self.volume.volume();

2865

                                    thread::spawn(move || {

2866

                                        let mut stream =

2867

                                            rodio::DeviceSinkBuilder::open_default_sink()?;

2868

2869

                                        let cursor = Cursor::new(SOUND_GAME_OVER);

2870

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

2871

                                        sound.set_volume(volume);

2872

                                        sound.sleep_until_end();

2873

2874

                                        stream.log_on_drop(false);

2875

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

2876

});

2877

2878

2879

                            // = join_game david abby rated fischer 900_000 10

2880

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

2881

                                self.screen = Screen::Game;

2882

                                self.status = Status::Ongoing;

2883

                                self.captures = HashSet::new();

2884

                                self.play_from = None;

2885

                                self.play_from_previous = None;

2886

                                self.play_to_previous = None;

2887

                                self.texts_game = VecDeque::new();

2888

                                self.archived_game_handle = None;

2889

2890

                                let attacker =

2891

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

2892

                                let defender =

2893

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

2894

2895

                                self.attacker = attacker.to_string();

2896

                                self.defender = defender.to_string();

2897

2898

                                let rated = text

2899

                                    .next()

2900

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

2901

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

2902

2903

                                self.game_settings.rated = rated;

2904

2905

                                let timed = text

2906

                                    .next()

2907

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

2908

                                let minutes =

2909

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

2910

                                let add_seconds =

2911

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

2912

2913

                                let timed = TimeSettings::try_from(vec![

2914

                                    "time_settings",

2915

                                    timed,

2916

                                    minutes,

2917

                                    add_seconds,

2918

])

2919

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

2920

2921

                                let board_size =

2922

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

2923

                                let board_size = BoardSize::from_str(board_size)

2924

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

2925

2926

                                let board = Board::new(board_size);

2927

2928

                                let mut game = Game {

2929

                                    attacker_time: timed.clone(),

2930

                                    defender_time: timed.clone(),

2931

                                    plays: Plays::new(&timed),

2932

                                    board,

2933

                                    ..Game::default()

2934

};

2935

2936

                                self.time_attacker = timed.clone();

2937

                                self.time_defender = timed;

2938

2939

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

2940

                                    let game_deserialized = ron::from_str(game_serialized)

2941

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

2942

2943

                                    game = game_deserialized;

2944

2945

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

2946

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

2947

2948

                                    match game.turn {

2949

                                        Role::Attacker => {

2950

                                            if let (

2951

                                                TimeSettings::Timed(time),

2952

                                                TimeUnix::Time(time_ago),

2953

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

2954

2955

                                                let now = Timestamp::now().as_millisecond();

2956

                                                time.milliseconds_left -= now - time_ago;

2957

                                                if time.milliseconds_left < 0 {

2958

                                                    time.milliseconds_left = 0;

2959

2960

2961

2962

                                        Role::Roleless => {}

2963

                                        Role::Defender => {

2964

                                            if let (

2965

                                                TimeSettings::Timed(time),

2966

                                                TimeUnix::Time(time_ago),

2967

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

2968

2969

                                                let now = Timestamp::now().as_millisecond();

2970

                                                time.milliseconds_left -= now - time_ago;

2971

                                                if time.milliseconds_left < 0 {

2972

                                                    time.milliseconds_left = 0;

2973

2974

2975

2976

2977

2978

2979

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

2980

                                let texts = texts.join(" ");

2981

                                if !texts.is_empty() {

2982

                                    let texts = ron::from_str(&texts)

2983

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

2984

2985

                                    self.texts_game = texts;

2986

2987

2988

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

2989

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

2990

2991

                                    self.my_turn = true;

2992

2993

2994

                                self.game = Some(game);

2995

2996

                            Some("join_game_pending") => {

2997

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

2998

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

2999

3000

                                self.game_id = id;

3001

                                self.challenger = true;

3002

3003

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

3004

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

3005

                            Some("new_game") => {

3006

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

3007

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

3008

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

3009

                                    let game_id =

3010

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

3011

3012

                                    self.game_id = game_id;

3013

                                    self.challenger = false;

3014

3015

3016

                            Some("ping") => {

3017

                                let after = Timestamp::now().as_millisecond();

3018

                                self.now_diff = after - self.now;

3019

3020

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

3021

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

3022

                            Some("tournament_status_0") => {

3023

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

3024

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

3025

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

3026

3027

                                    self.tournament = tournament;

3028

3029

3030

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

3031

3032

3033

                    Some("?") => {

3034

                        let text_next = text.next();

3035

                        match text_next {

3036

                            Some("create_account") => {

3037

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

3038

3039

                            // Fixme: translate.

3040

                            Some("email") => {

3041

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

3042

                                let text = text.join(" ");

3043

                                self.error_email = Some(text);

3044

3045

                            Some("email_code") => {

3046

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

3047

3048

                            Some("login") => {

3049

                                let text_next = text.next();

3050

                                match text_next {

3051

                                    Some("multiple_possible_errors") => {

3052

                                        self.error = Some(t!(

3053

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

3054

                                        ).to_string());

3055

3056

                                    Some("reset_password") => {

3057

                                        self.error = Some(t!(

3058

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

3059

                                        ).to_string());

3060

3061

                                    Some("wrong_version") => {

3062

                                        self.error = Some(t!(

3063

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

3064

                                        ).to_string());

3065

3066

                                    _ => {

3067

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

3068

                                        let text = text.join(" ");

3069

                                        self.error = Some(text);

3070

3071

3072

3073

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

3074

3075

3076

                    Some("game") => {

3077

                        // Plays the move then sends the result back.

3078

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

3079

                        let id = id

3080

                            .parse::<Id>()

3081

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

3082

3083

                        if id != self.game_id {

3084

                            return Task::none();

3085

3086

3087

                        // game 0 generate_move attacker

3088

                        let text_word = text.next();

3089

                        if text_word == Some("generate_move") {

3090

                            self.request_draw = false;

3091

                            self.my_turn = true;

3092

                        // game 0 play attacker a3 a4

3093

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

3094

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

3095

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

3096

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

3097

3098

                            if from == "resigns" {

3099

                                return Task::none();

3100

3101

3102

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

3103

3104

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

3105

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

3106

3107

                                self.play_from_previous = Some(from);

3108

                                self.play_to_previous = Some(to);

3109

3110

3111

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

3112

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

3113

3114

                            if game.status == Status::Ongoing {

3115

                                match game.turn {

3116

                                    Role::Attacker => {

3117

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

3118

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

3119

3120

3121

                                    Role::Roleless => {}

3122

                                    Role::Defender => {

3123

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

3124

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

3125

3126

3127

3128

3129

3130

3131

                    Some("request_draw") => {

3132

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

3133

                        let id = id

3134

                            .parse::<Id>()

3135

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

3136

3137

                        if id == self.game_id {

3138

                            self.request_draw = true;

3139

3140

3141

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

3142

3143

3144

            Message::TextSend => {

3145

                match self.screen {

3146

                    Screen::EmailEveryone => {

3147

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

3148

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

3149

3150

                    Screen::Game => {

3151

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

3152

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

3153

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

3154

3155

3156

                    Screen::Games => match self.active_tab {

3157

                        TabId::Games if !self.text_input.trim().is_empty() => {

3158

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

3159

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

3160

3161

                        TabId::AccountSettings => {

3162

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

3163

3164

                        _ => {}

3165

},

3166

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

3167

3168

3169

                self.text_input.clear();

3170

3171

            Message::TextSendEmail => {

3172

                self.error_email = None;

3173

3174

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

3175

                self.email_input.clear();

3176

3177

            Message::TextSendEmailCode => {

3178

                self.error_email = None;

3179

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

3180

3181

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

3182

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

3183

            Message::Tick => {

3184

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

3185

3186

                if self.counter.is_multiple_of(25) {

3187

                    self.now = Timestamp::now().as_millisecond();

3188

                    self.send("ping\n");

3189

3190

3191

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

3192

                    match game.turn {

3193

                        Role::Attacker => {

3194

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

3195

                                time.milliseconds_left -= TICK;

3196

                                if time.milliseconds_left < 0 {

3197

                                    time.milliseconds_left = 0;

3198

3199

3200

3201

                        Role::Roleless => {}

3202

                        Role::Defender => {

3203

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

3204

                                time.milliseconds_left -= TICK;

3205

                                if time.milliseconds_left < 0 {

3206

                                    time.milliseconds_left = 0;

3207

3208

3209

3210

3211

3212

3213

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

3214

            Message::Tournaments => open_url("https://hnefatafl.org/tournaments.html"),

3215

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

3216

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

3217

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

3218

            Message::VolumeChanged(volume) => self.volume.0 = volume,

3219

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

3220

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

3221

                    self.screen_size = Size::Giant;

3222

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

3223

                    self.screen_size = Size::Large;

3224

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

3225

                    self.screen_size = Size::Medium;

3226

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

3227

                    self.screen_size = Size::Small;

3228

                } else if width >= 1_100.0 {

3229

                    self.screen_size = Size::TinyWide;

3230

                } else {

3231

                    self.screen_size = Size::Tiny;

3232

3233

3234

3235

3236

        Task::none()

3237

3238

3239

    #[must_use]

3240

    fn accounts_sorted(&self) -> Vec<(String, Account)> {

3241

        let mut accounts: Vec<_> = self.accounts.clone().0.into_iter().collect();

3242

3243

        match self.users_sort_by {

3244

            SortBy::Name => {

3245

                accounts.sort_by(|(_, a_account), (_, b_account)| {

3246

                    b_account

3247

                        .rating

3248

                        .rating

3249

                        .partial_cmp(&a_account.rating.rating)

3250

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

3251

});

3252

                accounts.sort_by(|(a_name, _), (b_name, _)| a_name.cmp(b_name));

3253

3254

            SortBy::Rating => {

3255

                accounts.sort_by(|(a_name, _), (b_name, _)| a_name.cmp(b_name));

3256

                accounts.sort_by(|(_, a_account), (_, b_account)| {

3257

                    b_account

3258

                        .rating

3259

                        .rating

3260

                        .partial_cmp(&a_account.rating.rating)

3261

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

3262

});

3263

3264

3265

3266

        accounts

3267

3268

3269

    #[must_use]

3270

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

3271

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

3272

3273

        match self.users_sort_by {

3274

            SortBy::Name => {

3275

                users.sort_by(|a, b| {

3276

                    b.rating

3277

                        .rating

3278

                        .partial_cmp(&a.rating.rating)

3279

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

3280

});

3281

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

3282

3283

            SortBy::Rating => {

3284

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

3285

                users.sort_by(|a, b| {

3286

                    b.rating

3287

                        .rating

3288

                        .partial_cmp(&a.rating.rating)

3289

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

3290

});

3291

3292

3293

3294

        users

3295

3296

3297

    #[allow(clippy::too_many_lines)]

3298

    #[must_use]

3299

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

3300

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

3301

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

3302

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

3303

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

3304

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

3305

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

3306

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

3307

3308

        for (i, game) in self.games_light_vec.iter().enumerate() {

3309

            if self.my_games_only {

3310

                let mut includes_username = false;

3311

                if let Some(attacker) = &game.attacker

3312

                    && attacker == &self.username

3313

3314

                    includes_username = true;

3315

3316

3317

                if let Some(defender) = &game.defender

3318

                    && defender == &self.username

3319

3320

                    includes_username = true;

3321

3322

3323

                if !includes_username {

3324

                    continue;

3325

3326

3327

3328

            let id = game.id;

3329

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

3330

3331

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

3332

                let mut attacker = if self.admin {

3333

                    if let Some(account) = self.accounts.0.get(attacker_str) {

3334

                        text!("{attacker_str} ({})", account.rating.to_string_rounded())

3335

                    } else {

3336

                        text(attacker_str)

3337

3338

                } else {

3339

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

3340

                        text!("{attacker_str} ({})", user.rating.to_string_rounded())

3341

                    } else {

3342

                        text(attacker_str)

3343

3344

};

3345

3346

                if game.challenge_accepted

3347

                    && let Challenger(Some(name)) = &game.challenger

3348

                    && name == "A"

3349

3350

                    attacker = attacker.style(text::success);

3351

3352

3353

                attackers.push(attacker)

3354

            } else {

3355

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

3356

};

3357

3358

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

3359

                let mut defender = if self.admin {

3360

                    if let Some(account) = self.accounts.0.get(defender_str) {

3361

                        text!("{defender_str} ({})", account.rating.to_string_rounded())

3362

                    } else {

3363

                        text(defender_str)

3364

3365

                } else {

3366

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

3367

                        text!("{defender_str} ({})", user.rating.to_string_rounded())

3368

                    } else {

3369

                        text(defender_str)

3370

3371

};

3372

3373

                if game.challenge_accepted

3374

                    && let Challenger(Some(name)) = &game.challenger

3375

                    && name == "D"

3376

3377

                    defender = defender.style(text::success);

3378

3379

3380

                defenders.push(defender)

3381

            } else {

3382

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

3383

};

3384

3385

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

3386

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

3387

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

3388

3389

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

3390

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

3391

3392

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

3393

3394

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

3395

                format!(" ({i})")

3396

            } else {

3397

                String::new()

3398

};

3399

3400

            match self.join_game(game) {

3401

                JoinGame::Cancel => {

3402

                    buttons_row = buttons_row.push(

3403

                        button(text!("{}{i}", t!("Cancel"))).on_press(Message::GameCancel(id)),

3404

);

3405

3406

                JoinGame::Join => {

3407

                    buttons_row = buttons_row

3408

                        .push(button(text!("{}{i}", t!("Join"))).on_press(Message::GameJoin(id)));

3409

3410

                JoinGame::None => {}

3411

                JoinGame::Resume => {

3412

                    buttons_row = buttons_row.push(

3413

                        button(text!("{}{i}", t!("Resume"))).on_press(Message::GameResume(id)),

3414

);

3415

3416

                JoinGame::Watch => {

3417

                    buttons_row = buttons_row

3418

                        .push(button(text!("{}{i}", t!("Watch"))).on_press(Message::GameWatch(id)));

3419

3420

3421

3422

            match self.game_state(id) {

3423

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

3424

                State::Creator => {

3425

                    buttons_row = buttons_row.push(

3426

                        button(text!("{}{i}", t!("Accept"))).on_press(Message::GameAccept(id)),

3427

);

3428

                    buttons_row = buttons_row.push(

3429

                        button(text!("{}{}", t!("Decline"), i.to_ascii_uppercase()))

3430

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

3431

);

3432

3433

                State::CreatorOnly => {

3434

                    buttons_row = buttons_row.push(

3435

                        button(text!("{}{i}", t!("Cancel"))).on_press(Message::CancelGame(id)),

3436

);

3437

3438

3439

            buttons = buttons.push(buttons_row);

3440

3441

3442

        let game_id = t!("ID");

3443

        let game_ids = column![

3444

            text(game_id.to_string()),

3445

            text("-".repeat(game_id.chars().count())).font(Font::MONOSPACE),

3446

            game_ids

3447

3448

        .padding(PADDING);

3449

        let attacker = t!("attacker");

3450

        let attackers = column![

3451

            text(attacker.to_string()),

3452

            text("-".repeat(attacker.chars().count())).font(Font::MONOSPACE),

3453

            attackers

3454

3455

        .padding(PADDING);

3456

        let defender = t!("defender");

3457

        let defenders = column![

3458

            text(defender.to_string()),

3459

            text("-".repeat(defender.chars().count())).font(Font::MONOSPACE),

3460

            defenders

3461

3462

        .padding(PADDING);

3463

        let rated = t!("rated");

3464

        let ratings = column![

3465

            text(rated.to_string()),

3466

            text("-".repeat(rated.chars().count())).font(Font::MONOSPACE),

3467

            ratings

3468

3469

        .padding(PADDING);

3470

        let timed = t!("time");

3471

        let timings = column![

3472

            text(timed.to_string()),

3473

            text("-".repeat(timed.chars().count())).font(Font::MONOSPACE),

3474

            timings

3475

3476

        .padding(PADDING);

3477

        let size = t!("size");

3478

        let sizes = column![

3479

            text(size.to_string()),

3480

            text("-".repeat(size.chars().count())).font(Font::MONOSPACE),

3481

            sizes

3482

3483

        .padding(PADDING);

3484

        let buttons = column![text(""), text(""), buttons].padding(PADDING);

3485

3486

        scrollable(row![

3487

            game_ids, attackers, defenders, ratings, timings, sizes, buttons

3488

])

3489

3490

3491

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

3492

        let username = row![text!("{}: {}", t!("username"), &self.username)].spacing(SPACING);

3493

3494

        let username = container(username)

3495

            .padding(PADDING / 2)

3496

            .style(container::bordered_box);

3497

3498

        let my_games_text = text!("{} (8)", t!("My Games Only")).center();

3499

        let my_games = checkbox(self.my_games_only).on_toggle(Message::MyGamesOnly);

3500

        let get_archived_games =

3501

            button(text!("{} (6)", t!("Get Archived Games"))).on_press(Message::ArchivedGamesGet);

3502

3503

        let quit = button(text!("{} (Esc)", t!("Quit"))).on_press(Message::Leave);

3504

3505

        let mut middle = row![get_archived_games, quit].spacing(SPACING);

3506

3507

        if self.admin {

3508

            middle = middle.push(button("Email Everyone").on_press(Message::EmailEveryone));

3509

3510

3511

        let username = row![username, my_games, my_games_text].spacing(SPACING);

3512

        let user_area = self.user_area(false);

3513

3514

        column![middle, username, user_area]

3515

            .spacing(SPACING)

3516

            .padding(PADDING)

3517

3518

3519

    fn handle_play(&mut self, role: Option<&str>, from: &str, to: &str) {

3520

        self.captures = HashSet::new();

3521

3522

        let mut game_handle = None;

3523

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

3524

            game_handle = Some(Game::from(&handle.boards));

3525

3526

3527

        let game = if let Some(game) = &mut game_handle {

3528

            game

3529

        } else {

3530

            self.game.as_mut().expect("you should have a game by now")

3531

};

3532

3533

        let role = if let Some(role) = role {

3534

            Role::from_str(role).expect("there should be a valid role")

3535

        } else {

3536

            game.turn

3537

};

3538

3539

        let play = Plae::try_from(vec!["play", &role.to_string(), from, to])

3540

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

3541

        let captures = game.play(&play).expect("This should be a legal play.");

3542

        for vertex in captures.0 {

3543

            self.captures.insert(vertex);

3544

3545

3546

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

3547

            handle.boards.insert(&game.board);

3548

            handle.play += 1;

3549

3550

3551

        if self.sound_muted {

3552

            return;

3553

3554

3555

        let capture = !self.captures.is_empty();

3556

        let volume = self.volume.volume();

3557

3558

        thread::spawn(move || {

3559

            let mut stream = rodio::DeviceSinkBuilder::open_default_sink()?;

3560

            let cursor = if capture {

3561

                Cursor::new(SOUND_CAPTURE)

3562

            } else {

3563

                Cursor::new(SOUND_MOVE)

3564

};

3565

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

3566

            sound.set_volume(volume);

3567

            sound.sleep_until_end();

3568

3569

            stream.log_on_drop(false);

3570

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

3571

});

3572

3573

3574

    fn rating_max(&mut self) {

3575

        let mut max_rating = 0.0;

3576

3577

        for game in &self.archived_games {

3578

            let new_max_rating = f64::max(game.attacker_rating.rating, game.defender_rating.rating);

3579

3580

            if new_max_rating > max_rating {

3581

                max_rating = new_max_rating;

3582

3583

3584

3585

        if max_rating == 0.0 {

3586

            self.rating_maximum = MAX_RATING;

3587

        } else {

3588

            self.rating_maximum = max_rating.round_ties_even() + 1.0;

3589

3590

3591

3592

    fn rating_min(&mut self) {

3593

        let mut min_rating = MAX_RATING;

3594

3595

        for game in &self.archived_games {

3596

            let new_min_rating = f64::min(game.attacker_rating.rating, game.defender_rating.rating);

3597

3598

            if new_min_rating < min_rating {

3599

                min_rating = new_min_rating;

3600

3601

3602

3603

        if min_rating == MAX_RATING {

3604

            self.rating_minimum = 0.0;

3605

        } else {

3606

            self.rating_minimum = min_rating.round_ties_even() - 1.0;

3607

3608

3609

3610

    fn resign(&mut self) {

3611

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

3612

3613

        self.send(&format!(

3614

            "game {} play {} resigns _\n",

3615

            self.game_id, game.turn

3616

));

3617

3618

3619

    fn sound_muted(&mut self) {

3620

        self.sound_muted = !self.sound_muted;

3621

        handle_error(self.save_client_ron());

3622

3623

3624

    #[allow(

3625

        clippy::cast_precision_loss,

3626

        clippy::similar_names,

3627

        clippy::too_many_lines

3628

)]

3629

    #[must_use]

3630

    fn users(&self, show_logged_out_users: bool) -> Scrollable<'_, Message> {

3631

        if self.admin {

3632

            let mut ratings = Column::new();

3633

            let mut usernames = Column::new();

3634

            let mut wins = Column::new();

3635

            let mut losses = Column::new();

3636

            let mut draws = Column::new();

3637

            let mut win_percents = Column::new();

3638

            let mut emails = Column::new();

3639

            let mut emails_sent = Column::new();

3640

            let mut send_emails = Column::new();

3641

            let mut creation_dates = Column::new();

3642

            let mut last_logged_in = Column::new();

3643

3644

            for (name, account) in self.accounts_sorted() {

3645

                if show_logged_out_users || account.logged_in.is_some() {

3646

                    let wins_number = account.wins as f64;

3647

                    let mut win_percentage = wins_number / (wins_number + account.losses as f64);

3648

3649

                    win_percentage *= 100.0;

3650

                    win_percentage = win_percentage.round_ties_even();

3651

3652

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

3653

                    usernames = usernames.push(text(name));

3654

                    wins = wins.push(text(account.wins));

3655

                    losses = losses.push(text(account.losses));

3656

                    draws = draws.push(text(account.draws));

3657

                    win_percents = win_percents.push(text!("{}", win_percentage));

3658

3659

                    emails = if let Some(email) = &account.email {

3660

                        emails.push(text(email.address.clone()))

3661

                    } else {

3662

                        emails.push(text(""))

3663

};

3664

3665

                    if let Ok(timestamp) = Timestamp::from_second(account.email_sent) {

3666

                        emails_sent =

3667

                            emails_sent.push(text(timestamp.strftime("%Y-%m-%d").to_string()));

3668

                    } else {

3669

                        emails_sent = emails_sent.push(text(""));

3670

3671

3672

                    send_emails = send_emails.push(text(account.send_emails));

3673

3674

                    let date = account.creation_date.0.strftime("%Y-%m-%d").to_string();

3675

3676

                    creation_dates = creation_dates.push(text(date));

3677

3678

                    let date = account

3679

                        .last_logged_in

3680

.0

3681

                        .strftime("%Y-%m-%d %H:%M:%S %z")

3682

                        .to_string();

3683

3684

                    last_logged_in = if account.logged_in.is_some() {

3685

                        last_logged_in.push(text(date).style(text::success))

3686

                    } else {

3687

                        last_logged_in.push(text(date))

3688

};

3689

3690

3691

3692

            let rating = t!("rating");

3693

            let mut button_1 = button(text("(9)").size(10)).padding(PADDING_SMALL);

3694

3695

            if self.users_sort_by != SortBy::Rating {

3696

                button_1 = button_1.on_press(Message::UsersSortedBy(SortBy::Rating));

3697

3698

3699

            let ratings = column![

3700

                row![text(rating.to_string()), button_1,].spacing(SPACING),

3701

                text("-".repeat(rating.chars().count())).font(Font::MONOSPACE),

3702

                ratings

3703

3704

            .padding(PADDING);

3705

3706

            let username = t!("username");

3707

            let mut button_2 = button(text("(0)").size(10)).padding(PADDING_SMALL);

3708

3709

            if self.users_sort_by != SortBy::Name {

3710

                button_2 = button_2.on_press(Message::UsersSortedBy(SortBy::Name));

3711

3712

3713

            let usernames = column![

3714

                row![text(username.to_string()), button_2,].spacing(SPACING),

3715

                text("-".repeat(username.chars().count())).font(Font::MONOSPACE),

3716

                usernames

3717

3718

            .padding(PADDING);

3719

3720

            let win = t!("wins");

3721

            let wins = column![

3722

                text(win.to_string()),

3723

                text("-".repeat(win.chars().count())).font(Font::MONOSPACE),

3724

                wins

3725

3726

            .padding(PADDING);

3727

3728

            let loss = t!("losses");

3729

            let losses = column![

3730

                text(loss.to_string()),

3731

                text("-".repeat(loss.chars().count())).font(Font::MONOSPACE),

3732

                losses

3733

3734

            .padding(PADDING);

3735

3736

            let draw = t!("draws");

3737

            let draws = column![

3738

                text(draw.to_string()),

3739

                text("-".repeat(draw.chars().count())).font(Font::MONOSPACE),

3740

                draws

3741

3742

            .padding(PADDING);

3743

3744

            let win_percent = format!("{} %", t!("wins"));

3745

            let hyphens_count = win_percent.chars().count();

3746

            let win_percents = column![

3747

                text(win_percent),

3748

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3749

                win_percents

3750

3751

            .padding(PADDING);

3752

3753

            let email = "email".to_string();

3754

            let hyphens_count = email.chars().count();

3755

            let emails = column![

3756

                text(email),

3757

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3758

                emails

3759

3760

            .padding(PADDING);

3761

3762

            let email_sent = "email sent".to_string();

3763

            let hyphens_count = email_sent.chars().count();

3764

            let emails_sent = column![

3765

                text(email_sent),

3766

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3767

                emails_sent

3768

3769

            .padding(PADDING);

3770

3771

            let send_email = "send emails".to_string();

3772

            let hyphens_count = send_email.chars().count();

3773

            let send_emails = column![

3774

                text(send_email),

3775

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3776

                send_emails

3777

3778

            .padding(PADDING);

3779

3780

            let creation_date = "creation".to_string();

3781

            let hyphens_count = creation_date.chars().count();

3782

            let creation_dates = column![

3783

                text(creation_date),

3784

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3785

                creation_dates

3786

3787

            .padding(PADDING);

3788

3789

            let last_logged_in_ = "logged in".to_string();

3790

            let hyphens_count = last_logged_in_.chars().count();

3791

            let last_logged_in = column![

3792

                text(last_logged_in_),

3793

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3794

                last_logged_in

3795

3796

            .padding(PADDING);

3797

3798

            let mut rows = row![ratings, usernames, wins, losses, draws, win_percents,];

3799

3800

            if show_logged_out_users {

3801

                rows = rows.push(emails);

3802

                rows = rows.push(emails_sent);

3803

                rows = rows.push(send_emails);

3804

                rows = rows.push(creation_dates);

3805

                rows = rows.push(last_logged_in);

3806

3807

3808

            scrollable(rows).spacing(SPACING)

3809

        } else {

3810

            let mut ratings = Column::new();

3811

            let mut usernames = Column::new();

3812

            let mut wins = Column::new();

3813

            let mut losses = Column::new();

3814

            let mut draws = Column::new();

3815

            let mut win_percents = Column::new();

3816

3817

            for user in self.users_sorted() {

3818

                if show_logged_out_users || user.logged_in {

3819

                    let wins_number = f64::from_str(&user.wins).expect("This is a f64.");

3820

                    let mut win_percentage = wins_number

3821

                        / (wins_number + f64::from_str(&user.losses).expect("This is a f64."));

3822

3823

                    win_percentage *= 100.0;

3824

                    win_percentage = win_percentage.round_ties_even();

3825

3826

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

3827

3828

                    usernames = if user.logged_in && show_logged_out_users {

3829

                        usernames.push(text(user.name).style(text::success))

3830

                    } else {

3831

                        usernames.push(text(user.name))

3832

};

3833

3834

                    wins = wins.push(text(user.wins));

3835

                    losses = losses.push(text(user.losses));

3836

                    draws = draws.push(text(user.draws));

3837

                    win_percents = win_percents.push(text!("{}", win_percentage));

3838

3839

3840

3841

            let rating = t!("rating");

3842

            let mut button_1 = button(text("(9)").size(10)).padding(PADDING_SMALL);

3843

3844

            if self.users_sort_by != SortBy::Rating {

3845

                button_1 = button_1.on_press(Message::UsersSortedBy(SortBy::Rating));

3846

3847

3848

            let ratings = column![

3849

                row![text(rating.to_string()), button_1,].spacing(SPACING),

3850

                text("-".repeat(rating.chars().count())).font(Font::MONOSPACE),

3851

                ratings

3852

3853

            .padding(PADDING);

3854

3855

            let username = t!("username");

3856

            let mut button_2 = button(text("(0)").size(10)).padding(PADDING_SMALL);

3857

3858

            if self.users_sort_by != SortBy::Name {

3859

                button_2 = button_2.on_press(Message::UsersSortedBy(SortBy::Name));

3860

3861

3862

            let usernames = column![

3863

                row![text(username.to_string()), button_2,].spacing(SPACING),

3864

                text("-".repeat(username.chars().count())).font(Font::MONOSPACE),

3865

                usernames

3866

3867

            .padding(PADDING);

3868

3869

            let win = t!("wins");

3870

            let wins = column![

3871

                text(win.to_string()),

3872

                text("-".repeat(win.chars().count())).font(Font::MONOSPACE),

3873

                wins

3874

3875

            .padding(PADDING);

3876

3877

            let loss = t!("losses");

3878

            let losses = column![

3879

                text(loss.to_string()),

3880

                text("-".repeat(loss.chars().count())).font(Font::MONOSPACE),

3881

                losses

3882

3883

            .padding(PADDING);

3884

3885

            let draw = t!("draws");

3886

            let draws = column![

3887

                text(draw.to_string()),

3888

                text("-".repeat(draw.chars().count())).font(Font::MONOSPACE),

3889

                draws

3890

3891

            .padding(PADDING);

3892

3893

            let win_percent = format!("{} %", t!("wins"));

3894

            let hyphens_count = win_percent.chars().count();

3895

            let win_percents = column![

3896

                text(win_percent),

3897

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3898

                win_percents

3899

3900

            .padding(PADDING);

3901

3902

            scrollable(row![ratings, usernames, wins, losses, draws, win_percents]).spacing(SPACING)

3903

3904

3905

3906

    #[must_use]

3907

    fn user_area(&self, in_game: bool) -> Container<'_, Message> {

3908

        let texts = if in_game {

3909

            &self.texts_game

3910

        } else {

3911

            &self.texts

3912

};

3913

3914

        let games = self.games();

3915

        let texting = self.texting(texts, true).padding(PADDING);

3916

        let users = self.users(false);

3917

3918

        let user_area = scrollable(column![games, users, texting]);

3919

        container(user_area)

3920

            .padding(PADDING)

3921

            .style(container::bordered_box)

3922

3923

3924

    fn reset_password(&mut self) {

3925

        if !self.connected_tcp {

3926

            self.send("tcp_connect\n");

3927

            self.connected_tcp = true;

3928

3929

3930

        if self.screen == Screen::Login {

3931

            self.send(&format!(

3932

                "{VERSION_ID} reset_password {}\n",

3933

                self.text_input

3934

));

3935

3936

3937

3938

    #[must_use]

3939

    #[allow(clippy::too_many_lines)]

3940

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

3941

        match self.screen {

3942

            Screen::EmailEveryone => {

3943

                let subject = row![

3944

                    text("Subject: "),

3945

                    widget::text_input("", &self.text_input)

3946

                        .on_input(Message::TextChanged)

3947

                        .on_paste(Message::TextChanged)

3948

                        .on_submit(Message::TextSend),

3949

];

3950

3951

                let editor = text_editor(&self.content)

3952

                    .placeholder("Dear User, …")

3953

                    .on_action(Message::TextEdit);

3954

3955

                let send_emails = button("Send Emails").on_press(Message::TextSend);

3956

                let leave = button(text!("{} (Esc)", t!("Quit"))).on_press(Message::Leave);

3957

                let mut column = column![

3958

                    subject,

3959

                    text("From: Hnefatafl Org <noreply@hnefatafl.org>"),

3960

                    text("Content-Type: text/plain; charset=utf-8"),

3961

                    text("Content-Transfer-Encoding: 7bit"),

3962

                    text!("Date: {}", Timestamp::now().strftime("%F %T UTC")),

3963

                    text("Body:"),

3964

                    editor,

3965

                    send_emails,

3966

                    leave,

3967

                    text("Bcc:")

3968

3969

                .spacing(SPACING)

3970

                .padding(PADDING);

3971

3972

                for email in &self.emails_bcc {

3973

                    column = column.push(text(email));

3974

3975

3976

                scrollable(column).spacing(SPACING).into()

3977

3978

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

3979

            Screen::Games => Tabs::new(Message::TabSelected)

3980

                .push(

3981

                    TabId::Games,

3982

                    iced_aw::TabLabel::Text(format!("{} (1)", t!("Games"))),

3983

                    self.games_view(),

3984

3985

                .push(

3986

                    TabId::GameNew,

3987

                    iced_aw::TabLabel::Text(format!("{} (2)", t!("Create Game"))),

3988

                    self.game_new_view(),

3989

3990

                .push(

3991

                    TabId::Tournament,

3992

                    iced_aw::TabLabel::Text(format!("{} (3)", t!("Tournament"))),

3993

                    self.tournament_view(),

3994

3995

                .push(

3996

                    TabId::AccountSettings,

3997

                    iced_aw::TabLabel::Text(format!("{} (4)", t!("Account Settings"))),

3998

                    self.account_settings_view(),

3999

4000

                .push(

4001

                    TabId::Users,

4002

                    iced_aw::TabLabel::Text(format!("{} (5)", t!("Users"))),

4003

                    column![

4004

                        button(text!("{} (Esc)", t!("Quit"))).on_press(Message::Leave),

4005

                        self.users(true)

4006

4007

                    .padding(PADDING)

4008

                    .spacing(SPACING),

4009

4010

                .height(Length::Shrink)

4011

                .width(Length::Fill)

4012

                .set_active_tab(&self.active_tab)

4013

                .into(),

4014

            Screen::Login => {

4015

                let username = row![

4016

                    text!("{}:", t!("username")).size(20),

4017

                    widget::text_input("", &self.text_input)

4018

                        .on_input(Message::TextChanged)

4019

                        .on_paste(Message::TextChanged),

4020

4021

                .spacing(SPACING);

4022

4023

                let username = container(username)

4024

                    .padding(PADDING)

4025

                    .style(container::bordered_box);

4026

4027

                let password = row![

4028

                    text!("{}:", t!("password")).size(20),

4029

                    widget::text_input("", &self.password)

4030

                        .secure(!self.password_show)

4031

                        .on_input(Message::PasswordChanged)

4032

                        .on_paste(Message::PasswordChanged),

4033

4034

                .spacing(SPACING);

4035

4036

                let password = container(password)

4037

                    .padding(PADDING)

4038

                    .style(container::bordered_box);

4039

4040

                let show_password_text = text!("{} (1)", t!("show password"));

4041

                let show_password = checkbox(self.password_show).on_toggle(Message::PasswordShow);

4042

4043

                let save_password_text = text!("{} (2)", t!("save password"));

4044

                let save_password = checkbox(self.password_save).on_toggle(Message::PasswordSave);

4045

4046

                let mut login = button(text!("{} (Enter)", t!("Login")));

4047

                if !self.password_ends_with_whitespace {

4048

                    login = login.on_press(Message::TextSendLogin);

4049

4050

4051

                let mut create_account = button(text!("{} (4)", t!("Create Account")));

4052

                if !self.text_input.is_empty() && !self.password_ends_with_whitespace {

4053

                    create_account = create_account.on_press(Message::TextSendCreateAccount);

4054

4055

4056

                let mut reset_password = button(text!("{} (5)", t!("Reset Password")));

4057

                if !self.text_input.is_empty() {

4058

                    reset_password = reset_password.on_press(Message::ResetPassword);

4059

4060

4061

                let mut error = text("");

4062

                if let Some(error_) = &self.error {

4063

                    error = text(error_).style(text::danger);

4064

4065

4066

                let mut error_persistent = Column::new();

4067

                for error in &self.error_persistent {

4068

                    error_persistent = error_persistent.push(text(error).style(text::danger));

4069

4070

4071

                let minimum_rating = number_input(

4072

                    &self.rating_minimum,

4073

                    0.0..=self.rating_maximum,

4074

                    Message::RatingMinimumChanged,

4075

);

4076

4077

                let maximum_rating = number_input(

4078

                    &self.rating_maximum,

4079

                    self.rating_minimum..=MAX_RATING,

4080

                    Message::RatingMaximumChanged,

4081

);

4082

4083

                let mut review_game = button(text!("{} (a)", t!("Review Game")));

4084

                if self.archived_game_selected.is_some() {

4085

                    review_game = review_game.on_press(Message::ReviewGame);

4086

4087

4088

                let review_game = row![

4089

                    review_game,

4090

                    button(text!("{} (b)", t!("Minimum Rating"))).on_press(Message::RatingMinimum),

4091

                    minimum_rating,

4092

                    button(text!("{} (c)", t!("Maximum Rating"))).on_press(Message::RatingMaximum),

4093

                    maximum_rating

4094

4095

                .spacing(SPACING);

4096

4097

                let archived_games = if let Some(archived_games) = &self.archived_games_filtered {

4098

                    archived_games.clone()

4099

                } else {

4100

                    self.archived_games.clone()

4101

};

4102

4103

                let my_games_text = text!("{} (3)", t!("My Games Only"));

4104

                let my_games = checkbox(self.my_games_only).on_toggle(Message::MyGamesOnly);

4105

                let quit = button(text!("{} (Esc)", t!("Quit"))).on_press(Message::Leave);

4106

4107

                let buttons_1 = row![login, create_account, reset_password, quit].spacing(SPACING);

4108

4109

                let review_game_pick = pick_list(

4110

                    archived_games,

4111

                    self.archived_game_selected.clone(),

4112

                    Message::ArchivedGameSelected,

4113

4114

                .placeholder(t!("Archived Games"));

4115

4116

                let locale = [

4117

                    Locale::English,

4118

                    Locale::Chinese,

4119

                    Locale::Spanish,

4120

                    Locale::Arabic,

4121

                    Locale::Indonesian,

4122

                    Locale::PortugueseBr,

4123

                    Locale::PortuguesePt,

4124

                    Locale::French,

4125

                    Locale::Japanese,

4126

                    Locale::Russian,

4127

                    Locale::German,

4128

                    Locale::Icelandic,

4129

                    Locale::IcelandicRunic,

4130

                    Locale::Swedish,

4131

                    Locale::Korean,

4132

];

4133

4134

                let locale = row![

4135

                    text!("{}: ", t!("locale")).size(20),

4136

                    pick_list(locale, self.locale_selected, Message::LocaleSelected),

4137

];

4138

4139

                let theme = if self.theme == Theme::Light {

4140

                    row![

4141

                        button(text!("{} (6)", t!("Dark")))

4142

                            .on_press(Message::ChangeTheme(Theme::Dark)),

4143

                        button(text!("{} (7)", t!("Light"))),

4144

                        button(text("Tol (8)")).on_press(Message::ChangeTheme(Theme::Tol)),

4145

4146

                    .spacing(SPACING)

4147

                } else if self.theme == Theme::Dark {

4148

                    row![

4149

                        button(text!("{} (6)", t!("Dark"))),

4150

                        button(text!("{} (7)", t!("Light")))

4151

                            .on_press(Message::ChangeTheme(Theme::Light)),

4152

                        button(text("Tol (8)")).on_press(Message::ChangeTheme(Theme::Tol)),

4153

4154

                    .spacing(SPACING)

4155

                } else {

4156

                    row![

4157

                        button(text!("{} (6)", t!("Dark")))

4158

                            .on_press(Message::ChangeTheme(Theme::Dark)),

4159

                        button(text!("{} (7)", t!("Light")))

4160

                            .on_press(Message::ChangeTheme(Theme::Light)),

4161

                        button(text("Tol (8)")),

4162

4163

                    .spacing(SPACING)

4164

};

4165

4166

                let theme = LabeledFrame::new(text(t!("Theme")), theme);

4167

                let discord = button(text!("Discord (9)")).on_press(Message::OpenUrl(

4168

                    "https://discord.gg/h56CAHEBXd".to_string(),

4169

));

4170

4171

                let website = button(text!("{} (0)", t!("Rules"))).on_press(Message::OpenUrl(

4172

                    "https://hnefatafl.org/rules.html".to_string(),

4173

));

4174

4175

                let websites = row![discord, website].spacing(SPACING);

4176

                let websites = LabeledFrame::new(text(t!("Websites")), websites);

4177

                let help_text = container(text!(

4178

                    "Tab: {}, Shift + Tab: {}",

4179

                    self.chars.arrow_right,

4180

                    self.chars.arrow_left

4181

))

4182

                .padding(PADDING)

4183

                .style(container::bordered_box);

4184

4185

                let help_text_2 = text(t!(

4186

                    "You must hold down the control (Ctrl) or command (⌘) key when pressing a lettered or numbered hotkey."

4187

));

4188

4189

                let help_text_3 = text(t!(

4190

                    "You can play on the board by pressing control (Ctrl) or command (⌘) and a letter then a number or vice versa."

4191

));

4192

4193

                let help_text_4 = text(t!(

4194

                    "You have at maximum a week to move, then you lose the game."

4195

));

4196

4197

                column![

4198

                    username,

4199

                    password,

4200

                    row![

4201

                        show_password,

4202

                        show_password_text,

4203

                        save_password,

4204

                        save_password_text,

4205

                        my_games,

4206

                        my_games_text,

4207

4208

                    .spacing(SPACING),

4209

                    buttons_1,

4210

                    row![theme, websites].spacing(SPACING),

4211

                    locale,

4212

                    review_game,

4213

                    review_game_pick,

4214

                    help_text,

4215

                    help_text_2,

4216

                    help_text_3,

4217

                    help_text_4,

4218

                    error,

4219

                    error_persistent

4220

4221

                .padding(PADDING)

4222

                .spacing(SPACING)

4223

                .into()

4224

4225

4226

4227

4228

    fn reset_email(&mut self) {

4229

        self.email = None;

4230

        self.send("email_reset\n");

4231

4232

4233

    fn reset_markers(&mut self) {

4234

        self.captures = HashSet::new();

4235

        self.play_from = None;

4236

        self.play_from_previous = None;

4237

        self.play_to_previous = None;

4238

4239

4240

    fn review_game(&mut self) {

4241

        if let Some(archived_game) = &self.archived_game_selected {

4242

            self.archived_game_handle = Some(ArchivedGameHandle::new(archived_game));

4243

            self.screen = Screen::GameReview;

4244

4245

            self.captures = HashSet::new();

4246

            self.reset_markers();

4247

4248

4249

4250

    fn save_client_postcard(&self) -> anyhow::Result<()> {

4251

        let postcard_bytes = postcard::to_allocvec(&self.archived_games)?;

4252

        if !postcard_bytes.is_empty() {

4253

            let mut file = File::create(data_file(ARCHIVED_GAMES_FILE))?;

4254

            file.write_all(&postcard_bytes)?;

4255

4256

4257

        Ok(())

4258

4259

4260

    fn save_client_ron(&self) -> anyhow::Result<()> {

4261

        let password = if self.password_save {

4262

            self.password.clone()

4263

        } else {

4264

            String::new()

4265

};

4266

4267

        let client = Client {

4268

            archived_games: Vec::new(),

4269

            coordinates: self.coordinates,

4270

            locale_selected: self.locale_selected,

4271

            my_games_only: self.my_games_only,

4272

            password,

4273

            password_save: self.password_save,

4274

            password_show: self.password_show,

4275

            rating_maximum: self.rating_maximum,

4276

            rating_minimum: self.rating_minimum,

4277

            sound_muted: self.sound_muted,

4278

            theme: self.theme,

4279

            username: self.username.clone(),

4280

            ..Client::default()

4281

};

4282

4283

        let ron_string = ron::ser::to_string_pretty(&client, ron::ser::PrettyConfig::new())?;

4284

        if !ron_string.is_empty() {

4285

            let mut file = File::create(data_file(USER_CONFIG_FILE))?;

4286

            file.write_all(ron_string.as_bytes())?;

4287

4288

4289

        Ok(())

4290

4291

4292

    fn send(&mut self, string: &str) {

4293

        if let Err(error) = self

4294

.tx

4295

            .as_mut()

4296

            .unwrap_or_else(|| {

4297

                error!("Error sending {string:?}: you should have a tx available by now");

4298

                unreachable!();

4299

})

4300

            .send(string.to_string())

4301

4302

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

4303

            exit(1);

4304

4305

4306

4307

    fn send_estimate_score(&mut self, tree: Tree) {

4308

        handle_error(

4309

            self.estimate_score_tx

4310

                .as_mut()

4311

                .unwrap_or_else(|| {

4312

                    error!("Error sending {tree:?}: you should have a tx available by now");

4313

                    unreachable!();

4314

})

4315

                .send(tree),

4316

);

4317

4318

4319

    fn toggle_save_password(&mut self) {

4320

        self.password_save = !self.password_save;

4321

        handle_error(self.save_client_ron());

4322

4323

4324

    fn toggle_show_password(&mut self) {

4325

        self.password_show = !self.password_show;

4326

        handle_error(self.save_client_ron());

4327

4328

4329

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

4330

        let mut column = Column::new().padding(PADDING).spacing(SPACING);

4331

4332

        if self.admin_tournament {

4333

            let date_button = Button::new(text("Tournament Date")).on_press(Message::DateChoose);

4334

4335

            let date_picker = date_picker(

4336

                self.tournament_date_show_picker,

4337

                self.tournament_date,

4338

                date_button,

4339

                Message::DateCancel,

4340

                Message::DateSubmit,

4341

);

4342

4343

            let mut delete_button = button("Delete Tournament");

4344

4345

            if self.tournament.is_some() {

4346

                delete_button = delete_button.on_press(Message::TournamentDelete);

4347

4348

4349

            let row = row![date_picker, delete_button].spacing(SPACING);

4350

4351

            column = column.push(row);

4352

4353

4354

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

4355

            column = column.push(text(t!("There is no tournament.")));

4356

            column = column.push(button(text!("{} (Esc)", t!("Quit"))).on_press(Message::Leave));

4357

4358

            return scrollable(column).spacing(SPACING);

4359

};

4360

4361

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

4362

        let start_date = t!("Tournament Start Date");

4363

        date = date.push(text!(

4364

            "{start_date}: {}",

4365

            tournament.date.strftime("%F %T UTC")

4366

));

4367

4368

        let button_0 =

4369

            button(text!("{} (6)", t!("Tournaments Described"))).on_press(Message::Tournaments);

4370

4371

        let mut button_1 = button(text!("{} (7)", t!("Join Tournament")));

4372

        let mut button_2 = button(text!("{} (8)", t!("Leave Tournament")));

4373

4374

        if tournament.players.contains(&self.username) {

4375

            button_2 = button_2.on_press(Message::TournamentLeave);

4376

        } else {

4377

            button_1 = button_1.on_press(Message::TournamentJoin);

4378

4379

4380

        let buttons = row![

4381

            button_0,

4382

            button_1,

4383

            button_2,

4384

            button(text!("{} (Esc)", t!("Quit"))).on_press(Message::Leave),

4385

4386

        .spacing(SPACING);

4387

4388

        let mut players = Column::new();

4389

        let mut player_names: Vec<_> = tournament.players.iter().collect();

4390

        player_names.sort();

4391

4392

        for player in &player_names {

4393

            players = players.push(text(*player));

4394

4395

4396

        column = column.push(date);

4397

        column = column.push(buttons);

4398

        column = column.push(LabeledFrame::new(text(t!("Players")), players));

4399

4400

        if self.admin_tournament {

4401

            let mut delete_button = button("Delete Tournament Tree");

4402

4403

            if let Some(tournament) = &self.tournament

4404

                && tournament.groups.is_some()

4405

4406

                delete_button = delete_button.on_press(Message::TournamentTreeDelete);

4407

4408

4409

            let mut start_tournament = button("Start Tournament");

4410

4411

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

4412

                if tournament.groups.is_none() {

4413

                    start_tournament = start_tournament.on_press(Message::TournamentStart);

4414

4415

            } else {

4416

                start_tournament = start_tournament.on_press(Message::TournamentStart);

4417

4418

4419

            column = column.push(row![start_tournament, delete_button].spacing(SPACING));

4420

4421

4422

        column = column.push(self.display_tournament());

4423

        scrollable(column).spacing(SPACING)

4424

4425

4426

    fn letter(

4427

        &self,

4428

        letter: char,

4429

        column: Column<'a, Message>,

4430

        letter_size: u32,

4431

    ) -> Column<'a, Message> {

4432

        let mut text = text(letter).size(letter_size);

4433

        if self.press_letters.contains(&letter.to_ascii_lowercase()) {

4434

            text = text.style(text::success);

4435

4436

4437

        column.push(text)

4438

4439

4440

    fn numbers(&self, letter_size: u32, spacing: u32, board_size: usize) -> Column<'a, Message> {

4441

        let mut column = column![text(" ").size(letter_size)].spacing(spacing);

4442

4443

        for i in 0..board_size {

4444

            let i = board_size - i;

4445

            let mut text = text!("{i:2}").size(letter_size).align_y(Vertical::Center);

4446

            if self.press_numbers[i - 1] {

4447

                text = text.style(text::success);

4448

4449

            column = column.push(text);

4450

4451

4452

        column

4453

4454