fmc_vanilla 0.0.1

Bare-bones implementation of an fmc server
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

use fmc::{
    bevy::ecs::system::EntityCommands,
    blocks::{BlockData, BlockPosition, Blocks},
    prelude::*,
    world::BlockUpdate,
};

pub struct WheatPlugin;
impl Plugin for WheatPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Startup, setup).add_systems(Update, grow);
    }
}

#[derive(Component)]
struct Wheat {
    stage: u8,
    tick: u8,
}

fn setup(mut blocks: ResMut<Blocks>) {
    let block_id = blocks.get_id("wheat_0");
    let block = blocks.get_config_mut(&block_id);
    block.set_spawn_function(spawn_wheat_0);

    let block_id = blocks.get_id("wheat_1");
    let block = blocks.get_config_mut(&block_id);
    block.set_spawn_function(spawn_wheat_1);

    let block_id = blocks.get_id("wheat_2");
    let block = blocks.get_config_mut(&block_id);
    block.set_spawn_function(spawn_wheat_2);

    let block_id = blocks.get_id("wheat_3");
    let block = blocks.get_config_mut(&block_id);
    block.set_spawn_function(spawn_wheat_3);

    let block_id = blocks.get_id("wheat_4");
    let block = blocks.get_config_mut(&block_id);
    block.set_spawn_function(spawn_wheat_4);

    let block_id = blocks.get_id("wheat_5");
    let block = blocks.get_config_mut(&block_id);
    block.set_spawn_function(spawn_wheat_5);

    let block_id = blocks.get_id("wheat_6");
    let block = blocks.get_config_mut(&block_id);
    block.set_spawn_function(spawn_wheat_6);
}

fn spawn_wheat_0(commands: &mut EntityCommands, _block_data: Option<&BlockData>) {
    commands.insert(Wheat { stage: 0, tick: 0 });
}
fn spawn_wheat_1(commands: &mut EntityCommands, _block_data: Option<&BlockData>) {
    commands.insert(Wheat { stage: 1, tick: 0 });
}
fn spawn_wheat_2(commands: &mut EntityCommands, _block_data: Option<&BlockData>) {
    commands.insert(Wheat { stage: 2, tick: 0 });
}
fn spawn_wheat_3(commands: &mut EntityCommands, _block_data: Option<&BlockData>) {
    commands.insert(Wheat { stage: 3, tick: 0 });
}
fn spawn_wheat_4(commands: &mut EntityCommands, _block_data: Option<&BlockData>) {
    commands.insert(Wheat { stage: 4, tick: 0 });
}
fn spawn_wheat_5(commands: &mut EntityCommands, _block_data: Option<&BlockData>) {
    commands.insert(Wheat { stage: 5, tick: 0 });
}
fn spawn_wheat_6(commands: &mut EntityCommands, _block_data: Option<&BlockData>) {
    commands.insert(Wheat { stage: 6, tick: 0 });
}

// TODO: Make 'tick' increment randomly.
// TODO: Only run this function at daytime?
fn grow(
    mut growing: Query<(&mut Wheat, &BlockPosition)>,
    mut block_update_writer: EventWriter<BlockUpdate>,
) {
    for (mut wheat, block_position) in growing.iter_mut() {
        if !wheat.tick != 30 {
            wheat.tick += 1;
            continue;
        }

        let blocks = Blocks::get();
        let block_id = match wheat.stage {
            0 => blocks.get_id("wheat_1"),
            1 => blocks.get_id("wheat_2"),
            2 => blocks.get_id("wheat_3"),
            3 => blocks.get_id("wheat_4"),
            4 => blocks.get_id("wheat_5"),
            5 => blocks.get_id("wheat_6"),
            6 => blocks.get_id("wheat_7"),
            _ => unreachable!(),
        };

        block_update_writer.send(BlockUpdate::Change {
            position: **block_position,
            block_id,
            block_state: None,
        });
    }
}