rustic_mountain_core/objects/
bigchest.rs

1use std::{cell::RefCell, rc::Rc};
2
3use rand::Rng;
4
5use crate::{structures::*, Celeste};
6use serde::{Deserialize, Serialize};
7
8use super::orb::Orb;
9
10#[derive(Serialize, Deserialize)]
11pub struct BigChest {
12    state: u8,
13    timer: f32,
14    particles: Vec<ChestParticle>,
15}
16
17#[derive(Serialize, Deserialize)]
18struct ChestParticle {
19    x: f32,
20    y: f32,
21    h: f32,
22    spd: f32,
23}
24impl BigChest {
25    pub fn init(_celeste: &mut Celeste, x: f32, y: f32) -> Object {
26        Object {
27            pos: Vector { x, y },
28            spd: Vector { x: 0.0, y: 0.0 },
29            rem: Vector { x: 0.0, y: 0.0 },
30            spr: 1,
31            hitbox: Rectangle {
32                x: 0.0,
33                y: 0.0,
34                w: 16.0,
35                h: 8.0,
36            },
37            flip: FlipState { x: false, y: false },
38            collidable: true,
39            solids: false,
40            obj_type: ObjectType::BigChest(Rc::new(RefCell::new(Self {
41                state: 0,
42                timer: 0.0,
43                particles: vec![],
44            }))),
45            draw: ObjFunc(Self::draw),
46            update: ObjFunc(Self::update),
47            name: "BigChest",
48        }
49    }
50    pub fn update(_obj: &mut Object, _celeste: &mut Celeste) {}
51    pub fn draw(obj: &mut Object, celeste: &mut Celeste) {
52        let tref = match &mut obj.obj_type {
53            ObjectType::BigChest(p) => p.clone(),
54            _ => unreachable!(),
55        };
56        let mut this = tref.borrow_mut();
57        if this.state == 0 {
58            let hit = obj.check(celeste, "Player", 0.0, 8.0);
59            match hit {
60                Some(i) => {
61                    let jref = celeste.objects[i].clone();
62                    let mut playerobj = jref.borrow_mut();
63                    if playerobj.is_solid(0.0, 1.0, celeste) {
64                        // music -1 500 7
65                        // sfx 37
66                        celeste.pause_player = true;
67                        playerobj.spd = Vector { x: 0.0, y: 0.0 };
68                        this.state = 1;
69                        obj.init_smoke(celeste, 0.0, 0.0);
70                        obj.init_smoke(celeste, 8.0, 0.0);
71                        this.timer = 60.0;
72                    }
73                }
74                _ => (),
75            }
76            celeste
77                .mem
78                .spr(96, obj.pos.x as i32, obj.pos.y as i32, None);
79            celeste
80                .mem
81                .spr(97, obj.pos.x as i32 + 8, obj.pos.y as i32, None);
82        } else if this.state == 1 {
83            this.timer -= 1.0;
84            celeste.shake = 5;
85            celeste.flash_bg = true;
86            if this.timer <= 45.0 && this.particles.len() < 50 {
87                this.particles.push(ChestParticle {
88                    x: celeste.mem.rng.gen_range(1.0..15.0),
89                    y: 0.0,
90                    h: celeste.mem.rng.gen_range(32.0..64.0),
91                    spd: celeste.mem.rng.gen_range(8.0..16.0),
92                });
93            }
94            if this.timer < 0.0 {
95                this.state = 2;
96                this.particles.clear();
97                celeste.flash_bg = false;
98                celeste.new_bg = true;
99                let obj = Rc::new(RefCell::new(Orb::init(
100                    celeste,
101                    obj.pos.x + 4.0,
102                    obj.pos.y + 4.0,
103                )));
104                celeste.objects.push(obj);
105                celeste.pause_player = false;
106            }
107            for particle in &mut this.particles {
108                particle.y += particle.spd;
109                celeste.mem.rectfill(
110                    (obj.pos.x + particle.x) as i32,
111                    (obj.pos.y + 8.0 - particle.y) as i32,
112                    (obj.pos.x + particle.x) as i32,
113                    (obj.pos.y + 8.0).min(obj.pos.y + 8.0 - particle.y + particle.h) as i32,
114                    7,
115                )
116            }
117        }
118        celeste
119            .mem
120            .spr(112, obj.pos.x as i32, obj.pos.y as i32 + 8, None);
121        celeste
122            .mem
123            .spr(113, obj.pos.x as i32 + 8, obj.pos.y as i32 + 8, None);
124    }
125}