index : advtrains.git	atcjit doc l10n luaatcdebug master new-ks new-ks-orwell profiler route_prog_rework techage tracy trainhud trainhud-unifont
	Advtrains mod for minetest.	orwell

aboutsummaryrefslogtreecommitdiff

log msg author committer range

	Commit message (Expand)	Author	Age
...
*	Create models for Ks signals	orwell96	2018-06-14
*	Update nodedb.lua	imcasper	2018-06-14
*	Fix bugs found while testing	orwell96	2018-06-14
*	add option to show train and wagon id	orwell96	2018-06-14
*	Fix final bugs and to-do's (u.a.save/load system)	orwell96	2018-06-14
*	Fix yaw calculations, track placement orientation and speed up direction look...	orwell96	2018-06-14
*	Mainly make collisions and coupling work	orwell96	2018-06-14
*	Implement collisions. (does not work yet, still code errors)	orwell96	2018-06-14
*	Implement a reverse path lookup for trains instead of an occupations window s...	orwell96	2018-06-14
*	Fix path_dir to actually be an angle, path item deletion and orientation of w...	orwell96	2018-06-14
*	Bugfixes part 1	orwell96	2018-06-14
*	Occupation System, new train steps, still incomplete	orwell96	2018-06-14
*	Adapt wagons to new path system	orwell96	2018-06-14
*	Restructure path system	orwell96	2018-06-14
*	make platform creation possible from other mods	Gabriel Pérez-Cerezo	2018-06-10
*	Merge branch 'master' of https://github.com/orwell96/advtrains	Gabriel Pérez-Cerezo	2018-06-10
|\
| *	Write something into description.txt	orwell96	2018-05-25
| *	Add digiline interface and is_passive function to LuaATC	orwell96	2018-04-25
| *	Rework the privilege system completely	orwell96	2018-03-14
* |	Don't blame me for the sounds	Gabriel Pérez-Cerezo	2018-02-22
* |	fixed unmerged stuff	Gabriel Pérez-Cerezo	2018-02-22
* |	Merge https://github.com/orwell96/advtrains into log	Gabriel Pérez-Cerezo	2018-02-22
|\|
| *	Log certain events in a logfile in the world directory	Gabriel Pérez-Cerezo	2018-02-21
| *	Allow wagon owners to drive their trains #2	orwell96	2018-02-20
| *	Allow wagon owners to control their own trains	orwell96	2018-02-20
* |	added separate logging for railway networks	Gabriel Pérez-Cerezo	2018-02-18
|/
*	Do not crash when player gets on a train while it`s turning	orwell96	2018-02-07
*	Simplify /at_reroute	orwell96	2018-01-23
*	Correct discouple position	orwell96	2018-01-22
*	Fix crash	orwell96	2018-01-17
*	Actually use the static_save property	orwell96	2018-01-15
*	Relayout Wagon Properties form	orwell96	2018-01-15
*	Revert assign_to_seat_group order on subway train	orwell96	2018-01-15
*	Add "seat_access" to saved fields	orwell96	2018-01-15
*	Use directory delimter constant	orwell96	2018-01-15
*	Add train_operator privilege check on discouple	orwell96	2018-01-09
*	Add bord computer to trains	orwell96	2018-01-09
*	Move driving_ctrl_access property to seat group	orwell96	2018-01-09
*	Merge branch 'master' of https://github.com/orwell96/advtrains	orwell96	2018-01-07
|\
| *	steam locomotive: Add sounds and improve textures	mbb	2017-12-23
* |	Don't use looped sounds on subway	orwell96	2018-01-07
* |	Change controls for trains (again)	orwell96	2018-01-07
* |	Decrease the amount of garbage saved in save files	orwell96	2018-01-07
|/
*	Remove path invalidation statement.	orwell96	2017-12-18
*	Fix detector lookup in ATC rails	orwell96	2017-12-18
*	Do not spam the server chat with messages from /at_sync_ndb and trains going ...	orwell96	2017-12-18
*	Rewrite rail connection system...	orwell96	2017-12-18
*	Use preferred rail orientation algorithm also for double connections	orwell96	2017-12-18
*	Move train_load() function into advtrains_train_track	orwell96	2017-12-18
*	Try to fix occasional crash when placing wagons	orwell96	2017-12-17

• [prev]
• [next]

generated by cgit v1.2.3 (git 2.39.1) at 2024-12-24 02:28:36 +0000

/*
Minetest
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>

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.
*/

#ifndef MAPBLOCK_HEADER
#define MAPBLOCK_HEADER

#include <set>
#include "debug.h"
#include "irr_v3d.h"
#include "mapnode.h"
#include "exceptions.h"
#include "constants.h"
#include "staticobject.h"
#include "nodemetadata.h"
#include "nodetimer.h"
#include "modifiedstate.h"
#include "util/numeric.h" // getContainerPos
#include "settings.h"

class Map;
class NodeMetadataList;
class IGameDef;
class MapBlockMesh;
class VoxelManipulator;

#define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff

/*// Named by looking towards z+
enum{
	FACE_BACK=0,
	FACE_TOP,
	FACE_RIGHT,
	FACE_FRONT,
	FACE_BOTTOM,
	FACE_LEFT
};*/

// NOTE: If this is enabled, set MapBlock to be initialized with
//       CONTENT_IGNORE.
/*enum BlockGenerationStatus
{
	// Completely non-generated (filled with CONTENT_IGNORE).
	BLOCKGEN_UNTOUCHED=0,
	// Trees or similar might have been blitted from other blocks to here.
	// Otherwise, the block contains CONTENT_IGNORE
	BLOCKGEN_FROM_NEIGHBORS=2,
	// Has been generated, but some neighbors might put some stuff in here
	// when they are generated.
	// Does not contain any CONTENT_IGNORE
	BLOCKGEN_SELF_GENERATED=4,
	// The block and all its neighbors have been generated
	BLOCKGEN_FULLY_GENERATED=6
};*/

#if 0
enum
{
	NODECONTAINER_ID_MAPBLOCK,
	NODECONTAINER_ID_MAPSECTOR,
	NODECONTAINER_ID_MAP,
	NODECONTAINER_ID_MAPBLOCKCACHE,
	NODECONTAINER_ID_VOXELMANIPULATOR,
};

class NodeContainer
{
public:
	virtual bool isValidPosition(v3s16 p) = 0;
	virtual MapNode getNode(v3s16 p) = 0;
	virtual void setNode(v3s16 p, MapNode & n) = 0;
	virtual u16 nodeContainerId() const = 0;

	MapNode getNodeNoEx(v3s16 p)
	{
		try{
			return getNode(p);
		}
		catch(InvalidPositionException &e){
			return MapNode(CONTENT_IGNORE);
		}
	}
};
#endif

////
//// MapBlock modified reason flags
////

#define MOD_REASON_INITIAL                   (1 << 0)
#define MOD_REASON_REALLOCATE                (1 << 1)
#define MOD_REASON_SET_IS_UNDERGROUND        (1 << 2)
#define MOD_REASON_SET_LIGHTING_EXPIRED      (1 << 3)
#define MOD_REASON_SET_GENERATED             (1 << 4)
#define MOD_REASON_SET_NODE                  (1 << 5)
#define MOD_REASON_SET_NODE_NO_CHECK         (1 << 6)
#define MOD_REASON_SET_TIMESTAMP             (1 << 7)
#define MOD_REASON_REPORT_META_CHANGE        (1 << 8)
#define MOD_REASON_CLEAR_ALL_OBJECTS         (1 << 9)
#define MOD_REASON_BLOCK_EXPIRED             (1 << 10)
#define MOD_REASON_ADD_ACTIVE_OBJECT_RAW     (1 << 11)
#define MOD_REASON_REMOVE_OBJECTS_REMOVE     (1 << 12)
#define MOD_REASON_REMOVE_OBJECTS_DEACTIVATE (1 << 13)
#define MOD_REASON_TOO_MANY_OBJECTS          (1 << 14)
#define MOD_REASON_STATIC_DATA_ADDED         (1 << 15)
#define MOD_REASON_STATIC_DATA_REMOVED       (1 << 16)
#define MOD_REASON_STATIC_DATA_CHANGED       (1 << 17)
#define MOD_REASON_EXPIRE_DAYNIGHTDIFF       (1 << 18)
#define MOD_REASON_UNKNOWN                   (1 << 19)

////
//// MapBlock itself
////

class MapBlock /*: public NodeContainer*/
{
public:
	MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy=false);
	~MapBlock();

	/*virtual u16 nodeContainerId() const
	{
		return NODECONTAINER_ID_MAPBLOCK;
	}*/

	Map * getParent()
	{
		return m_parent;
	}

	void reallocate()
	{
		delete[] data;
		data = new MapNode[nodecount];
		for (u32 i = 0; i < nodecount; i++)
			data[i] = MapNode(CONTENT_IGNORE);

		raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_REALLOCATE);
	}

	////
	//// Modification tracking methods
	////
	void raiseModified(u32 mod, u32 reason=MOD_REASON_UNKNOWN)
	{
		if (mod > m_modified) {
			m_modified = mod;
			m_modified_reason = reason;
			if (m_modified >= MOD_STATE_WRITE_AT_UNLOAD)
				m_disk_timestamp = m_timestamp;
		} else if (mod == m_modified) {
			m_modified_reason |= reason;
		}
	}

	inline u32 getModified()
	{
		return m_modified;
	}

	inline u32 getModifiedReason()
	{
		return m_modified_reason;
	}

	std::string getModifiedReasonString();

	inline void resetModified()
	{
		m_modified = MOD_STATE_CLEAN;
		m_modified_reason = 0;
	}

	////
	//// Flags
	////

	inline bool isDummy()
	{
		return (data == NULL);
	}

	inline void unDummify()
	{
		assert(isDummy()); // Pre-condition
		reallocate();
	}

	// is_underground getter/setter
	inline bool getIsUnderground()
	{
		return is_underground;
	}

	inline void setIsUnderground(bool a_is_underground)
	{
		is_underground = a_is_underground;
		raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_IS_UNDERGROUND);
	}

	inline void setLightingExpired(bool expired)
	{
		if (expired != m_lighting_expired){
			m_lighting_expired = expired;
			raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_EXPIRED);
		}
	}

	inline bool getLightingExpired()
	{
		return m_lighting_expired;
	}

	inline bool isGenerated()
	{
		return m_generated;
	}

	inline void setGenerated(bool b)
	{
		if (b != m_generated) {
			raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_GENERATED);
			m_generated = b;
		}
	}

	inline bool isValid()
	{
		if (m_lighting_expired)
			return false;
		if (data == NULL)
			return false;
		return true;
	}

	////
	//// Position stuff
	////

	inline v3s16 getPos()
	{
		return m_pos;
	}

	inline v3s16 getPosRelative()
	{
		return m_pos_relative;
	}

	inline core::aabbox3d<s16> getBox()
	{
		return core::aabbox3d<s16>(getPosRelative(),
				getPosRelative()
				+ v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE)
				- v3s16(1,1,1));
	}

	////
	//// Regular MapNode get-setters
	////

	inline bool isValidPosition(s16 x, s16 y, s16 z)
	{
		return data != NULL
			&& x >= 0 && x < MAP_BLOCKSIZE
			&& y >= 0 && y < MAP_BLOCKSIZE
			&& z >= 0 && z < MAP_BLOCKSIZE;
	}

	inline bool isValidPosition(v3s16 p)
	{
		return isValidPosition(p.X, p.Y, p.Z);
	}

	inline MapNode getNode(s16 x, s16 y, s16 z, bool *valid_position)
	{
		*valid_position = isValidPosition(x, y, z);

		if (!*valid_position)
			return MapNode(CONTENT_IGNORE);

		return data[z * zstride + y * ystride + x];
	}

	inline MapNode getNode(v3s16 p, bool *valid_position)
	{
		return getNode(p.X, p.Y, p.Z, valid_position);
	}

	inline MapNode getNodeNoEx(v3s16 p)
	{
		bool is_valid;
		return getNode(p.X, p.Y, p.Z, &is_valid);
	}

	inline void setNode(s16 x, s16 y, s16 z, MapNode & n)
	{
		if (!isValidPosition(x, y, z))
			throw InvalidPositionException();

		data[z * zstride + y * ystride + x] = n;
		raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE);
	}

	inline void setNode(v3s16 p, MapNode & n)
	{
		setNode(p.X, p.Y, p.Z, n);
	}

	////
	//// Non-checking variants of the above
	////

	inline MapNode getNodeNoCheck(s16 x, s16 y, s16 z, bool *valid_position)
	{
		*valid_position = data != NULL;
		if (!valid_position)
			return MapNode(CONTENT_IGNORE);

		return data[z * zstride + y * ystride + x];
	}

	inline MapNode getNodeNoCheck(v3s16 p, bool *valid_position)
	{
		return getNodeNoCheck(p.X, p.Y, p.Z, valid_position);
	}

	////
	//// Non-checking, unsafe variants of the above
	//// MapBlock must be loaded by another function in the same scope/function
	//// Caller must ensure that this is not a dummy block (by calling isDummy())
	////

	inline const MapNode &getNodeUnsafe(s16 x, s16 y, s16 z)
	{
		return data[z * zstride + y * ystride + x];
	}

	inline const MapNode &getNodeUnsafe(v3s16 &p)
	{
		return getNodeUnsafe(p.X, p.Y, p.Z);
	}

	inline void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode & n)
	{
		if (data == NULL)
			throw InvalidPositionException();

		data[z * zstride + y * ystride + x] = n;
		raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE_NO_CHECK);
	}

	inline void setNodeNoCheck(v3s16 p, MapNode & n)
	{
		setNodeNoCheck(p.X, p.Y, p.Z, n);
	}

	// These functions consult the parent container if the position
	// is not valid on this MapBlock.
	bool isValidPositionParent(v3s16 p);
	MapNode getNodeParent(v3s16 p, bool *is_valid_position = NULL);
	void setNodeParent(v3s16 p, MapNode & n);

	inline void drawbox(s16 x0, s16 y0, s16 z0, s16 w, s16 h, s16 d, MapNode node)
	{
		for (u16 z = 0; z < d; z++)
		for (u16 y = 0; y < h; y++)
		for (u16 x = 0; x < w; x++)
			setNode(x0 + x, y0 + y, z0 + z, node);
	}

	// See comments in mapblock.cpp
	bool propagateSunlight(std::set<v3s16> &light_sources,
		bool remove_light=false, bool *black_air_left=NULL);

	// Copies data to VoxelManipulator to getPosRelative()