ap_manual 0.2.0

A rust package to cannonically interact with manual AP worlds
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use serde::{Serialize,Deserialize};

use crate::item::Item;
fn default_index()->i32{
    1
}
/// Cannonical representation of the Game json
#[derive(Debug,Serialize,Deserialize,PartialEq, Eq,Clone)]
pub struct Game{
    pub game: String,
    #[serde(alias="player")]
    pub creator: String,
    pub filler_item_name: String,
    pub starting_items: Vec<Item>,
    #[serde(default)]
    pub death_link: bool,
    #[serde(default="default_index")]
    pub starting_index: i32
}
impl Game{
    /// Create a simple game, using default options for everything else
    pub fn simple(game: String, creator: String, filler_item_name: String)->Self{
        Self{
            game,creator,filler_item_name,starting_items: vec![],death_link: false,starting_index: 1
        }
    }
    /// add a starting item
    pub fn add_starting_item(&mut self, item: Item){
        self.starting_items.push(item);
    }
    pub fn with_start_item(mut self,item: Item)->Self{
        self.add_starting_item(item);
        self
    }
    pub fn with_deathlink(mut self)->Self{
        self.death_link=true;
        self
    }
}
#[derive(Debug,Clone,PartialEq, Eq)]
pub struct GameBuilderCF{
    creator: String,
    filler_item_name: String,
}
impl GameBuilderCF{
    pub fn with_game(self,game: String)->Game{
        Game::simple(game, self.creator, self.filler_item_name)
    }
}
#[derive(Debug,Clone,PartialEq, Eq)]
pub struct GameBuilderCG{
    creator: String,
    game: String
}

impl GameBuilderCG{
    pub fn with_filler_item_name(self,name: String)->Game{
        Game::simple(self.game, self.creator, name)
    }
}
#[derive(Debug,Clone,PartialEq, Eq)]
pub struct GameBuilderFG{
    filler_item_name: String,
    game: String
}
impl GameBuilderFG{
    pub fn with_creator(self,creator: String)->Game{
        Game::simple(self.game, creator, self.filler_item_name)
    }
}
#[derive(Debug,Clone,PartialEq, Eq)]
pub struct GameBuilderG{
    game: String
}
impl GameBuilderG{
    pub fn with_creator(self,creator: String)->GameBuilderCG{
        GameBuilderCG { creator, game: self.game }
    }
    pub fn with_filler_item_name(self,name: String)->GameBuilderFG{
        GameBuilderFG { filler_item_name: name, game: self.game }
    }
}
#[derive(Debug,Clone,PartialEq, Eq)]
pub struct GameBuilderC{
    creator: String
}
impl GameBuilderC{
    pub fn with_filler_item_name(self,name: String)->GameBuilderCF{
        GameBuilderCF { creator: self.creator, filler_item_name: name }
    }
    pub fn with_game(self,game: String)->GameBuilderCG{
        GameBuilderCG {creator: self.creator, game}
    }
}
#[derive(Debug,Clone,PartialEq, Eq)]
pub struct GameBuilderF{
    filler_item_name: String
}
impl GameBuilderF{
    pub fn with_creator(self,creator: String)->GameBuilderCF{
        GameBuilderCF { creator, filler_item_name: self.filler_item_name }
    }
    pub fn with_game(self,game: String)->GameBuilderFG{
        GameBuilderFG { filler_item_name: self.filler_item_name, game }
    }
}
#[derive(Debug,Clone,PartialEq, Eq)]
pub struct GameBuilder{}
impl GameBuilder{
    pub fn with_game(self,game: String)->GameBuilderG{
        GameBuilderG { game }
    }
    pub fn with_creator(self,creator: String)->GameBuilderC{
        GameBuilderC { creator }
    }
    pub fn with_filler_item_name(self,name: String)->GameBuilderF{
        GameBuilderF { filler_item_name:name }
    }
}

impl Game{
    pub fn builder()->GameBuilder{
        GameBuilder {  }
    }
}