Skip to content

Check

Jump to bottom
Kasugaccho edited this page Mar 9, 2019 · 6 revisions

number

#include <cstdint>
#include <cstddef>
#include <array>
#include "DTL.hpp"

int main() {

	using dungeon_t = std::uint8_t;
	constexpr std::size_t x{ 9 };
	constexpr std::size_t y{ 9 };
	constexpr std::size_t layer{ 2 };
	std::array<std::array<dungeon_t, x>, y> matrix{ {} };
	std::array<std::array<std::array<dungeon_t, layer>, x>, y> matrix_layer{ {} };
	std::array<dungeon_t, x*y> matrix_array{ {} };

	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::PointGridField<dungeon_t>().create(matrix);
	dtl::console::output::stl::number(matrix);

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::PointGridField<dungeon_t>().create(matrix, x, y);
	dtl::console::output::normal::number(matrix, x, y);

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::PointGridField<dungeon_t>().create(matrix_array, x, y);
	dtl::console::output::array::number(matrix_array, x, y);

	dtl::utility::rangeBasedFor::init(matrix);
	dtl::generator::common::stl::PointGridField<dungeon_t>().create(matrix);
	dtl::console::output::rangeBasedFor::number(matrix);

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::PointGridField<dungeon_t>().create(matrix_layer, layer);
	dtl::console::output::layer::stl::number(matrix_layer, layer);

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::PointGridField<dungeon_t>().create(matrix_layer, layer, x, y);
	dtl::console::output::layer::normal::number(matrix_layer, layer, x, y);


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::PointGridField<dungeon_t>().create(matrix);
	dtl::console::output::stl::number(matrix, ",");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::PointGridField<dungeon_t>().create(matrix, x, y);
	dtl::console::output::normal::number(matrix, x, y, ",");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::PointGridField<dungeon_t>().create(matrix_array, x, y);
	dtl::console::output::array::number(matrix_array, x, y, ",");

	dtl::utility::rangeBasedFor::init(matrix);
	dtl::generator::common::stl::PointGridField<dungeon_t>().create(matrix);
	dtl::console::output::rangeBasedFor::number(matrix, ",");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::PointGridField<dungeon_t>().create(matrix_layer, layer);
	dtl::console::output::layer::stl::number(matrix_layer, layer, ",");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::PointGridField<dungeon_t>().create(matrix_layer, layer, x, y);
	dtl::console::output::layer::normal::number(matrix_layer, layer, x, y, ",");

	return 0;
}

stringBool

#include <cstdint>
#include <cstddef>
#include <array>
#include "DTL.hpp"

