bevy-tnua 0.30.0

A floating character controller for Bevy
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

use bevy_tnua_physics_integration_layer::data_for_backends::TnuaMotor;
use serde::{Deserialize, Serialize};

use crate::{TnuaAction, TnuaActionContext, TnuaBasis};
use crate::{TnuaActionLifecycleDirective, TnuaActionLifecycleStatus, TnuaBasisContext};

/// The full state of a single [`TnuaAction`].
///
/// These are used in the variants of the [action state enum](crate::TnuaScheme::ActionState),
/// created automatically by [the `TnuaScheme` derive](bevy_tnua_macros::TnuaScheme).
#[derive(Serialize, Deserialize)]
pub struct TnuaActionState<A: TnuaAction<B>, B: TnuaBasis> {
    /// The data that the user control system feeds to the
    /// [`TnuaController`](crate::TnuaController).
    pub input: A,
    /// The action configuration, retrieved from an asset.
    pub config: A::Config,
    /// Initiated when the action starts, and gets updated by the action itself.
    pub memory: A::Memory,
}

impl<A: TnuaAction<B>, B: TnuaBasis> TnuaActionState<A, B> {
    pub fn new(input: A, config: &A::Config) -> Self {
        Self {
            input,
            config: config.clone(),
            memory: Default::default(),
        }
    }
}

#[doc(hidden)]
pub trait TnuaActionStateInterface<B: TnuaBasis> {
    fn apply(
        &mut self,
        sensors: &B::Sensors<'_>,
        ctx: TnuaActionContext<B>,
        lifecycle_status: TnuaActionLifecycleStatus,
        motor: &mut TnuaMotor,
    ) -> TnuaActionLifecycleDirective;

    fn influence_basis(
        &self,
        ctx: TnuaBasisContext,
        basis_input: &B,
        basis_config: &B::Config,
        basis_memory: &mut B::Memory,
    );
}

impl<A: TnuaAction<B>, B: TnuaBasis> TnuaActionStateInterface<B> for TnuaActionState<A, B> {
    fn apply(
        &mut self,
        sensors: &B::Sensors<'_>,
        ctx: TnuaActionContext<B>,
        lifecycle_status: TnuaActionLifecycleStatus,
        motor: &mut TnuaMotor,
    ) -> TnuaActionLifecycleDirective {
        self.input.apply(
            &self.config,
            &mut self.memory,
            sensors,
            ctx,
            lifecycle_status,
            motor,
        )
    }

    fn influence_basis(
        &self,
        ctx: TnuaBasisContext,
        basis_input: &B,
        basis_config: &<B as TnuaBasis>::Config,
        basis_memory: &mut <B as TnuaBasis>::Memory,
    ) {
        self.input.influence_basis(
            &self.config,
            &self.memory,
            ctx,
            basis_input,
            basis_config,
            basis_memory,
        );
    }
}