namespace s3d
{
	template<int32 Oclock>
	struct Polar
	{
	private:

		static constexpr double Clock() noexcept
		{
			return Oclock * (Math::TwoPi / 12);
		}

	public:

		// 中心
		Vec2 center;

		// 半径
		double r;

		// 角度
		double theta;

		//デフォルトコンストラクタ
		Polar() = default;

		//コピーコンストラクタ
		Polar(const Polar& polar) noexcept = default;

		Polar(const Vec2& _center, double _r, double _theta) noexcept
			: center(_center)
			, r(_r)
			, theta(_theta)
		{}

		// 始点と終点を設定し、その関係を極座標で表現します
		Polar(const Vec2& center, const Vec2& pos)
		{
			const Vec2 vec = pos - center;

			*this = Polar(pos, vec.length(), atan2(vec.y, vec.x) - Clock());
		}

		Polar operator +() const noexcept
		{
			return *this;
		}

		Polar operator -() const noexcept
		{
			return rotated(Math::Pi);
		}

		Vec2 operator +(const Vec2& v) const noexcept
		{
			return toVec2() + v;
		}

		Vec2 operator -(const Vec2& v) const noexcept
		{
			return toVec2() - v;
		}

		// 極座標が示す先の座標を取得
		Vec2 toVec2() const
		{
			return center.movedBy(std::sin(theta + Clock()) * r, -std::cos(theta + Clock()) * r);
		}

		Float2 toFloat2() const
		{
			return { center.x + std::sin(theta + Clock()) * r, center.y - std::cos(theta + Clock()) * r };
		}

		operator Vec2() const noexcept
		{
			return toVec2();
		}

		// 始点を移動
		Polar& setCenter(const Vec2& _center)
		{
			center = _center;
			return *this;
		}

		// 極座標が指し示す先を座標で指定し直す
		Polar& setPos(const Vec2& to)
		{
			*this = Polar(center, to);
			return *this;
		}

		// 一時的に回転させる
		Polar rotated(double _theta) const
		{
			Polar polar(*this);
			polar.theta += _theta;
			return polar;
		}

		// 半径を変更した新しいオブジェクトを返す
		Polar resized(double _r) const noexcept
		{
			Polar polar(*this);
			polar.r = _r;
			return polar;
		}

		// 半径に倍率をかけた新しいオブジェクトを返す
		Polar scaled(double _scale) const
		{
			Polar polar(*this);
			polar.r *= _scale;
			return polar;
		}

		// 始点と終点を結んだ線を返す
		Line Polar::getLine() const
		{
			return Line(center, toVec2());
		}
	};

	using Polar3 = Polar<3>;
}

std::array<Shape2D, 2> CreateTriangleFlag(double poleHeight, double poleWidth, double flagHeight, double flagWidth, const Vec2& pos)
{
	const float poleHeightF = static_cast<float>(poleHeight);
	const float poleHalfWidthF = static_cast<float>(poleWidth)*0.5f;
	const float flagHeightF = static_cast<float>(flagHeight);
	const float flagWidthF = static_cast<float>(flagWidth);

	Array<Float2> verticesPole(4, pos);
	Array<uint32> indicesPole(6);
	verticesPole[0].moveBy(-poleHalfWidthF, -poleHeightF);
	verticesPole[1].moveBy(+poleHalfWidthF, -poleHeightF);
	verticesPole[2].moveBy(+poleHalfWidthF, 0.0f);
	verticesPole[3].moveBy(-poleHalfWidthF, 0.0f);
	indicesPole = { 0,1,2, 2,3,0 };

	Array<Float2> verticesFlag(3, verticesPole[1]);
	Array<uint32> indicesFlag(3);

	verticesFlag[1].moveBy(flagWidthF, flagHeightF*0.5f);
	verticesFlag[2].moveBy(0.0f, flagHeightF);
	indicesFlag = { 0,1,2 };

	return { Shape2D{verticesPole,indicesPole}, Shape2D{verticesFlag,indicesFlag} };
}

