rusteal 0.9.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
133
134
135
136
137

use bindings::engine::ActorComponent;
use rusteal_runtime::runtime::{RustealResult, UObjectRef, UeArray};
use rusteal_runtime::{uclass, uclass_impl};

use crate::item::{{ plugin }}Item;
use crate::settings::{{ plugin }}Settings;

#[uclass(parent = ActorComponent)]
pub struct {{ plugin }}Component {
    #[uproperty(VisibleAnywhere, BlueprintReadOnly, category = "{{ plugin }}")]
    items: UeArray<UObjectRef<{{ plugin }}Item>>,
    #[uproperty(VisibleAnywhere, BlueprintReadOnly, category = "{{ plugin }}")]
    counts: UeArray<i32>,
}

#[uclass_impl]
impl {{ plugin }}Component {
    #[udelegate]
    pub fn on_inventory_changed(&self, item: UObjectRef<{{ plugin }}Item>, count: i32) {}

    #[ufunction]
    pub fn add_item(&mut self, item: UObjectRef<{{ plugin }}Item>, count: i32) -> i32 {
        let added = self.try_add(item, count).unwrap_or(0);
        if added > 0 {
            self.on_inventory_changed(item, self.count_of(item));
        }
        added
    }

    #[ufunction]
    pub fn remove_item(&mut self, item: UObjectRef<{{ plugin }}Item>, count: i32) -> i32 {
        let removed = self.try_remove(item, count).unwrap_or(0);
        if removed > 0 {
            self.on_inventory_changed(item, self.count_of(item));
        }
        removed
    }

    #[ufunction(BlueprintPure)]
    pub fn count_of(&self, item: UObjectRef<{{ plugin }}Item>) -> i32 {
        self.stacks()
            .map(|stacks| {
                stacks
                    .iter()
                    .filter(|(i, _)| *i == item)
                    .map(|(_, c)| c)
                    .sum()
            })
            .unwrap_or(0)
    }

    #[ufunction(BlueprintPure)]
    pub fn total_weight(&self) -> f32 {
        self.stacks()
            .map(|stacks| {
                stacks
                    .iter()
                    .map(|(item, count)| weight_of(*item) * *count as f32)
                    .sum()
            })
            .unwrap_or(0.0)
    }

    pub fn stacks(&self) -> RustealResult<Vec<(UObjectRef<{{ plugin }}Item>, i32)>> {
        let items = self.items().to_vec()?;
        let counts = self.counts().to_vec()?;
        Ok(items.into_iter().zip(counts).collect())
    }

    fn try_add(&mut self, item: UObjectRef<{{ plugin }}Item>, count: i32) -> RustealResult<i32> {
        let definition = {{ plugin }}Item::from_obj(item)?;
        let settings = {{ plugin }}Settings::get_default()?;
        let max_stack = definition.max_stack().max(1);
        let mut wanted = count.max(0);
        let weight = definition.weight();
        if settings.max_weight() > 0.0 && weight > 0.0 {
            let room = ((settings.max_weight() - self.total_weight()) / weight).floor() as i32;
            wanted = wanted.min(room.max(0));
        }

        let (items, counts) = (self.items(), self.counts());
        let mut left = wanted;
        for index in 0..items.len()? {
            if left == 0 {
                break;
            }

            let held = counts.get(index)?;

            if items.get(index)? == item && held < max_stack {
                let put = left.min(max_stack - held);
                counts.set(index, &(held + put))?;
                left -= put;
            }
        }
        while left > 0 && (items.len()? as i32) < settings.max_slots() {
            let put = left.min(max_stack);
            items.push(&item)?;
            counts.push(&put)?;
            left -= put;
        }
        Ok(wanted - left)
    }

    fn try_remove(&mut self, item: UObjectRef<{{ plugin }}Item>, count: i32) -> RustealResult<i32> {
        let (items, counts) = (self.items(), self.counts());
        let mut left = count.max(0);
        for index in (0..items.len()?).rev() {
            if left == 0 {
                break;
            }

            if items.get(index)? != item {
                continue;
            }

            let held = counts.get(index)?;
            let take = left.min(held);

            if take == held {
                items.remove(index)?;
                counts.remove(index)?;
            } else {
                counts.set(index, &(held - take))?;
            }

            left -= take;
        }
        Ok(count.max(0) - left)
    }
}

fn weight_of(item: UObjectRef<{{ plugin }}Item>) -> f32 {
    {{ plugin }}Item::from_obj(item)
        .map(|item| item.weight())
        .unwrap_or(0.0)
}