nil-core 0.5.3

Multiplayer strategy game
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

// Copyright (C) Call of Nil contributors
// SPDX-License-Identifier: AGPL-3.0-only

use super::Round;
use crate::error::{Error, Result};
use crate::player::PlayerId;
use std::assert_matches;

#[test]
#[cfg_attr(miri, ignore)]
fn lifecycle() -> Result<()> {
  let mut round = Round::default();
  let players = vec![
    PlayerId::from("Player A"),
    PlayerId::from("Player B"),
    PlayerId::from("Player C"),
  ];

  assert_eq!(round.id(), 1u32);
  assert!(round.is_idle());

  assert_matches!(round.next([]), Err(Error::RoundNotStarted));

  round.start(players.clone())?;
  assert!(round.is_waiting());

  assert_matches!(round.start([]), Err(Error::RoundAlreadyStarted));

  round.set_ready(&players[0], true);

  for player in &players {
    assert_eq!(round.is_player_ready(player), player == &players[0]);
    assert_eq!(round.is_player_pending(player), player != &players[0]);
    assert!(round.is_waiting_player(player));
  }

  round.set_ready(&players[0], false);

  for player in &players {
    assert!(!round.is_player_ready(player));
    assert!(round.is_player_pending(player));
    assert!(round.is_waiting_player(player));
  }

  assert_matches!(round.next([]), Err(Error::RoundHasPendingPlayers));

  for player in &players {
    round.set_ready(player, true);
  }

  assert!(round.is_done());
  round.next(players.clone())?;

  assert_eq!(round.id(), 2u32);
  assert!(round.is_waiting());

  for player in &players {
    assert!(!round.is_player_ready(player));
    assert!(round.is_player_pending(player));
    assert!(round.is_waiting_player(player));
  }

  Ok(())
}