rustorio 0.1.2

The first game written and played entirely in Rust's type system. Not just do you play by writing Rust code, the rules of the game are enforced by the Rust compiler! If you can write the program so it compiles and doesn't panic, you win!
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

//! A recipe is a way of turning resources into other resources.
//! Some recipes can be performed by hand, but most can be automated using buildings like the [`Assembler`](crate::buildings::Assembler) or the [`Furnace`](crate::buildings::Furnace).
//! To figure out where the recipe can be performed, look at the trait impls.
//! For example, the [`CopperWireRecipe`] implements the [`AssemblerRecipe`] and [`HandRecipe`] traits, meaning it can be performed by hand and in an [`Assembler`](crate::buildings::Assembler).
//!
//! The documentation for each recipe struct provides more details about the recipe, including inputs, outputs and time taken.

use std::fmt::Debug;

use rustorio_engine::{
    Sealed,
    recipe::{HandRecipe, Recipe, RecipeEx, recipe_doc},
};

use crate::{
    research::RedScience,
    resources::{Copper, CopperOre, CopperWire, ElectronicCircuit, Iron, IronOre, Point, Steel},
};

/// Any recipe that implements this trait can be used in an [`Assembler`](crate::buildings::Assembler).
pub trait AssemblerRecipe: Debug + Sealed + RecipeEx {}

#[derive(Debug, Clone, Copy, Recipe, RecipeEx)]
#[recipe_doc]
#[recipe_inputs(
    (1, Copper),
)]
#[recipe_outputs(
    (2, CopperWire),
)]
#[recipe_ticks(1)]
pub struct CopperWireRecipe;
impl Sealed for CopperWireRecipe {}
impl AssemblerRecipe for CopperWireRecipe {}
impl HandRecipe for CopperWireRecipe {}

#[derive(Debug, Clone, Copy, Recipe, RecipeEx)]
#[recipe_doc]
#[recipe_inputs(
    (1, Iron),
    (2, CopperWire),
)]
#[recipe_outputs(
    (1, ElectronicCircuit),
)]
#[recipe_ticks(3)]
pub struct ElectronicCircuitRecipe;
impl Sealed for ElectronicCircuitRecipe {}
impl AssemblerRecipe for ElectronicCircuitRecipe {}
impl HandRecipe for ElectronicCircuitRecipe {}

/// A recipe for crafting red science packs.
#[derive(Debug, Clone, Copy, Recipe, RecipeEx)]
#[recipe_doc]
#[recipe_inputs(
    (1, Iron),
    (1, ElectronicCircuit),
)]
#[recipe_outputs(
    (1, RedScience),
)]
#[recipe_ticks(10)]
pub struct RedScienceRecipe;
impl Sealed for RedScienceRecipe {}
impl AssemblerRecipe for RedScienceRecipe {}
impl HandRecipe for RedScienceRecipe {}

/// The recipe you need to win! An [`Assembler`](crate::buildings::Assembler) recipe that creates points.
///
/// You can unlock this recipe by researching [`PointsTechnology`](crate::research::PointsTechnology).
#[derive(Debug, Clone, Copy, Recipe, RecipeEx)]
#[recipe_doc]
#[recipe_inputs(
    (4, ElectronicCircuit),
    (1, Steel),
)]
#[recipe_outputs(
    (1, Point),
)]
#[recipe_ticks(20)]
#[non_exhaustive]
pub struct PointRecipe;
impl Sealed for PointRecipe {}
impl AssemblerRecipe for PointRecipe {}

/// Any recipe that implements this trait can be used in a [`Furnace`](crate::buildings::Furnace).
pub trait FurnaceRecipe: Debug + Sealed + RecipeEx {}

/// A [`Furnace`](crate::buildings::Furnace) recipe that smelts iron ore into iron.
#[derive(Debug, Clone, Copy, Recipe, RecipeEx)]
#[recipe_doc]
#[recipe_inputs(
    (1, IronOre),
)]
#[recipe_outputs(
    (1, Iron),
)]
#[recipe_ticks(6)]
pub struct IronSmelting;
impl Sealed for IronSmelting {}
impl FurnaceRecipe for IronSmelting {}

/// A [`Furnace`](crate::buildings::Furnace) recipe that smelts copper ore into copper.
#[derive(Debug, Clone, Copy, Recipe, RecipeEx)]
#[recipe_doc]
#[recipe_inputs(
    (1, CopperOre),
)]
#[recipe_outputs(
    (1, Copper),
)]
#[recipe_ticks(6)]
pub struct CopperSmelting;
impl Sealed for CopperSmelting {}
impl FurnaceRecipe for CopperSmelting {}

/// A [`Furnace`](crate::buildings::Furnace) recipe that smelts iron into steel.
#[derive(Debug, Clone, Copy, Recipe, RecipeEx)]
#[recipe_doc]
#[recipe_inputs(
    (5, Iron),
)]
#[recipe_outputs(
    (1, Steel),
)]
#[recipe_ticks(30)]
#[non_exhaustive]
pub struct SteelSmelting;
impl Sealed for SteelSmelting {}
impl FurnaceRecipe for SteelSmelting {}