turtlers/src/turtle.rs

use std::time::Duration;

use bevy::prelude::*;
use bevy_inspector_egui::{Inspectable, RegisterInspectable};
use bevy_prototype_lyon::{prelude::*, shapes::Line};
use bevy_tweening::{
    lens::TransformPositionLens, Animator, EaseFunction, Sequence, Tween, TweenCompleted,
    TweeningPlugin, TweeningType,
};

use crate::{turtle_movement::turtle_move, turtle_shapes};

pub struct TurtlePlugin;

impl Plugin for TurtlePlugin {
    fn build(&self, app: &mut bevy::prelude::App) {
        app.add_plugin(TweeningPlugin)
            .add_startup_system(setup)
            .add_system(keypresses)
            .add_system(draw_lines)
            .register_inspectable::<Colors>()
            .register_inspectable::<TurtleCommands>();
    }
}
#[derive(Bundle)]
pub struct Turtle {
    colors: Colors,
    commands: TurtleCommands,
    name: Name,
}

impl Default for Turtle {
    fn default() -> Self {
        Self {
            colors: Colors {
                color: Color::DARK_GRAY,
                fill_color: Color::BLACK,
            },
            commands: TurtleCommands::new(vec![
                TurtleCommand::Forward(Length(100.)),
                TurtleCommand::Right(Angle(90.)),
                TurtleCommand::Backward(Length(100.)),
                TurtleCommand::Right(Angle(90.)),
                TurtleCommand::Forward(Length(100.)),
                TurtleCommand::Right(Angle(45.)),
                TurtleCommand::Forward(Length(100.)),
                TurtleCommand::Right(Angle(90.)),
                TurtleCommand::Forward(Length(50.)),
                TurtleCommand::Right(Angle(90.)),
                TurtleCommand::Forward(Length(100.)),
                TurtleCommand::Right(Angle(90.)),
                TurtleCommand::Forward(Length(50.)),
                TurtleCommand::Right(Angle(45.)),
                TurtleCommand::Forward(Length(100.)),
                TurtleCommand::Left(Angle(120.)),
                TurtleCommand::Forward(Length(100.)),
                TurtleCommand::Left(Angle(120.)),
                TurtleCommand::Forward(Length(100.)),
                TurtleCommand::Right(Angle(150.)),
                TurtleCommand::Forward(Length(100.)),
            ]),
            name: Name::new("Turtle"),
        }
    }
}

impl Turtle {
    pub fn set_color(&mut self, color: Color) {
        self.colors.color = color;
    }
    pub fn set_fill_color(&mut self, color: Color) {
        self.colors.fill_color = color;
    }
    pub fn get_colors(&self) -> &Colors {
        &self.colors
    }
    pub fn forward(&mut self) -> &mut Self {
        self.commands
            .commands
            .push(TurtleCommand::Forward(Length(100.0)));
        self
    }
}

#[derive(Component, Inspectable)]
pub struct TurtleCommands {
    commands: Vec<TurtleCommand>,
    lines: Vec<TurtleGraphElement>,
}

impl TurtleCommands {
    fn new(commands: Vec<TurtleCommand>) -> Self {
        Self {
            commands,
            lines: vec![],
        }
    }
}

impl TurtleCommands {
    fn generate_tweenable(&mut self) -> Sequence<Transform> {
        self.lines.clear();
        let mut seq = Sequence::with_capacity(self.commands.len());
        let mut pos = Vec2::ZERO;
        let mut ori: f32 = 0.;
        for (index, op) in self.commands.iter().enumerate() {
            match op {
                TurtleCommand::Forward(Length(x)) => {
                    let (target, animation, line) = turtle_move(pos, ori, *x as f32, index as f32);
                    self.lines.push(line);
                    seq = seq.then(animation);
                    pos = target;
                }
                TurtleCommand::Backward(Length(x)) => {
                    let (target, animation, line) = turtle_move(pos, ori, -*x as f32, index as f32);
                    self.lines.push(line);
                    seq = seq.then(animation);
                    pos = target;
                }
                TurtleCommand::Left(Angle(x)) => {
                    let (nori, tween, line) = crate::turtle_movement::turtle_turn(ori, *x as f32);
                    ori = nori;
                    seq = seq.then(tween);
                    self.lines.push(line);
                }
                TurtleCommand::Right(Angle(x)) => {
                    let (nori, tween, line) = crate::turtle_movement::turtle_turn(ori, -*x as f32);
                    ori = nori;
                    seq = seq.then(tween);
                    self.lines.push(line);
                }
                TurtleCommand::PenUp => todo!(),
                TurtleCommand::PenDown => todo!(),
                TurtleCommand::Circle => todo!(),
                TurtleCommand::Pause => todo!(),
            }
        }
        seq
    }
}

