eldenring 0.14.0

Structures, bindings, and utilities for From Software's title Elden Ring
Documentation 
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

use vtable_rs::VPtr;

use shared::{Subclass, Superclass};

pub static TEAM_TYPE_RIVAL: CSTeamTypeRival = CSTeamTypeRival {
    base: CSTeamTypeBase {
        vftable: VPtr::new(),
    },
};

pub static TEAM_TYPE_ENEMY: CSTeamTypeEnemy = CSTeamTypeEnemy {
    base: CSTeamTypeBase {
        vftable: VPtr::new(),
    },
};

pub static TEAM_TYPE_FRIEND: CSTeamTypeFriend = CSTeamTypeFriend {
    base: CSTeamTypeBase {
        vftable: VPtr::new(),
    },
};

#[repr(C)]
#[derive(Superclass)]
#[superclass(children(CSTeamTypeNeutral, CSTeamTypeFriend, CSTeamTypeEnemy, CSTeamTypeRival))]
pub struct CSTeamTypeBase {
    vftable: VPtr<dyn CSTeamTypeVmt, Self>,
}

#[vtable_rs::vtable]
pub trait CSTeamTypeVmt {
    extern "C" fn validate(
        &self,
        team_relation: &TeamRelationTargetInfo,
        self_target: bool,
    ) -> bool;
}

impl CSTeamTypeVmt for CSTeamTypeBase {
    extern "C" fn validate(
        &self,
        _team_relation: &TeamRelationTargetInfo,
        _self_target: bool,
    ) -> bool {
        unimplemented!("CSTeamTypeBase should not be used directly");
    }
}

#[repr(C)]
#[derive(Subclass)]
pub struct CSTeamTypeNeutral {
    pub base: CSTeamTypeBase,
}

impl CSTeamTypeVmt for CSTeamTypeNeutral {
    extern "C" fn validate(
        &self,
        team_relation: &TeamRelationTargetInfo,
        self_target: bool,
    ) -> bool {
        if self_target {
            return team_relation.self_target;
        }
        false
    }
}

#[repr(C)]
#[derive(Subclass)]
pub struct CSTeamTypeFriend {
    pub base: CSTeamTypeBase,
}

impl CSTeamTypeVmt for CSTeamTypeFriend {
    extern "C" fn validate(
        &self,
        team_relation: &TeamRelationTargetInfo,
        self_target: bool,
    ) -> bool {
        if self_target {
            return team_relation.self_target;
        }
        team_relation.friendly_target
    }
}

#[repr(C)]
#[derive(Subclass)]
pub struct CSTeamTypeEnemy {
    pub base: CSTeamTypeBase,
}

impl CSTeamTypeVmt for CSTeamTypeEnemy {
    extern "C" fn validate(
        &self,
        team_relation: &TeamRelationTargetInfo,
        self_target: bool,
    ) -> bool {
        if self_target {
            return team_relation.self_target;
        }
        team_relation.oppose_target
    }
}

#[repr(C)]
#[derive(Subclass)]
pub struct CSTeamTypeRival {
    pub base: CSTeamTypeBase,
}

impl CSTeamTypeVmt for CSTeamTypeRival {
    extern "C" fn validate(
        &self,
        team_relation: &TeamRelationTargetInfo,
        self_target: bool,
    ) -> bool {
        if self_target {
            return team_relation.self_target;
        }
        if !team_relation.oppose_target && !team_relation.friendly_target {
            return false;
        }
        true
    }
}

#[repr(C)]
pub struct TeamRelationTargetInfo {
    pub oppose_target: bool,
    pub friendly_target: bool,
    pub self_target: bool,
}