spru 0.1.0

Reusable components for the spru strategy and digital board game framework.
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
65
66
67
68

pub mod error;
pub use error::Error;

use std::collections::VecDeque;

use crate::{
    interactor,
    item::{self},
};

/// Initializes a game.  
/// This is used once during [Server::init](crate::Server::init) to create the [Root](Init::Root)
/// and any other initial state.
pub trait Init {
    /// The game's [Common::Root](crate::Common::Root).
    /// Created by [Init::initialize].
    type Root;
    /// The game's [trait@crate::State]
    type State: tagset::TagSet;
    /// The game's [trait@crate::Action]
    type Action;

    /// Initialize the game and return the [Root](Init::Root).
    fn initialize(self, interactor: &mut Interactor<Self>) -> self::Result<Self::Root>;
}

/// An alias for the [Interactor](crate::Interactor) used in [game::Init](Init).
pub type Interactor<'l, Init> = crate::Interactor<
    'l,
    item::storage::Canonical<
        <<Init as self::Init>::State as tagset::TagSet>::Repr,
        <Init as self::Init>::State,
    >,
    <Init as self::Init>::Action,
    Context,
    Output,
>;

/// [Interactor] context object. Contains no context, any required data should be contained
/// within the [Init] object.
#[derive(Debug)]
#[non_exhaustive]
pub struct Context {}

impl interactor::PlayerContext for Context {
    fn player_context(&self) -> Option<crate::player::Id> {
        None
    }
}

#[derive(Debug, Default)]
#[doc(hidden)]
pub struct Output {}

impl<Trigger> interactor::TakeTriggers<Trigger> for Output {
    fn take_triggers(&mut self) -> VecDeque<Trigger> {
        VecDeque::new()
    }
}

impl<GameOutcome> interactor::TakeGameOutcome<GameOutcome> for Output {
    fn take_game_outcome(&mut self) -> Option<GameOutcome> {
        None
    }
}

/// A result with an [Error] `Err`
pub type Result<T> = std::result::Result<T, self::Error>;