#[derive(Inspectable, Default)]
pub enum TurtleGraphElement {
    TurtleLine {
        start: Vec2,
        end: Vec2,
    },
    #[default]
    Noop,
}

#[derive(Clone, Component, Inspectable)]
pub struct TurtleShape;

#[derive(Clone, Component, Inspectable)]
pub struct Colors {
    color: Color,
    fill_color: Color,
}

#[derive(Inspectable, Default)]
pub struct Length(f64);
#[derive(Inspectable, Default)]
pub struct Angle(f64);

#[derive(Component, Inspectable, Default)]
pub enum TurtleCommand {
    Forward(Length),
    Backward(Length),
    Left(Angle),
    Right(Angle),
    PenUp,
    PenDown,
    #[default]
    Pause,
    Circle,
}

fn setup(mut commands: Commands) {
    let animator = Animator::new(Tween::new(
        // Use a quadratic easing on both endpoints.
        EaseFunction::QuadraticInOut,
        // Loop animation back and forth.
        TweeningType::PingPong,
        // Animation time (one way only; for ping-pong it takes 2 seconds
        // to come back to start).
        Duration::from_secs(1),
        // The lens gives access to the Transform component of the Entity,
        // for the Animator to animate it. It also contains the start and
        // end values respectively associated with the progress ratios 0. and 1.
        TransformPositionLens {
            start: Vec3::ZERO,
            end: Vec3::new(40., 40., 0.),
        },
    ));
    commands.spawn_bundle(Camera2dBundle::default());
    commands
        .spawn_bundle(Turtle::default())
        .insert_bundle(GeometryBuilder::build_as(
            &turtle_shapes::turtle(),
            DrawMode::Outlined {
                fill_mode: FillMode::color(Color::MIDNIGHT_BLUE),
                outline_mode: StrokeMode::new(Color::BLACK, 1.0),
            },
            Transform::identity(),
        ))
        .insert(animator)
        .insert(TurtleShape);
}

fn draw_lines(
    mut commands: Commands,
    tcmd: Query<&TurtleCommands>,
    mut query_event: EventReader<TweenCompleted>, // TODO: howto attach only to the right event?
) {
    for ev in query_event.iter() {
        let index = ev.user_data;

        for t in tcmd.iter() {
            let t = t.lines.get(index as usize).unwrap();
            match t {
                TurtleGraphElement::TurtleLine { start, end } => {
                    commands.spawn_bundle(GeometryBuilder::build_as(
                        &Line(*start, *end),
                        DrawMode::Outlined {
                            fill_mode: FillMode::color(Color::MIDNIGHT_BLUE),
                            outline_mode: StrokeMode::new(Color::BLACK, 1.0),
                        },
                        Transform::identity(),
                    ));
                }
                TurtleGraphElement::Noop => (),
            }
        }
    }
}

fn keypresses(
    keys: Res<Input<KeyCode>>,
    mut qry: Query<&mut Animator<Transform>, With<TurtleShape>>,
    mut tcmd: Query<&mut TurtleCommands>,
) {
    if keys.just_pressed(KeyCode::W) {
        let mut tcmd = tcmd.single_mut();
        let c = tcmd.generate_tweenable();
        let mut shap = qry.single_mut();
        shap.set_tweenable(c);
    }
}