std::array<Shape2D, 2> CreateRectFlag(double poleHeight, double poleWidth, double flagHeight, double flagWidth, const Vec2& pos)
{
	const float poleHeightF = static_cast<float>(poleHeight);
	const float poleHalfWidthF = static_cast<float>(poleWidth)*0.5f;
	const float flagHeightF = static_cast<float>(flagHeight);
	const float flagWidthF = static_cast<float>(flagWidth);

	Array<Float2> verticesPole(4, pos);
	Array<uint32> indicesPole(6);
	verticesPole[0].moveBy(-poleHalfWidthF, -poleHeightF);
	verticesPole[1].moveBy(+poleHalfWidthF, -poleHeightF);
	verticesPole[2].moveBy(+poleHalfWidthF, 0.0f);
	verticesPole[3].moveBy(-poleHalfWidthF, 0.0f);
	indicesPole = { 0,1,2, 2,3,0 };

	Array<Float2> verticesFlag(4, verticesPole[1]);
	Array<uint32> indicesFlag(6);

	verticesFlag[1].moveBy(flagWidthF, 0.0f);
	verticesFlag[2].moveBy(flagWidthF, flagHeightF);
	verticesFlag[3].moveBy(0.0f, flagHeightF);
	indicesFlag = { 0,1,2, 2,3,0 };

	return { Shape2D{ verticesPole,indicesPole }, Shape2D{ verticesFlag,indicesFlag } };
}

std::array<Shape2D, 2> CreateSwallowtailFlag(double poleHeight, double poleWidth, double flagHeight, double flagWidthLarger, double flagWidthSmaller, const Vec2& pos)
{
	const float poleHeightF = static_cast<float>(poleHeight);
	const float poleHalfWidthF = static_cast<float>(poleWidth)*0.5f;
	const float flagHeightF = static_cast<float>(flagHeight);
	const float flagWidthLargerF = static_cast<float>(flagWidthLarger);
	const float flagWidthSmallerF = static_cast<float>(flagWidthSmaller);

	Array<Float2> verticesPole(4, pos);
	Array<uint32> indicesPole(6);
	verticesPole[0].moveBy(-poleHalfWidthF, -poleHeightF);
	verticesPole[1].moveBy(+poleHalfWidthF, -poleHeightF);
	verticesPole[2].moveBy(+poleHalfWidthF, 0.0f);
	verticesPole[3].moveBy(-poleHalfWidthF, 0.0f);
	indicesPole = { 0,1,2, 2,3,0 };

	Array<Float2> verticesFlag(5, verticesPole[1]);
	Array<uint32> indicesFlag(9);

	verticesFlag[1].moveBy(flagWidthLargerF, 0.0f);
	verticesFlag[2].moveBy(flagWidthSmallerF, flagHeightF*0.5f);
	verticesFlag[3].moveBy(flagWidthLargerF, flagHeightF);
	verticesFlag[4].moveBy(0.0f, flagHeightF);
	indicesFlag = { 0,1,2, 2,3,4, 4,0,2 };

	return { Shape2D{ verticesPole,indicesPole }, Shape2D{ verticesFlag,indicesFlag } };
}

struct Hoge {
	double operator () (const Vec2& v) {
		return v.x;
	}

	String operator () (Vec2&& v) {
		return Format(v);
	}
};

Array<Vec2> arr = f();

auto newArr = arr.map(Hoge{});

template <class Fty>
auto map(Fty f) const
	-> Array<decltype(f(*this[0]))>
{
	Array<decltype(f(*this[0]))> new_array;

	new_array.reserve(size());

	for (const auto& v : *this)
	{
		new_array.push_back(f(v));
	}

	return new_array;
}

# include <Siv3D.hpp>
# include <HamFramework.hpp>

namespace s3d
{
	namespace Trump
	{
		enum Mark
		{
			Spade,
			Heart,
			Clover,
			Diamond,
			Joker,
		};


		struct Card
		{
			Font font;
			Vec2 size;
			Mark mark;
			int32 number;

			Card() = default;

			explicit constexpr Card(const Font& _font, const Vec2& _size, Mark _mark, int32 _number = 1) noexcept
				: font(_font)
				, size(_size)
				, mark(_mark)
				, number(_number)
			{
				assert(InRange(_number, 1, 13) || _mark == Joker);
			}

