sketchbook/boxing.cpp

// raboot of atari 2600 Boxing
// TODO: gore (destructable nose, eyes)
// TODO: death animation (drift, arms flail, eyes fly, blood squirts)
// TODO: ropes (and some padding)
// TODO: gamepad controls
// TODO: touch controls
// TODO: finish music
// TODO: menu - 1/2 players, audio levels
// TODO: menu - gore level (in case become olympic sport),
//
// TODO: menu - hoboplayer

/*
#canvas {
    position: absolute;
    top: 0px;
    left: 0px;
    margin: 0px;
    width: 100%;
    height: 100%;
    overflow: hidden;
    display: block;
}
*/


#include "common/sketchbook.hpp"
#include "common/math.hpp"

float quadratic_out(float x) { return 1.f - motion::quadratic_curve(1.f - x); };
float stairwave(float x)
{
	// TODO: must be a way to just parameterize sinus to do less work and be less smooth, instead of doing more work to make it jagged
	constexpr auto levels = 12.f;
	return int(std::clamp(common::sinus(x)  *levels, -levels,levels)) /levels;
}

struct key_vector
{
	scancode k;
	float2 v;
};

struct keymap
{
	std::array<key_vector,4> legwork;
	std::array<scancode,3> punch;
};

keymap wasd
{
	{
		key_vector{scancode::w, -float2::j()},
		key_vector{scancode::a, -float2::i()},
		key_vector{scancode::s,  float2::j()},
		key_vector{scancode::d,  float2::i()}
	},
	{ scancode::tab, scancode::f, scancode::v }
};

keymap ijkl
{
	{
		key_vector{scancode::i, -float2::j()},
		key_vector{scancode::j, -float2::i()},
		key_vector{scancode::k,  float2::j()},
		key_vector{scancode::l,  float2::i()}
	},
	{ scancode::h, scancode::semicolon, scancode::n}
};

keymap arrow_keys
{
	{
		key_vector{scancode::up,   -float2::j()},
		key_vector{scancode::left, -float2::i()},
		key_vector{scancode::down,  float2::j()},
		key_vector{scancode::right, float2::i()}
	},
	{}
};

std::vector control_options {wasd, ijkl, arrow_keys}; // FIXME: numpad, gamepad, touchscreen, mouse

rect ring{};

constexpr float2 half = float2::one(0.5);

constexpr float2 starting_pos = float2::one(0.1);

constexpr auto scale(rect ratio, rect world)
{
	ratio.size *= world.size;
	ratio.position *= world.size;
	ratio.position += world.position;
	return ratio;
}

constexpr auto faded_wave(float fade_factor, auto&& f)
{
	return [fade_factor, f = std::forward<decltype(f)>(f)](auto ratio) mutable
	{
		auto [freq, ampl] = f(ratio);
		float fade = std::min(ratio*fade_factor, (1-ratio)*fade_factor);
		return way(0.f,common::sinus(ratio * freq) * ampl, std::min(fade, 1.f));
	};
};


struct blood_drop
{
	rgb cola;
	movement<float2, motion::cubic_curve> veloc;
	float2 position;

	void update(frame& frame, auto delta)
	{
		veloc.advance(delta);
		auto oldpos = position;
		position += veloc.value();

		frame.begin_sketch()
			.line(ring.size*oldpos + ring.position, ring.size*position + ring.position)
			.line_width(0.01 * ring.size.x())
			.line_cap(sketch::cap::round)
			.outline(cola)
		;
	}

	bool done()
	{
		return veloc.done();
	}
};

std::vector<blood_drop> blood;


struct complayer
{
	using timer = movement<support::tuple_void_t>;

	// params ideas
	// amnesia - aims at target position N ms in the past
	// shortsigtedness - aims at random offset from target
	// slowpokedom - punch speed
	// kindness - backs off after N hit chain
	// juke'n'jive - just randomly offset legwork in x and y direction

	// parameters
	std::array<Program::duration, 3> punch_intervals = {600ms, 300ms, 100ms};
	Program::duration legwork_interval = 250ms;
	Program::duration stun_interval = 250ms;

	// state
	timer legwork_timer = {legwork_interval};
	timer punch_timer = {punch_intervals[0]};
	timer stun_timer = {stun_interval};
	float2 legwork_flank = {};
	int sidestep = 0;

};

