foxtrot 0.1.0

A 3D reference project and tech demo for the Bevy Engine.
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

//! Player dialogue handling. This module starts the Yarn Spinner dialogue when the player starts interacting with an NPC.

use avian3d::prelude::{SpatialQuery, SpatialQueryFilter};
use bevy::prelude::*;
use bevy_enhanced_input::{events::Started, prelude::Actions};
#[cfg(feature = "hot_patch")]
use bevy_simple_subsecond_system::hot;
use bevy_yarnspinner::{events::DialogueCompleteEvent, prelude::*};

use crate::{
    PostPhysicsAppSystems,
    screens::Screen,
    third_party::{
        avian3d::CollisionLayer,
        bevy_yarnspinner::{YarnNode, is_dialogue_running},
    },
};

mod ui;

use super::{
    Player,
    camera::PlayerCamera,
    default_input::{DefaultInputContext, Interact},
    pickup::is_holding_prop,
};

pub(super) fn plugin(app: &mut App) {
    app.register_type::<InteractionPrompt>();

    app.configure_sets(
        Update,
        (
            DialogueSystems::UpdateOpportunity,
            DialogueSystems::UpdateUi,
        )
            .chain()
            .in_set(PostPhysicsAppSystems::ChangeUi),
    );

    app.add_systems(
        Update,
        check_for_dialogue_opportunity
            .in_set(DialogueSystems::UpdateOpportunity)
            .run_if(
                in_state(Screen::Gameplay)
                    .and(not(is_dialogue_running))
                    .and(not(is_holding_prop)),
            ),
    );
    app.add_systems(
        Update,
        restore_input_context
            .run_if(in_state(Screen::Gameplay).and(on_event::<DialogueCompleteEvent>))
            .in_set(PostPhysicsAppSystems::Update),
    );

    app.add_observer(interact_with_dialogue);

    app.add_plugins(ui::plugin);
}

#[derive(Debug, SystemSet, Hash, Eq, PartialEq, Clone, Copy)]
pub(super) enum DialogueSystems {
    UpdateOpportunity,
    UpdateUi,
}

#[cfg_attr(feature = "hot_patch", hot)]
fn check_for_dialogue_opportunity(
    player: Single<&GlobalTransform, With<PlayerCamera>>,
    player_collider: Single<Entity, With<Player>>,
    mut interaction_prompt: Single<&mut InteractionPrompt>,
    q_yarn_node: Query<&YarnNode>,
    spatial_query: SpatialQuery,
) {
    let camera_transform = player.compute_transform();
    const MAX_INTERACTION_DISTANCE: f32 = 3.0;
    let hit = spatial_query.cast_ray(
        camera_transform.translation,
        camera_transform.forward(),
        MAX_INTERACTION_DISTANCE,
        true,
        &SpatialQueryFilter::from_mask(CollisionLayer::Character)
            .with_excluded_entities([*player_collider]),
    );
    let node = hit
        .and_then(|hit| q_yarn_node.get(hit.entity).ok())
        .cloned();
    if interaction_prompt.0 != node {
        interaction_prompt.0 = node;
    }
}

#[derive(Component, Default, Reflect)]
#[reflect(Component, Default)]
struct InteractionPrompt(Option<YarnNode>);

#[cfg_attr(feature = "hot_patch", hot)]
fn interact_with_dialogue(
    _trigger: Trigger<Started<Interact>>,
    mut commands: Commands,
    mut interaction_prompt: Single<&mut InteractionPrompt>,
    mut dialogue_runner: Single<&mut DialogueRunner>,
    player: Single<Entity, With<Player>>,
) {
    let Some(node) = interaction_prompt.0.take() else {
        return;
    };
    dialogue_runner.start_node(&node.yarn_node);
    commands
        .entity(*player)
        .remove::<Actions<DefaultInputContext>>();
}

#[cfg_attr(feature = "hot_patch", hot)]
fn restore_input_context(mut commands: Commands, player: Single<Entity, With<Player>>) {
    commands
        .entity(*player)
        .insert(Actions::<DefaultInputContext>::default());
}