			void drawAt(const Vec2& center) const
			{
				static const String numbercs[13] = {L"A",L"2",L"3",L"4",L"5",L"6",L"7",L"8",L"9",L"10",L"J",L"Q",L"K"};
				const RectF rect(Arg::center = center, size);

				RoundRect(rect,rect.w*0.05).draw();

				if (mark != Joker)
				{
					const Color color = mark % 2 ? Palette::Red : Palette::Black;
					const wchar markc = L"♠♥♣♦J"[mark];
					const String numberc = numbercs[number - 1];

					font(markc, numberc).drawAt(rect.center(), color);
				}
				else
				{
					font(L"♋").drawAt(rect.center(), Palette::Black);
				}
			}
		};

		class TrumpSet
		{
		private:
			
			Font m_font = Font(15);
			Vec2 m_size = Vec2(50*1,50*1.618);

		public:

			TrumpSet() = default;

			Card operator()(Mark _mark, int32 _number = 1) const
			{
				return Card(m_font,m_size,_mark,_number);
			}

//			Card operator()(const String& card)
//			{}
		};
	}
}

void Hoge(Trump::Card card)
{}
void Main()
{
	Window::Resize(1280, 720);

	const Trump::TrumpSet trump;

	while (System::Update())
	{
		if (KeyP.down())
		{
			ScreenCapture::SaveCurrentFrame();
		}
		for (auto i : Range(1, 13))
		{
			trump(Trump::Spade, i)	.drawAt(Vec2(50 + i * 55, 50 + 100 * 0));
			trump(Trump::Heart, i)	.drawAt(Vec2(50 + i * 55, 50 + 100 * 1));
			trump(Trump::Clover, i)	.drawAt(Vec2(50 + i * 55, 50 + 100 * 2));
			trump(Trump::Diamond, i).drawAt(Vec2(50 + i * 55, 50 + 100 * 3));
			trump(Trump::Joker, i)	.drawAt(Vec2(50 + i * 55, 50 + 100 * 4));
		}
	}
}

# include <Siv3D.hpp> // OpenSiv3D v0.1.6

void Main()
{
	const Vec2 p1(0, 1);
	const Vec2 p2(1, 1);

	LineString lineString;

	for (double x = 0; x <= 1.0; x += 0.01)
		lineString.emplace_back(p1.lerp(p2, x).movedBy(0, 1.0*(pow(0.5 - x, 2.0) - 0.25)));

	while (System::Update())
	{
		const auto t = Transformer2D(Mat3x2::Scale(300));

		//描画されない
		lineString.draw(0.1);

		//描画される
		for (int i = 0; i < int(lineString.size() - 1); i++)
			Line(lineString[i], lineString[i + 1]).draw(0.1);
	}
}

[[nodiscrad]] constexpr bool isEnd(const Transition& transition) noexcept
{
	return transition.value() == 1.0 || transition.value() == 0.0;
}

Shape2D CreateDiamond(double w, double h, const Vec2& center = Vec2(0, 0), double angle = 0.0)
{
	Array<Float2> vertices(4, center);
	Array<uint32> indices(6);

	const float halfW = static_cast<float>(w)*0.5f;
	const float halfH = static_cast<float>(h)*0.5f;
	const float angleF = static_cast<float>(angle);
	const float s = std::sin(angleF);
	const float c = std::cos(angleF);

	vertices[0].moveBy(halfH * s, -halfH * c);
	vertices[1].moveBy(halfW * c, halfW * s);
	vertices[2].moveBy(-halfH * s, halfH * c);
	vertices[3].moveBy(-halfW * c, -halfW * s);

	indices = { 0,1,3, 2,3,1 };

	return { vertices, indices };
}

bool Window::SetFullscreen(bool fullscreen, const Optional<Size>& fullscreenResolution = unspecified)

bool Window::SetFullscreen(bool fullscreen, const Optional<Size>& fullscreenResolution = unspecified, WindowResizeOption option = WindowResizeOption::ResizeSceneSize)