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
|
/*
Hurry Curry! - a game about cooking
Copyright (C) 2025 Hurry Curry! Contributors
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, version 3 of the License only.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
use anyhow::Result;
use hurrycurry_protocol::{
Gamedata, ItemIndex, Message, Recipe, RecipeIndex,
book::{Diagram, DiagramEdge, DiagramNode, NodeStyle},
glam::Vec2,
};
use hurrycurry_server::data::Serverdata;
use std::collections::{BTreeMap, BTreeSet, HashSet};
pub(crate) fn recipe_diagram(
data: &Gamedata,
serverdata: &Serverdata,
target_items: &[String],
) -> Result<Diagram> {
let ambient_items = serverdata
.initial_map
.iter()
.flat_map(|(_, (_, item))| item)
.copied()
.collect::<HashSet<_>>();
let mut need = BTreeSet::from_iter(
target_items
.iter()
.map(|name| data.get_item_by_name(name).unwrap()),
);
let mut have = BTreeSet::<ItemIndex>::new();
let mut recipes = BTreeSet::new();
#[derive(PartialEq, PartialOrd, Eq, Ord)]
struct GraphRecipe {
index: RecipeIndex,
inputs: Vec<ItemIndex>,
outputs: Vec<ItemIndex>,
}
while let Some(item) = need.pop_last() {
for (ri, r) in data.recipes() {
if r.outputs().contains(&item) {
let gr = GraphRecipe {
inputs: r
.inputs()
.iter()
.filter(|i| !ambient_items.contains(i))
.copied()
.collect(),
outputs: r
.outputs()
.iter()
.filter(|i| !ambient_items.contains(i))
.copied()
.collect(),
index: ri,
};
need.extend(&gr.inputs);
have.extend(&gr.outputs);
recipes.insert(gr);
}
}
}
let mut diag = Diagram::default();
let mut item_index = BTreeMap::new();
for i in have {
item_index.insert(i, diag.nodes.len());
diag.nodes.push(DiagramNode {
label: Message::Item(i),
position: Vec2::ZERO,
style: if target_items.contains(data.item_name(i)) {
NodeStyle::FinalProduct
} else {
NodeStyle::IntermediateProduct
},
});
}
for r in recipes {
let index = diag.nodes.len();
let recipe = data.recipe(r.index);
let (kind, style) = match recipe {
Recipe::Passive { .. } => ("Passive", NodeStyle::ProcessPassive),
Recipe::Active { .. } => ("Active", NodeStyle::ProcessActive),
Recipe::Instant { .. } => ("Instant", NodeStyle::ProcessInstant),
};
diag.nodes.push(DiagramNode {
position: Vec2::ZERO,
label: if let Some(tile) = recipe.tile() {
Message::Tile(tile)
} else {
Message::Text(kind.to_string())
},
style,
});
for i in r.inputs {
diag.edges.push(DiagramEdge {
src: item_index[&i],
dst: index,
label: None,
});
}
for o in r.outputs {
diag.edges.push(DiagramEdge {
src: index,
dst: item_index[&o],
label: None,
});
}
}
Ok(diag)
}
|
