libfj 0.10.0

An unofficial collection of APIs used in FreeJam games and mods
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277

use serde::{Deserialize, Serialize};

// list endpoint

#[derive(Deserialize, Serialize, Clone)]
pub struct ListPayload {
    #[serde(rename = "page")]
    pub page: isize,
    #[serde(rename = "pageSize")]
    pub page_size: isize,
    #[serde(rename = "order")]
    pub order: isize,
    #[serde(rename = "playerFilter")]
    pub player_filter: bool,
    #[serde(rename = "movementFilter")]
    pub movement_filter: String, // csv int enums as str
    #[serde(rename = "movementCategoryFilter")]
    pub movement_category_filter: String, // csv int enums as str
    #[serde(rename = "weaponFilter")]
    pub weapon_filter: String, // csv int enums as str
    #[serde(rename = "weaponCategoryFilter")]
    pub weapon_category_filter: String, // csv int enums as str
    #[serde(rename = "minimumCpu")]
    pub minimum_cpu: isize,
    #[serde(rename = "maximumCpu")]
    pub maximum_cpu: isize,
    #[serde(rename = "textFilter")]
    pub text_filter: String,
    #[serde(rename = "textSearchField")]
    pub text_search_field: isize, // ???
    #[serde(rename = "buyable")]
    pub buyable: bool,
    #[serde(rename = "prependFeaturedRobot")]
    pub prepend_featured_robot: bool,
    #[serde(rename = "featuredOnly")]
    pub featured_only: bool,
    #[serde(rename = "defaultPage")]
    pub default_page: bool,
}

impl ListPayload {
    pub fn default() -> ListPayload {
        ListPayload {
            page: 1,
            page_size: 100,
            order: 0,
            player_filter: false,
            movement_filter: "100000,200000,300000,400000,500000,600000,700000,800000,900000,1000000,1100000,1200000".to_string(),
            movement_category_filter: "100000,200000,300000,400000,500000,600000,700000,800000,900000,1000000,1100000,1200000".to_string(),
            weapon_filter: "10000000,20000000,25000000,30000000,40000000,50000000,60000000,65000000,70100000,75000000".to_string(),
            weapon_category_filter: "10000000,20000000,25000000,30000000,40000000,50000000,60000000,65000000,70100000,75000000".to_string(),
            minimum_cpu: -1,
            maximum_cpu: -1,
            text_filter: "".to_string(),
            text_search_field: 0,
            buyable: true,
            prepend_featured_robot: false,
            featured_only: false,
            default_page: true,
        }
    }
    
    pub fn empty() -> ListPayload {
        ListPayload {
            page: 1,
            page_size: 100,
            order: 0,
            player_filter: false,
            movement_filter: "".to_string(),
            movement_category_filter: "".to_string(),
            weapon_filter: "".to_string(),
            weapon_category_filter: "".to_string(),
            minimum_cpu: -1,
            maximum_cpu: -1,
            text_filter: "".to_string(),
            text_search_field: 0,
            buyable: true,
            prepend_featured_robot: false,
            featured_only: false,
            default_page: false,
        }
    }
}


/// Standard factory response format.
#[derive(Deserialize, Serialize, Clone)]
pub struct FactoryInfo<T> {
    #[serde(rename = "response")]
    /// The response data
    pub response: T,
    #[serde(rename = "statusCode")]
    /// HTTP status code for the query
    pub status_code: usize,
}

/// Collection of robots in response to a list query.
#[derive(Deserialize, Serialize, Clone)]
pub struct RoboShopItemsInfo {
    #[serde(rename = "roboShopItems")]
    /// Robot items
    pub roboshop_items: Vec<FactoryRobotListInfo>,
}

