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

// Fixme: we reuse the email when you log out ans switch accounts.

24

25

mod archived_game_handle;

26

mod command_line;

27

mod dimensions;

28

mod enums;

29

mod new_game_settings;

30

mod tabs;

31

mod user;

32

mod volume;

33

34

use std::{

35

    collections::{HashMap, HashSet, VecDeque},

36

    fmt::{self, Write as _},

37

    fs::{self, File},

38

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

39

    net::{Shutdown, TcpStream, ToSocketAddrs},

40

    process::exit,

41

    str::{FromStr, SplitAsciiWhitespace},

42

    sync::mpsc,

43

    thread::{self, sleep},

44

    time::Duration,

45

};

46

47

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

48

use clap::{CommandFactory, Parser};

49

use hnefatafl_copenhagen::{

50

    COPYRIGHT, Id, SERVER_PORT, VERSION_ID,

51

    accounts::{Account, Accounts},

52

    board::{Board, BoardSize},

53

    characters::Characters,

54

    draw::Draw,

55

    email::Email,

56

    game::{Game, LegalMoves, TimeUnix},

57

    heat_map::{Heat, HeatMap},

58

    locale::Locale,

59

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

60

    rating::Rated,

61

    role::Role,

62

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

63

    space::Space,

64

    status::Status,

65

    tcp_keep_alive,

66

    time::{TimeEnum, TimeSettings},

67

    tournament::Tournament,

68

    tree::Tree,

69

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

70

};

71

#[cfg(target_os = "linux")]

72

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

73

use iced::{

74

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

75

    alignment::{Horizontal, Vertical},

76

    color, event,

77

    futures::{SinkExt, Stream, executor},

78

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

79

    stream,

80

    theme::Palette,

81

    widget::{

82

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

83

        operation::{focus_next, focus_previous},

84

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

85

},

86

    window::{self, icon},

87

};

88

use iced_aw::{

89

    ICED_AW_FONT_BYTES, Tabs, date_picker::Date, helpers::date_picker, widget::LabeledFrame,

90

};

91

use image::ImageFormat;

92

use jiff::Timestamp;

93

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

94

use rust_i18n::t;

95

use smol_str::ToSmolStr;

96

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

97

use sys_locale::{get_locale, get_locales};

98

99

use crate::{

100

    archived_game_handle::ArchivedGameHandle,

101

    command_line::Args,

102

    dimensions::Dimensions,

103

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

104

    new_game_settings::NewGameSettings,

105

    tabs::TabId,

106

    user::User,

107

    volume::{MAX_VOLUME, Volume},

108

};

109

110

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

111

/// color blind.

112

///

113

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

114

pub const TOL: Palette = Palette {

115

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

116

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

117

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

118

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

119

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

120

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

121

};

122

123

const ALPHABET: [char; 26] = [

124

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

125

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

126

];

127

128

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

129

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

130

131

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

132

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

133

134

const BOARD_LETTERS_LOWERCASE: [char; 13] = [

135

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

136

];

137

138

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

139

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

140

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

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

159

    let mut strings = HashMap::new();

160

161

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

162

    strings.insert(

163

        "Create Account".to_string(),

164

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

165

);

166

    strings.insert(

167

        "Reset Password".to_string(),

168

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

169

);

170

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

171

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

172

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

173

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

174

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

175

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

176

    strings.insert(

177

        "Account Settings".to_string(),

178

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

179

);

180

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

181

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

182

    strings.insert(

183

        "Change Password".to_string(),

184

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

185

);

186

    strings.insert(

187

        "Delete Account".to_string(),

188

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

189

);

190

    strings.insert(

191

        "REALLY DELETE ACCOUNT".to_string(),

192

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

193

);

194

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

195

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

196

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

197

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

198

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

199

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

200

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

201

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

202

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

203

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

204

    strings.insert(

205

        "Get Archived Games".to_string(),

206

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

207

);

208

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

209

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

210

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

211

    strings.insert(

212

        "Join Tournament".to_string(),

213

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

214

);

215

    strings.insert(

216

        "Leave Tournament".to_string(),

217

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

218

);

219

    strings.insert(

220

        "Tournaments Described".to_string(),

221

        t!("Tournaments Described").to_string(),

222

);

223

224

    strings

225

226

227

#[allow(clippy::too_many_lines)]

228