struct boxa
{
	rgb cola;
	float2 position = {};
	float2 velocity = {};
	float speed = 0.5;
	movement<float, common::sinus> idle = {500ms, 0.f, 0.005f}; // FIXME: random delay per boxa to desync them
	movement<float2, quadratic_out> shovement = {0s, float2::zero(), float2::zero()};
	melody<movement<float2>, movement<float2>> squeezement = {};
	melody<movement<float2>, movement<float2>> glove_squeezement = {};
	boxa* target;
	std::optional<keymap> controls{};
	std::optional<complayer> brainz;

	float punch = 0.0f;
	bool hit = false;
	unsigned punch_glove = 0;
	unsigned hit_glove = 0;
	unsigned damage = 0;

	auto direction() const
	{
		const auto distance = target->position - position;

		auto clamped_distance = distance;
		if(clamped_distance.y() > 0.2)
			clamped_distance.y() = 0.2;
		else if(clamped_distance.y() < -0.2)
			clamped_distance.y() = -0.2;

		if(abs(clamped_distance.x()) > 0.18f)
			clamped_distance *= float2::i();
		else
			clamped_distance = support::average(clamped_distance, clamped_distance * float2::i());

		return common::normalize(clamped_distance);
	}

	rect body() const
	{
		return {float2::one(0.1), position, half};
	};

	auto elbows() const
	{
		const auto normal = common::rotate(this->direction(), common::protractor<>::tau(1/4.f));
		auto body = this->body();
		std::array<float2,2> elbows{};
		const auto spread = 1.7f;
		auto arm = 1;
		for(auto&& elbow : elbows)
		{
			elbow = body.position;
			elbow += body.size.x() * normal * spread * arm;
			elbow += - this->direction() * body.size.x()/2 * 1.3;
			if(elbow == elbows[punch_glove])
				elbow -= body.size.x() * normal * (0.7 * punch) * arm;

			arm = -arm;
		}

		elbows[punch_glove] += this->direction() * punch * 0.1;

		return elbows;
	};

	auto gloves() const
	{
		const auto normal = common::rotate(this->direction(), common::protractor<>::tau(1/4.f));
		auto body = this->body();
		std::array<rect,2> gloves{};
		for(auto&& glove : gloves)
		{
			glove = body;
			glove.size *= 0.9;
			glove.position += body.size.x() * normal;
			glove.position += this->direction() * body.size.x()/2;
		}
		gloves[1].position -= body.size.x() * 2 * normal;
		gloves[punch_glove].position += this->direction() * punch * 0.2;

		return gloves;
	};