/// Information about a single robot in response to a list query.
///
/// This does not include robot block data since it is not returned by this API endpoint.
/// Use `FactoryAPI.get(data.item_id)` to retrieve all info for a single robot.
#[derive(Deserialize, Serialize, Clone)]
pub struct FactoryRobotListInfo {
    /// Item ID
    #[serde(rename = "itemId")]
    pub item_id: usize,
    /// Robot name
    #[serde(rename = "itemName")]
    pub item_name: String,
    /// Robot description
    #[serde(rename = "itemDescription")]
    pub item_description: String,
    /// Thumbnail URL, as displayed to preview the robot.
    #[serde(rename = "thumbnail")]
    pub thumbnail: String, // url
    /// Robot author's username or UUID
    #[serde(rename = "addedBy")]
    pub added_by: String,
    /// Robot author's display name
    #[serde(rename = "addedByDisplayName")]
    pub added_by_display_name: String,
    /// Date added, in standard ISO format
    #[serde(rename = "addedDate")]
    pub added_date: String, // ISO date
    /// Expiry date, in standard ISO format
    #[serde(rename = "expiryDate")]
    pub expiry_date: String, // ISO date
    /// Robot CPU value
    #[serde(rename = "cpu")]
    pub cpu: usize,
    /// Robot RR
    #[serde(rename = "totalRobotRanking")]
    pub total_robot_ranking: usize,
    /// Robot's rentals
    #[serde(rename = "rentCount")]
    pub rent_count: usize,
    /// Robot's purchases
    #[serde(rename = "buyCount")]
    pub buy_count: usize,
    /// Is this robot buyable? (probably yes, unless you're a mod/admin or missing parts)
    #[serde(rename = "buyable")]
    pub buyable: bool,
    /// Removed date, in standard ISO format (probably None, unless authenticated as a mod/admin)
    #[serde(rename = "removedDate")]
    pub removed_date: Option<String>,
    /// Author ban date, in standard ISO format (probable None)
    #[serde(rename = "banDate")]
    pub ban_date: Option<String>,
    /// Is this robot featured?
    #[serde(rename = "featured")]
    pub featured: bool,
    /// CRF Banner message
    #[serde(rename = "bannerMessage")]
    pub banner_message: Option<String>,
    /// Robot's combat rating, out of 5
    #[serde(rename = "combatRating")]
    pub combat_rating: f32,
    /// Robot's cosmetic rating, out of 5
    #[serde(rename = "cosmeticRating")]
    pub cosmetic_rating: f32,
    /// Robot's count of (some?) blocks it uses
    #[serde(rename = "cubeAmounts")]
    pub cube_amounts: String, // JSON as str
}

impl FactoryRobotListInfo {
    pub fn cube_amounts_map(&self) -> serde_json::Result<std::collections::HashMap<u32, u32>> {
        parse_cube_amounts(&self.cube_amounts)
    }
}

impl std::string::ToString for FactoryRobotListInfo {
    fn to_string(&self) -> String {
        format!("{} by {} ({})", &self.item_name, &self.added_by_display_name, &self.item_id)
    }
}

// get/<item_id> endpoint
/// Complete information about a single robot in response to a get query.
/// Please refer to FactoryRobotListInfo for more in-depth documentation of fields.
#[derive(Deserialize, Serialize, Clone)]
pub struct FactoryRobotGetInfo {
    /// Item ID
    #[serde(rename = "id")]
    pub item_id: usize,
    /// Robot name
    #[serde(rename = "name")]
    pub item_name: String,
    /// Robot description
    #[serde(rename = "description")]
    pub item_description: String,
    /// Robot thumbnail URL
    #[serde(rename = "thumbnail")]
    pub thumbnail: String, // url
    /// Robot author's username or UUID
    #[serde(rename = "addedBy")]
    pub added_by: String,
    /// Robot author's display name
    #[serde(rename = "addedByDisplayName")]
    pub added_by_display_name: String,
    /// ISO date added
    #[serde(rename = "addedDate")]
    pub added_date: String, // ISO date
    /// ISO date expiring
    #[serde(rename = "expiryDate")]
    pub expiry_date: String, // ISO date
    /// CPU
    #[serde(rename = "cpu")]
    pub cpu: usize,
    /// RR
    #[serde(rename = "totalRobotRanking")]
    pub total_robot_ranking: usize,
    /// Robot rent count
    #[serde(rename = "rentCount")]
    pub rent_count: usize,
    /// Robot buy count
    #[serde(rename = "buyCount")]
    pub buy_count: usize,
    /// Robot is buyable?
    #[serde(rename = "buyable")]
    pub buyable: bool,
    /// ISO date removed
    #[serde(rename = "removedDate")]
    pub removed_date: Option<String>,
    /// ISO date banned
    #[serde(rename = "banDate")]
    pub ban_date: Option<String>,
    /// Robot is featured?
    #[serde(rename = "featured")]
    pub featured: bool,
    /// CRF banner message
    #[serde(rename = "bannerMessage")]
    pub banner_message: Option<String>,
    /// Robot's combat rating, out of 5
    #[serde(rename = "combatRating")]
    pub combat_rating: f32,
    /// Robot's cosmetic rating, out of 5
    #[serde(rename = "cosmeticRating")]
    pub cosmetic_rating: f32,
    /// Robot block cube and position data
    #[serde(rename = "cubeData")]
    pub cube_data: String,
    /// Robot block colour data
    #[serde(rename = "colourData")]
    pub colour_data: String,
    /// Cube counts
    #[serde(rename = "cubeAmounts")]
    pub cube_amounts: String, // JSON as str
}

impl FactoryRobotGetInfo {
    pub fn cube_amounts_map(&self) -> serde_json::Result<std::collections::HashMap<u32, u32>> {
        parse_cube_amounts(&self.cube_amounts)
    }
}

impl std::string::ToString for FactoryRobotGetInfo {
    fn to_string(&self) -> String {
        format!("{} by {} ({})", &self.item_name, &self.added_by_display_name, &self.item_id)
    }
}

pub fn parse_cube_amounts(s: &str) -> serde_json::Result<std::collections::HashMap<u32, u32>> {
    if s.is_empty() {
        Ok(std::collections::HashMap::default())
    } else {
        serde_json::from_str(s)
    }

}