559 lines
16 KiB
Rust
559 lines
16 KiB
Rust
use bevy::prelude::*;
|
|
use bevy::render::render_resource::PrimitiveTopology;
|
|
use bevy::render::render_asset::RenderAssetUsages;
|
|
use std::f64::consts::PI;
|
|
use rand::seq::SliceRandom;
|
|
use rand::RngCore;
|
|
|
|
use crate::Player;
|
|
use crate::GameState;
|
|
use crate::MainGame;
|
|
use crate::Sky;
|
|
use crate::Constellation;
|
|
use crate::ConstellationLine;
|
|
use crate::PlayerState;
|
|
|
|
use crate::celestial_to_cartesian;
|
|
use crate::spawn_cons_lines;
|
|
|
|
use crate::NORMAL_BUTTON;
|
|
use crate::RIGHT_BUTTON;
|
|
use crate::WRONG_BUTTON;
|
|
use crate::SKY_RADIUS;
|
|
|
|
#[derive(Component)]
|
|
pub struct AnswerButton;
|
|
|
|
#[derive(Component)]
|
|
pub struct HealthLabel;
|
|
|
|
#[derive(Component)]
|
|
pub struct ScoreLabel;
|
|
|
|
#[derive(Component)]
|
|
pub struct HintLabel;
|
|
|
|
#[derive(Component)]
|
|
pub struct DebugLine;
|
|
|
|
pub fn setup(
|
|
mut commands: Commands,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<StandardMaterial>>,
|
|
) {
|
|
let container_node = NodeBundle {
|
|
style: Style {
|
|
width: Val::Percent(100.0),
|
|
height: Val::Percent(100.0),
|
|
flex_direction: FlexDirection::Row,
|
|
justify_content: JustifyContent::Center,
|
|
align_items: AlignItems::FlexEnd,
|
|
padding: UiRect::all(Val::Px(10.0)),
|
|
..default()
|
|
},
|
|
..default()
|
|
};
|
|
|
|
let button_style = Style {
|
|
width: Val::Px(150.0),
|
|
height: Val::Px(65.0),
|
|
margin: UiRect::all(Val::Px(10.0)),
|
|
justify_content: JustifyContent::Center,
|
|
align_items: AlignItems::Center,
|
|
border: UiRect::all(Val::Px(5.0)),
|
|
..default()
|
|
};
|
|
|
|
let container = commands.spawn(container_node).id();
|
|
|
|
for _i in 1..=4 {
|
|
let button_node = ButtonBundle {
|
|
style: button_style.clone(),
|
|
border_color: BorderColor(Color::BLACK),
|
|
background_color: NORMAL_BUTTON.into(),
|
|
..default()
|
|
};
|
|
|
|
let button_text_node = TextBundle::from_section(
|
|
"".to_string(),
|
|
TextStyle {
|
|
//font: asset_server.load("fonts/FiraSans-Bold.ttf"), // Load font
|
|
font_size: 15.0,
|
|
color: Color::srgb(0.9, 0.9, 0.9),
|
|
..default()
|
|
},
|
|
);
|
|
|
|
let button = commands.spawn((button_node, MainGame)).id();
|
|
let button_text = commands.spawn((button_text_node, AnswerButton, MainGame)).id();
|
|
|
|
commands.entity(button).push_children(&[button_text]);
|
|
commands.entity(container).push_children(&[button]);
|
|
}
|
|
|
|
let label_style = Style {
|
|
position_type: PositionType::Absolute,
|
|
width: Val::Auto,
|
|
height: Val::Auto,
|
|
margin: UiRect::all(Val::Px(10.0)),
|
|
..default()
|
|
};
|
|
|
|
// Top left label
|
|
let top_left_label_node = TextBundle {
|
|
style: Style {
|
|
position_type: PositionType::Absolute,
|
|
left: Val::Px(10.0),
|
|
top: Val::Px(10.0),
|
|
..label_style.clone()
|
|
},
|
|
text: Text::from_section(
|
|
"* * *",
|
|
TextStyle {
|
|
// font: asset_server.load("fonts/FiraSans-Bold.ttf"),
|
|
font_size: 30.0,
|
|
color: Color::WHITE,
|
|
..default()
|
|
},
|
|
),
|
|
..default()
|
|
};
|
|
|
|
// Top right label
|
|
let top_right_label_node = TextBundle {
|
|
style: Style {
|
|
position_type: PositionType::Absolute,
|
|
right: Val::Px(10.0),
|
|
top: Val::Px(10.0),
|
|
..label_style.clone()
|
|
},
|
|
text: Text::from_section(
|
|
"0",
|
|
TextStyle {
|
|
// font: asset_server.load("fonts/FiraSans-Bold.ttf"),
|
|
font_size: 30.0,
|
|
color: Color::WHITE,
|
|
..default()
|
|
},
|
|
),
|
|
..default()
|
|
};
|
|
|
|
let centered_container_node = NodeBundle {
|
|
style: Style {
|
|
position_type: PositionType::Absolute,
|
|
width: Val::Percent(100.0),
|
|
top: Val::Px(20.0),
|
|
justify_content: JustifyContent::Center,
|
|
align_items: AlignItems::Center,
|
|
..default()
|
|
},
|
|
..default()
|
|
};
|
|
|
|
// Hint label
|
|
let hint_label_node = TextBundle::from_section(
|
|
"hint",
|
|
TextStyle {
|
|
// font: asset_server.load("fonts/FiraSans-Bold.ttf"),
|
|
font_size: 20.0,
|
|
color: Color::srgb(0.7, 0.7, 0.7),
|
|
..default()
|
|
},
|
|
);
|
|
|
|
commands.spawn((top_left_label_node, MainGame, HealthLabel));
|
|
commands.spawn((top_right_label_node, MainGame, ScoreLabel));
|
|
|
|
let centered_container = commands.spawn(centered_container_node).id();
|
|
let hint_label = commands.spawn((hint_label_node, MainGame, HintLabel)).id();
|
|
|
|
commands.entity(centered_container).push_children(&[hint_label]);
|
|
|
|
|
|
let line_material = materials.add(StandardMaterial {
|
|
emissive: LinearRgba::rgb(2.0, 0.5, 0.5),
|
|
..default()
|
|
});
|
|
|
|
let vertices = vec![
|
|
Vec3::new(0.0, 0.0, 0.0),
|
|
Vec3::new(1.0, 0.0, 0.0)
|
|
];
|
|
|
|
let mut mesh = Mesh::new(PrimitiveTopology::LineList, RenderAssetUsages::RENDER_WORLD);
|
|
mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, vertices);
|
|
|
|
commands.spawn((
|
|
PbrBundle {
|
|
mesh: meshes.add(mesh),
|
|
material: line_material.clone(),
|
|
transform: Transform::default(),
|
|
..default()
|
|
},
|
|
DebugLine,
|
|
MainGame
|
|
));
|
|
}
|
|
|
|
|
|
pub fn player_interact(
|
|
keys: Res<ButtonInput<KeyCode>>,
|
|
mut player_query: Query<(&mut Player, &mut Transform)>,
|
|
sky: Res<Sky>,
|
|
text_query: Query<&mut Text, With<AnswerButton>>,
|
|
button_query: Query<(&mut BackgroundColor, &mut BorderColor), With<Button>>,
|
|
constellation_line_query : Query<(Entity, &ConstellationLine)>,
|
|
commands: Commands,
|
|
game_state: ResMut<NextState<GameState>>,
|
|
meshes: ResMut<Assets<Mesh>>,
|
|
materials: ResMut<Assets<StandardMaterial>>,
|
|
) {
|
|
if let Ok((mut player, mut transform)) = player_query.get_single_mut() {
|
|
|
|
if keys.just_pressed(KeyCode::Space) || player.target_cons_name.is_none() {
|
|
choose_constellation(&mut player, sky, text_query, button_query, constellation_line_query, commands, game_state);
|
|
return
|
|
}
|
|
|
|
let mut rotation = Quat::IDENTITY;
|
|
|
|
if keys.pressed(KeyCode::KeyA) {
|
|
rotation *= Quat::from_rotation_y((PI / 60.0) as f32);
|
|
}
|
|
|
|
if keys.pressed(KeyCode::KeyD) {
|
|
rotation *= Quat::from_rotation_y((-PI / 60.0) as f32);
|
|
}
|
|
|
|
if keys.pressed(KeyCode::KeyI) && player.state == PlayerState::Playing {
|
|
if let Some(target_cons) = player.target_cons_name.clone() {
|
|
player.state = PlayerState::Hinted;
|
|
spawn_cons_lines(commands, meshes, materials, sky, target_cons);
|
|
return
|
|
}
|
|
}
|
|
|
|
if rotation != Quat::IDENTITY {
|
|
transform.rotation *= rotation;
|
|
player.target_rotation = None;
|
|
}
|
|
|
|
if keys.pressed(KeyCode::KeyR) {
|
|
if let Some(target_constellation_name) = player.target_cons_name.clone() {
|
|
let mut target_constellation = sky.content[0].clone();
|
|
for constellation in sky.content.clone() {
|
|
if constellation.name == target_constellation_name {
|
|
target_constellation = constellation
|
|
}
|
|
}
|
|
player.target_rotation = Some(constellation_center(target_constellation));
|
|
}
|
|
}
|
|
|
|
if keys.pressed(KeyCode::KeyW) {
|
|
let target_constellation_name: String = "Ursa Minor".into();
|
|
|
|
let mut target_constellation = sky.content[0].clone();
|
|
for constellation in sky.content.clone() {
|
|
if constellation.name == target_constellation_name {
|
|
target_constellation = constellation
|
|
}
|
|
}
|
|
|
|
player.target_rotation = Some(constellation_center(target_constellation));
|
|
}
|
|
|
|
if let Some(target_rotation) = player.target_rotation {
|
|
let current_rotation = transform.rotation;
|
|
|
|
transform.rotation = current_rotation.slerp(target_rotation, 0.1);
|
|
|
|
if transform.rotation.angle_between(target_rotation) < 0.01 {
|
|
player.target_rotation = None;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn player_mouse_move (
|
|
buttons: Res<ButtonInput<MouseButton>>,
|
|
mut player_query: Query<(&mut Player, &mut Transform)>,
|
|
camera_query: Query<(&Camera, &GlobalTransform), With<Player>>,
|
|
window_query: Query<&Window, With<bevy::window::PrimaryWindow>>,
|
|
debug_line_query: Query<&mut Transform, (With<DebugLine>, Without<Player>)>,
|
|
) {
|
|
let Ok((mut player, mut player_transform)) = player_query.get_single_mut() else {
|
|
return;
|
|
};
|
|
|
|
if !buttons.pressed(MouseButton::Left) {
|
|
player.dragging_pos = None;
|
|
return
|
|
}
|
|
|
|
let window = window_query.single();
|
|
let Some(cursor_position) = window.cursor_position() else {
|
|
return;
|
|
};
|
|
|
|
let (camera, camera_transform) = camera_query.single();
|
|
|
|
let Some(ray) = camera.viewport_to_world(camera_transform, cursor_position) else {
|
|
return;
|
|
};
|
|
|
|
let new_global_cursor = ray.get_point(SKY_RADIUS);
|
|
|
|
let Some(old_global_cursor) = player.dragging_pos else {
|
|
player.dragging_pos = Some(new_global_cursor);
|
|
return;
|
|
};
|
|
|
|
|
|
debug_vector(debug_line_query, new_global_cursor, old_global_cursor - new_global_cursor);
|
|
|
|
if old_global_cursor.distance(new_global_cursor) < f32::EPSILON {
|
|
return;
|
|
}
|
|
|
|
let delta_rotation = rotate_to_align(old_global_cursor, new_global_cursor);
|
|
|
|
player_transform.rotation = delta_rotation * player_transform.rotation;
|
|
|
|
|
|
|
|
player.dragging_pos = Some(new_global_cursor);
|
|
// let Some(ray) = camera.viewport_to_world(camera_transform, cursor_position) else {
|
|
// return;
|
|
// };
|
|
//
|
|
// player.dragging_pos = Some(ray.get_point(SKY_RADIUS));
|
|
}
|
|
|
|
fn rotate_vector_with_quaternion(v: Vec3, q: Quat) -> Vec3 {
|
|
// Convert the vector to a quaternion (0, v.x, v.y, v.z)
|
|
let vector_as_quaternion = Quat::from_xyzw(0.0, v.x, v.y, v.z);
|
|
|
|
// Apply the rotation: q * vector * q^-1
|
|
let rotated_vector = q * vector_as_quaternion * q.conjugate();
|
|
|
|
// Extract the rotated vector from the quaternion
|
|
Vec3::new(rotated_vector.x, rotated_vector.y, rotated_vector.z)
|
|
}
|
|
|
|
fn rotate_to_align(old_pos: Vec3, new_pos: Vec3) -> Quat {
|
|
// Step 1: Normalize the input vectors (assuming they're not already normalized)
|
|
let old_pos_normalized = old_pos.normalize();
|
|
let new_pos_normalized = new_pos.normalize();
|
|
|
|
// Step 2: Compute the axis of rotation (cross product between old and new positions)
|
|
let axis_of_rotation = old_pos_normalized.cross(new_pos_normalized).normalize();
|
|
|
|
if axis_of_rotation.length_squared() < f32::EPSILON {
|
|
return Quat::IDENTITY;
|
|
}
|
|
|
|
// Step 3: Compute the angle of rotation (dot product and arccosine)
|
|
//let dot_product = old_pos_normalized.dot(new_pos_normalized);
|
|
let dot_product = new_pos_normalized.dot(old_pos_normalized);
|
|
let angle_of_rotation = dot_product.acos(); // This gives us the angle in radians
|
|
|
|
if angle_of_rotation.is_nan() || angle_of_rotation.is_infinite() {
|
|
return Quat::IDENTITY;
|
|
}
|
|
|
|
// Step 4: Create a quaternion representing the rotation
|
|
Quat::from_axis_angle(axis_of_rotation, angle_of_rotation)
|
|
}
|
|
|
|
fn debug_vector(
|
|
mut debug_line_query: Query<&mut Transform, (With<DebugLine>, Without<Player>)>,
|
|
pos: Vec3, vec: Vec3
|
|
) {
|
|
let Ok(mut debug_transform) = debug_line_query.get_single_mut() else {
|
|
info!("no debug line");
|
|
return;
|
|
};
|
|
|
|
let vec_norm = vec.length();
|
|
|
|
debug_transform.scale = Vec3::new(vec_norm, 1.0, 1.0);
|
|
|
|
debug_transform.translation = pos;
|
|
|
|
if vec_norm > f32::EPSILON {
|
|
let rotation = Quat::from_rotation_arc(Vec3::X, vec.normalize());
|
|
debug_transform.rotation = rotation;
|
|
}
|
|
}
|
|
|
|
|
|
pub fn ui_labels(
|
|
mut param_set: ParamSet<(
|
|
Query<&mut Text, With<HealthLabel>>,
|
|
Query<&mut Text, With<ScoreLabel>>,
|
|
Query<&mut Text, With<HintLabel>>,
|
|
)>,
|
|
mut player_query: Query<(&mut Player, &mut Transform)>,
|
|
) {
|
|
if let Ok((player, _)) = player_query.get_single_mut() {
|
|
if let Ok(mut health_text) = param_set.p0().get_single_mut() {
|
|
health_text.sections[0].value = "# ".repeat(player.health);
|
|
}
|
|
|
|
if let Ok(mut score_text) = param_set.p1().get_single_mut() {
|
|
score_text.sections[0].value = format!("{}", player.score);
|
|
}
|
|
|
|
if let Ok(mut hint_text) = param_set.p2().get_single_mut() {
|
|
if player.state == PlayerState::Answered {
|
|
hint_text.sections[0].value = "press space to continue".into();
|
|
} else {
|
|
hint_text.sections[0].value = "press i to get an hint".into();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
pub fn ui_buttons(
|
|
mut interaction_query: Query<
|
|
(
|
|
&Interaction,
|
|
&mut BackgroundColor,
|
|
&mut BorderColor,
|
|
&Children,
|
|
),
|
|
With<Button>,
|
|
>,
|
|
mut text_query: Query<&mut Text, With<AnswerButton>>,
|
|
mut player_query: Query<&mut Player>,
|
|
commands: Commands,
|
|
meshes: ResMut<Assets<Mesh>>,
|
|
materials: ResMut<Assets<StandardMaterial>>,
|
|
sky: Res<Sky>
|
|
) {
|
|
if let Ok(mut player) = player_query.get_single_mut() {
|
|
if player.state == PlayerState::Answered {
|
|
return
|
|
}
|
|
|
|
let mut pressed_button: Option<String> = None;
|
|
|
|
for (
|
|
interaction,
|
|
_color,
|
|
_border_color,
|
|
children
|
|
) in &mut interaction_query {
|
|
if *interaction == Interaction::Pressed {
|
|
if let Ok(text) = text_query.get_mut(children[0]) {
|
|
pressed_button = Some(text.sections[0].value.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(selected_cons) = pressed_button {
|
|
if let Some(target_cons) = player.target_cons_name.clone() {
|
|
if player.state == PlayerState::Playing {
|
|
spawn_cons_lines(commands, meshes, materials, sky, target_cons.clone());
|
|
}
|
|
|
|
if target_cons == selected_cons {
|
|
if player.state == PlayerState::Hinted {
|
|
player.score += 20;
|
|
} else {
|
|
player.score += 100;
|
|
}
|
|
} else {
|
|
player.health -= 1;
|
|
}
|
|
|
|
player.state = PlayerState::Answered;
|
|
|
|
for (
|
|
_interaction,
|
|
mut color,
|
|
mut border_color,
|
|
children
|
|
) in &mut interaction_query {
|
|
if let Ok(text) = text_query.get_mut(children[0]) {
|
|
let button_text = text.sections[0].value.clone();
|
|
|
|
*color = if button_text == target_cons {
|
|
RIGHT_BUTTON.into()
|
|
} else {
|
|
WRONG_BUTTON.into()
|
|
};
|
|
|
|
border_color.0 = if button_text == selected_cons {
|
|
Color::WHITE
|
|
} else {
|
|
Color::BLACK
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn choose_constellation(
|
|
player: &mut Player,
|
|
sky: Res<Sky>,
|
|
mut text_query: Query<&mut Text, With<AnswerButton>>,
|
|
mut button_query: Query<(&mut BackgroundColor, &mut BorderColor), With<Button>>,
|
|
constellation_line_query : Query<(Entity, &ConstellationLine)>,
|
|
mut commands: Commands,
|
|
mut game_state: ResMut<NextState<GameState>>
|
|
) {
|
|
if player.health == 0 {
|
|
game_state.set(GameState::End);
|
|
}
|
|
if sky.content.len() >= 4 {
|
|
let mut rng = rand::thread_rng();
|
|
let mut selected_constellations = sky.content.clone();
|
|
selected_constellations.shuffle(&mut rng);
|
|
let constellations = &selected_constellations[0..4];
|
|
|
|
let target_index = rng.next_u32().rem_euclid(4) as usize;
|
|
let target_constellation = &constellations[target_index];
|
|
|
|
player.target_rotation = Some(constellation_center(target_constellation.clone()));
|
|
player.target_cons_name = Some(target_constellation.name.clone());
|
|
|
|
info!("Target constellation: {}", target_constellation.name);
|
|
|
|
for (i, mut text) in text_query.iter_mut().enumerate() {
|
|
text.sections[0].value = constellations[i].name.clone();
|
|
}
|
|
|
|
for (mut bg_color, mut border_color) in &mut button_query {
|
|
*bg_color = NORMAL_BUTTON.into();
|
|
*border_color = Color::BLACK.into();
|
|
}
|
|
|
|
for (entity, _line) in constellation_line_query.iter() {
|
|
commands.entity(entity).despawn();
|
|
}
|
|
|
|
player.state = PlayerState::Playing;
|
|
} else {
|
|
info!("Not enough constellations in the sky (need 4)");
|
|
}
|
|
}
|
|
|
|
fn constellation_center(target_constellation: Constellation) -> Quat {
|
|
let mut mean_pos = Vec3::ZERO;
|
|
|
|
for star in target_constellation.stars.clone() {
|
|
mean_pos += celestial_to_cartesian(star.rah, star.dec)
|
|
}
|
|
|
|
Quat::from_rotation_arc(
|
|
Vec3::Z,
|
|
-mean_pos*(1.0/target_constellation.stars.len() as f32),
|
|
)
|
|
}
|