	void update(frame& f, auto delta_time)
	{
		{ // draw
			const auto direction = this->direction();
			const auto normal = common::rotate(this->direction(), common::protractor<>::tau(1/4.f));
			const auto facingdom = float2x2{direction, normal};
			auto body = this->body();
			{
				float2 squeezement = float2::one();
				this->squeezement.move(squeezement, delta_time);
				const auto squeezed_body_size = body.size * squeezement;
				body.position += direction * (squeezed_body_size.x() - body.size.x());
				body.size = squeezed_body_size;
			}
			auto elbows = this->elbows();
			auto gloves = this->gloves();

			{
				float idle_sway = 0.f;
				auto idle_normal = normal;
				motion::loop(idle_sway, idle, delta_time);
				for(auto&& glove : gloves)
				{
					glove.position += idle_normal * idle_sway;
					idle_normal = -idle_normal;
				}
				body.position += direction * idle_sway;
			}

			{
				gloves[punch_glove].size += gloves[punch_glove].size * float2{0.1f, -0.1f} * punch;
			}

			{
				float2 squeezement = float2::one();
				this->glove_squeezement.move(squeezement, delta_time);
				const auto squeezed_glove_size = gloves[hit_glove].size * squeezement;
				gloves[hit_glove].position += direction * (squeezed_glove_size.x() - gloves[hit_glove].size.x());
				gloves[hit_glove].size = squeezed_glove_size;

			}

			auto scaled_body = scale(body,ring);
			for(auto&& [elbow, glove] : range{vbegin(elbows, gloves), vend(elbows,gloves)})
			{
				auto scaled_elbow = elbow * ring.size + ring.position;
				auto scaled_glove = scale(glove,ring);
				f.begin_sketch()
					.move(scaled_body.position)
					.bezier(scaled_elbow, scaled_glove.position)
					.line_width((0.04f) * ring.size.x()).outline(0x333333_rgb)
				;
			}

			f.begin_sketch()
				.ellipse(scaled_body.position, facingdom * geom::column(scaled_body.size/2))
				.fill(rgb::white(0.5))
			;

			auto thumb_offsetdom = geom::vector(
				-direction * 0.1f,
				-normal * 0.4f
			);
			auto glove_sketch = f.begin_sketch();
			for(auto&& glove : gloves)
			{
				auto scaled_glove = scale(glove,ring);
				glove_sketch
					.ellipse(scaled_glove.position, facingdom * geom::column(scaled_glove.size/2))
					.ellipse(scaled_glove.position + thumb_offsetdom(scaled_glove.size), facingdom * geom::column(scaled_glove.size/2/2))
				;
				thumb_offsetdom[1] = -thumb_offsetdom[1];
			}
			glove_sketch.fill(cola);

		}

		{ // move
			const range2f bounds {position - 0.05, position + 0.05};
			constexpr auto world_bounds = range2f{float2::zero(), float2::one()};
			const auto lower_overshoot = world_bounds.lower() - bounds.lower();
			const auto upper_overshoot = bounds.upper() - world_bounds.upper();

			constexpr float springback_factor = 20;
			velocity += springback_factor * max(lower_overshoot, float2::zero());
			velocity -= springback_factor * max(upper_overshoot, float2::zero());

			position += velocity * speed * delta_time.count();
			if(not shovement.done())
			{
				position += shovement.value() * (speed /2) * delta_time.count();
				shovement.advance(delta_time);
			}

			auto diameter = 0.2f;
			const auto distance = target->position - position;
			if(distance.quadrance() < diameter * diameter)
			{
				auto direction = common::normalize(distance);
				auto force_field = direction * diameter;
				auto correction = distance - force_field;
				position += correction;
			}

			if(punch > 0 || hit)
			{
				if(not hit)
				{
					punch += 10 * delta_time.count();;

					if(punch >= 1)
					{
						hit = true;
						punch = 1;
					}
				}
				else
				{
					if(punch > 0)
					{
						punch -= 10 * delta_time.count();
					}
					else
					{
						punch = 0;
						hit = false;
					}
				}
			}
		}
	}

	std::optional<rect> punching_glove() const
	{
		if(punch > 0 && not hit)
			return gloves()[punch_glove];
		else
			return std::nullopt;
	}

	unsigned closest_glove_index() const
	{
		return
			(position.y() > target->position.y())
			^
			(position.x() > target->position.x())
		;
	}

	rect closest_glove() const
	{ return gloves()[closest_glove_index()]; }

};

std::array boxas
{
	boxa{rgb::red(), starting_pos},
	boxa{rgb::blue(), float2::one() - starting_pos}
};

constexpr rect fit_square(float2 size)
{
	float2 fit_size = float2::one(*min_element(size));
	return {fit_size, (size - fit_size) / 2}; // hmmm, does this sub/2 thing have a name? midpointish but not quite
}

void punch(Program& program, boxa& boxa)
{
	if(boxa.punch == 0)
	{
		auto hiss = [rand = make_trand_float({0,0.1})](auto ratio) mutable
		{ return std::pair{rand(), ratio/5}; };
		program.request_wave({faded_wave(20, std::move(hiss)), 125ms});
		// program.request_wave({faded_wave(20, std::move(hiss)), 50ms});

		boxa.punch = 0.001;
		boxa.punch_glove = boxa.closest_glove_index();
	}
}

