alex/beta-minecraft-rust

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

//! `EntityLightningBolt`: kept apart from other entities like `World.weatherEffects`.

use common::JavaRandom;
use common::entity::mob::MobKind;
use common::math::floor_f64;
use common::physics::Aabb;
use common::protocol::Packet;
use common::world::Block;
use glam::DVec3;

use super::Kind;
use crate::level::Level;

pub struct Lightning {
    pub id: i32,
    pub pos: DVec3,
    rand: JavaRandom,
    /// `lightningState`: 2 when it strikes, counting down between flashes.
    state: i32,
    /// `boltLivingTime`: flashes left.
    flashes: i32,
}

impl Level {
    /// Ignites the block at `position` if fire can burn there.
    fn ignite(&mut self, [x, y, z]: [i32; 3]) {
        if self.is_air(x, y, z) && crate::blocks::fire_fits(self, x, y, z) {
            self.set_block_notify(x, y, z, Block::FIRE);
        }
    }

    /// `World.addLightningBolt` with the `EntityLightningBolt` constructor: on hard difficulty
    /// and up it sets fire to the ground around it.
    pub fn strike_lightning(&mut self, pos: DVec3) {
        let id = self.entities.allocate();
        let mut rand = self.entities.random();
        rand.next_long();
        let flashes = rand.next_int(3) + 1;
        let [x, y, z] = pos.to_array().map(floor_f64);
        if self.difficulty >= 2 && self.chunks_exist_around(x, y, z, 10) {
            self.ignite([x, y, z]);
            for _ in 0..4 {
                let spot = [x, y, z].map(|v| v + rand.next_int(3) - 1);
                self.ignite(spot);
            }
        }
        let [x, y, z] = pos.to_array().map(|v| floor_f64(v * 32.0));
        self.events.push(Packet::Weather {
            entity: id,
            lightning: true,
            x,
            y,
            z,
        });
        self.lightning.push(Lightning {
            id,
            pos,
            rand,
            state: 2,
            flashes,
        });
    }

    /// `EntityLightningBolt.onUpdate` for every bolt; their sounds are the clients'.
    pub(super) fn tick_lightning(&mut self) {
        let mut bolts = std::mem::take(&mut self.lightning);
        bolts.retain_mut(|bolt| {
            bolt.state -= 1;
            if bolt.state < 0 {
                if bolt.flashes == 0 {
                    return false;
                }
                if bolt.state < -bolt.rand.next_int(10) {
                    bolt.flashes -= 1;
                    bolt.state = 1;
                    bolt.rand.next_long();
                    let [x, y, z] = bolt.pos.to_array().map(floor_f64);
                    if self.chunks_exist_around(x, y, z, 10) {
                        self.ignite([x, y, z]);
                    }
                }
            }
            if bolt.state >= 0 {
                self.strike_entities(bolt.pos);
            }
            true
        });
        bolts.append(&mut self.lightning);
        self.lightning = bolts;
    }

    /// `Entity.onStruckByLightning` for everything within three blocks.
    fn strike_entities(&mut self, pos: DVec3) {
        let area = Aabb::new(pos, pos + DVec3::Y * 6.0).inflate(DVec3::splat(3.0));
        let ids: Vec<i32> = self
            .entities
            .iter()
            .filter(|e| e.entity.bb.intersects(&area))
            .map(|e| e.entity.id)
            .collect();
        for id in ids {
            let Some(stored) = self.entities.get_mut(id) else {
                continue;
            };
            // `EntityPig.onStruckByLightning`
            if matches!(&stored.kind, Kind::Mob(mob) if mob.kind == MobKind::Pig) {
                if stored.entity.dead {
                    continue;
                }
                stored.entity.dead = true;
                let (pos, yaw, pitch) = (stored.entity.pos, stored.entity.yaw, stored.entity.pitch);
                let mut pigman = self.mob_entity(MobKind::PigZombie, pos, yaw);
                pigman.entity.set_location_and_angles(pos, yaw, pitch);
                self.spawn(pigman);
                continue;
            }
            if !stored.entity.immune_to_fire {
                self.attack_entity(id, None, 5);
            }
            let Some(stored) = self.entities.get_mut(id) else {
                continue;
            };
            let entity = &mut stored.entity;
            entity.fire += 1;
            if entity.fire == 0 {
                entity.fire = 300;
            }
            if let Kind::Mob(mob) = &mut stored.kind
                && mob.kind == MobKind::Creeper
            {
                mob.powered = true;
            }
        }
    }
}