rusteal 0.7.0

Rust bindings for Unreal Engine 5.8.2
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

use bindings::core_ue::Object;
use bindings::engine::{
    Actor, ActorExt, ControllerExt, GameplayStatics, SubsystemBlueprintLibrary, WorldSubsystem,
};
use bindings::rusteal::RustealWorldSubsystem;
use rusteal_runtime::runtime::{
    LOG_DISPLAY, LOG_WARNING, RustealResult, SubclassOf, UObjectRef, UeClass, ulog,
};
use rusteal_runtime::{uclass, uclass_impl};

use crate::save_data::CheckpointSaveData;

pub const SLOT_NAME: &str = "SAVE";

#[uclass(parent = RustealWorldSubsystem)]
pub struct CheckpointSubsystem {
    #[uproperty(BlueprintReadOnly, category = "Checkpoint")]
    save: UObjectRef<CheckpointSaveData>,
}

#[uclass_impl]
impl CheckpointSubsystem {
    #[ufunction(Override)]
    fn receive_world_begin_play(&mut self) {
        self.load_game_data();

        if !self.respawn_player() {
            return;
        }

        ulog!(
            LOG_DISPLAY,
            "[Checkpoints] the player starts at the last spawn point"
        );
    }

    #[ufunction(BlueprintCallable)]
    pub fn update_spawn_point(&mut self, spawn_point: UObjectRef<Actor>) {
        if let Err(e) = self.save_spawn_point(spawn_point) {
            ulog!(
                LOG_WARNING,
                "[Checkpoints] cannot save the spawn point: {e}"
            );
        }
    }

    #[ufunction(BlueprintCallable)]
    pub fn respawn_player(&mut self) -> bool {
        self.move_player_to_checkpoint().unwrap_or(false)
    }

    #[ufunction(BlueprintCallable)]
    pub fn clear_checkpoint(&mut self) {
        if let Ok(save) = CheckpointSaveData::from_obj(self.save()) {
            save.set_has_checkpoint(false);
            save.set_spawn_point(UObjectRef::null());
            GameplayStatics::save_game_to_slot(self.save().upcast_to(), SLOT_NAME, 0);
        }
    }

    #[ufunction(BlueprintPure)]
    pub fn has_checkpoint(&self) -> bool {
        CheckpointSaveData::from_obj(self.save())
            .is_ok_and(|save| save.has_checkpoint() && save.level_name() == self.level_name())
    }
}

impl CheckpointSubsystem {
    pub fn get(context: UObjectRef<Object>) -> RustealResult<Self> {
        let class = unsafe { SubclassOf::<WorldSubsystem>::from_raw(Self::static_class()) };
        Self::from_obj(SubsystemBlueprintLibrary::get_world_subsystem(
            context, class,
        ))
    }

    fn level_name(&self) -> String {
        GameplayStatics::get_current_level_name(self.as_ref().upcast_to(), Some(true))
    }

    fn load_game_data(&mut self) {
        let loaded = if GameplayStatics::does_save_game_exist(SLOT_NAME, 0) {
            GameplayStatics::load_game_from_slot(SLOT_NAME, 0).cast::<CheckpointSaveData>()
        } else {
            Err(rusteal_runtime::runtime::RustealError::null_argument())
        };

        let save = match loaded {
            Ok(save) => save,
            Err(_) => {
                let save = GameplayStatics::create_save_game_object(
                    SubclassOf::<CheckpointSaveData>::base().upcast(),
                );
                GameplayStatics::save_game_to_slot(save, SLOT_NAME, 0);
                save.cast::<CheckpointSaveData>().unwrap_or_default()
            }
        };

        self.set_save(save);
    }

    fn save_spawn_point(&mut self, spawn_point: UObjectRef<Actor>) -> RustealResult<()> {
        if !self.save().is_valid() {
            self.load_game_data();
        }

        let actor = spawn_point.checked()?;
        let save = CheckpointSaveData::from_obj(self.save())?;
        save.set_has_checkpoint(true);
        save.set_level_name(&self.level_name());
        save.set_location(&actor.k2_get_actor_location());
        save.set_rotation(&actor.k2_get_actor_rotation());
        save.set_spawn_point(spawn_point);

        GameplayStatics::save_game_to_slot(self.save().upcast_to(), SLOT_NAME, 0);
        Ok(())
    }

    fn move_player_to_checkpoint(&self) -> RustealResult<bool> {
        if !self.has_checkpoint() {
            return Ok(false);
        }

        let save = CheckpointSaveData::from_obj(self.save())?;
        let controller = GameplayStatics::get_player_controller(self.as_ref().upcast_to(), 0);
        let controller = controller.checked()?;
        let pawn = controller.k2_get_pawn().checked()?;

        pawn.k2_set_actor_location_and_rotation(&save.location(), &save.rotation(), false, true);
        controller.set_control_rotation(&save.rotation());
        Ok(true)
    }
}