void start(Program& program)
{
	// program.frametime = framerate<60>::frametime;
	program.resizable = true;
	program.size = float2::one(400.f);
	ring = fit_square(program.size);

	boxas[0].target = &boxas[1];
	boxas[1].target = &boxas[0];
	boxas[1].brainz = complayer{};
	// boxas[0].brainz = complayer{};

	boxas[0].idle.advance(trand_float() * boxas[0].idle.total);
	boxas[1].idle.advance(trand_float() * boxas[0].idle.total);

	if(program.argc > 2)
	{
		using support::ston;
		using seed_t = decltype(tiny_rand());
		tiny_rand.seed({ ston<seed_t>(program.argv[1]), ston<seed_t>(program.argv[2]) });
	}

	std::cout << "seed: " << std::hex << std::showbase << tiny_rand << '\n';

	program.key_up = [&](scancode code, keycode)
	{
		switch(code)
		{
			case scancode::leftbracket:
			case scancode::c:
				if(pressed(scancode::rctrl) || pressed(scancode::lctrl))
			case scancode::escape:
				program.end();
			break;

			default: break;
		}
	};

	program.key_down = [&](scancode code, keycode)
	{
		for(auto&& boxa : boxas)
			if(boxa.controls)
				if(support::find(boxa.controls->punch, code) != boxa.controls->punch.end())
					punch(program, boxa);
	};

	program.mouse_down = [&](float2, auto)
	{
	};

	program.size_changed = [&](float2 size)
	{
		std::cout << size << '\n';
		ring = fit_square(size);
		std::cout << ring << '\n';
	};

	program.draw_loop = [&](auto frame, auto delta_time)
	{
		frame.begin_sketch()
			.rectangle(rect{frame.size})
			.fill(rgb::white(0.4f))
		;

		frame.begin_sketch()
			.rectangle(ring)
			.fill(rgb(0.3f, 0.4f, 0.0f))
		;

		for(auto&& boxa : boxas)
		{
			boxa.velocity = float2::zero();
			if(boxa.controls)
			{
				for(auto&& kv : boxa.controls->legwork)
					if(pressed(kv.k))
						boxa.velocity += kv.v;
				if(boxa.velocity != float2::zero())
					boxa.velocity = common::normalize(boxa.velocity); // here length can only be root(2) or 1 so a bit of an overkill
			}
			else
			{
				auto selected = support::find_if(control_options, [](auto option)
				{
					return support::any_of(option.legwork, [](auto kv) { return pressed(kv.k); });
				});

				if(selected != control_options.end())
				{
					boxa.controls = *selected;
					control_options.erase(selected);
				}
			}

			if(boxa.brainz)
			{
				if(boxa.brainz->stun_timer.done())
				{
					// FIXME: need more randomness for comp v comp demo
					const auto get_flank_offset = [&boxa](float2 flank){ return boxa.target->position + flank - boxa.position; };
					if(motion::loop(boxa.brainz->legwork_timer, delta_time) != 0)
					{
						const auto direction = boxa.target->direction();
						const auto normal = common::rotate(direction, common::protractor<>::tau(1/4.f));
						const auto faceoff = direction * boxa.target->body().size * 2.9;
						const auto backstab = -faceoff;
						const auto normal_flank = faceoff + normal * boxa.target->body().size;
						const auto unnormal_flank = faceoff - normal * boxa.target->body().size;
						const auto back_normal_flank = backstab + normal * boxa.target->body().size;
						const auto back_unnormal_flank = backstab - normal * boxa.target->body().size;
						std::array<float2, 4> candidates {normal_flank, unnormal_flank, back_normal_flank, back_unnormal_flank};
						auto ring_candidates_end = std::remove_if(candidates.begin(), candidates.end(),
							[&boxa](auto flank){ return not range{float2::zero(),float2::one()}.contains(boxa.target->position + flank); });
						using support::transform_arg;
						boxa.brainz->legwork_flank = *std::min_element(candidates.begin(), ring_candidates_end,
							transform_arg{get_flank_offset, transform_arg{&float2::quadrance}});

						if(boxa.direction().y() != 0 && (boxa.position - boxa.target->position).quadrance() < 0.04)
						{
							auto normal = common::rotate(boxa.direction(), common::protractor<>::tau(1/4.f));
							auto diff = boxa.target->position - boxa.position;
							boxa.brainz->sidestep = normal(diff) > 0 ? -1 : 1;
						}
						else
							boxa.brainz->sidestep = 0;
					}

					auto flank_offset = get_flank_offset(boxa.brainz->legwork_flank);
					if(flank_offset.quadrance() > 0.0001)
						boxa.velocity = common::normalize(flank_offset);

					if(boxa.brainz->sidestep != 0)
					{
						auto normal = common::rotate(boxa.direction(), common::protractor<>::tau(1/4.f));
						boxa.velocity = normal * boxa.brainz->sidestep;
					}

					{
						const auto closest_glove_offset = (boxa.target->position - boxa.closest_glove().position);
						if(boxa.brainz->punch_timer.done())
						{
							// make these complayer parameters, along with faceoff distance above close
							const float punch_length = 0.26f;
							const float punch_width = 0.25f * (0.1f + 0.9f * std::max((1.f - boxa.damage/100.f),0.f));
							auto normal = common::rotate(boxa.direction(), common::protractor<>::tau(1/4.f));
							if
							(
								closest_glove_offset(boxa.direction()) < punch_length
								&& closest_glove_offset(normal) < punch_width
								&& closest_glove_offset(-normal) < punch_width
							)
							{
								punch(program, boxa);
								boxa.brainz->punch_timer.total = boxa.brainz->punch_intervals[trand_int({0, (int)boxa.brainz->punch_intervals.size()})];
								boxa.brainz->punch_timer.total *= 0.25f + 0.75f * std::max((1.f - boxa.damage/100.f),0.f);
								boxa.brainz->punch_timer.reset();
							}
						}
						else
							boxa.brainz->punch_timer.advance(delta_time);
					}


					frame.begin_sketch().rectangle(scale(rect{{float2::one(0.1), boxa.position + flank_offset}, float2::one(0.5f)},ring)).fill(0x00000033_rgba);
					frame.begin_sketch().rectangle(scale(rect{{float2::one(0.1), boxa.gloves()[boxa.punch_glove].position}, float2::one(0.5f)},ring)).fill(0x00000033_rgba);
				}
				else
					boxa.brainz->stun_timer.advance(delta_time);
			}
		}

		for(auto&& b : boxas) b.update(frame, delta_time);
		for(auto&& b : boxas)
		{
			auto glove = b.punching_glove();
			bool collided_target = false;
			bool collided_a_glove = false;
			bool collided_punching_glove = false;

			if(glove)
			{
				collided_target = (glove->position - b.target->position).quadrance() <= 0.085*0.085;

				if(not collided_target)
				{
					auto other_gloves = b.target->gloves();

					auto collided_glove = support::find_if(other_gloves, [pos = glove->position](auto x) {
						return (pos - x.position).quadrance() <= x.size.quadrance()/2;
					});
					collided_a_glove = collided_glove != other_gloves.end();
					auto other_punching_glove = b.target->punching_glove();
					if(collided_a_glove && other_punching_glove)
					{
						collided_punching_glove = (*collided_glove) == (*other_punching_glove);
					}
					if(collided_a_glove)
					{
						b.target->hit_glove = collided_glove - other_gloves.begin();
					}
				}
			}


			if(collided_target)
			{
				b.target->shovement.total = 250ms;
				b.target->shovement.start = (b.direction() + (b.position.y() < b.target->position.y() ? -float2::j(2) : float2::j(2))) * 5;
				b.target->shovement.reset();
				{
					constexpr auto squeezementat = float2{0.5f, 1.5f};
					b.target->squeezement = melody{
						movement<float2>{125ms, float2::one(), squeezementat},
						movement<float2>{125ms, squeezementat, float2::one()}
					};
				}
				++b.target->damage; // TODO: more damage for combos?

				auto boink = [](auto ratio)
				{ return std::pair{way(40.f, 20.f, ratio), 1}; };
				program.request_wave({faded_wave(20, std::move(boink)), 125ms});

				const auto splatter_direction = (b.target->position - b.position).signum();
				for(int i = 10; i --> 0;) blood.push_back({
					wayback(0x55cccc_rgb,0x660000_rgb, std::min(b.target->damage/50.f, 1.f)),
					{250ms, trand_float2() / 50 * splatter_direction, float2::zero()},
					b.target->position
				});

				if(b.target->brainz)
				{
					b.target->brainz->stun_timer.total = b.target->brainz->stun_interval * (0.10f + 0.90f * std::max((1.f - b.target->damage/100.f),0.f));
					b.target->brainz->stun_timer.reset();
				}

				std::cout << std::dec << boxas[0].damage << " vs " << boxas[1].damage << '\n';
			}

			if(collided_a_glove)
			{
				constexpr auto squeezementat = float2{0.7f, 1.3f};
				b.target->glove_squeezement = melody{
					movement<float2>{60ms, float2::one(), squeezementat},
					movement<float2>{60ms, squeezementat, float2::one()}
				};

				auto bunk = [](auto ratio)
				{ return std::pair{way(25.f, 0.f, ratio), .3f}; };
				program.request_wave({faded_wave(20, std::move(bunk)), 125ms});
			}

			if(collided_target || collided_a_glove)
				b.hit = true;

			if(collided_punching_glove)
			{
				b.target->hit = true;
				break;
			}
		}

		for(auto&& b : blood) b.update(frame, delta_time);
		blood.erase(std::remove_if(blood.begin(),blood.end(), [](auto& b) {return b.done();}), blood.end());

	};


















	program.request_wave({
		[
			time = 0.f, freq = 0.f,
			musac = motion::melody
			{
				movement<float>{50ms, 0.f,120.f},
				movement<float>{50ms, 120.f,0.f},
				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,150.f},
				movement<float>{50ms, 150.f,0.f},
				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,100.f},
				movement<float>{50ms, 100.f,0.f},

				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,200.f},
				movement<float>{50ms, 200.f,0.f},
				movement<float>{100ms, 0.f,0.f},

				movement<float>{50ms, 0.f,220.f},
				movement<float>{50ms, 220.f,0.f},
				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,250.f},
				movement<float>{50ms, 250.f,0.f},
				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,200.f},
				movement<float>{50ms, 200.f,0.f},

				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,100.f},
				movement<float>{50ms, 100.f,0.f},
				movement<float>{100ms, 0.f,0.f},



				movement<float>{50ms, 0.f,120.f},
				movement<float>{50ms, 120.f,0.f},
				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,0.f},
				movement<float>{50ms, 0.f,0.f},
				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,100.f},
				movement<float>{50ms, 100.f,0.f},

				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,200.f},
				movement<float>{50ms, 200.f,0.f},
				movement<float>{100ms, 0.f,0.f},

				movement<float>{50ms, 0.f,0.f},
				movement<float>{50ms, 0.f,0.f},
				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,250.f},
				movement<float>{50ms, 250.f,0.f},
				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,200.f},
				movement<float>{50ms, 200.f,0.f},

				movement<float>{100ms, 0.f,0.f},
				movement<float>{50ms, 0.f,0.f},
				movement<float>{50ms, 0.f,0.f},
				movement<float>{100ms, 0.f,0.f},
			}
		](auto tick) mutable
		{
			motion::loop(freq, musac, Program::duration(tick));
			time += tick * freq;
			time = support::wrap(time,1.f);
			return stairwave(time) * 0.2f;
		},
	0ms});

	program.request_wave({
		[
			time = 0.f, freq = 0.f,
			musac = motion::melody
			{

				movement<float, quadratic_out>{10ms, 0.f, 350.f},
				movement<float, quadratic_out>{90ms, 350.f,420.f},
				movement<float, motion::quadratic_curve>{200ms, 420.f,350.f},
				movement<float, quadratic_out>{100ms, 350.f,350.f},
				movement<float, quadratic_out>{100ms, 350.f,750.f},
				movement<float, motion::quadratic_curve>{200ms, 750.f,350.f},
				movement<float, quadratic_out>{100ms, 350.f,350.f},

				movement<float, motion::quadratic_curve>{200ms, 350.f,400.f},
				movement<float, quadratic_out>{100ms, 400.f,350.f},
				movement<float, quadratic_out>{500ms, 350.f,350.f},

				movement<float, quadratic_out>{100ms, 350.f,420.f},
				movement<float, motion::quadratic_curve>{200ms, 420.f,350.f},
				movement<float, quadratic_out>{100ms, 350.f,350.f},
				movement<float, quadratic_out>{100ms, 350.f,750.f},
				movement<float, motion::quadratic_curve>{200ms, 750.f,350.f},
				movement<float, quadratic_out>{90ms, 350.f,350.f},
				movement<float, quadratic_out>{10ms, 350.f,0.f},

				movement<float>{800ms, 0.f,0.f},

				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},

			}
		](auto tick) mutable
		{
			motion::loop(freq, musac, Program::duration(tick));
			time += tick * (freq/3);
			time = support::wrap(time,1.f);
			return stairwave(time) * 0.3f;
		},
	0ms});

	program.request_wave({
		[
			time = 0.f, freq = 0.f,
			musac = motion::melody
			{

				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},

				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},

				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},
				movement<float>{800ms, 0.f,0.f},

				movement<float, quadratic_out>{400ms, 0.f, 1350.f},
				movement<float, quadratic_out>{400ms, 1350.f,1000.f},
				movement<float, quadratic_out>{400ms, 1000.f, 1200.f},
				movement<float, quadratic_out>{400ms, 1200.f, 350.f},
				movement<float, quadratic_out>{400ms, 350.f,1000.f},
				movement<float, quadratic_out>{400ms, 1000.f, 0.f},

				movement<float>{800ms, 0.f,0.f},


			}
		](auto tick) mutable
		{
			motion::loop(freq, musac, Program::duration(tick));
			time += tick * (freq/3);
			time = support::wrap(time,1.f);
			return stairwave(time) * 0.1f;
		},
	0ms});

}