fn init_client() -> Client {

229

    let archived_games_file = data_file(ARCHIVED_GAMES_FILE);

230

    let user_file = data_file(USER_CONFIG_FILE);

231

    let mut error = Vec::new();

232

233

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

234

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

235

            Ok(client) => client,

236

            Err(err) => {

237

                error.push(format!(

238

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

239

                    user_file.display()

240

));

241

                Client::default()

242

243

},

244

        Err(err) => {

245

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

246

                error.push(format!(

247

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

248

                    user_file.display()

249

));

250

                Client::default()

251

            } else {

252

                error.push(format!(

253

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

254

                    user_file.display()

255

));

256

                Client::default()

257

258

259

};

260

261

    client.tournament_date = Date::today();

262

263

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

264

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

265

    } else {

266

        let mut locale_1 = None;

267

268

        if get_locales().count() > 0 {

269

            for locale_2 in get_locales() {

270

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

271

                    locale_1 = Some(locale);

272

                    break;

273

274

275

276

277

        if locale_1.is_none() {

278

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

279

280

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

281

                locale_1 = Some(locale);

282

            } else {

283

                locale_1 = Some(Locale::English);

284

285

286

287

        if let Some(locale) = locale_1 {

288

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

289

            client.locale_selected = Some(locale);

290

            client

291

                .save_client_ron()

292

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

293

294

295

296

    client.strings = i18n_buttons();

297

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

298

299

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

300

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

301

            Ok(client) => client,

302

            Err(err) => {

303

                error.push(format!(

304

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

305

                    archived_games_file.display()

306

));

307

                Vec::new()

308

309

},

310

        Err(err) => {

311

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

312

                error.push(format!(

313

                    "{}: {}",

314

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

315

                    archived_games_file.display()

316

));

317

                Vec::new()

318

            } else {

319

                error.push(format!(

320

                    "{} {}: {err}",

321

                    t!("Error opening the file"),

322

                    archived_games_file.display()

323

));

324

                Vec::new()

325

326

327

};

328

329

    client.archived_games = archived_games;

330

    client.error_persistent = error;

331

332

    let args = Args::parse();

333

    if args.ascii {

334

        client.chars.ascii();

335

336

337

    let mut letters = HashMap::new();

338

    for ch in BOARD_LETTERS_LOWERCASE {

339

        letters.insert(ch, false);

340

341

342

    client

343

344

345

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

346

    let args = Args::parse();

347

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

348

349

    if args.man {

350

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

351

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

352

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

353

354

        man.render(&mut buffer)?;

355

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

356

357

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

358

        return Ok(());

359

360

361

    create_data_folder()?;

362

363

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

364

        .title("Hnefatafl Copenhagen")

365

        .subscription(Client::subscriptions)

366

        .window(window::Settings {

367

            #[cfg(target_os = "linux")]

368

            platform_specific: PlatformSpecific {

369

                application_id: APPLICATION_ID.to_string(),

370

                ..PlatformSpecific::default()

371

},

372

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

373

            ..window::Settings::default()

374

})

375

        .font(ICED_AW_FONT_BYTES)

376

        .theme(Client::theme);

377

378

    // For screenshots.

379

    if args.tiny_window {

380

        application = application.window_size(iced::Size {

381

            width: 868.0,

382

            height: 541.0,

383

});

384

385

386

    if args.social_preview {

387

        application = application.window_size(iced::Size {

388

            width: 1148.0,

389

            height: 481.0,

390

});

391

392

393

    application.run()?;

394

    Ok(())

395

396

397

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

398

    let args = Args::parse();

399

400

    stream::channel(

401

        100,

402

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

403

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

404

405

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

406

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

407

                exit(1);

408

409

410

            thread::spawn(move || {

411

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

412

                    Ok(ai) => ai,

413

                    Err(error) => {

414

                        error!("{error}");

415

                        exit(1);

416

417

};

418

419

                for tree in &rx {

420

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

421

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

422

423

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

424

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

425

) {

426

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

427

                        exit(1);

428

429

430

});

431

},

432

433

434

435

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

436

    match result {

437

        Ok(value) => value,

438

        Err(error) => {

439

            error!("{error}");

440

            exit(1)

441

442

443

444

445

fn open_url(url: &str) {

446

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

447

        error!("{error}");

448

449

450

451

#[allow(clippy::too_many_lines)]

452

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

453

    stream::channel(

454

        100,

455

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

456

            let mut args = Args::parse();

457

            args.host.push_str(SERVER_PORT);

458

            let address_string = args.host;

459

460

            thread::spawn(move || {

461

                'start_over: loop {

462

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

463

464

                    if let Err(error) =

465

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

466

467

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

468

                        exit(1);

469

470

471

                    loop {

472

                        let message = match rx.recv() {

473

                            Ok(message) => message,

474

                            Err(error) => {

475

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

476

477

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

478

                                    error!("{error}");

479

480

481

                                return;

482

483

};

484

                        let message_trim = message.trim();

485

486

                        if message_trim == "tcp_connect" {

487

                            break;

488

489

490

491

                    let mut is_ipv6 = false;

492

                    let mut socket_address = None;

493

                    let socket_addresses = match address_string.to_socket_addrs() {

494

                        Ok(socket_addresses) => socket_addresses,

495

                        Err(error) => {

496

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

497

498

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

499

                            handle_error(executor::block_on(

500

                                sender.send(Message::TcpConnectFailed),

501

));

502

503

                            continue 'start_over;

504

505

};

506

507

                    for address in socket_addresses.clone() {

508

                        if address.is_ipv6() {

509

                            socket_address = Some(address);

510

                            is_ipv6 = true;

511

                            break;

512

513

514

515

                    if !is_ipv6 {

516

                        for address in socket_addresses {

517

                            if address.is_ipv4() {

518

                                socket_address = Some(address);

519

                                break;

520

521

522

523

524

                    let Some(socket_address) = socket_address else {

525

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

526

527

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

528

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

529

530

                        continue 'start_over;

531

};

532

533

                    let address: SockAddr = socket_address.into();

534

                    let keep_alive = tcp_keep_alive();

535

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

536

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

537

                    handle_error(socket.set_tcp_keepalive(&keep_alive));

538

539

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

540

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

541

                            handle_error(executor::block_on(

542

                                sender.send(Message::TcpConnectFailed),

543

));

544

                        } else {

545

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

546

547

548

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

549

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

550

551

                        continue 'start_over;

552

553

554

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

555

556

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

557

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

558

559

                    let mut sender_clone = sender.clone();

560

                    thread::spawn(move || {

561

                        for message in rx {

562

                            let message_trim = message.trim();

563

564

                            if message_trim == "ping" {

565

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

566

                            } else {

567

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

568

569

570

                            if message_trim == "quit" {

571

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

572

                                    tcp_stream

573

                                        .shutdown(Shutdown::Both)

574

                                        .expect("shutdown call failed");

575

576

577

                                return;

578

579

580

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

581

582

583

                        for _ in 0..2 {

584

                            if let Err(error) =

585

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

586

587

                                error!("{error}");

588

589

590

591

                        if let Err(error) =

592

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

593

594

                            error!("{error}");

595

596

});

597

598

                    let mut buffer = String::new();

599

                    handle_error(executor::block_on(

600

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

601

));

602

603

                    if cfg!(target_os = "redox") {

604

                        sleep(Duration::from_secs(1));

605

606

607

                    loop {

608

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

609

                        if bytes > 0 {

610

                            let buffer_trim = buffer.trim();

611

                            let buffer_trim_vec: Vec<_> =

612

                                buffer_trim.split_ascii_whitespace().collect();

613

614

                            if buffer_trim_vec[1] == "display_users"

615

                                || buffer_trim_vec[1] == "display_games"

616

                                || buffer_trim_vec[1] == "ping"

617

618

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

619

                            } else {

620

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

621

622

623

                            handle_error(executor::block_on(

624

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

625

));

626

627

                            if buffer_trim_vec[1] == "archived_games" {

628

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

629

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

630

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

631

                                let archived_games: Vec<ArchivedGame> =

632

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

633

634

                                handle_error(executor::block_on(

635

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

636

));

637

638

639

                            buffer.clear();

640

                        } else {

641

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

642

                            continue 'start_over;

643

644

645

646

});

647

},

648

649

650

651

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

652

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

653

    text.join(" ")

654

655

656

#[allow(clippy::struct_excessive_bools)]

657

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

658

struct Client {

659

    #[serde(skip)]

660

    accounts: Accounts,

661

    #[serde(skip)]

662

    active_tab: TabId,

663

    #[serde(skip)]

664

    admin: bool,

665

    #[serde(skip)]

666

    admin_tournament: bool,

667

    #[serde(skip)]

668

    attacker: String,

669

    #[serde(default)]

670

    archived_games: Vec<ArchivedGame>,

671

    #[serde(skip)]

672

    archived_games_filtered: Option<Vec<ArchivedGame>>,

673

    #[serde(skip)]

674

    archived_game_selected: Option<ArchivedGame>,

675

    #[serde(skip)]

676

    archived_game_handle: Option<ArchivedGameHandle>,

677

    #[serde(default)]

678

    coordinates: Coordinates,

679

    #[serde(skip)]

680

    defender: String,

681

    #[serde(skip)]

682

    delete_account: bool,

683

    #[serde(skip)]

684

    estimate_score: bool,

685

    #[serde(skip)]

686

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

687

    #[serde(skip)]

688

    captures: HashSet<Vertex>,

689

    #[serde(skip)]

690

    counter: u64,

691

    #[serde(skip)]

692

    chars: Characters,

693

    #[serde(skip)]

694

    challenger: bool,

695

    #[serde(skip)]

696

    connected_tcp: bool,

697

    #[serde(skip)]

698

    connected_to: String,

699

    #[serde(skip)]

700

    content: text_editor::Content,

701

    #[serde(skip)]

702

    email: Option<Email>,

703

    #[serde(skip)]

704

    email_input: String,

705

    #[serde(skip)]

706

    emails_bcc: Vec<String>,

707

    #[serde(skip)]

708

    error: Option<String>,

709

    #[serde(skip)]

710

    error_email: Option<String>,

711

    #[serde(skip)]

712

    error_persistent: Vec<String>,

713

    #[serde(skip)]

714

    game: Option<Game>,

715

    #[serde(skip)]

716

    game_id: Id,

717

    #[serde(skip)]

718

    games_light: ServerGamesLight,

719

    #[serde(skip)]

720

    games_light_vec: Vec<ServerGameLight>,

721

    #[serde(skip)]

722

    game_settings: NewGameSettings,

723

    #[serde(skip)]

724

    heat_map: Option<HeatMap>,

725

    #[serde(skip)]

726

    heat_map_display: bool,

727

    #[serde(default)]

728

    locale_selected: Option<Locale>,

729

    #[serde(default)]

730

    my_games_only: bool,

731

    #[serde(skip)]

732

    my_turn: bool,

733

    #[serde(skip)]

734

    now: i64,

735

    #[serde(skip)]

736

    now_diff: i64,

737

    #[serde(default)]

738

    password: String,

739

    #[serde(skip)]

740

    password_ends_with_whitespace: bool,

741

    #[serde(default)]

742

    password_save: bool,

743

    #[serde(default)]

744

    password_show: bool,

745

    #[serde(skip)]

746

    play_from: Option<Vertex>,

747

    #[serde(skip)]

748

    play_from_previous: Option<Vertex>,

749

    #[serde(skip)]

750

    play_to_previous: Option<Vertex>,

751

    #[serde(skip)]

752

    press_letters: HashSet<char>,

753

    #[serde(skip)]

754

    press_numbers: [bool; 13],

755

    #[serde(skip)]

756

    request_draw: bool,

757

    #[serde(skip)]

758

    screen: Screen,

759

    #[serde(skip)]

760

    screen_size: Size,

761

    #[serde(default)]

762

    sound_muted: bool,

763

    #[serde(skip)]

764

    spectators: Vec<String>,

765

    #[serde(skip)]

766

    status: Status,

767

    #[serde(skip)]

768

    strings: HashMap<String, String>,

769

    #[serde(skip)]

770

    texts: VecDeque<String>,

771

    #[serde(skip)]

772

    texts_game: VecDeque<String>,

773

    #[serde(skip)]

774

    text_input: String,

775

    #[serde(default)]

776

    theme: Theme,

777

    #[serde(skip)]

778

    time_attacker: TimeSettings,

779

    #[serde(skip)]

780

    time_defender: TimeSettings,

781

    #[serde(skip)]

782

    tournament: Option<Tournament>,

783

    #[serde(skip)]

784

    tournament_date: Date,

785

    #[serde(skip)]

786

    tournament_date_show_picker: bool,

787

    #[serde(skip)]

788

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

789

    #[serde(default)]

790

    username: String,

791

    #[serde(skip)]

792

    users: HashMap<String, User>,

793

    #[serde(skip)]

794

    users_sort_by: SortBy,

795

    #[serde(default)]

796

    volume: Volume,

797

798

799

impl<'a> Client {

800

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

801

        let mut columns = column![

802

            text!(

803

                "{} {} {} TCP",

804

                t!("connected to"),

805

                &self.connected_to,

806

                t!("via")

807

),

808

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

809

810

        .padding(PADDING)

811

        .spacing(SPACING);

812

813

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

814

            let mut row = Row::new();

815

            if email.verified {

816

                row = row.push(text!(

817

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

818

                    t!("email address"),

819

                    t!("verified"),

820

                    email.address,

821

));

822

                columns = columns.push(row);

823

            } else {

824

                row = row.push(text!(

825

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

826

                    t!("email address"),

827

                    t!("unverified"),

828

                    email.address,

829

));

830

                columns = columns.push(row);

831

832

                let mut row = Row::new();

833

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

834

                row = row.push(

835

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

836

                        .on_input(Message::EmailChanged)

837

                        .on_paste(Message::EmailChanged)

838

                        .on_submit(Message::TextSendEmailCode),

839

);

840

                columns = columns.push(row);

841

842

        } else {

843

            let mut row = Row::new();

844

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

845

            row = row.push(

846

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

847

                    .on_input(Message::EmailChanged)

848

                    .on_paste(Message::EmailChanged)

849

                    .on_submit(Message::TextSendEmail),

850

);

851

852

            columns = columns.push(row);

853

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

854

855

856

        columns = columns.push(row![

857

            button(text!("{} (6)", self.strings["Reset Email"].as_str()))

858

                .on_press(Message::EmailReset)

859

]);

860

861

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

862

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

863

864

865

        let mut change_password_button =

866

            button(text!("{} (7)", self.strings["Change Password"].as_str()));

867

868

        if !self.password_ends_with_whitespace {

869

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

870

871

872

        columns = columns.push(

873

            row![

874

                change_password_button,

875

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

876

                    .secure(!self.password_show)

877

                    .on_input(Message::PasswordChanged)

878

                    .on_paste(Message::PasswordChanged),

879

880

            .spacing(SPACING),

881

);

882

883

        columns = columns.push(

884

            row![

885

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

886

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

887

888

            .spacing(SPACING),

889

);

890

891

        if self.delete_account {

892

            columns = columns.push(

893

                button(text!(

894

                    "{} (9)",

895

                    self.strings["REALLY DELETE ACCOUNT"].as_str()

896

))

897

                .on_press(Message::DeleteAccount),

898

);

899

        } else {

900

            columns = columns.push(

901

                button(text!("{} (9)", self.strings["Delete Account"].as_str()))

902

                    .on_press(Message::DeleteAccount),

903

);

904

905

906

        columns = columns.push(

907

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

908

);

909

910

        columns

911

912

913

    fn archived_game_reset(&mut self) {

914

        self.archived_game_handle = None;

915

        self.archived_game_selected = None;

916

917

918

    #[must_use]

919

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

920

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

921

        let board_size = board.size();

922

        let board_size_usize: usize = board_size.into();

923

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

924

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

925

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

926

        let possible_moves = self.possible_moves();

927

928

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

929

        if coordinates {

930

            game_display =

931

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

932

933

934

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

935

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

936

937

            if coordinates {

938

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

939

940

941

            for y in 0..board_size_usize {

942

                let vertex = Vertex {

943

                    size: board.size(),

944

x,

945

y,

946

};

947

948

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

949

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

950

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

951

                    Space::Empty => {

952

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

953

                            text(arrow)

954

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

955

                            text(&self.chars.captured)

956

                        } else if vertex.on_restricted_square() {

957

                            text(&self.chars.restricted_square)

958

                        } else {

959

                            text(" ")

960

961

962

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

963

};

964

965

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

966

                    && possible_moves.is_some()

967

968

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

969

                        let space = board.get(vertex_from);

970

                        let turn = Role::from(space);

971

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

972

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

973

974

                            if heat == Heat::UnRanked {

975

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

976

                            } else {

977

                                let txt_char = match space {

978

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

979

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

980

                                    Space::Empty => "",

981

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

982

};

983

984

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

985

                                    0.0,

986

                                    0.0,

987

                                    0.0,

988

                                    heat.into(),

989

));

990

991

992

                    } else {

993

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

994

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

995

996

997

998

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

999

                let mut button = button(txt)

1000

                    .width(d.board_dimension)

1001

                    .height(d.board_dimension);

1002

1003

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

1004

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

1005

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

1006

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

1007

                    Move::None => {}

1008

1009

1010

                column = column.push(button);

1011

1012

1013

            if coordinates {

1014

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

1015

1016

1017

            game_display = game_display.push(column);

1018

1019

1020

        if coordinates {

1021

            game_display =

1022

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

1023

1024

1025

        game_display

1026

1027

1028

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

1029

        if let Some(legal_moves) = possible_moves {

1030

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

1031

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

1032

                    if vertex == vertex_from {

1033

                        Move::Revert

1034

                    } else if vertexes.contains(vertex) {

1035

                        Move::To

1036

                    } else {

1037

                        Move::None

1038

1039

                } else {

1040

                    Move::None

1041

1042

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

1043

                Move::From

1044

            } else {

1045

                Move::None

1046

1047

        } else {

1048

            Move::None

1049

1050

1051

1052

    #[allow(clippy::type_complexity)]

1053

    fn board_and_heatmap(

1054

        &self,

1055

    ) -> (

1056

        Board,

1057

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

1058

) {

1059

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

1060

            let node = game_handle.boards.here();

1061

1062

            if self.heat_map_display

1063

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

1064

1065

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

1066

            } else {

1067

                (node.board.clone(), None)

1068

1069

        } else {

1070

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

1071

1072

            (game.board.clone(), None)

1073

1074

1075

1076

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

1077

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

1078

            if game.challenge_accepted {

1079

                return State::Spectator;

1080

1081

1082

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

1083

                if let Some(attacker) = &game.attacker

1084

                    && &self.username == attacker

1085

1086

                    return State::CreatorOnly;

1087

1088

1089

                if let Some(defender) = &game.defender

1090

                    && &self.username == defender

1091

1092

                    return State::CreatorOnly;

1093

1094

1095

1096

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

1097

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

1098

1099

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

1100

                    if &self.username != challenger {

1101

                        return State::Creator;

1102

1103

                } else {

1104

                    return State::Challenger;

1105

1106

1107

1108

1109

        State::Spectator

1110

1111

1112

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

1113

        for l in BOARD_LETTERS_LOWERCASE {

1114

            if l != letter {

1115

                self.press_letters.remove(&l);

1116

1117

1118

1119

1120

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

1121

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

1122

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

1123

1124

        for i in 0..board_size {

1125

            let i = board_size - i;

1126

            if i != number {

1127

                self.press_numbers[i - 1] = false;

1128

1129

1130

1131

1132

    fn create_account(&mut self) {

1133

        if !self.connected_tcp {

1134

            self.send("tcp_connect\n");

1135

            self.connected_tcp = true;

1136

1137

1138

        if self.screen == Screen::Login {

1139

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

1140

                let username = self.text_input.clone();

1141

                self.send(&format!(

1142

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

1143

                    self.password,

1144

));

1145

                self.username = username;

1146

1147

            self.text_input.clear();

1148

            self.archived_game_reset();

1149

            handle_error(self.save_client_ron());

1150

1151

1152

1153

    fn delete_account(&mut self) {

1154

        if self.delete_account {

1155

            self.send("delete_account\n");

1156

            self.leave();

1157

            self.delete_account = false;

1158

        } else {

1159

            self.delete_account = true;

1160

1161

1162

1163

    #[allow(clippy::too_many_lines)]

1164

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

1165

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

1166

            return Column::new();

1167

};

1168

1169

        let tournament_string = t!("Tournament");

1170

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

1171

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

1172

        let column_1 = column![row_1, row_2];

1173

1174

        let players_len = tournament.players.len();

1175

1176

        if players_len == 0 {

1177

            return Column::new();

1178

1179

1180

        let mut column_rounds = Column::new();

1181

1182

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

1183

            let mut column_round = Column::new();

1184

1185

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

1186

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

1187

1188

                    let winner = t!("Winner");

1189

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

1190

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

1191

1192

                    column![row_1, row_2]

1193

                } else {

1194

                    let round = t!("Round");

1195

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

1196

                    let row_2 = text!(

1197

                        "{}-{}",

1198

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

1199

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

1200

1201

                    .font(Font::MONOSPACE);

1202

1203

                    column![row_1, row_2]

1204

};

1205

1206

                column_round = column_round.push(round_title);

1207

1208

                let mut column_groups = Column::new();

1209

1210

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

1211

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

1212

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

1213

                            continue;

1214

1215

1216

                        let mut games_count = 0;

1217

                        let mut column_group = Column::new();

1218

1219

                        if j > 0 {

1220

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

1221

1222

1223

                        let mut column_group_vec = Vec::new();

1224

1225

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

1226

                            games_count += record.games_count();

1227

1228

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

1229

                                column_group_vec.push(

1230

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

1231

                                        .font(Font::MONOSPACE),

1232

);

1233

                            } else {

1234

                                column_group_vec.push(

1235

                                    text!(

1236

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

1237

                                        player,

1238

                                        record.rating.to_string_rounded(),

1239

                                        t!("wins"),

1240

                                        record.wins,

1241

                                        t!("losses"),

1242

                                        record.losses,

1243

                                        t!("draws"),

1244

                                        record.draws,

1245

1246

                                    .font(Font::MONOSPACE),

1247

);

1248

1249

1250

1251

                        // If round finished:

1252

                        if games_count / 2 == players.total_games {

1253

                            column_group_vec.clear();

1254

1255

                            let mut records: Vec<_> = players

1256

                                .records

1257

                                .iter()

1258

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

1259

                                .collect();

1260

1261

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

1262

                                record_2.draws.cmp(&record_1.draws)

1263

});

1264

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

1265

                                record_2.wins.cmp(&record_1.wins)

1266

});

1267

1268

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

1269

                                column_group_vec.clear();

1270

                                for (name_2, record_2) in &records {

1271

                                    if record_1.wins == record_2.wins

1272

                                        && record_1.losses == record_2.losses

1273

                                        && record_1.draws == record_2.draws

1274

1275

                                        column_group_vec.push(

1276

                                            text!(

1277

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

1278

                                                name_2,

1279

                                                record_2.rating.to_string_rounded(),

1280

                                                t!("wins"),

1281

                                                record_2.wins,

1282

                                                t!("losses"),

1283

                                                record_2.losses,

1284

                                                t!("draws"),

1285

                                                record_2.draws,

1286

1287

                                            .font(Font::MONOSPACE)

1288

                                            .style(text::success),

1289

);

1290

                                    } else {

1291

                                        column_group_vec.push(

1292

                                            text!(

1293

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

1294

                                                name_2,

1295

                                                record_2.rating.to_string_rounded(),

1296

                                                t!("wins"),

1297

                                                record_2.wins,

1298

                                                t!("losses"),

1299

                                                record_2.losses,

1300

                                                t!("draws"),

1301

                                                record_2.draws,

1302

1303

                                            .font(Font::MONOSPACE)

1304

                                            .style(text::danger),

1305

);

1306

1307

1308

1309

1310

1311

                        for player in column_group_vec {

1312

                            column_group = column_group.push(player);

1313

1314

1315

                        column_groups = column_groups.push(column_group);

1316

1317

1318

                column_round = column_round.push(column_groups);

1319

1320

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

1321

1322

1323

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

1324

1325

1326

    fn draw(&mut self) {

1327

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

1328

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

1329

1330

1331

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

1332

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

1333

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

1334

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

1335

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

1336

                let mut arrow = " ";

1337

1338

                if y_diff < 0 {

1339

                    arrow = &self.chars.arrow_down;

1340

                } else if y_diff > 0 {

1341

                    arrow = &self.chars.arrow_up;

1342

                } else if x_diff < 0 {

1343

                    arrow = &self.chars.arrow_right;

1344

                } else if x_diff > 0 {

1345

                    arrow = &self.chars.arrow_left;

1346

1347

1348

                Some(arrow)

1349

            } else {

1350

                None

1351

1352

        } else {

1353

            None

1354

1355

1356

1357

    fn estimate_score(&mut self) {

1358

        if !self.estimate_score {

1359

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

1360

1361

            let handle = self

1362

                .archived_game_handle

1363

                .as_ref()

1364

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

1365

1366

            self.estimate_score = true;

1367

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

1368

1369

1370

1371

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

1372

        let attacker = radio(

1373

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

1374

            Role::Attacker,

1375

            self.game_settings.role_selected,

1376

            Message::RoleSelected,

1377

);

1378

1379

        let defender = radio(

1380

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

1381

            Role::Defender,

1382

            self.game_settings.role_selected,

1383

            Message::RoleSelected,

1384

);

1385

1386

        let rated = LabeledFrame::new(

1387

            text(t!("rated")),

1388

            row![

1389

                text!("(6)"),

1390

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

1391

1392

            .padding(PADDING)

1393

            .spacing(SPACING),

1394

);

1395

1396

        let mut new_game = button(text!("{} (Enter)", self.strings["New Game"].as_str()));

1397

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

1398

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

1399

1400

1401

        let leave =

1402

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

1403

1404

        let size_11x11 = radio(

1405

            "11x11 (9)",

1406

            BoardSize::_11,

1407

            Some(self.game_settings.board_size),

1408

            Message::BoardSizeSelected,

1409

);

1410

1411

        let size_13x13 = radio(

1412

            "13x13 (0)",

1413

            BoardSize::_13,

1414

            Some(self.game_settings.board_size),

1415

            Message::BoardSizeSelected,

1416

);

1417

1418

        let row_role = LabeledFrame::new(

1419

            text(t!("role")),

1420

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

1421

);

1422

1423

        let row_board_size = LabeledFrame::new(

1424

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

1425

            row![size_11x11, size_13x13]

1426

                .padding(PADDING)

1427

                .spacing(SPACING),

1428

);

1429

1430

        let rapid = radio(

1431

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

1432

            TimeEnum::Rapid,

1433

            self.game_settings.time,

1434

            Message::Time,

1435

);

1436

1437

        let classical = radio(

1438

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

1439

            TimeEnum::Classical,

1440

            self.game_settings.time,

1441

            Message::Time,

1442

);

1443

1444

        let long = radio(

1445

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

1446

            TimeEnum::Long,

1447

            self.game_settings.time,

1448

            Message::Time,

1449

);

1450

1451

        let very_long = radio(

1452

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

1453

            TimeEnum::VeryLong,

1454

            self.game_settings.time,

1455

            Message::Time,

1456

);

1457

1458

        let infinity = radio(

1459

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

1460

            TimeEnum::Infinity,

1461

            self.game_settings.time,

1462

            Message::Time,

1463

);

1464

1465

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

1466

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

1467

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

1468

1469

        let row_time = LabeledFrame::new(

1470

            text(t!("time")),

1471

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

1472

);

1473

1474

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

1475

1476

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

1477

1478

1479

    fn game_submit(&mut self) {

1480

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

1481

            error!("No role selected.");

1482

            unreachable!();

1483

};

1484

1485

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

1486

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

1487

            unreachable!();

1488

};

1489

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

1490

1491

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

1492

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

1493

        self.send(&format!(

1494

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

1495

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

1496

));

1497

1498

        self.screen = Screen::Games;

1499

1500

1501

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

1502

        self.clear_letters_except(letter);

1503

        self.press_letters.insert(letter);

1504

1505

1506

    fn press_letter_and_number(&mut self) {

1507

        let mut number = None;

1508

        let mut letter = None;

1509

1510

        for i in 0..13 {

1511

            if self.press_numbers[i] {

1512

                number = Some(i);

1513

                break;

1514

1515

1516

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

1517

            if self.press_letters.contains(l) {

1518

                letter = Some(i);

1519

                break;

1520

1521

1522

1523

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

1524

            Some(game.board.size())

1525

        } else {

1526

            self.archived_game_handle

1527

                .as_ref()

1528

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

1529

};

1530

1531

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

1532

            let board_usize: usize = size.into();

1533

            let vertex = Vertex {

1534

                size,

1535

                x: letter,

1536

                y: board_usize - number - 1,

1537

};

1538

            let possible_moves = self.possible_moves();

1539

1540

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

1541

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

1542

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

1543

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

1544

                Move::None => {}

1545

1546

1547

            for i in 0..13 {

1548

                self.press_numbers[i] = false;

1549

1550

            self.press_letters.clear();

1551

1552

1553

1554

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

1555

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

1556

            match self.join_game(game) {

1557

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

1558

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

1559

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

1560

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

1561

                    State::Creator => {

1562

                        if shift {

1563

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

1564

                        } else {

1565

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

1566

1567

1568

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

1569

},

1570

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

1571

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

1572

1573

1574

1575

1576

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

1577

        if game.challenge_accepted {

1578

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

1579

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

1580

1581

                JoinGame::Resume

1582

            } else if game.challenge_accepted {

1583

                JoinGame::Watch

1584

            } else {

1585

                JoinGame::None

1586

1587

        } else if game.attacker.is_some()

1588

            && game.defender.is_some()

1589

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

1590

1591

            JoinGame::Cancel

1592

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

1593

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

1594

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

1595

1596

            JoinGame::Join

1597

        } else {

1598

            JoinGame::None

1599

1600

1601

1602

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

1603

        self.game_id = id;

1604

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

1605

1606

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

1607

1608

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

1609

            Some(Role::Defender)

1610

        } else {

1611

            Some(Role::Attacker)

1612

};

1613

1614

1615

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

1616

        self.game_id = id;

1617

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

1618

1619

1620

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

1621

        self.game_id = id;

1622

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

1623

1624

1625

    fn login(&mut self) {

1626

        if !self.connected_tcp {

1627

            self.send("tcp_connect\n");

1628

            self.connected_tcp = true;

1629

1630

1631

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

1632

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

1633

1634

            self.send(&format!(

1635

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

1636

                self.password

1637

));

1638

            self.username = username;

1639

        } else {

1640

            let username = self.text_input.clone();

1641

1642

            self.send(&format!(

1643

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

1644

                self.password

1645

));

1646

            self.username = username;

1647

1648

1649

        self.texts.clear();

1650

        self.text_input.clear();

1651

        self.archived_game_reset();

1652

        handle_error(self.save_client_ron());

1653

1654

1655

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

1656

        let from = self

1657

            .play_from

1658

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

1659

1660

        let mut turn = Role::Roleless;

1661

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

1662

            turn = game.turn;

1663

1664

1665

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

1666

1667

        if self.archived_game_handle.is_none() {

1668

            self.send(&format!(

1669

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

1670

                self.game_id, turn

1671

));

1672

1673

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

1674

            if game.status == Status::Ongoing {

1675

                match game.turn {

1676

                    Role::Attacker => {

1677

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

1678

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

1679

1680

1681

                    Role::Roleless => {}

1682

                    Role::Defender => {

1683

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

1684

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

1685

1686

1687

1688

1689

1690

            self.my_turn = false;

1691

1692

1693

        self.play_from_previous = self.play_from;

1694

        self.play_to_previous = Some(to);

1695

        self.play_from = None;

1696

1697

1698

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

1699

        let mut possible_moves = None;

1700

1701

        if self.my_turn {

1702

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

1703

                possible_moves = Some(game.all_legal_moves());

1704

1705

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

1706

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

1707

            possible_moves = Some(game.all_legal_moves());

1708

1709

1710

        possible_moves

1711

1712

1713

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

1714

        self.theme = theme;

1715

        handle_error(self.save_client_ron());

1716

1717

1718

    fn coordinates(&mut self) {

1719

        self.coordinates = !self.coordinates;

1720

        handle_error(self.save_client_ron());

1721

1722

1723

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

1724

    #[allow(clippy::too_many_lines)]

1725

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

1726

        let mut attacker_rating = String::new();

1727

        let mut defender_rating = String::new();

1728

1729

        let (

1730

            game_id,

1731

            attacker_string,

1732

            attacker_time,

1733

            defender_string,

1734

            defender_time,

1735

            board,

1736

            play,

1737

            status,

1738

            texts,

1739

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

1740

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

1741

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

1742

1743

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

1744

                &game_handle.game.status

1745

            } else {

1746

                &Status::Ongoing

1747

};

1748

1749

1750

                &game_handle.game.id,

1751

                &game_handle.game.attacker,

1752

                game_handle

1753

                    .game

1754

                    .plays

1755

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

1756

                &game_handle.game.defender,

1757

                game_handle

1758

                    .game

1759

                    .plays

1760

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

1761

                &game_handle.boards.here().board,

1762

                game_handle.play,

1763

                status,

1764

                &game_handle.game.texts,

1765

1766

        } else {

1767

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

1768

                attacker_rating = user.rating.to_string_rounded();

1769

1770

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

1771

                defender_rating = user.rating.to_string_rounded();

1772

1773

1774

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

1775

1776

1777

                &self.game_id,

1778

                &self.attacker,

1779

                self.time_attacker.time_left(),

1780

                &self.defender,

1781

                self.time_defender.time_left(),

1782

                &game.board,

1783

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

1784

                &self.status,

1785

                &self.texts_game,

1786

1787

};

1788

1789

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

1790

            attacker_rating = user.rating.to_string_rounded();

1791

1792

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

1793

            defender_rating = user.rating.to_string_rounded();

1794

1795

1796

        let captured = board.captured();

1797

1798

        let mut row_1 = row![

1799

            text(attacker_string),

1800

            text(attacker_rating).center(),

1801

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

1802

];

1803

1804

        if !self.spectators.contains(attacker_string) {

1805

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

1806

1807

1808

        let attacker = container(

1809

            column![

1810

                row_1.spacing(SPACING),

1811

                row![

1812

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

1813

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

1814

1815

                .spacing(SPACING),

1816

1817

            .spacing(SPACING),

1818

1819

        .padding(PADDING)

1820

        .style(container::bordered_box);

1821

1822

        let mut row_2 = row![

1823

            text(defender_string),

1824

            text(defender_rating).center(),

1825

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

1826

];

1827

1828

        if !self.spectators.contains(defender_string) {

1829

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

1830

1831

1832

        let defender = container(

1833

            column![

1834

                row_2.spacing(SPACING),

1835

                row![

1836

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

1837

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

1838

1839

                .spacing(SPACING),

1840

1841

            .spacing(SPACING),

1842

1843

        .padding(PADDING)

1844

        .style(container::bordered_box);

1845

1846

        let mut watching = false;

1847

1848

        let sub_second = self.now_diff % 1_000;

1849

        let seconds = self.now_diff / 1_000;

1850

1851

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

1852

1853

        let is_rated = match self.game_settings.rated {

1854

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

1855

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

1856

};

1857

1858

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

1859

1860

        match self.screen_size {

1861

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

1862

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

1863

1864

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

1865

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

1866

1867

1868

1869

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

1870

            watching = true;

1871

1872

1873

        let mut spectators = Column::new();

1874

        let mut players_length = 0;

1875

        for spectator in &self.spectators {

1876

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

1877

                players_length += 1;

1878

                continue;

1879

1880

1881

            let mut spectator = spectator.clone();

1882

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

1883

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

1884

1885

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

1886

1887

1888

        let resign =

1889

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

1890

1891

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

1892

            .on_press(Message::PlayDraw);

1893

1894

        if !watching {

1895

            if self.my_turn {

1896

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

1897

            } else {

1898

                let row = if self.request_draw {

1899

                    column![

1900

                        row![

1901

                            button(text!("{} (r)", self.strings["Accept Draw"].as_str()))

1902

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

1903

1904

                        .spacing(SPACING)

1905

1906

                } else {

1907

                    Column::new()

1908

};

1909

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

1910

1911

1912

1913

        let coordinates_muted = row![

1914

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

1915

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

1916

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

1917

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

1918

1919

        .spacing(SPACING);

1920

        user_area = user_area.push(coordinates_muted);

1921

1922

        let volume = row![

1923

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

1924

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

1925

1926

        .spacing(SPACING);

1927

        user_area = user_area.push(volume);

1928

1929

        let leave =

1930

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

1931

1932

        match status {

1933

            Status::AttackerWins => {

1934

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

1935

1936

            Status::Draw => {

1937

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

1938

1939

            Status::Ongoing => {}

1940

            Status::DefenderWins => {

1941

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

1942

1943

1944

1945

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

1946

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

1947

            if self.heat_map.is_some() {

1948

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

1949

1950

1951

            let mut heat_map_button =

1952

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

1953

1954

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

1955

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

1956

1957

1958

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

1959

1960

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

1961

            let child_right = button(

1962

                text(&self.chars.double_arrow_right)

1963

                    .center()

1964

                    .font(Font::MONOSPACE),

1965

1966

            .on_press(Message::ReviewGameChildNext);

1967

1968

            user_area = user_area.push(

1969

                row![

1970

                    leave,

1971

                    child_right,

1972

                    container(child_number)

1973

                        .style(container::bordered_box)

1974

                        .padding(PADDING_MEDIUM),

1975

1976

                .spacing(SPACING),

1977

);

1978

1979

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

1980

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

1981

1982

            if handle.play > 0 {

1983

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

1984

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

1985

1986

1987

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

1988

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

1989

1990

            if handle.boards.has_children() {

1991

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

1992

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

1993

1994

1995

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

1996

        } else {

1997

            user_area = user_area.push(leave);

1998

1999

            let spectator = text!(

2000

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

2001

                &self.chars.people,

2002

                self.spectators.len() - players_length,

2003

                t!("lag"),

2004

);

2005

2006

            if self.spectators.is_empty() {

2007

                user_area = user_area.push(spectator);

2008

            } else {

2009

                user_area = user_area.push(tooltip(

2010

                    spectator,

2011

                    container(spectators)

2012

                        .style(container::bordered_box)

2013

                        .padding(PADDING),

2014

                    tooltip::Position::Bottom,

2015

));

2016

2017

2018

2019

        if self.archived_game_handle.is_some() {

2020

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

2021

        } else {

2022

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

2023

2024

2025

        let user_area = container(user_area)

2026

            .padding(PADDING)

2027

            .style(container::bordered_box);

2028

2029

        let board = container(self.board())

2030

            .style(container::bordered_box)

2031

            .padding(PADDING);

2032

2033

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

2034

2035

2036

    fn leave(&mut self) {

2037

        match self.screen {

2038

            Screen::EmailEveryone => {

2039

                self.screen = Screen::Games;

2040

                self.text_input = String::new();

2041

2042

            Screen::Game => {

2043

                self.screen = Screen::Games;

2044

                self.my_turn = false;

2045

                self.request_draw = false;

2046

2047

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

2048

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

2049

2050

                self.spectators = Vec::new();

2051

2052

            Screen::Games => {

2053

                self.send("quit\n");

2054

                self.admin = false;

2055

                self.admin_tournament = false;

2056

                self.connected_tcp = false;

2057

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

2058

                self.screen = Screen::Login;

2059

                self.email = None;

2060

2061

            Screen::GameReview => {

2062

                self.heat_map = None;

2063

                self.heat_map_display = false;

2064

                self.screen = Screen::Login;

2065

2066

            Screen::Login => {}

2067

2068

2069

2070

    fn my_games_only(&mut self) {

2071

        let selected = !self.my_games_only;

2072

        if selected {

2073

            self.archived_games_filtered = Some(

2074

                self.archived_games

2075

                    .iter()

2076

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

2077

                    .cloned()

2078

                    .collect(),

2079

);

2080

        } else {

2081

            self.archived_games_filtered = None;

2082

2083

2084

        self.my_games_only = selected;

2085

        handle_error(self.save_client_ron());

2086

2087

2088

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

2089

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

2090

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

2091

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

2092

                    .map(|_instant| Message::Tick)

2093

            } else {

2094

                Subscription::none()

2095

2096

        } else {

2097

            Subscription::none()

2098

};

2099

2100

        let subscription_2 = Subscription::run(pass_messages);

2101

        let subscription_3 = Subscription::run(estimate_score);

2102

2103

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

2104

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

2105

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

2106

2107

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

2108

                let shift = modifiers.shift();

2109

2110

                match key {

2111

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

2112

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

2113

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

2114

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

2115

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

2116

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

2117

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

2118

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

2119

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

2120

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

2121

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

2122

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

2123

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

2124

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

2125

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

2126

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

2127

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

2128

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

2129

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

2130

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

2131

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

2132

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

2133

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

2134

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

2135

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

2136

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

2137

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

2138

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

2139

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

2140

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

2141

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

2142

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

2143

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

2144

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

2145

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

2146

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

2147

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

2148

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

2149

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

2150

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

2151

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

2152

                            Some(Message::PressPlus)

2153

2154

                        _ => None,

2155

},

2156

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

2157

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

2158

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

2159

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

2160

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

2161

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

2162

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

2163

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

2164

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

2165

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

2166

                        _ => None,

2167

},

2168

                    _ => None,

2169

2170

2171

            _ => None,

2172

});

2173

2174

        Subscription::batch(vec![

2175

            subscription_1,

2176

            subscription_2,

2177

            subscription_3,

2178

            subscription_4,

2179

])

2180

2181

2182

    fn texting(

2183

        &'a self,

2184

        messages: &'a VecDeque<String>,

2185

        enable_texting: bool,

2186

    ) -> Container<'a, Message> {

2187

        let text_input = if enable_texting {

2188

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

2189

                .on_input(Message::TextChanged)

2190

                .on_paste(Message::TextChanged)

2191

                .on_submit(Message::TextSend)

2192

        } else {

2193

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

2194

};

2195

2196

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

2197

2198

        let mut texting = Column::new();

2199

        for message in messages {

2200

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

2201

2202

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

2203

2204

        container(text_box)

2205

            .padding(PADDING)

2206

            .style(container::bordered_box)

2207

2208

2209

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

2210

        match self.theme {

2211

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

2212

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

2213

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

2214

2215

2216

2217

    #[allow(clippy::too_many_lines)]

2218

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

2219

        self.error = None;

2220

2221

        match message {

2222

            Message::ArchivedGames(mut archived_games) => {

2223

                archived_games.reverse();

2224

                self.archived_games = archived_games;

2225

                self.archived_games_filtered = None;

2226

                handle_error(self.save_client_postcard());

2227

2228

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

2229

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

2230

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

2231

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

2232

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

2233

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

2234

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

2235

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

2236

            Message::DateSubmit(date) => {

2237

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

2238

                self.tournament_date = date;

2239

                self.tournament_date_show_picker = false;

2240

2241

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

2242

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

2243

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

2244

            Message::EmailEveryone => {

2245

                self.screen = Screen::EmailEveryone;

2246

                self.send("emails_bcc\n");

2247

2248

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

2249

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

2250

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

2251

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

2252

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

2253

2254

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

2255

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

2256

2257

                    info!("{generate_move}");

2258

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

2259

                    self.heat_map = Some(generate_move.heat_map);

2260

2261

2262

                self.estimate_score = false;

2263

2264

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

2265

            Message::FocusNext => return focus_next(),

2266

            Message::FocusPrevious => return focus_previous(),

2267

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

2268

            Message::GameAccept(id) => {

2269

                self.game_id = id;

2270

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

2271

2272

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

2273

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

2274

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

2275

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

2276

            Message::Leave => {

2277

                if self.screen == Screen::Login {

2278

                    return iced::exit();

2279

2280

2281

                self.leave();

2282

2283

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

2284

            Message::LocaleSelected(locale) => {

2285

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

2286

2287

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

2288

                for string in string_keys {

2289

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

2290

2291

2292

                self.locale_selected = Some(locale);

2293

                handle_error(self.save_client_ron());

2294

2295

            Message::MyGamesOnly(_selected) => {

2296

                self.my_games_only();

2297

2298

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

2299

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

2300

            Message::GameSubmit => {

2301

                self.game_submit();

2302

                self.active_tab = TabId::Games;

2303

2304

            Message::PasswordChanged(password) => {

2305

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

2306

                self.password_ends_with_whitespace = ends_with_whitespace;

2307

                if password.len() <= 32 {

2308

                    self.password = password;

2309

2310

2311

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

2312

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

2313

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

2314

            Message::PlayDrawDecision(draw) => {

2315

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

2316

2317

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

2318

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

2319

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

2320

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

2321

            Message::PressEnter => match self.screen {

2322

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

2323

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

2324

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

2325

},

2326

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

2327

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

2328

                    self.press_letter('a');

2329

                    self.press_letter_and_number();

2330

2331

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

2332

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

2333

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

2334

2335

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

2336

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

2337

},

2338

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

2339

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

2340

                    self.press_letter('b');

2341

                    self.press_letter_and_number();

2342

2343

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

2344

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

2345

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

2346

2347

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

2348

},

2349

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

2350

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

2351

                    self.press_letter('c');

2352

                    self.press_letter_and_number();

2353

2354

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

2355

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

2356

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

2357

2358

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

2359

},

2360

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

2361

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

2362

                    self.press_letter('d');

2363

                    self.press_letter_and_number();

2364

2365

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

2366

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

2367

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

2368

2369

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

2370

},

2371

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

2372

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

2373

                    self.press_letter('e');

2374

                    self.press_letter_and_number();

2375

2376

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

2377

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

2378

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

2379

2380

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

2381

},

2382

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

2383

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

2384

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

2385

                    self.press_letter('f');

2386

                    self.press_letter_and_number();

2387

2388

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

2389

},

2390

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

2391

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

2392

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

2393

                    self.press_letter('g');

2394

                    self.press_letter_and_number();

2395

2396

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

2397

},

2398

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

2399

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

2400

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

2401

                    self.press_letter('h');

2402

                    self.press_letter_and_number();

2403

2404

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

2405

},

2406

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

2407

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

2408

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

2409

                    self.press_letter('i');

2410

                    self.press_letter_and_number();

2411

2412

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

2413

},

2414

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

2415

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

2416

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

2417

                    self.press_letter('j');

2418

                    self.press_letter_and_number();

2419

2420

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

2421

},

2422

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

2423

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

2424

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

2425

                    self.press_letter('k');

2426

                    self.press_letter_and_number();

2427

2428

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

2429

},

2430

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

2431

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

2432

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

2433

                    self.press_letter('l');

2434

                    self.press_letter_and_number();

2435

2436

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

2437

},

2438

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

2439

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

2440

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

2441

                    self.press_letter('m');

2442

                    self.press_letter_and_number();

2443

2444

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

2445

},

2446

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

2447

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

2448

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

2449

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

2450

},

2451

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

2452

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

2453

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

2454

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

2455

},

2456

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

2457

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

2458

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

2459

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

2460

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

2461

},

2462

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

2463

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

2464

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

2465

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

2466

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

2467

},

2468

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

2469

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

2470

                Screen::Game => {

2471

                    if self.request_draw {

2472

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

2473

2474

2475

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

2476

},

2477

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

2478

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

2479

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

2480

},

2481

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

2482

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

2483

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

2484

},

2485

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

2486

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

2487

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

2488

},

2489

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

2490

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

2491

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

2492

},

2493

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

2494

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

2495

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

2496

},

2497

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

2498

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

2499

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

2500

},

2501

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

2502

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

2503

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

2504

},

2505

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

2506

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

2507

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

2508

},

2509

            Message::Press1 => match self.screen {

2510

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

2511

                Screen::EmailEveryone => {}

2512

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

2513

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

2514

                    if !(self.press_numbers[0]

2515

                        || self.press_numbers[10]

2516

                        || self.press_numbers[11]

2517

                        || self.press_numbers[12])

2518

2519

                        self.clear_numbers_except(0);

2520

                        self.press_numbers[0] = true;

2521

                    } else if self.press_numbers[0] {

2522

                        self.clear_numbers_except(10);

2523

                        self.press_numbers[10] = true;

2524

                    } else {

2525

                        self.clear_numbers_except(11);

2526

                        self.press_numbers[10] = false;

2527

2528

2529

                    self.press_letter_and_number();

2530

2531

},

2532

            Message::Press2 => match self.screen {

2533

                Screen::EmailEveryone => {}

2534

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

2535

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

2536

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

2537

                    match board.size() {

2538

                        BoardSize::_11 => {

2539

                            self.clear_numbers_except(2);

2540

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

2541

                            self.press_letter_and_number();

2542

2543

                        BoardSize::_13 => {

2544

                            if !self.press_numbers[0]

2545

                                && !self.press_numbers[1]

2546

                                && !self.press_numbers[11]

2547

2548

                                self.clear_numbers_except(2);

2549

                                self.press_numbers[1] = true;

2550

                            } else if self.press_numbers[1] {

2551

                                self.press_numbers[1] = false;

2552

                            } else if self.press_numbers[11] {

2553

                                self.press_numbers[11] = false;

2554

                            } else {

2555

                                self.press_numbers[0] = false;

2556

                                self.press_numbers[11] = true;

2557

2558

2559

2560

2561

                    self.press_letter_and_number();

2562

2563

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

2564

},

2565

            Message::Press3 => match self.screen {

2566

                Screen::EmailEveryone => {}

2567

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

2568

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

2569

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

2570

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

2571

                    match board.size() {

2572

                        BoardSize::_11 => {

2573

                            self.clear_numbers_except(3);

2574

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

2575

                            self.press_letter_and_number();

2576

2577

                        BoardSize::_13 => {

2578

                            if !self.press_numbers[0]

2579

                                && !self.press_numbers[2]

2580

                                && !self.press_numbers[12]

2581

2582

                                self.clear_numbers_except(3);

2583

                                self.press_numbers[2] = true;

2584

                            } else if self.press_numbers[2] {

2585

                                self.press_numbers[2] = false;

2586

                            } else if self.press_numbers[12] {

2587

                                self.press_numbers[12] = false;

2588

                            } else {

2589

                                self.press_numbers[0] = false;

2590

                                self.press_numbers[12] = true;

2591

2592

2593

2594

2595

                    self.press_letter_and_number();

2596

2597

},

2598

            Message::Press4 => match self.screen {

2599

                Screen::EmailEveryone => {}

2600

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

2601

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

2602

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

2603

                    self.clear_numbers_except(4);

2604

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

2605

                    self.press_letter_and_number();

2606

2607

},

2608

            Message::Press5 => match self.screen {

2609

                Screen::EmailEveryone => {}

2610

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

2611

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

2612

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

2613

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

2614

                    self.clear_numbers_except(5);

2615

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

2616

                    self.press_letter_and_number();

2617

2618

},

2619

            Message::Press6 => match self.screen {

2620

                Screen::EmailEveryone => {}

2621

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

2622

                Screen::Games => match self.active_tab {

2623

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

2624

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

2625

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

2626

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

2627

                    TabId::Users => {}

2628

},

2629

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

2630

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

2631

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

2632

                        self.clear_numbers_except(6);

2633

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

2634

                        self.press_letter_and_number();

2635

2636

2637

},

2638

            Message::Press7 => match self.screen {

2639

                Screen::EmailEveryone => {}

2640

                Screen::Games => match self.active_tab {

2641

                    // Fixme!

2642

                    TabId::AccountSettings => {

2643

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

2644

2645

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

2646

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

2647

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

2648

                    TabId::Users => {}

2649

},

2650

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

2651

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

2652

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

2653

                    self.clear_numbers_except(7);

2654

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

2655

                    self.press_letter_and_number();

2656

2657

},

2658

            Message::Press8 => match self.screen {

2659

                Screen::EmailEveryone => {}

2660

                Screen::Games => match self.active_tab {

2661

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

2662

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

2663

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

2664

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

2665

                    TabId::Users => {}

2666

},

2667

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

2668

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

2669

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

2670

                    self.clear_numbers_except(8);

2671

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

2672

                    self.press_letter_and_number();

2673

2674

},

2675

            Message::Press9 => match self.screen {

2676

                Screen::EmailEveryone => {}

2677

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

2678

                Screen::Games => match self.active_tab {

2679

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

2680

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

2681

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

2682

                    TabId::Tournament => {}

2683

},

2684

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

2685

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

2686

                    self.clear_numbers_except(9);

2687

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

2688

                    self.press_letter_and_number();

2689

2690

},

2691

            Message::Press0 => match self.screen {

2692

                Screen::EmailEveryone => {}

2693

                Screen::Games => match self.active_tab {

2694

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

2695

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

2696

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

2697

},

2698

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

2699

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

2700

                    self.clear_numbers_except(10);

2701

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

2702

                    self.press_letter_and_number();

2703

2704

},

2705

            Message::PressMinus => match self.screen {

2706

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

2707

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

2708

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

2709

2710

},

2711

            Message::PressPlus => match self.screen {

2712

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

2713

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

2714

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

2715

2716

},

2717

            Message::ServerShutdown => {

2718

                self.error_persistent

2719

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

2720

2721

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

2722

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

2723

            Message::TcpConnectFailed => {

2724

                self.error_persistent

2725

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

2726

2727

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

2728

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

2729

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

2730

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

2731

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

2732

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

2733

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

2734

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

2735

            Message::ReviewGameBackward => {

2736

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

2737

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

2738

                    handle.boards.backward();

2739

                    self.reset_markers();

2740

2741

2742

            Message::ReviewGameBackwardAll => {

2743

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

2744

                    handle.play = 0;

2745

                    handle.boards.backward_all();

2746

                    self.reset_markers();

2747

2748

2749

            Message::ReviewGameChildNext => {

2750

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

2751

                    handle.boards.next_child();

2752

                    self.reset_markers();

2753

2754

2755

            Message::ReviewGameForward => {

2756

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

2757

                    && handle.boards.has_children()

2758

2759

                    handle.play += 1;

2760

                    handle.boards.forward();

2761

                    self.reset_markers();

2762

2763

2764

            Message::ReviewGameForwardAll => {

2765

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

2766

                    let count = handle.boards.forward_all();

2767

                    handle.play += count;

2768

                    self.reset_markers();

2769

2770

2771

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

2772

            Message::TextChanged(string) => {

2773

                if self.screen == Screen::Login {

2774

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

2775

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

2776

                        if string.len() <= 16 {

2777

                            self.text_input = string.to_ascii_lowercase();

2778

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

2779

2780

                    } else {

2781

                        self.text_input = String::new();

2782

2783

                } else {

2784

                    self.text_input = string;

2785

2786

2787

            Message::TextEdit(action) => {

2788

                self.content.perform(action);

2789

2790

            Message::TextReceived(string) => {

2791

                let mut text = string.split_ascii_whitespace();

2792

                match text.next() {

2793

                    Some("=") => {

2794

                        let text_next = text.next();

2795

                        match text_next {

2796

                            Some(

2797

                                "archived_games"

2798

                                | "challenge_requested"

2799

                                | "change_password"

2800

                                | "decline_game"

2801

                                | "email_reset"

2802

                                | "game"

2803

                                | "request_draw",

2804

                            ) => {}

2805

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

2806

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

2807

                            Some("display_games") => {

2808

                                self.games_light.0.clear();

2809

                                self.games_light_vec.clear();

2810

2811

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

2812

2813

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

2814

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

2815

};

2816

2817

                                for chunks in chunks {

2818

                                    let game = ServerGameLight::try_from(chunks)

2819

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

2820

2821

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

2822

                                    self.games_light_vec.push(game);

2823

2824

2825

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

2826

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

2827

                                    self.spectators.sort();

2828

2829

2830

                            Some("display_users") => {

2831

                                self.users.clear();

2832

2833

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

2834

2835

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

2836

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

2837

};

2838

2839

                                for user in chunks {

2840

                                    let user: User = user.into();

2841

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

2842

2843

2844

                            Some("display_users_admin") => {

2845

                                let accounts: Accounts = ron::from_str(

2846

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

2847

2848

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

2849

2850

                                self.accounts = accounts;

2851

2852

                            Some("draw") => {

2853

                                self.request_draw = false;

2854

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

2855

                                    self.my_turn = false;

2856

                                    self.status = Status::Draw;

2857

2858

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

2859

                                        game.turn = Role::Roleless;

2860

2861

2862

                                    if !self.sound_muted {

2863

                                        let volume = self.volume.volume();

2864

                                        thread::spawn(move || {

2865

                                            let mut stream =

2866

                                                rodio::DeviceSinkBuilder::open_default_sink()?;

2867

2868

                                            let cursor = Cursor::new(SOUND_GAME_OVER);

2869

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

2870

                                            sound.set_volume(volume);

2871

                                            sound.sleep_until_end();

2872

2873

                                            stream.log_on_drop(false);

2874

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

2875

});

2876

2877

2878

2879

                            Some("email") => {

2880

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

2881

2882

                                    self.email = Some(Email {

2883

                                        username: String::new(),

2884

                                        address: address.to_string(),

2885

                                        code: None,

2886

                                        verified: handle_error(verified.parse()),

2887

});

2888

2889

2890

                            Some("emails_bcc") => {

2891

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

2892

2893

                            Some("email_code") => {

2894

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

2895

                                    email.verified = true;

2896

2897

                                self.error_email = None;

2898

2899

                            Some("game_over") => {

2900

                                self.my_turn = false;

2901

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

2902

                                    game.turn = Role::Roleless;

2903

2904

2905

                                text.next();

2906

                                match text.next() {

2907

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

2908

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

2909

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

2910

2911

2912

                                if !self.sound_muted {

2913

                                    let volume = self.volume.volume();

2914

                                    thread::spawn(move || {

2915

                                        let mut stream =

2916

                                            rodio::DeviceSinkBuilder::open_default_sink()?;

2917

2918

                                        let cursor = Cursor::new(SOUND_GAME_OVER);

2919

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

2920

                                        sound.set_volume(volume);

2921

                                        sound.sleep_until_end();

2922

2923

                                        stream.log_on_drop(false);

2924

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

2925

});

2926

2927

2928

                            // = join_game david abby rated fischer 900_000 10

2929

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

2930

                                self.screen = Screen::Game;

2931

                                self.status = Status::Ongoing;

2932

                                self.captures = HashSet::new();

2933

                                self.play_from = None;

2934

                                self.play_from_previous = None;

2935

                                self.play_to_previous = None;

2936

                                self.texts_game = VecDeque::new();

2937

                                self.archived_game_handle = None;

2938

2939

                                let attacker =

2940

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

2941

                                let defender =

2942

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

2943

2944

                                self.attacker = attacker.to_string();

2945

                                self.defender = defender.to_string();

2946

2947

                                let rated = text

2948

                                    .next()

2949

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

2950

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

2951

2952

                                self.game_settings.rated = rated;

2953

2954

                                let timed = text

2955

                                    .next()

2956

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

2957

                                let minutes =

2958

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

2959

                                let add_seconds =

2960

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

2961

2962

                                let timed = TimeSettings::try_from(vec![

2963

                                    "time_settings",

2964

                                    timed,

2965

                                    minutes,

2966

                                    add_seconds,

2967

])

2968

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

2969

2970

                                let board_size =

2971

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

2972

                                let board_size = BoardSize::from_str(board_size)

2973

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

2974

2975

                                let board = Board::new(board_size);

2976

2977

                                let mut game = Game {

2978

                                    attacker_time: timed.clone(),

2979

                                    defender_time: timed.clone(),

2980

                                    plays: Plays::new(&timed),

2981

                                    board,

2982

                                    ..Game::default()

2983

};

2984

2985

                                self.time_attacker = timed.clone();

2986

                                self.time_defender = timed;

2987

2988

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

2989

                                    let game_deserialized = ron::from_str(game_serialized)

2990

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

2991

2992

                                    game = game_deserialized;

2993

2994

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

2995

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

2996

2997

                                    match game.turn {

2998

                                        Role::Attacker => {

2999

                                            if let (

3000

                                                TimeSettings::Timed(time),

3001

                                                TimeUnix::Time(time_ago),

3002

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

3003

3004

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

3005

                                                time.milliseconds_left -= now - time_ago;

3006

                                                if time.milliseconds_left < 0 {

3007

                                                    time.milliseconds_left = 0;

3008

3009

3010

3011

                                        Role::Roleless => {}

3012

                                        Role::Defender => {

3013

                                            if let (

3014

                                                TimeSettings::Timed(time),

3015

                                                TimeUnix::Time(time_ago),

3016

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

3017

3018

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

3019

                                                time.milliseconds_left -= now - time_ago;

3020

                                                if time.milliseconds_left < 0 {

3021

                                                    time.milliseconds_left = 0;

3022

3023

3024

3025

3026

3027

3028

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

3029

                                let texts = texts.join(" ");

3030

                                if !texts.is_empty() {

3031

                                    let texts = ron::from_str(&texts)

3032

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

3033

3034

                                    self.texts_game = texts;

3035

3036

3037

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

3038

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

3039

3040

                                    self.my_turn = true;

3041

3042

3043

                                self.game = Some(game);

3044

3045

                            Some("join_game_pending") => {

3046

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

3047

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

3048

3049

                                self.game_id = id;

3050

                                self.challenger = true;

3051

3052

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

3053

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

3054

                            Some("new_game") => {

3055

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

3056

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

3057

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

3058

                                    let game_id =

3059

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

3060

3061

                                    self.game_id = game_id;

3062

                                    self.challenger = false;

3063

3064

3065

                            Some("ping") => {

3066

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

3067

                                self.now_diff = after - self.now;

3068

3069

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

3070

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

3071

                            Some("tournament_status_0") => {

3072

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

3073

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

3074

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

3075

3076

                                    self.tournament = tournament;

3077

3078

3079

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

3080

3081

3082

                    Some("?") => {

3083

                        let text_next = text.next();

3084

                        match text_next {

3085

                            Some("create_account") => {

3086

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

3087

3088

                            // Fixme: translate.

3089

                            Some("email") => {

3090

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

3091

                                let text = text.join(" ");

3092

                                self.error_email = Some(text);

3093

3094

                            Some("email_code") => {

3095

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

3096

3097

                            Some("login") => {

3098

                                let text_next = text.next();

3099

                                match text_next {

3100

                                    Some("multiple_possible_errors") => {

3101

                                        self.error = Some(t!(

3102

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

3103

                                        ).to_string());

3104

3105

                                    Some("reset_password") => {

3106

                                        self.error = Some(t!(

3107

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

3108

                                        ).to_string());

3109

3110

                                    Some("wrong_version") => {

3111

                                        self.error = Some(t!(

3112

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

3113

                                        ).to_string());

3114

3115

                                    _ => {

3116

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

3117

                                        let text = text.join(" ");

3118

                                        self.error = Some(text);

3119

3120

3121

3122

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

3123

3124

3125

                    Some("game") => {

3126

                        // Plays the move then sends the result back.

3127

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

3128

                        let id = id

3129

                            .parse::<Id>()

3130

                            .expect("the game_id should be a valid usize");

3131

3132

                        if id != self.game_id {

3133

                            return Task::none();

3134

3135

3136

                        // game 0 generate_move attacker

3137

                        let text_word = text.next();

3138

                        if text_word == Some("generate_move") {

3139

                            self.request_draw = false;

3140

                            self.my_turn = true;

3141

                        // game 0 play attacker a3 a4

3142

                        } else if text_word == Some("play") {

3143

                            let role = text.next().expect("this should be a role string");

3144

                            let role = Role::from_str(role).expect("this should be a role");

3145

                            let from = text.next().expect("this should be from");

3146

3147

                            if from == "resigns" {

3148

                                return Task::none();

3149

3150

3151

                            let to = text.next().expect("this should be to");

3152

3153

                            if let (Ok(from), Ok(to)) =

3154

                                (Vertex::from_str(from), Vertex::from_str(to))

3155

3156

                                self.play_from_previous = Some(from);

3157

                                self.play_to_previous = Some(to);

3158

3159

3160

                            self.handle_play(Some(&role.to_string()), from, to);

3161

                            let game = self.game.as_ref().expect("you should have a game by now");

3162

3163

                            if game.status == Status::Ongoing {

3164

                                match game.turn {

3165

                                    Role::Attacker => {

3166

                                        if let TimeSettings::Timed(time) = &mut self.time_defender {

3167

                                            time.milliseconds_left += time.add_seconds * 1_000;

3168

3169

3170

                                    Role::Roleless => {}

3171

                                    Role::Defender => {

3172

                                        if let TimeSettings::Timed(time) = &mut self.time_attacker {

3173

                                            time.milliseconds_left += time.add_seconds * 1_000;

3174

3175

3176

3177

3178

3179

3180

                    Some("request_draw") => {

3181

                        let id = text.next().expect("there should be a game id");

3182

                        let id = id

3183

                            .parse::<Id>()

3184

                            .expect("the game_id should be a valid usize");

3185

3186

                        if id == self.game_id {

3187

                            self.request_draw = true;

3188

3189

3190

                    _ => error!("(4) unexpected text: {}", string.trim()),

3191

3192

3193

            Message::TextSend => {

3194

                match self.screen {

3195

                    // Fixme: account settings self.send(&format!("change_password {}\n", self.password));

3196

                    Screen::EmailEveryone => {

3197

                        // subject == self.text_input

3198

                        let email = self.content.text().replace('\n', "\\n");

3199

                        self.send(&format!("email_everyone {} {email}\n", self.text_input));

3200

3201

                    Screen::Game => {

3202

                        if !self.text_input.trim().is_empty() {

3203

                            self.text_input.push('\n');

3204

                            self.send(&format!("text_game {} {}", self.game_id, self.text_input));

3205

3206

3207

                    Screen::Games => {

3208

                        if !self.text_input.trim().is_empty() {

3209

                            self.text_input.push('\n');

3210

                            self.send(&format!("text {}", self.text_input));

3211

3212

3213

                    Screen::GameReview | Screen::Login => {}

3214

3215

3216

                self.text_input.clear();

3217

3218

            Message::TextSendEmail => {

3219

                self.error_email = None;

3220

3221

                self.send(&format!("email {}\n", self.email_input));

3222

                self.email_input.clear();

3223

3224

            Message::TextSendEmailCode => {

3225

                self.error_email = None;

3226

                self.send(&format!("email_code {}\n", self.email_input));

3227

3228

            Message::TextSendCreateAccount => self.create_account(),

3229

            Message::TextSendLogin => self.login(),

3230

            Message::Tick => {

3231

                self.counter = self.counter.wrapping_add(1);

3232

3233

                if self.counter.is_multiple_of(25) {

3234

                    self.now = Timestamp::now().as_millisecond();

3235

                    self.send("ping\n");

3236

3237

3238

                if let Some(game) = &mut self.game {

3239

                    match game.turn {

3240

                        Role::Attacker => {

3241

                            if let TimeSettings::Timed(time) = &mut self.time_attacker {

3242

                                time.milliseconds_left -= TICK;

3243

                                if time.milliseconds_left < 0 {

3244

                                    time.milliseconds_left = 0;

3245

3246

3247

3248

                        Role::Roleless => {}

3249

                        Role::Defender => {

3250

                            if let TimeSettings::Timed(time) = &mut self.time_defender {

3251

                                time.milliseconds_left -= TICK;

3252

                                if time.milliseconds_left < 0 {

3253

                                    time.milliseconds_left = 0;

3254

3255

3256

3257

3258

3259

3260

            Message::Time(time) => self.game_settings.time = Some(time),

3261

            Message::Tournaments => open_url("https://hnefatafl.org/tournaments.html"),

3262

            Message::TournamentDelete => self.send("tournament_delete\n"),

3263

            Message::TournamentTreeDelete => self.send("tournament_groups_delete\n"),

3264

            Message::UsersSortedBy(sort_by) => self.users_sort_by = sort_by,

3265

            Message::VolumeChanged(volume) => self.volume.0 = volume,

3266

            Message::WindowResized((width, height)) => {

3267

                if width >= 1_500.0 && height >= 1_000.0 {

3268

                    self.screen_size = Size::Giant;

3269

                } else if width >= 1_300.0 && height >= 1_000.0 {

3270

                    self.screen_size = Size::Large;

3271

                } else if width >= 1_200.0 && height >= 850.0 {

3272

                    self.screen_size = Size::Medium;

3273

                } else if width >= 1_000.0 && height >= 750.0 {

3274

                    self.screen_size = Size::Small;

3275

                } else if width >= 1_100.0 {

3276

                    self.screen_size = Size::TinyWide;

3277

                } else {

3278

                    self.screen_size = Size::Tiny;

3279

3280

3281

3282

3283

        Task::none()

3284

3285

3286

    #[must_use]

3287

    fn accounts_sorted(&self) -> Vec<(String, Account)> {

3288

        let mut accounts: Vec<_> = self.accounts.clone().0.into_iter().collect();

3289

3290

        match self.users_sort_by {

3291

            SortBy::Name => {

3292

                accounts.sort_by(|(_, a_account), (_, b_account)| {

3293

                    b_account

3294

                        .rating

3295

                        .rating

3296

                        .partial_cmp(&a_account.rating.rating)

3297

                        .expect("The number should be comparable.")

3298

});

3299

                accounts.sort_by(|(a_name, _), (b_name, _)| a_name.cmp(b_name));

3300

3301

            SortBy::Rating => {

3302

                accounts.sort_by(|(a_name, _), (b_name, _)| a_name.cmp(b_name));

3303

                accounts.sort_by(|(_, a_account), (_, b_account)| {

3304

                    b_account

3305

                        .rating

3306

                        .rating

3307

                        .partial_cmp(&a_account.rating.rating)

3308

                        .expect("The number should be comparable.")

3309

});

3310

3311

3312

3313

        accounts

3314

3315

3316

    #[must_use]

3317

    fn users_sorted(&self) -> Vec<User> {

3318

        let mut users: Vec<_> = self.users.values().cloned().collect();

3319

3320

        match self.users_sort_by {

3321

            SortBy::Name => {

3322

                users.sort_by(|a, b| {

3323

                    b.rating

3324

                        .rating

3325

                        .partial_cmp(&a.rating.rating)

3326

                        .expect("The number should be comparable.")

3327

});

3328

                users.sort_by(|a, b| a.name.cmp(&b.name));

3329

3330

            SortBy::Rating => {

3331

                users.sort_by(|a, b| a.name.cmp(&b.name));

3332

                users.sort_by(|a, b| {

3333

                    b.rating

3334

                        .rating

3335

                        .partial_cmp(&a.rating.rating)

3336

                        .expect("The number should be comparable.")

3337

});

3338

3339

3340

3341

        users

3342

3343

3344

    #[allow(clippy::too_many_lines)]

3345

    #[must_use]

3346

    fn games(&self) -> Scrollable<'_, Message> {

3347

        let mut game_ids = Column::new().spacing(SPACING_B);

3348

        let mut attackers = Column::new().spacing(SPACING_B);

3349

        let mut defenders = Column::new().spacing(SPACING_B);

3350

        let mut ratings = Column::new().spacing(SPACING_B);

3351

        let mut timings = Column::new().spacing(SPACING_B);

3352

        let mut sizes = Column::new().spacing(SPACING_B);

3353

        let mut buttons = Column::new().spacing(SPACING);

3354

3355

        for (i, game) in self.games_light_vec.iter().enumerate() {

3356

            if self.my_games_only {

3357

                let mut includes_username = false;

3358

                if let Some(attacker) = &game.attacker

3359

                    && attacker == &self.username

3360

3361

                    includes_username = true;

3362

3363

3364

                if let Some(defender) = &game.defender

3365

                    && defender == &self.username

3366

3367

                    includes_username = true;

3368

3369

3370

                if !includes_username {

3371

                    continue;

3372

3373

3374

3375

            let id = game.id;

3376

            game_ids = game_ids.push(text(id));

3377

3378

            attackers = if let Some(attacker_str) = &game.attacker {

3379

                let mut attacker = if self.admin {

3380

                    if let Some(account) = self.accounts.0.get(attacker_str) {

3381

                        text!("{attacker_str} ({})", account.rating.to_string_rounded())

3382

                    } else {

3383

                        text(attacker_str)

3384

3385

                } else {

3386

                    if let Some(user) = self.users.get(attacker_str) {

3387

                        text!("{attacker_str} ({})", user.rating.to_string_rounded())

3388

                    } else {

3389

                        text(attacker_str)

3390

3391

};

3392

3393

                if game.challenge_accepted

3394

                    && let Challenger(Some(name)) = &game.challenger

3395

                    && name == "A"

3396

3397

                    attacker = attacker.style(text::success);

3398

3399

3400

                attackers.push(attacker)

3401

            } else {

3402

                attackers.push(text(t!("none")))

3403

};

3404

3405

            defenders = if let Some(defender_str) = &game.defender {

3406

                let mut defender = if self.admin {

3407

                    if let Some(account) = self.accounts.0.get(defender_str) {

3408

                        text!("{defender_str} ({})", account.rating.to_string_rounded())

3409

                    } else {

3410

                        text(defender_str)

3411

3412

                } else {

3413

                    if let Some(user) = self.users.get(defender_str) {

3414

                        text!("{defender_str} ({})", user.rating.to_string_rounded())

3415

                    } else {

3416

                        text(defender_str)

3417

3418

};

3419

3420

                if game.challenge_accepted

3421

                    && let Challenger(Some(name)) = &game.challenger

3422

                    && name == "D"

3423

3424

                    defender = defender.style(text::success);

3425

3426

3427

                defenders.push(defender)

3428

            } else {

3429

                defenders.push(text(t!("none")))

3430

};

3431

3432

            let rating: bool = game.rated.into();

3433

            let rating = if rating { t!("yes") } else { t!("no") };

3434

            ratings = ratings.push(text(rating));

3435

3436

            timings = timings.push(text(game.timed.to_string()));

3437

            sizes = sizes.push(text(game.board_size.to_string()));

3438

3439

            let mut buttons_row = Row::new().spacing(SPACING);

3440

3441

            let i = if let Some(i) = ALPHABET.get(i) {

3442

                format!(" ({i})")

3443

            } else {

3444

                String::new()

3445

};

3446

3447

            match self.join_game(game) {

3448

                JoinGame::Cancel => {

3449

                    buttons_row = buttons_row.push(

3450

                        button(text!("{}{i}", self.strings["Cancel"].as_str()))

3451

                            .on_press(Message::GameCancel(id)),

3452

);

3453

3454

                JoinGame::Join => {

3455

                    buttons_row = buttons_row.push(

3456

                        button(text!("{}{i}", self.strings["Join"].as_str()))

3457

                            .on_press(Message::GameJoin(id)),

3458

);

3459

3460

                JoinGame::None => {}

3461

                JoinGame::Resume => {

3462

                    buttons_row = buttons_row.push(

3463

                        button(text!("{}{i}", self.strings["Resume"].as_str()))

3464

                            .on_press(Message::GameResume(id)),

3465

);

3466

3467

                JoinGame::Watch => {

3468

                    buttons_row = buttons_row.push(

3469

                        button(text!("{}{i}", self.strings["Watch"].as_str()))

3470

                            .on_press(Message::GameWatch(id)),

3471

);

3472

3473

3474

3475

            match self.game_state(id) {

3476

                State::Challenger | State::Spectator => {}

3477

                State::Creator => {

3478

                    buttons_row = buttons_row.push(

3479

                        button(text!("{}{i}", self.strings["Accept"].as_str()))

3480

                            .on_press(Message::GameAccept(id)),

3481

);

3482

                    buttons_row = buttons_row.push(

3483

                        button(text!(

3484

                            "{}{}",

3485

                            self.strings["Decline"].as_str(),

3486

                            i.to_ascii_uppercase()

3487

))

3488

                        .on_press(Message::GameDecline(id)),

3489

);

3490

3491

                State::CreatorOnly => {

3492

                    buttons_row = buttons_row.push(

3493

                        button(text!("{}{i}", self.strings["Cancel"].as_str()))

3494

                            .on_press(Message::CancelGame(id)),

3495

);

3496

3497

3498

            buttons = buttons.push(buttons_row);

3499

3500

3501

        let game_id = t!("ID");

3502

        let game_ids = column![

3503

            text(game_id.to_string()),

3504

            text("-".repeat(game_id.chars().count())).font(Font::MONOSPACE),

3505

            game_ids

3506

3507

        .padding(PADDING);

3508

        let attacker = t!("attacker");

3509

        let attackers = column![

3510

            text(attacker.to_string()),

3511

            text("-".repeat(attacker.chars().count())).font(Font::MONOSPACE),

3512

            attackers

3513

3514

        .padding(PADDING);

3515

        let defender = t!("defender");

3516

        let defenders = column![

3517

            text(defender.to_string()),

3518

            text("-".repeat(defender.chars().count())).font(Font::MONOSPACE),

3519

            defenders

3520

3521

        .padding(PADDING);

3522

        let rated = t!("rated");

3523

        let ratings = column![

3524

            text(rated.to_string()),

3525

            text("-".repeat(rated.chars().count())).font(Font::MONOSPACE),

3526

            ratings

3527

3528

        .padding(PADDING);

3529

        let timed = t!("time");

3530

        let timings = column![

3531

            text(timed.to_string()),

3532

            text("-".repeat(timed.chars().count())).font(Font::MONOSPACE),

3533

            timings

3534

3535

        .padding(PADDING);

3536

        let size = t!("size");

3537

        let sizes = column![

3538

            text(size.to_string()),

3539

            text("-".repeat(size.chars().count())).font(Font::MONOSPACE),

3540

            sizes

3541

3542

        .padding(PADDING);

3543

        let buttons = column![text(""), text(""), buttons].padding(PADDING);

3544

3545

        scrollable(row![

3546

            game_ids, attackers, defenders, ratings, timings, sizes, buttons

3547

])

3548

3549

3550

    fn games_view(&self) -> Column<'_, Message> {

3551

        let username = row![text!("{}: {}", t!("username"), &self.username)].spacing(SPACING);

3552

3553

        let username = container(username)

3554

            .padding(PADDING / 2)

3555

            .style(container::bordered_box);

3556

3557

        let my_games_text = text!("{} (8)", t!("My Games Only")).center();

3558

        let my_games = checkbox(self.my_games_only).on_toggle(Message::MyGamesOnly);

3559

        let get_archived_games =

3560

            button(text!("{} (6)", self.strings["Get Archived Games"].as_str()))

3561

                .on_press(Message::ArchivedGamesGet);

3562

3563

        let website = button(text!("{} (7)", self.strings["Rules"].as_str())).on_press(

3564

            Message::OpenUrl("https://hnefatafl.org/rules.html".to_string()),

3565

);

3566

3567

        let quit =

3568

            button(text!("{} (Esc)", self.strings["Quit"].as_str())).on_press(Message::Leave);

3569

3570

        let mut middle = row![get_archived_games, website, quit].spacing(SPACING);

3571

3572

        if self.admin {

3573

            middle = middle.push(button("Email Everyone").on_press(Message::EmailEveryone));

3574

3575

3576

        let username = row![username, my_games, my_games_text].spacing(SPACING);

3577

        let user_area = self.user_area(false);

3578

3579

        column![middle, username, user_area]

3580

            .spacing(SPACING)

3581

            .padding(PADDING)

3582

3583

3584

    fn handle_play(&mut self, role: Option<&str>, from: &str, to: &str) {

3585

        self.captures = HashSet::new();

3586

3587

        let mut game_handle = None;

3588

        if let Some(handle) = &mut self.archived_game_handle {

3589

            game_handle = Some(Game::from(&handle.boards));

3590

3591

3592

        let game = if let Some(game) = &mut game_handle {

3593

            game

3594

        } else {

3595

            self.game.as_mut().expect("you should have a game by now")

3596

};

3597

3598

        let role = if let Some(role) = role {

3599

            Role::from_str(role).expect("there should be a valid role")

3600

        } else {

3601

            game.turn

3602

};

3603

3604

        let play = Plae::try_from(vec!["play", &role.to_string(), from, to])

3605

            .expect("This is a valid plae.");

3606

        let captures = game.play(&play).expect("This should be a legal play.");

3607

        for vertex in captures.0 {

3608

            self.captures.insert(vertex);

3609

3610

3611

        if let Some(handle) = &mut self.archived_game_handle {

3612

            handle.boards.insert(&game.board);

3613

            handle.play += 1;

3614

3615

3616

        if self.sound_muted {

3617

            return;

3618

3619

3620

        let capture = !self.captures.is_empty();

3621

        let volume = self.volume.volume();

3622

3623

        thread::spawn(move || {

3624

            let mut stream = rodio::DeviceSinkBuilder::open_default_sink()?;

3625

            let cursor = if capture {

3626

                Cursor::new(SOUND_CAPTURE)

3627

            } else {

3628

                Cursor::new(SOUND_MOVE)

3629

};

3630

            let sound = rodio::play(stream.mixer(), cursor)?;

3631

            sound.set_volume(volume);

3632

            sound.sleep_until_end();

3633

3634

            stream.log_on_drop(false);

3635

            Ok::<(), anyhow::Error>(())

3636

});

3637

3638

3639

    fn resign(&mut self) {

3640

        let game = self.game.as_ref().expect("you should have a game by now");

3641

3642

        self.send(&format!(

3643

            "game {} play {} resigns _\n",

3644

            self.game_id, game.turn

3645

));

3646

3647

3648

    fn sound_muted(&mut self) {

3649

        self.sound_muted = !self.sound_muted;

3650

        handle_error(self.save_client_ron());

3651

3652

3653

    #[allow(

3654

        clippy::cast_precision_loss,

3655

        clippy::similar_names,

3656

        clippy::too_many_lines

3657

)]

3658

    #[must_use]

3659

    fn users(&self, show_logged_out_users: bool) -> Scrollable<'_, Message> {

3660

        if self.admin {

3661

            let mut ratings = Column::new();

3662

            let mut usernames = Column::new();

3663

            let mut wins = Column::new();

3664

            let mut losses = Column::new();

3665

            let mut draws = Column::new();

3666

            let mut win_percents = Column::new();

3667

            let mut emails = Column::new();

3668

            let mut emails_sent = Column::new();

3669

            let mut send_emails = Column::new();

3670

            let mut creation_dates = Column::new();

3671

            let mut last_logged_in = Column::new();

3672

3673

            for (name, account) in self.accounts_sorted() {

3674

                if show_logged_out_users || account.logged_in.is_some() {

3675

                    let wins_number = account.wins as f64;

3676

                    let mut win_percentage = wins_number / (wins_number + account.losses as f64);

3677

3678

                    win_percentage *= 100.0;

3679

                    win_percentage = win_percentage.round_ties_even();

3680

3681

                    ratings = ratings.push(text(account.rating.to_string_rounded()));

3682

                    usernames = usernames.push(text(name));

3683

                    wins = wins.push(text(account.wins));

3684

                    losses = losses.push(text(account.losses));

3685

                    draws = draws.push(text(account.draws));

3686

                    win_percents = win_percents.push(text!("{}", win_percentage));

3687

3688

                    emails = if let Some(email) = &account.email {

3689

                        emails.push(text(email.address.clone()))

3690

                    } else {

3691

                        emails.push(text(""))

3692

};

3693

3694

                    if let Ok(timestamp) = Timestamp::from_second(account.email_sent) {

3695

                        emails_sent =

3696

                            emails_sent.push(text(timestamp.strftime("%Y-%m-%d").to_string()));

3697

                    } else {

3698

                        emails_sent = emails_sent.push(text(""));

3699

3700

3701

                    send_emails = send_emails.push(text(account.send_emails));

3702

3703

                    let date = account.creation_date.0.strftime("%Y-%m-%d").to_string();

3704

3705

                    creation_dates = creation_dates.push(text(date));

3706

3707

                    let date = account

3708

                        .last_logged_in

3709

.0

3710

                        .strftime("%Y-%m-%d %H:%M:%S %z")

3711

                        .to_string();

3712

3713

                    last_logged_in = if account.logged_in.is_some() {

3714

                        last_logged_in.push(text(date).style(text::success))

3715

                    } else {

3716

                        last_logged_in.push(text(date))

3717

};

3718

3719

3720

3721

            let rating = t!("rating");

3722

            let mut button_1 = button(text("(9)").size(10)).padding(PADDING_SMALL);

3723

3724

            if self.users_sort_by != SortBy::Rating {

3725

                button_1 = button_1.on_press(Message::UsersSortedBy(SortBy::Rating));

3726

3727

3728

            let ratings = column![

3729

                row![text(rating.to_string()), button_1,].spacing(SPACING),

3730

                text("-".repeat(rating.chars().count())).font(Font::MONOSPACE),

3731

                ratings

3732

3733

            .padding(PADDING);

3734

3735

            let username = t!("username");

3736

            let mut button_2 = button(text("(0)").size(10)).padding(PADDING_SMALL);

3737

3738

            if self.users_sort_by != SortBy::Name {

3739

                button_2 = button_2.on_press(Message::UsersSortedBy(SortBy::Name));

3740

3741

3742

            let usernames = column![

3743

                row![text(username.to_string()), button_2,].spacing(SPACING),

3744

                text("-".repeat(username.chars().count())).font(Font::MONOSPACE),

3745

                usernames

3746

3747

            .padding(PADDING);

3748

3749

            let win = t!("wins");

3750

            let wins = column![

3751

                text(win.to_string()),

3752

                text("-".repeat(win.chars().count())).font(Font::MONOSPACE),

3753

                wins

3754

3755

            .padding(PADDING);

3756

3757

            let loss = t!("losses");

3758

            let losses = column![

3759

                text(loss.to_string()),

3760

                text("-".repeat(loss.chars().count())).font(Font::MONOSPACE),

3761

                losses

3762

3763

            .padding(PADDING);

3764

3765

            let draw = t!("draws");

3766

            let draws = column![

3767

                text(draw.to_string()),

3768

                text("-".repeat(draw.chars().count())).font(Font::MONOSPACE),

3769

                draws

3770

3771

            .padding(PADDING);

3772

3773

            let win_percent = format!("{} %", t!("wins"));

3774

            let hyphens_count = win_percent.chars().count();

3775

            let win_percents = column![

3776

                text(win_percent),

3777

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3778

                win_percents

3779

3780

            .padding(PADDING);

3781

3782

            let email = "email".to_string();

3783

            let hyphens_count = email.chars().count();

3784

            let emails = column![

3785

                text(email),

3786

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3787

                emails

3788

3789

            .padding(PADDING);

3790

3791

            let email_sent = "email sent".to_string();

3792

            let hyphens_count = email_sent.chars().count();

3793

            let emails_sent = column![

3794

                text(email_sent),

3795

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3796

                emails_sent

3797

3798

            .padding(PADDING);

3799

3800

            let send_email = "send emails".to_string();

3801

            let hyphens_count = send_email.chars().count();

3802

            let send_emails = column![

3803

                text(send_email),

3804

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3805

                send_emails

3806

3807

            .padding(PADDING);

3808

3809

            let creation_date = "creation".to_string();

3810

            let hyphens_count = creation_date.chars().count();

3811

            let creation_dates = column![

3812

                text(creation_date),

3813

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3814

                creation_dates

3815

3816

            .padding(PADDING);

3817

3818

            let last_logged_in_ = "logged in".to_string();

3819

            let hyphens_count = last_logged_in_.chars().count();

3820

            let last_logged_in = column![

3821

                text(last_logged_in_),

3822

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3823

                last_logged_in

3824

3825

            .padding(PADDING);

3826

3827

            let mut rows = row![ratings, usernames, wins, losses, draws, win_percents,];

3828

3829

            if show_logged_out_users {

3830

                rows = rows.push(emails);

3831

                rows = rows.push(emails_sent);

3832

                rows = rows.push(send_emails);

3833

                rows = rows.push(creation_dates);

3834

                rows = rows.push(last_logged_in);

3835

3836

3837

            scrollable(rows).spacing(SPACING)

3838

        } else {

3839

            let mut ratings = Column::new();

3840

            let mut usernames = Column::new();

3841

            let mut wins = Column::new();

3842

            let mut losses = Column::new();

3843

            let mut draws = Column::new();

3844

            let mut win_percents = Column::new();

3845

3846

            for user in self.users_sorted() {

3847

                if show_logged_out_users || user.logged_in {

3848

                    let wins_number = f64::from_str(&user.wins).expect("This is a f64.");

3849

                    let mut win_percentage = wins_number

3850

                        / (wins_number + f64::from_str(&user.losses).expect("This is a f64."));

3851

3852

                    win_percentage *= 100.0;

3853

                    win_percentage = win_percentage.round_ties_even();

3854

3855

                    ratings = ratings.push(text(user.rating.to_string_rounded()));

3856

3857

                    usernames = if user.logged_in && show_logged_out_users {

3858

                        usernames.push(text(user.name).style(text::success))

3859

                    } else {

3860

                        usernames.push(text(user.name))

3861

};

3862

3863

                    wins = wins.push(text(user.wins));

3864

                    losses = losses.push(text(user.losses));

3865

                    draws = draws.push(text(user.draws));

3866

                    win_percents = win_percents.push(text!("{}", win_percentage));

3867

3868

3869

3870

            let rating = t!("rating");

3871

            let mut button_1 = button(text("(9)").size(10)).padding(PADDING_SMALL);

3872

3873

            if self.users_sort_by != SortBy::Rating {

3874

                button_1 = button_1.on_press(Message::UsersSortedBy(SortBy::Rating));

3875

3876

3877

            let ratings = column![

3878

                row![text(rating.to_string()), button_1,].spacing(SPACING),

3879

                text("-".repeat(rating.chars().count())).font(Font::MONOSPACE),

3880

                ratings

3881

3882

            .padding(PADDING);

3883

3884

            let username = t!("username");

3885

            let mut button_2 = button(text("(0)").size(10)).padding(PADDING_SMALL);

3886

3887

            if self.users_sort_by != SortBy::Name {

3888

                button_2 = button_2.on_press(Message::UsersSortedBy(SortBy::Name));

3889

3890

3891

            let usernames = column![

3892

                row![text(username.to_string()), button_2,].spacing(SPACING),

3893

                text("-".repeat(username.chars().count())).font(Font::MONOSPACE),

3894

                usernames

3895

3896

            .padding(PADDING);

3897

3898

            let win = t!("wins");

3899

            let wins = column![

3900

                text(win.to_string()),

3901

                text("-".repeat(win.chars().count())).font(Font::MONOSPACE),

3902

                wins

3903

3904

            .padding(PADDING);

3905

3906

            let loss = t!("losses");

3907

            let losses = column![

3908

                text(loss.to_string()),

3909

                text("-".repeat(loss.chars().count())).font(Font::MONOSPACE),

3910

                losses

3911

3912

            .padding(PADDING);

3913

3914

            let draw = t!("draws");

3915

            let draws = column![

3916

                text(draw.to_string()),

3917

                text("-".repeat(draw.chars().count())).font(Font::MONOSPACE),

3918

                draws

3919

3920

            .padding(PADDING);

3921

3922

            let win_percent = format!("{} %", t!("wins"));

3923

            let hyphens_count = win_percent.chars().count();

3924

            let win_percents = column![

3925

                text(win_percent),

3926

                text("-".repeat(hyphens_count)).font(Font::MONOSPACE),

3927

                win_percents

3928

3929

            .padding(PADDING);

3930

3931

            scrollable(row![ratings, usernames, wins, losses, draws, win_percents]).spacing(SPACING)

3932

3933

3934

3935

    #[must_use]

3936

    fn user_area(&self, in_game: bool) -> Container<'_, Message> {

3937

        let texts = if in_game {

3938

            &self.texts_game

3939

        } else {

3940

            &self.texts

3941

};

3942

3943

        let games = self.games();

3944

        let texting = self.texting(texts, true).padding(PADDING);

3945

        let users = self.users(false);

3946

3947

        let user_area = scrollable(column![games, users, texting]);

3948

        container(user_area)

3949

            .padding(PADDING)

3950

            .style(container::bordered_box)

3951

3952

3953

    fn reset_password(&mut self) {

3954

        if !self.connected_tcp {

3955

            self.send("tcp_connect\n");

3956

            self.connected_tcp = true;

3957

3958

3959

        if self.screen == Screen::Login {

3960

            self.send(&format!(

3961

                "{VERSION_ID} reset_password {}\n",

3962

                self.text_input

3963

));

3964

3965

3966

3967

    #[must_use]

3968

    #[allow(clippy::too_many_lines)]

3969

    pub fn view(&self) -> Element<'_, Message> {

3970

        match self.screen {

3971

            Screen::EmailEveryone => {

3972

                let subject = row![

3973

                    text("Subject: "),

3974

                    widget::text_input("", &self.text_input)

3975

                        .on_input(Message::TextChanged)

3976

                        .on_paste(Message::TextChanged)

3977

                        .on_submit(Message::TextSend),

3978

];

3979

3980

                let editor = text_editor(&self.content)

3981

                    .placeholder("Dear User, …")

3982

                    .on_action(Message::TextEdit);

3983

3984

                let send_emails = button("Send Emails").on_press(Message::TextSend);

3985

                let leave = button(text!("{} (Esc)", self.strings["Quit"].as_str()))

3986

                    .on_press(Message::Leave);

3987

                let mut column = column![

3988

                    subject,

3989

                    text("From: Hnefatafl Org <noreply@hnefatafl.org>"),

3990

                    text("Content-Type: text/plain; charset=utf-8"),

3991

                    text("Content-Transfer-Encoding: 7bit"),

3992

                    text!("Date: {}", Timestamp::now().strftime("%F %T UTC")),

3993

                    text("Body:"),

3994

                    editor,

3995

                    send_emails,

3996

                    leave,

3997

                    text("Bcc:")

3998

3999

                .spacing(SPACING)

4000

                .padding(PADDING);

4001

4002

                for email in &self.emails_bcc {

4003

                    column = column.push(text(email));

4004

4005

4006

                scrollable(column).spacing(SPACING).into()

4007

4008

            Screen::Game | Screen::GameReview => self.display_game(),

4009

            Screen::Games => Tabs::new(Message::TabSelected)

4010

                .push(

4011

                    TabId::Games,

4012

                    iced_aw::TabLabel::Text(format!("{} (1)", t!("Games"))),

4013

                    self.games_view(),

4014

4015

                .push(

4016

                    TabId::GameNew,

4017

                    iced_aw::TabLabel::Text(format!(

4018

                        "{} (2)",

4019

                        self.strings["Create Game"].as_str()

4020

)),

4021

                    self.game_new_view(),

4022

4023

                .push(

4024

                    TabId::Tournament,

4025

                    iced_aw::TabLabel::Text(format!("{} (3)", self.strings["Tournament"].as_str())),

4026

                    self.tournament_view(),

4027

4028

                .push(

4029

                    TabId::AccountSettings,

4030

                    iced_aw::TabLabel::Text(format!("{} (4)", self.strings["Account Settings"])),

4031

                    self.account_settings_view(),

4032

4033

                .push(

4034

                    TabId::Users,

4035

                    iced_aw::TabLabel::Text(format!("{} (5)", self.strings["Users"])),

4036

                    column![

4037

                        button(text!("{} (Esc)", self.strings["Quit"].as_str()))

4038

                            .on_press(Message::Leave),

4039

                        self.users(true)

4040

4041

                    .padding(PADDING)

4042

                    .spacing(SPACING),

4043

4044

                .height(Length::Shrink)

4045

                .width(Length::Fill)

4046

                .set_active_tab(&self.active_tab)

4047

                .into(),

4048

            Screen::Login => {

4049

                let username = row![

4050

                    text!("{}:", t!("username")).size(20),

4051

                    widget::text_input("", &self.text_input)

4052

                        .on_input(Message::TextChanged)

4053

                        .on_paste(Message::TextChanged),

4054

4055

                .spacing(SPACING);

4056

4057

                let username = container(username)

4058

                    .padding(PADDING)

4059

                    .style(container::bordered_box);

4060

4061

                let password = row![

4062

                    text!("{}:", t!("password")).size(20),

4063

                    widget::text_input("", &self.password)

4064

                        .secure(!self.password_show)

4065

                        .on_input(Message::PasswordChanged)

4066

                        .on_paste(Message::PasswordChanged),

4067

4068

                .spacing(SPACING);

4069

4070

                let password = container(password)

4071

                    .padding(PADDING)

4072

                    .style(container::bordered_box);

4073

4074

                let show_password_text = text!("{} (1)", t!("show password"));

4075

                let show_password = checkbox(self.password_show).on_toggle(Message::PasswordShow);

4076

4077

                let save_password_text = text!("{} (2)", t!("save password"));

4078

                let save_password = checkbox(self.password_save).on_toggle(Message::PasswordSave);

4079

4080

                let mut login = button(text!("{} (Enter)", self.strings["Login"].as_str()));

4081

                if !self.password_ends_with_whitespace {

4082

                    login = login.on_press(Message::TextSendLogin);

4083

4084

4085

                let mut create_account =

4086

                    button(text!("{} (4)", self.strings["Create Account"].as_str()));

4087

                if !self.text_input.is_empty() && !self.password_ends_with_whitespace {

4088

                    create_account = create_account.on_press(Message::TextSendCreateAccount);

4089

4090

4091

                let mut reset_password =

4092

                    button(text!("{} (5)", self.strings["Reset Password"].as_str()));

4093

                if !self.text_input.is_empty() {

4094

                    reset_password = reset_password.on_press(Message::ResetPassword);

4095

4096

4097

                let mut error = text("");

4098

                if let Some(error_) = &self.error {

4099

                    error = text(error_).style(text::danger);

4100

4101

4102

                let mut error_persistent = Column::new();

4103

                for error in &self.error_persistent {

4104

                    error_persistent = error_persistent.push(text(error).style(text::danger));

4105

4106

4107

                let mut review_game = button(text!("{} (a)", self.strings["Review Game"].as_str()));

4108

                if self.archived_game_selected.is_some() {

4109

                    review_game = review_game.on_press(Message::ReviewGame);

4110

4111

4112

                let archived_games = if let Some(archived_games) = &self.archived_games_filtered {

4113

                    archived_games.clone()

4114

                } else {

4115

                    self.archived_games.clone()

4116

};

4117

4118

                let my_games_text = text!("{} (3)", t!("My Games Only"));

4119

                let my_games = checkbox(self.my_games_only).on_toggle(Message::MyGamesOnly);

4120

                let quit = button(text!("{} (Esc)", self.strings["Quit"].as_str()))

4121

                    .on_press(Message::Leave);

4122

4123

                let buttons_1 = row![login, create_account, reset_password, quit].spacing(SPACING);

4124

4125

                let review_game_pick = pick_list(

4126

                    archived_games,

4127

                    self.archived_game_selected.clone(),

4128

                    Message::ArchivedGameSelected,

4129

4130

                .placeholder(t!("Archived Games"));

4131

4132

                let review_game_pick = row![review_game, review_game_pick].spacing(SPACING);

4133

4134

                let locale = [

4135

                    Locale::English,

4136

                    Locale::Chinese,

4137

                    Locale::Spanish,

4138

                    Locale::Arabic,

4139

                    Locale::Indonesian,

4140

                    Locale::PortugueseBr,

4141

                    Locale::PortuguesePt,

4142

                    Locale::French,

4143

                    Locale::Japanese,

4144

                    Locale::Russian,

4145

                    Locale::German,

4146

                    Locale::Icelandic,

4147

                    Locale::IcelandicRunic,

4148

                    Locale::Swedish,

4149

                    Locale::Korean,

4150

];

4151

4152

                let locale = row![

4153

                    text!("{}: ", t!("locale")).size(20),

4154

                    pick_list(locale, self.locale_selected, Message::LocaleSelected),

4155

];

4156

4157

                let theme = if self.theme == Theme::Light {

4158

                    row![

4159

                        button(text!("{} (6)", self.strings["Dark"].as_str()))

4160

                            .on_press(Message::ChangeTheme(Theme::Dark)),

4161

                        button(text!("{} (7)", self.strings["Light"].as_str())),

4162

                        button(text("Tol (8)")).on_press(Message::ChangeTheme(Theme::Tol)),

4163

4164

                    .spacing(SPACING)

4165

                } else if self.theme == Theme::Dark {

4166

                    row![

4167

                        button(text!("{} (6)", self.strings["Dark"].as_str())),

4168

                        button(text!("{} (7)", self.strings["Light"].as_str()))

4169

                            .on_press(Message::ChangeTheme(Theme::Light)),

4170

                        button(text("Tol (8)")).on_press(Message::ChangeTheme(Theme::Tol)),

4171

4172

                    .spacing(SPACING)

4173

                } else {

4174

                    row![

4175

                        button(text!("{} (6)", self.strings["Dark"].as_str()))

4176

                            .on_press(Message::ChangeTheme(Theme::Dark)),

4177

                        button(text!("{} (7)", self.strings["Light"].as_str()))

4178

                            .on_press(Message::ChangeTheme(Theme::Light)),

4179

                        button(text("Tol (8)")),

4180

4181

                    .spacing(SPACING)

4182

};

4183

4184

                let theme = LabeledFrame::new(text(t!("Theme")), theme);

4185

                let discord = button(text!("Discord (9)")).on_press(Message::OpenUrl(

4186

                    "https://discord.gg/h56CAHEBXd".to_string(),

4187

));

4188

4189

                let website = button("Hnefatafl Org (0)")

4190

                    .on_press(Message::OpenUrl("https://hnefatafl.org".to_string()));

4191

4192

                let websites = row![discord, website].spacing(SPACING);

4193

                let websites = LabeledFrame::new(text(t!("Websites")), websites);

4194

                let help_text = container(text!(

4195

                    "Tab: {}, Shift + Tab: {}",

4196

                    self.chars.arrow_right,

4197

                    self.chars.arrow_left

4198

))

4199

                .padding(PADDING)

4200

                .style(container::bordered_box);

4201

4202

                let help_text_2 = text(t!(

4203

                    "You must hold down the control (Ctrl) or command (⌘) key when pressing a lettered or numbered hotkey."

4204

));

4205

4206

                let help_text_3 = text(t!(

4207

                    "You can play on the board by pressing control (Ctrl) or command (⌘) and a letter then a number or vice versa."

4208

));

4209

4210

                let help_text_4 = text(t!("You have a week to move, then you lose the game."));

4211

4212

                column![

4213

                    username,

4214

                    password,

4215

                    row![

4216

                        show_password,

4217

                        show_password_text,

4218

                        save_password,

4219

                        save_password_text,

4220

                        my_games,

4221

                        my_games_text,

4222

4223

                    .spacing(SPACING),

4224

                    buttons_1,

4225

                    row![theme, websites].spacing(SPACING),

4226

                    locale,

4227

                    review_game_pick,

4228

                    help_text,

4229

                    help_text_2,

4230

                    help_text_3,

4231

                    help_text_4,

4232

                    error,

4233

                    error_persistent

4234

4235

                .padding(PADDING)

4236

                .spacing(SPACING)

4237

                .into()

4238

4239

4240

4241

4242

    fn reset_email(&mut self) {

4243

        self.email = None;

4244

        self.send("email_reset\n");

4245

4246

4247

    fn reset_markers(&mut self) {

4248

        self.captures = HashSet::new();

4249

        self.play_from = None;

4250

        self.play_from_previous = None;

4251

        self.play_to_previous = None;

4252

4253

4254

    fn review_game(&mut self) {

4255

        if let Some(archived_game) = &self.archived_game_selected {

4256

            self.archived_game_handle = Some(ArchivedGameHandle::new(archived_game));

4257

            self.screen = Screen::GameReview;

4258

4259

            self.captures = HashSet::new();

4260

            self.reset_markers();

4261

4262

4263

4264

    fn save_client_postcard(&self) -> anyhow::Result<()> {

4265

        let postcard_bytes = postcard::to_allocvec(&self.archived_games)?;

4266

        if !postcard_bytes.is_empty() {

4267

            let mut file = File::create(data_file(ARCHIVED_GAMES_FILE))?;

4268

            file.write_all(&postcard_bytes)?;

4269

4270

4271

        Ok(())

4272

4273

4274

    fn save_client_ron(&self) -> anyhow::Result<()> {

4275

        let password = if self.password_save {

4276

            self.password.clone()

4277

        } else {

4278

            String::new()

4279

};

4280

4281

        let client = Client {

4282

            archived_games: Vec::new(),

4283

            coordinates: self.coordinates,

4284

            locale_selected: self.locale_selected,

4285

            my_games_only: self.my_games_only,

4286

            password,

4287

            password_save: self.password_save,

4288

            password_show: self.password_show,

4289

            sound_muted: self.sound_muted,

4290

            theme: self.theme,

4291

            username: self.username.clone(),

4292

            ..Client::default()

4293

};

4294

4295

        let ron_string = ron::ser::to_string_pretty(&client, ron::ser::PrettyConfig::new())?;

4296

        if !ron_string.is_empty() {

4297

            let mut file = File::create(data_file(USER_CONFIG_FILE))?;

4298

            file.write_all(ron_string.as_bytes())?;

4299

4300

4301

        Ok(())

4302

4303

4304

    fn send(&mut self, string: &str) {

4305

        if let Err(error) = self

4306

.tx

4307

            .as_mut()

4308

            .unwrap_or_else(|| {

4309

                error!("Error sending {string:?}: you should have a tx available by now");

4310

                unreachable!();

4311

})

4312

            .send(string.to_string())

4313

4314

            error!("{error}: {string}");

4315

            exit(1);

4316

4317

4318

4319

    fn send_estimate_score(&mut self, tree: Tree) {

4320

        handle_error(

4321

            self.estimate_score_tx

4322

                .as_mut()

4323

                .unwrap_or_else(|| {

4324

                    error!("Error sending {tree:?}: you should have a tx available by now");

4325

                    unreachable!();

4326

})

4327

                .send(tree),

4328

);

4329

4330

4331

    fn toggle_save_password(&mut self) {

4332

        self.password_save = !self.password_save;

4333

        handle_error(self.save_client_ron());

4334

4335

4336

    fn toggle_show_password(&mut self) {

4337

        self.password_show = !self.password_show;

4338

        handle_error(self.save_client_ron());

4339

4340

4341

    fn tournament_view(&self) -> Scrollable<'_, Message> {

4342

        let mut column = Column::new().padding(PADDING).spacing(SPACING);

4343

4344

        if self.admin_tournament {

4345

            let date_button = Button::new(text("Tournament Date")).on_press(Message::DateChoose);

4346

4347

            let date_picker = date_picker(

4348

                self.tournament_date_show_picker,

4349

                self.tournament_date,

4350

                date_button,

4351

                Message::DateCancel,

4352

                Message::DateSubmit,

4353

);

4354

4355

            let mut delete_button = button("Delete Tournament");

4356

4357

            if self.tournament.is_some() {

4358

                delete_button = delete_button.on_press(Message::TournamentDelete);

4359

4360

4361

            let row = row![date_picker, delete_button].spacing(SPACING);

4362

4363

            column = column.push(row);

4364

4365

4366

        let Some(tournament) = &self.tournament else {

4367

            column = column.push(text(t!("There is no tournament.")));

4368

            column = column.push(

4369

                button(text!("{} (Esc)", self.strings["Quit"].as_str())).on_press(Message::Leave),

4370

);

4371

4372

            return scrollable(column).spacing(SPACING);

4373

};

4374

4375

        let mut date = Row::new().spacing(SPACING);

4376

        let start_date = t!("Tournament Start Date");

4377

        date = date.push(text!(

4378

            "{start_date}: {}",

4379

            tournament.date.strftime("%F %T UTC")

4380

));

4381

4382

        let button_0 = button(text!(

4383

            "{} (6)",

4384

            self.strings["Tournaments Described"].as_str()

4385

))

4386

        .on_press(Message::Tournaments);

4387

4388

        let mut button_1 = button(text!("{} (7)", self.strings["Join Tournament"].as_str()));

4389

4390

        let mut button_2 = button(text!("{} (8)", self.strings["Leave Tournament"].as_str()));

4391

4392

        if tournament.players.contains(&self.username) {

4393

            button_2 = button_2.on_press(Message::TournamentLeave);

4394

        } else {

4395

            button_1 = button_1.on_press(Message::TournamentJoin);

4396

4397

4398

        let buttons = row![

4399

            button_0,

4400

            button_1,

4401

            button_2,

4402

            button(text!("{} (Esc)", self.strings["Quit"].as_str())).on_press(Message::Leave),

4403

4404

        .spacing(SPACING);

4405

4406

        let mut players = Column::new();

4407

        let mut player_names: Vec<_> = tournament.players.iter().collect();

4408

        player_names.sort();

4409

4410

        for player in &player_names {

4411

            players = players.push(text(*player));

4412

4413

4414

        column = column.push(date);

4415

        column = column.push(buttons);

4416

        column = column.push(LabeledFrame::new(text(t!("Players")), players));

4417

4418

        if self.admin_tournament {

4419

            let mut delete_button = button("Delete Tournament Tree");

4420

4421

            if let Some(tournament) = &self.tournament

4422

                && tournament.groups.is_some()

4423

4424

                delete_button = delete_button.on_press(Message::TournamentTreeDelete);

4425

4426

4427

            let mut start_tournament = button("Start Tournament");

4428

4429

            if let Some(tournament) = &self.tournament {

4430

                if tournament.groups.is_none() {

4431

                    start_tournament = start_tournament.on_press(Message::TournamentStart);

4432

4433

            } else {

4434

                start_tournament = start_tournament.on_press(Message::TournamentStart);

4435

4436

4437

            column = column.push(row![start_tournament, delete_button].spacing(SPACING));

4438

4439

4440

        column = column.push(self.display_tournament());

4441

        scrollable(column).spacing(SPACING)

4442

4443

4444

    fn letter(

4445

        &self,

4446

        letter: char,

4447

        column: Column<'a, Message>,

4448

        letter_size: u32,

4449

    ) -> Column<'a, Message> {

4450

        let mut text = text(letter).size(letter_size);

4451

        if self.press_letters.contains(&letter.to_ascii_lowercase()) {

4452

            text = text.style(text::success);

4453

4454

4455

        column.push(text)

4456

4457

4458

    fn numbers(&self, letter_size: u32, spacing: u32, board_size: usize) -> Column<'a, Message> {

4459

        let mut column = column![text(" ").size(letter_size)].spacing(spacing);

4460

4461

        for i in 0..board_size {

4462

            let i = board_size - i;

4463

            let mut text = text!("{i:2}").size(letter_size).align_y(Vertical::Center);

4464

            if self.press_numbers[i - 1] {

4465

                text = text.style(text::success);

4466

4467

            column = column.push(text);

4468

4469

4470

        column

4471

4472