aboutsummaryrefslogtreecommitdiff
path: root/advtrains/debugitems.lua
blob: e672308c5df28d3730201a3658207390c4a0f485 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
minetest.register_tool("advtrains:tunnelborer",
{
	description = "tunnelborer",
	groups = {cracky=1}, -- key=name, value=rating; rating=1..3.
	inventory_image = "drwho_screwdriver.png",
	wield_image = "drwho_screwdriver.png",
	stack_max = 1,
	range = 7.0,
		
	on_place = function(itemstack, placer, pointed_thing)
	
	end,
	--[[
	^ Shall place item and return the leftover itemstack
	^ default: minetest.item_place ]]
	on_use = function(itemstack, user, pointed_thing)
		if pointed_thing.type=="node" then
			for x=-1,1 do
				for y=-1,1 do
					for z=-1,1 do
						minetest.remove_node(vector.add(pointed_thing.under, {x=x, y=y, z=z}))
					end
				end
			end
		end
	end,
}
)

minetest.register_chatcommand("atyaw",
	{
        params = "angledeg conn1 conn2", 
        description = "", 
        func = function(name, param)
			local angledegs, conn1s, conn2s = string.match(param, "^(%S+)%s(%S+)%s(%S+)$")
			if angledegs and conn1s and conn2s then
				local angledeg, conn1, conn2 = angledegs+0,conn1s+0,conn2s+0
				local yaw = angledeg*math.pi/180
				local yaw1 = advtrains.dir_to_angle(conn1)
				local yaw2 = advtrains.dir_to_angle(conn2)
				local adiff1 = advtrains.minAngleDiffRad(yaw, yaw1)
				local adiff2 = advtrains.minAngleDiffRad(yaw, yaw2)
				
				atdebug("yaw1",atfloor(yaw1*180/math.pi))
				atdebug("yaw2",atfloor(yaw2*180/math.pi))
				atdebug("dif1",atfloor(adiff1*180/math.pi))
				atdebug("dif2",atfloor(adiff2*180/math.pi))
				
				minetest.chat_send_all(advtrains.yawToAnyDir(yaw))
				return true, advtrains.yawToDirection(yaw, conn1, conn2)
			end
        end,
})
f='#n312'>312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
/*
Minetest
Copyright (C) 2015-2019 paramat
Copyright (C) 2015-2016 kwolekr, Ryan Kwolek

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/


#include "mapgen.h"
#include <cmath>
#include "voxel.h"
#include "noise.h"
#include "mapblock.h"
#include "mapnode.h"
#include "map.h"
#include "content_sao.h"
#include "nodedef.h"
#include "voxelalgorithms.h"
//#include "profiler.h" // For TimeTaker
#include "settings.h" // For g_settings
#include "emerge.h"
#include "dungeongen.h"
#include "cavegen.h"
#include "mg_biome.h"
#include "mg_ore.h"
#include "mg_decoration.h"
#include "mapgen_fractal.h"


FlagDesc flagdesc_mapgen_fractal[] = {
	{"terrain", MGFRACTAL_TERRAIN},
	{NULL,      0}
};

///////////////////////////////////////////////////////////////////////////////////////


MapgenFractal::MapgenFractal(MapgenFractalParams *params, EmergeManager *emerge)
	: MapgenBasic(MAPGEN_FRACTAL, params, emerge)
{
	spflags          = params->spflags;
	cave_width       = params->cave_width;
	large_cave_depth = params->large_cave_depth;
	lava_depth       = params->lava_depth;
	dungeon_ymin     = params->dungeon_ymin;
	dungeon_ymax     = params->dungeon_ymax;
	fractal          = params->fractal;
	iterations       = params->iterations;
	scale            = params->scale;
	offset           = params->offset;
	slice_w          = params->slice_w;
	julia_x          = params->julia_x;
	julia_y          = params->julia_y;
	julia_z          = params->julia_z;
	julia_w          = params->julia_w;

	//// 2D noise
	if (spflags & MGFRACTAL_TERRAIN)
		noise_seabed = new Noise(&params->np_seabed, seed, csize.X, csize.Z);

	noise_filler_depth = new Noise(&params->np_filler_depth, seed, csize.X, csize.Z);

	//// 3D noise
	MapgenBasic::np_dungeons = params->np_dungeons;
	// Overgeneration to node_min.Y - 1
	MapgenBasic::np_cave1    = params->np_cave1;
	MapgenBasic::np_cave2    = params->np_cave2;

	formula = fractal / 2 + fractal % 2;
	julia   = fractal % 2 == 0;
}


MapgenFractal::~MapgenFractal()
{
	if (noise_seabed)
		delete noise_seabed;

	delete noise_filler_depth;
}


MapgenFractalParams::MapgenFractalParams():
	np_seabed       (-14, 9,   v3f(600, 600, 600), 41900, 5, 0.6, 2.0),
	np_filler_depth (0,   1.2, v3f(150, 150, 150), 261,   3, 0.7, 2.0),
	np_cave1        (0,   12,  v3f(61,  61,  61),  52534, 3, 0.5, 2.0),
	np_cave2        (0,   12,  v3f(67,  67,  67),  10325, 3, 0.5, 2.0),
	np_dungeons     (0.9, 0.5, v3f(500, 500, 500), 0,     2, 0.8, 2.0)
{
}


void MapgenFractalParams::readParams(const Settings *settings)
{
	settings->getFlagStrNoEx("mgfractal_spflags",      spflags, flagdesc_mapgen_fractal);
	settings->getFloatNoEx("mgfractal_cave_width",     cave_width);
	settings->getS16NoEx("mgfractal_large_cave_depth", large_cave_depth);
	settings->getS16NoEx("mgfractal_lava_depth",       lava_depth);
	settings->getS16NoEx("mgfractal_dungeon_ymin",     dungeon_ymin);
	settings->getS16NoEx("mgfractal_dungeon_ymax",     dungeon_ymax);
	settings->getU16NoEx("mgfractal_fractal",          fractal);
	settings->getU16NoEx("mgfractal_iterations",       iterations);
	settings->getV3FNoEx("mgfractal_scale",            scale);
	settings->getV3FNoEx("mgfractal_offset",           offset);
	settings->getFloatNoEx("mgfractal_slice_w",        slice_w);
	settings->getFloatNoEx("mgfractal_julia_x",        julia_x);
	settings->getFloatNoEx("mgfractal_julia_y",        julia_y);
	settings->getFloatNoEx("mgfractal_julia_z",        julia_z);
	settings->getFloatNoEx("mgfractal_julia_w",        julia_w);

	settings->getNoiseParams("mgfractal_np_seabed",       np_seabed);
	settings->getNoiseParams("mgfractal_np_filler_depth", np_filler_depth);
	settings->getNoiseParams("mgfractal_np_cave1",        np_cave1);
	settings->getNoiseParams("mgfractal_np_cave2",        np_cave2);
	settings->getNoiseParams("mgfractal_np_dungeons",     np_dungeons);
}


void MapgenFractalParams::writeParams(Settings *settings) const
{
	settings->setFlagStr("mgfractal_spflags",      spflags, flagdesc_mapgen_fractal, U32_MAX);
	settings->setFloat("mgfractal_cave_width",     cave_width);
	settings->setS16("mgfractal_large_cave_depth", large_cave_depth);
	settings->setS16("mgfractal_lava_depth",       lava_depth);
	settings->setS16("mgfractal_dungeon_ymin",     dungeon_ymin);
	settings->setS16("mgfractal_dungeon_ymax",     dungeon_ymax);
	settings->setU16("mgfractal_fractal",          fractal);
	settings->setU16("mgfractal_iterations",       iterations);
	settings->setV3F("mgfractal_scale",            scale);
	settings->setV3F("mgfractal_offset",           offset);
	settings->setFloat("mgfractal_slice_w",        slice_w);
	settings->setFloat("mgfractal_julia_x",        julia_x);
	settings->setFloat("mgfractal_julia_y",        julia_y);
	settings->setFloat("mgfractal_julia_z",        julia_z);
	settings->setFloat("mgfractal_julia_w",        julia_w);

	settings->setNoiseParams("mgfractal_np_seabed",       np_seabed);
	settings->setNoiseParams("mgfractal_np_filler_depth", np_filler_depth);
	settings->setNoiseParams("mgfractal_np_cave1",        np_cave1);
	settings->setNoiseParams("mgfractal_np_cave2",        np_cave2);
	settings->setNoiseParams("mgfractal_np_dungeons",     np_dungeons);
}


/////////////////////////////////////////////////////////////////


int MapgenFractal::getSpawnLevelAtPoint(v2s16 p)
{
	bool solid_below = false; // Fractal node is present below to spawn on
	u8 air_count = 0; // Consecutive air nodes above a fractal node
	s16 search_start = 0; // No terrain search start

	// If terrain present, don't start search below terrain or water level
	if (noise_seabed) {
		s16 seabed_level = NoisePerlin2D(&noise_seabed->np, p.X, p.Y, seed);
		search_start = MYMAX(search_start, MYMAX(seabed_level, water_level));
	}

	for (s16 y = search_start; y <= search_start + 4096; y++) {
		if (getFractalAtPoint(p.X, y, p.Y)) {
			// Fractal node
			solid_below = true;
			air_count = 0;
		} else if (solid_below) {
			// Air above fractal node
			air_count++;
			// 3 and -2 to account for biome dust nodes
			if (air_count == 3)
				return y - 2;
		}
	}

	return MAX_MAP_GENERATION_LIMIT;  // Unsuitable spawn point
}


void MapgenFractal::makeChunk(BlockMakeData *data)
{
	// Pre-conditions
	assert(data->vmanip);
	assert(data->nodedef);
	assert(data->blockpos_requested.X >= data->blockpos_min.X &&
		data->blockpos_requested.Y >= data->blockpos_min.Y &&
		data->blockpos_requested.Z >= data->blockpos_min.Z);
	assert(data->blockpos_requested.X <= data->blockpos_max.X &&
		data->blockpos_requested.Y <= data->blockpos_max.Y &&
		data->blockpos_requested.Z <= data->blockpos_max.Z);

	//TimeTaker t("makeChunk");

	this->generating = true;
	this->vm = data->vmanip;
	this->ndef = data->nodedef;

	v3s16 blockpos_min = data->blockpos_min;
	v3s16 blockpos_max = data->blockpos_max;
	node_min = blockpos_min * MAP_BLOCKSIZE;
	node_max = (blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
	full_node_min = (blockpos_min - 1) * MAP_BLOCKSIZE;
	full_node_max = (blockpos_max + 2) * MAP_BLOCKSIZE - v3s16(1, 1, 1);

	blockseed = getBlockSeed2(full_node_min, seed);

	// Generate fractal and optional terrain
	s16 stone_surface_max_y = generateTerrain();

	// Create heightmap
	updateHeightmap(node_min, node_max);

	// Init biome generator, place biome-specific nodes, and build biomemap
	if (flags & MG_BIOMES) {
		biomegen->calcBiomeNoise(node_min);
		generateBiomes();
	}

	// Generate tunnels and randomwalk caves
	if (flags & MG_CAVES) {
		generateCavesNoiseIntersection(stone_surface_max_y);
		generateCavesRandomWalk(stone_surface_max_y, large_cave_depth);
	}

	// Generate the registered ores
	m_emerge->oremgr->placeAllOres(this, blockseed, node_min, node_max);

	// Generate dungeons
	if ((flags & MG_DUNGEONS) && full_node_min.Y >= dungeon_ymin &&
			full_node_max.Y <= dungeon_ymax)
		generateDungeons(stone_surface_max_y);

	// Generate the registered decorations
	if (flags & MG_DECORATIONS)
		m_emerge->decomgr->placeAllDecos(this, blockseed, node_min, node_max);

	// Sprinkle some dust on top after everything else was generated
	if (flags & MG_BIOMES)
		dustTopNodes();

	// Update liquids
	if (spflags & MGFRACTAL_TERRAIN)
		updateLiquid(&data->transforming_liquid, full_node_min, full_node_max);

	// Calculate lighting
	if (flags & MG_LIGHT)
		calcLighting(node_min - v3s16(0, 1, 0), node_max + v3s16(0, 1, 0),
			full_node_min, full_node_max);

	this->generating = false;

	//printf("makeChunk: %lums\n", t.stop());
}


bool MapgenFractal::getFractalAtPoint(s16 x, s16 y, s16 z)
{
	float cx, cy, cz, cw, ox, oy, oz, ow;

	if (julia) {  // Julia set
		cx = julia_x;
		cy = julia_y;
		cz = julia_z;
		cw = julia_w;
		ox = (float)x / scale.X - offset.X;
		oy = (float)y / scale.Y - offset.Y;
		oz = (float)z / scale.Z - offset.Z;
		ow = slice_w;
	} else {  // Mandelbrot set
		cx = (float)x / scale.X - offset.X;
		cy = (float)y / scale.Y - offset.Y;
		cz = (float)z / scale.Z - offset.Z;
		cw = slice_w;
		ox = 0.0f;
		oy = 0.0f;
		oz = 0.0f;
		ow = 0.0f;
	}

	float nx = 0.0f;
	float ny = 0.0f;
	float nz = 0.0f;
	float nw = 0.0f;

	for (u16 iter = 0; iter < iterations; iter++) {
		switch (formula) {
		default:
		case 1: // 4D "Roundy"
			nx = ox * ox - oy * oy - oz * oz - ow * ow + cx;
			ny = 2.0f * (ox * oy + oz * ow) + cy;
			nz = 2.0f * (ox * oz + oy * ow) + cz;
			nw = 2.0f * (ox * ow + oy * oz) + cw;
			break;
		case 2: // 4D "Squarry"
			nx = ox * ox - oy * oy - oz * oz - ow * ow + cx;
			ny = 2.0f * (ox * oy + oz * ow) + cy;
			nz = 2.0f * (ox * oz + oy * ow) + cz;
			nw = 2.0f * (ox * ow - oy * oz) + cw;
			break;
		case 3: // 4D "Mandy Cousin"
			nx = ox * ox - oy * oy - oz * oz + ow * ow + cx;
			ny = 2.0f * (ox * oy + oz * ow) + cy;
			nz = 2.0f * (ox * oz + oy * ow) + cz;
			nw = 2.0f * (ox * ow + oy * oz) + cw;
			break;
		case 4: // 4D "Variation"
			nx = ox * ox - oy * oy - oz * oz - ow * ow + cx;
			ny = 2.0f * (ox * oy + oz * ow) + cy;
			nz = 2.0f * (ox * oz - oy * ow) + cz;
			nw = 2.0f * (ox * ow + oy * oz) + cw;
			break;
		case 5: // 3D "Mandelbrot/Mandelbar"
			nx = ox * ox - oy * oy - oz * oz + cx;
			ny = 2.0f * ox * oy + cy;
			nz = -2.0f * ox * oz + cz;
			break;
		case 6: // 3D "Christmas Tree"
			// Altering the formula here is necessary to avoid division by zero
			if (std::fabs(oz) < 0.000000001f) {
				nx = ox * ox - oy * oy - oz * oz + cx;
				ny = 2.0f * oy * ox + cy;
				nz = 4.0f * oz * ox + cz;
			} else {
				float a = (2.0f * ox) / (std::sqrt(oy * oy + oz * oz));
				nx = ox * ox - oy * oy - oz * oz + cx;