int main() {

	using dungeon_t = std::uint8_t;
	constexpr std::size_t x{ 9 };
	constexpr std::size_t y{ 9 };
	constexpr std::size_t layer{ 2 };
	std::array<std::array<dungeon_t, x>, y> matrix{ {} };
	std::array<std::array<std::array<dungeon_t, layer>, x>, y> matrix_layer{ {} };
	std::array<dungeon_t, x*y> matrix_array{ {} };

	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::PointGridField<dungeon_t>().create(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::PointGridField<dungeon_t>().create(matrix, x, y);
	dtl::console::output::normal::stringBool(matrix, x, y, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::PointGridField<dungeon_t>().create(matrix_array, x, y);
	dtl::console::output::array::stringBool(matrix_array, x, y, "##", "//");

	dtl::utility::rangeBasedFor::init(matrix);
	dtl::generator::common::stl::PointGridField<dungeon_t>().create(matrix);
	dtl::console::output::rangeBasedFor::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::PointGridField<dungeon_t>().create(matrix_layer, layer);
	dtl::console::output::layer::stl::stringBool(matrix_layer, layer, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::PointGridField<dungeon_t>().create(matrix_layer, layer, x, y);
	dtl::console::output::layer::normal::stringBool(matrix_layer, layer, x, y, "##", "//");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::PointGridField<dungeon_t>().create(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//", 2);

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::PointGridField<dungeon_t>().create(matrix, x, y);
	dtl::console::output::normal::stringBool(matrix, x, y, "##", "//", 2);

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::PointGridField<dungeon_t>().create(matrix_array, x, y);
	dtl::console::output::array::stringBool(matrix_array, x, y, "##", "//", 2);

	dtl::utility::rangeBasedFor::init(matrix);
	dtl::generator::common::stl::PointGridField<dungeon_t>().create(matrix);
	//dtl::console::output::rangeBasedFor::stringBool(matrix, "##", "//", 2);

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::PointGridField<dungeon_t>().create(matrix_layer, layer);
	dtl::console::output::layer::stl::stringBool(matrix_layer, layer, "##", "//", 2);

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::PointGridField<dungeon_t>().create(matrix_layer, layer, x, y);
	dtl::console::output::layer::normal::stringBool(matrix_layer, layer, x, y, "##", "//", 2);

	return 0;
}

string

#include <cstdint>
#include <cstddef>
#include <array>
#include "DTL.hpp"

int main() {

	using dungeon_t = std::uint8_t;
	constexpr std::size_t x{ 9 };
	constexpr std::size_t y{ 9 };
	constexpr std::size_t layer{ 2 };
	std::array<std::array<dungeon_t, x>, y> matrix{ {} };
	std::array<std::array<std::array<dungeon_t, layer>, x>, y> matrix_layer{ {} };
	std::array<dungeon_t, x*y> matrix_array{ {} };

	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::PointGridFieldPutBlock<dungeon_t>().create(matrix);
	dtl::console::output::stl::string(matrix, "  ", "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::PointGridFieldPutBlock<dungeon_t>().create(matrix, x, y);
	dtl::console::output::normal::string(matrix, x, y, "  ", "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::PointGridFieldPutBlock<dungeon_t>().create(matrix_array, x, y);
	dtl::console::output::array::string(matrix_array, x, y, "  ", "##", "//");

	dtl::utility::rangeBasedFor::init(matrix);
	dtl::generator::common::stl::PointGridFieldPutBlock<dungeon_t>().create(matrix);
	dtl::console::output::rangeBasedFor::string(matrix, "  ", "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::PointGridFieldPutBlock<dungeon_t>().create(matrix_layer, layer);
	dtl::console::output::layer::stl::string(matrix_layer, layer, "  ", "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::PointGridFieldPutBlock<dungeon_t>().create(matrix_layer, layer, x, y);
	dtl::console::output::layer::normal::string(matrix_layer, layer, x, y, "  ", "##", "//");

	return 0;
}

OneLine

#include <cstdint>
#include <cstddef>
#include <array>
#include "DTL.hpp"

int main() {

	using dungeon_t = std::uint8_t;
	constexpr std::size_t x{ 9 };
	constexpr std::size_t y{ 9 };
	constexpr std::size_t layer{ 2 };
	std::array<std::array<dungeon_t, x>, y> matrix{ {} };
	std::array<std::array<std::array<dungeon_t, layer>, x>, y> matrix_layer{ {} };
	std::array<dungeon_t, x*y> matrix_array{ {} };

	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::OneLineDown<dungeon_t>().create(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::OneLineDown<dungeon_t>().create(matrix, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::OneLineDown<dungeon_t>().create(matrix_array, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::OneLineDown<dungeon_t>().create(matrix_layer, layer);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::OneLineDown<dungeon_t>().create(matrix_layer, layer, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::OneLineUp<dungeon_t>().create(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::OneLineUp<dungeon_t>().create(matrix, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::OneLineUp<dungeon_t>().create(matrix_array, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::OneLineUp<dungeon_t>().create(matrix_layer, layer);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::OneLineUp<dungeon_t>().create(matrix_layer, layer, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::OneLineLeft<dungeon_t>().create(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::OneLineLeft<dungeon_t>().create(matrix, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::OneLineLeft<dungeon_t>().create(matrix_array, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::OneLineLeft<dungeon_t>().create(matrix_layer, layer);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::OneLineLeft<dungeon_t>().create(matrix_layer, layer, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::OneLineRight<dungeon_t>().create(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::OneLineRight<dungeon_t>().create(matrix, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::OneLineRight<dungeon_t>().create(matrix_array, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::OneLineRight<dungeon_t>().create(matrix_layer, layer);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::OneLineRight<dungeon_t>().create(matrix_layer, layer, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");



	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::OneLineDown<dungeon_t>().create(matrix, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::OneLineDown<dungeon_t>().create(matrix, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::OneLineDown<dungeon_t>().create(matrix_array, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::OneLineDown<dungeon_t>().create(matrix_layer, layer, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::OneLineDown<dungeon_t>().create(matrix_layer, layer, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::OneLineUp<dungeon_t>().create(matrix, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::OneLineUp<dungeon_t>().create(matrix, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::OneLineUp<dungeon_t>().create(matrix_array, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::OneLineUp<dungeon_t>().create(matrix_layer, layer, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::OneLineUp<dungeon_t>().create(matrix_layer, layer, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::OneLineLeft<dungeon_t>().create(matrix, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::OneLineLeft<dungeon_t>().create(matrix, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::OneLineLeft<dungeon_t>().create(matrix_array, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::OneLineLeft<dungeon_t>().create(matrix_layer, layer, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::OneLineLeft<dungeon_t>().create(matrix_layer, layer, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::OneLineRight<dungeon_t>().create(matrix, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::OneLineRight<dungeon_t>().create(matrix, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::OneLineRight<dungeon_t>().create(matrix_array, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::OneLineRight<dungeon_t>().create(matrix_layer, layer, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::OneLineRight<dungeon_t>().create(matrix_layer, layer, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");



	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::createOneLineDown(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::createOneLineDown(matrix, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::createOneLineDown(matrix_array, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::createOneLineDown(matrix_layer, layer);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::createOneLineDown(matrix_layer, layer, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::createOneLineUp(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::createOneLineUp(matrix, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::createOneLineUp(matrix_array, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::createOneLineUp(matrix_layer, layer);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::createOneLineUp(matrix_layer, layer, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::createOneLineLeft(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::createOneLineLeft(matrix, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::createOneLineLeft(matrix_array, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::createOneLineLeft(matrix_layer, layer);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::createOneLineLeft(matrix_layer, layer, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::createOneLineRight(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::createOneLineRight(matrix, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::createOneLineRight(matrix_array, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::createOneLineRight(matrix_layer, layer);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::createOneLineRight(matrix_layer, layer, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");



	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::createOneLineDown<dungeon_t>(matrix, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::createOneLineDown<dungeon_t>(matrix, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::createOneLineDown<dungeon_t>(matrix_array, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::createOneLineDown<dungeon_t>(matrix_layer, layer, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::createOneLineDown<dungeon_t>(matrix_layer, layer, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::createOneLineUp<dungeon_t>(matrix, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::createOneLineUp<dungeon_t>(matrix, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::createOneLineUp<dungeon_t>(matrix_array, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::createOneLineUp<dungeon_t>(matrix_layer, layer, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::createOneLineUp<dungeon_t>(matrix_layer, layer, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::createOneLineLeft<dungeon_t>(matrix, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::createOneLineLeft<dungeon_t>(matrix, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::createOneLineLeft<dungeon_t>(matrix_array, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::createOneLineLeft<dungeon_t>(matrix_layer, layer, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::createOneLineLeft<dungeon_t>(matrix_layer, layer, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");


	dtl::utility::stl::init(matrix);
	dtl::generator::common::stl::createOneLineRight<dungeon_t>(matrix, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::common::normal::createOneLineRight<dungeon_t>(matrix, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::common::array::createOneLineRight<dungeon_t>(matrix_array, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::common::layer::stl::createOneLineRight<dungeon_t>(matrix_layer, layer, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::common::layer::normal::createOneLineRight<dungeon_t>(matrix_layer, layer, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	return 0;
}

common

#include <cstdint>
#include <cstddef>
#include <array>
#include "DTL.hpp"

#define TERRAIN_TYPE_NAME common
#define CLASS_NAME PointGridField
#define FUNCTION_NAME createPointGridField

int main() {

	using dungeon_t = std::uint8_t;
	constexpr std::size_t x{ 9 };
	constexpr std::size_t y{ 9 };
	constexpr std::size_t layer{ 2 };
	std::array<std::array<dungeon_t, x>, y> matrix{ {} };
	std::array<std::array<std::array<dungeon_t, layer>, x>, y> matrix_layer{ {} };
	std::array<dungeon_t, x*y> matrix_array{ {} };

	dtl::utility::stl::init(matrix);
	dtl::generator::TERRAIN_TYPE_NAME::stl::CLASS_NAME<dungeon_t>().create(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::normal::CLASS_NAME<dungeon_t>().create(matrix, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::array::CLASS_NAME<dungeon_t>().create(matrix_array, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::TERRAIN_TYPE_NAME::layer::stl::CLASS_NAME<dungeon_t>().create(matrix_layer, layer);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::layer::normal::CLASS_NAME<dungeon_t>().create(matrix_layer, layer, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");



	dtl::utility::stl::init(matrix);
	dtl::generator::TERRAIN_TYPE_NAME::stl::CLASS_NAME<dungeon_t>().create(matrix, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::normal::CLASS_NAME<dungeon_t>().create(matrix, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::array::CLASS_NAME<dungeon_t>().create(matrix_array, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::TERRAIN_TYPE_NAME::layer::stl::CLASS_NAME<dungeon_t>().create(matrix_layer, layer, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::layer::normal::CLASS_NAME<dungeon_t>().create(matrix_layer, layer, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");



	dtl::utility::stl::init(matrix);
	dtl::generator::TERRAIN_TYPE_NAME::stl::FUNCTION_NAME(matrix);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::normal::FUNCTION_NAME(matrix, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::array::FUNCTION_NAME(matrix_array, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::TERRAIN_TYPE_NAME::layer::stl::FUNCTION_NAME(matrix_layer, layer);
	dtl::console::output::stl::stringBool(matrix, "##", "//");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::layer::normal::FUNCTION_NAME(matrix_layer, layer, x, y);
	dtl::console::output::stl::stringBool(matrix, "##", "//");



	dtl::utility::stl::init(matrix);
	dtl::generator::TERRAIN_TYPE_NAME::stl::FUNCTION_NAME<dungeon_t>(matrix, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::normal::FUNCTION_NAME<dungeon_t>(matrix, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::array::FUNCTION_NAME<dungeon_t>(matrix_array, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::stl::init(matrix_layer, layer);
	dtl::generator::TERRAIN_TYPE_NAME::layer::stl::FUNCTION_NAME<dungeon_t>(matrix_layer, layer, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	dtl::utility::layer::normal::init(matrix_layer, layer, x, y);
	dtl::generator::TERRAIN_TYPE_NAME::layer::normal::FUNCTION_NAME<dungeon_t>(matrix_layer, layer, x, y, 2);
	dtl::console::output::stl::string(matrix, "//", "  ", "##");

	return 0;
}

SimpleCellularAutomatonIsland

#include <cstdint>
#include <cstddef>
#include <array>
#include "DTL.hpp"

int main() {

	using dungeon_t = std::uint8_t;
	constexpr std::size_t x{ 64 };
	constexpr std::size_t y{ 64 };
	constexpr std::size_t layer{ 2 };
	std::array<std::array<dungeon_t, x>, y> matrix{ {} };
	std::array<std::array<std::array<dungeon_t, layer>, x>, y> matrix_layer{ {} };
	std::array<dungeon_t, x*y> matrix_array{ {} };

	dtl::utility::stl::init(matrix);
	dtl::generator::terrain::stl::SimpleCellularAutomatonIsland<dungeon_t>().create(matrix, 10);
	dtl::utility::stl::setItem<dungeon_t>(matrix, 10);
	dtl::console::output::stl::string(matrix, "ใƒป", "โ–ก", "โ– ");

	dtl::utility::normal::init(matrix, x, y);
	dtl::generator::terrain::normal::SimpleCellularAutomatonIsland<dungeon_t>().create(matrix, x, y, 10);
	dtl::utility::normal::setItem<dungeon_t>(matrix, x, y, 10);
	dtl::console::output::normal::string(matrix, x, y, "ใƒป", "โ–ก", "โ– ");

	dtl::utility::array::init(matrix_array, x, y);
	dtl::generator::terrain::array::SimpleCellularAutomatonIsland<dungeon_t>().create(matrix_array, x, y, 10);
	dtl::utility::array::setItem<dungeon_t>(matrix_array, x, y, 10);
	dtl::console::output::array::string(matrix_array, x, y, "ใƒป", "โ–ก", "โ– ");

	dtl::utility::layer::stl::init(matrix_layer, 0);
	dtl::generator::terrain::layer::stl::SimpleCellularAutomatonIsland<dungeon_t>().create(matrix_layer, 0, 10);
	dtl::utility::layer::stl::setItem<dungeon_t>(matrix_layer, 0, 10);
	dtl::console::output::layer::stl::string(matrix_layer, 0, "ใƒป", "โ–ก", "โ– ");

	dtl::utility::layer::normal::init(matrix_layer, 0, x, y);
	dtl::generator::terrain::layer::normal::SimpleCellularAutomatonIsland<dungeon_t>().create(matrix_layer, 0, x, y, 10);
	dtl::utility::layer::normal::setItem<dungeon_t>(matrix_layer, 0, x, y, 10);
	dtl::console::output::layer::normal::string(matrix_layer, 0, x, y, "ใƒป", "โ–ก", "โ– ");

	return 0;
}

Copyright (c) 2018-2021 As Project.

Distributed under the Boost Software License, Version 1.0.(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

Menu Language ๐ŸŒ

English ๐Ÿ‡ฌ๐Ÿ‡ง / ๆ—ฅๆœฌ่ชž ๐Ÿ‡ฏ๐Ÿ‡ต

Download ๐Ÿ“ฅ

SDK Downloads ๐Ÿ“ฅ

Unity SDK Downloads ๐Ÿ“ฅ

Web Trial ๐Ÿท

Image Viewer ๐Ÿ“ฅ

Version History ๐Ÿ“œ

Roadmap ๐Ÿ›

API reference ๐Ÿ“š

API reference ๐Ÿ“š

API List ๐Ÿ“‹

Matrix Type ๐Ÿ“ฆ

Terrain Type โ›ฐ

Console Output ๐Ÿ–ฅ

Macro ๐Ÿ“Œ

Old Reference ๐Ÿ“š

GUI Library ๐Ÿ“ฑ

DxLib

openFrameworks

OpenSiv3D

Game Engine ๐ŸŽฎ

Unity โ™ป๏ธ

Unreal Engine โ›Ž

License ๐Ÿ’ณ

View License ๐Ÿ’ณ

Clone this wiki locally