2010-11-27 00:02:21 +01:00
|
|
|
/*
|
2013-02-24 18:40:43 +01:00
|
|
|
Minetest
|
2013-02-24 19:38:45 +01:00
|
|
|
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
2010-11-29 19:13:04 +01:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
2012-06-05 16:56:56 +02:00
|
|
|
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
|
2010-11-29 19:13:04 +01:00
|
|
|
(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
|
2012-06-05 16:56:56 +02:00
|
|
|
GNU Lesser General Public License for more details.
|
2010-11-29 19:13:04 +01:00
|
|
|
|
2012-06-05 16:56:56 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
2010-11-29 19:13:04 +01:00
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2010-11-27 00:02:21 +01:00
|
|
|
*/
|
|
|
|
|
2017-08-17 22:19:39 +02:00
|
|
|
#pragma once
|
2010-11-27 00:02:21 +01:00
|
|
|
|
2023-12-12 15:30:26 +01:00
|
|
|
#include <vector>
|
2012-06-17 03:00:31 +02:00
|
|
|
#include "irr_v3d.h"
|
2010-11-27 00:02:21 +01:00
|
|
|
#include "mapnode.h"
|
|
|
|
#include "exceptions.h"
|
|
|
|
#include "constants.h"
|
2011-04-10 03:15:10 +02:00
|
|
|
#include "staticobject.h"
|
2012-03-19 01:08:04 +01:00
|
|
|
#include "nodemetadata.h"
|
|
|
|
#include "nodetimer.h"
|
2011-11-27 23:45:34 +01:00
|
|
|
#include "modifiedstate.h"
|
2012-06-17 01:40:36 +02:00
|
|
|
#include "util/numeric.h" // getContainerPos
|
2015-07-13 17:01:31 +02:00
|
|
|
#include "settings.h"
|
2011-06-17 22:20:31 +02:00
|
|
|
|
2011-06-26 00:31:43 +02:00
|
|
|
class Map;
|
2011-11-13 11:54:33 +01:00
|
|
|
class NodeMetadataList;
|
2011-11-13 23:19:48 +01:00
|
|
|
class IGameDef;
|
2012-03-13 18:56:12 +01:00
|
|
|
class MapBlockMesh;
|
2013-08-11 04:09:45 +02:00
|
|
|
class VoxelManipulator;
|
2010-11-27 00:02:21 +01:00
|
|
|
|
2011-05-22 16:00:09 +02:00
|
|
|
#define BLOCK_TIMESTAMP_UNDEFINED 0xffffffff
|
2011-04-03 18:50:54 +02:00
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
////
|
|
|
|
//// MapBlock modified reason flags
|
|
|
|
////
|
|
|
|
|
|
|
|
#define MOD_REASON_INITIAL (1 << 0)
|
|
|
|
#define MOD_REASON_REALLOCATE (1 << 1)
|
|
|
|
#define MOD_REASON_SET_IS_UNDERGROUND (1 << 2)
|
2016-10-27 23:25:44 +02:00
|
|
|
#define MOD_REASON_SET_LIGHTING_COMPLETE (1 << 3)
|
2015-05-18 04:14:26 +02:00
|
|
|
#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)
|
2017-09-23 17:05:55 +02:00
|
|
|
#define MOD_REASON_VMANIP (1 << 19)
|
|
|
|
#define MOD_REASON_UNKNOWN (1 << 20)
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
////
|
|
|
|
//// MapBlock itself
|
|
|
|
////
|
2011-04-03 18:50:54 +02:00
|
|
|
|
2017-06-17 19:11:28 +02:00
|
|
|
class MapBlock
|
2010-11-27 00:02:21 +01:00
|
|
|
{
|
|
|
|
public:
|
2023-12-12 15:43:39 +01:00
|
|
|
MapBlock(v3s16 pos, IGameDef *gamedef);
|
2010-12-19 15:51:45 +01:00
|
|
|
~MapBlock();
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2023-03-24 12:34:44 +01:00
|
|
|
// Any server-modding code can "delete" arbitrary blocks (i.e. with
|
|
|
|
// core.delete_area), which makes them orphan. Avoid using orphan blocks for
|
|
|
|
// anything.
|
|
|
|
bool isOrphan() const
|
|
|
|
{
|
2023-12-12 15:43:39 +01:00
|
|
|
return m_orphan;
|
2023-03-24 12:34:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void makeOrphan()
|
|
|
|
{
|
2023-12-12 15:43:39 +01:00
|
|
|
m_orphan = true;
|
2023-03-24 12:34:44 +01:00
|
|
|
}
|
|
|
|
|
2011-01-30 00:44:54 +01:00
|
|
|
void reallocate()
|
|
|
|
{
|
2015-05-31 06:23:10 +02:00
|
|
|
for (u32 i = 0; i < nodecount; i++)
|
2011-06-25 03:25:14 +02:00
|
|
|
data[i] = MapNode(CONTENT_IGNORE);
|
2015-05-18 04:14:26 +02:00
|
|
|
raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_REALLOCATE);
|
2010-11-27 00:02:21 +01:00
|
|
|
}
|
2011-11-27 23:45:34 +01:00
|
|
|
|
2017-04-15 09:55:52 +02:00
|
|
|
MapNode* getData()
|
|
|
|
{
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
////
|
|
|
|
//// Modification tracking methods
|
|
|
|
////
|
|
|
|
void raiseModified(u32 mod, u32 reason=MOD_REASON_UNKNOWN)
|
2015-01-13 15:19:54 +01:00
|
|
|
{
|
2015-05-18 04:14:26 +02:00
|
|
|
if (mod > m_modified) {
|
2015-01-13 15:19:54 +01:00
|
|
|
m_modified = mod;
|
|
|
|
m_modified_reason = reason;
|
2015-05-18 04:14:26 +02:00
|
|
|
if (m_modified >= MOD_STATE_WRITE_AT_UNLOAD)
|
2015-01-13 15:19:54 +01:00
|
|
|
m_disk_timestamp = m_timestamp;
|
2015-05-18 04:14:26 +02:00
|
|
|
} else if (mod == m_modified) {
|
|
|
|
m_modified_reason |= reason;
|
2015-01-13 15:19:54 +01:00
|
|
|
}
|
2018-07-21 12:07:43 +02:00
|
|
|
if (mod == MOD_STATE_WRITE_NEEDED)
|
|
|
|
contents_cached = false;
|
2015-01-13 15:19:54 +01:00
|
|
|
}
|
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
inline u32 getModified()
|
2011-06-25 03:25:14 +02:00
|
|
|
{
|
|
|
|
return m_modified;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline u32 getModifiedReason()
|
2011-11-21 12:29:16 +01:00
|
|
|
{
|
|
|
|
return m_modified_reason;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
std::string getModifiedReasonString();
|
|
|
|
|
|
|
|
inline void resetModified()
|
2011-06-25 03:25:14 +02:00
|
|
|
{
|
|
|
|
m_modified = MOD_STATE_CLEAN;
|
2015-05-18 04:14:26 +02:00
|
|
|
m_modified_reason = 0;
|
2011-06-25 03:25:14 +02:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
////
|
|
|
|
//// Flags
|
|
|
|
////
|
|
|
|
|
2011-06-25 03:25:14 +02:00
|
|
|
// is_underground getter/setter
|
2015-05-18 04:14:26 +02:00
|
|
|
inline bool getIsUnderground()
|
2011-01-30 00:44:54 +01:00
|
|
|
{
|
|
|
|
return is_underground;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline void setIsUnderground(bool a_is_underground)
|
2011-01-30 00:44:54 +01:00
|
|
|
{
|
|
|
|
is_underground = a_is_underground;
|
2015-05-18 04:14:26 +02:00
|
|
|
raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_IS_UNDERGROUND);
|
2011-01-30 00:44:54 +01:00
|
|
|
}
|
|
|
|
|
2016-10-27 23:25:44 +02:00
|
|
|
inline void setLightingComplete(u16 newflags)
|
2011-01-30 00:44:54 +01:00
|
|
|
{
|
2016-10-27 23:25:44 +02:00
|
|
|
if (newflags != m_lighting_complete) {
|
|
|
|
m_lighting_complete = newflags;
|
|
|
|
raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_LIGHTING_COMPLETE);
|
2011-10-12 09:53:37 +02:00
|
|
|
}
|
2011-01-30 00:44:54 +01:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2016-10-27 23:25:44 +02:00
|
|
|
inline u16 getLightingComplete()
|
2011-01-30 00:44:54 +01:00
|
|
|
{
|
2016-10-27 23:25:44 +02:00
|
|
|
return m_lighting_complete;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void setLightingComplete(LightBank bank, u8 direction,
|
|
|
|
bool is_complete)
|
|
|
|
{
|
|
|
|
assert(direction >= 0 && direction <= 5);
|
|
|
|
if (bank == LIGHTBANK_NIGHT) {
|
|
|
|
direction += 6;
|
|
|
|
}
|
|
|
|
u16 newflags = m_lighting_complete;
|
|
|
|
if (is_complete) {
|
|
|
|
newflags |= 1 << direction;
|
|
|
|
} else {
|
|
|
|
newflags &= ~(1 << direction);
|
|
|
|
}
|
|
|
|
setLightingComplete(newflags);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool isLightingComplete(LightBank bank, u8 direction)
|
|
|
|
{
|
|
|
|
assert(direction >= 0 && direction <= 5);
|
|
|
|
if (bank == LIGHTBANK_NIGHT) {
|
|
|
|
direction += 6;
|
|
|
|
}
|
|
|
|
return (m_lighting_complete & (1 << direction)) != 0;
|
2011-01-30 00:44:54 +01:00
|
|
|
}
|
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
inline bool isGenerated()
|
2011-04-02 19:55:22 +02:00
|
|
|
{
|
2011-06-25 03:25:14 +02:00
|
|
|
return m_generated;
|
2011-04-02 19:55:22 +02:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline void setGenerated(bool b)
|
2011-04-02 19:55:22 +02:00
|
|
|
{
|
2015-05-18 04:14:26 +02:00
|
|
|
if (b != m_generated) {
|
|
|
|
raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_GENERATED);
|
2011-10-12 09:53:37 +02:00
|
|
|
m_generated = b;
|
|
|
|
}
|
2011-06-25 03:25:14 +02:00
|
|
|
}
|
2011-04-02 19:55:22 +02:00
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
////
|
|
|
|
//// Position stuff
|
|
|
|
////
|
2011-01-30 00:44:54 +01:00
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
inline v3s16 getPos()
|
2010-11-27 00:02:21 +01:00
|
|
|
{
|
|
|
|
return m_pos;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline v3s16 getPosRelative()
|
2010-11-27 00:02:21 +01:00
|
|
|
{
|
2015-07-29 10:49:40 +02:00
|
|
|
return m_pos_relative;
|
2010-11-27 00:02:21 +01:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline core::aabbox3d<s16> getBox()
|
2010-11-27 00:02:21 +01:00
|
|
|
{
|
|
|
|
return core::aabbox3d<s16>(getPosRelative(),
|
|
|
|
getPosRelative()
|
|
|
|
+ v3s16(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE)
|
|
|
|
- v3s16(1,1,1));
|
|
|
|
}
|
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
////
|
|
|
|
//// Regular MapNode get-setters
|
|
|
|
////
|
|
|
|
|
|
|
|
inline bool isValidPosition(s16 x, s16 y, s16 z)
|
2014-11-14 09:05:34 +01:00
|
|
|
{
|
2022-10-05 13:55:33 +02:00
|
|
|
return x >= 0 && x < MAP_BLOCKSIZE
|
2015-05-18 04:14:26 +02:00
|
|
|
&& y >= 0 && y < MAP_BLOCKSIZE
|
|
|
|
&& z >= 0 && z < MAP_BLOCKSIZE;
|
2014-11-14 09:05:34 +01:00
|
|
|
}
|
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
inline bool isValidPosition(v3s16 p)
|
2010-11-27 00:02:21 +01:00
|
|
|
{
|
2014-11-14 09:05:34 +01:00
|
|
|
return isValidPosition(p.X, p.Y, p.Z);
|
2010-11-27 00:02:21 +01:00
|
|
|
}
|
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
inline MapNode getNode(s16 x, s16 y, s16 z, bool *valid_position)
|
2010-11-27 00:02:21 +01:00
|
|
|
{
|
2014-11-14 09:05:34 +01:00
|
|
|
*valid_position = isValidPosition(x, y, z);
|
|
|
|
|
|
|
|
if (!*valid_position)
|
2017-08-19 09:12:54 +02:00
|
|
|
return {CONTENT_IGNORE};
|
2014-11-14 09:05:34 +01:00
|
|
|
|
2015-05-31 06:23:10 +02:00
|
|
|
return data[z * zstride + y * ystride + x];
|
2010-11-27 00:02:21 +01:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline MapNode getNode(v3s16 p, bool *valid_position)
|
2010-11-27 00:02:21 +01:00
|
|
|
{
|
2014-11-14 09:05:34 +01:00
|
|
|
return getNode(p.X, p.Y, p.Z, valid_position);
|
2010-11-27 00:02:21 +01:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline MapNode getNodeNoEx(v3s16 p)
|
2011-05-22 16:00:09 +02:00
|
|
|
{
|
2014-11-14 09:05:34 +01:00
|
|
|
bool is_valid;
|
2017-01-04 20:11:55 +01:00
|
|
|
return getNode(p.X, p.Y, p.Z, &is_valid);
|
2011-05-22 16:00:09 +02:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2022-10-05 13:55:33 +02:00
|
|
|
inline void setNode(s16 x, s16 y, s16 z, MapNode n)
|
2010-11-27 00:02:21 +01:00
|
|
|
{
|
2015-05-18 04:14:26 +02:00
|
|
|
if (!isValidPosition(x, y, z))
|
2010-11-27 00:02:21 +01:00
|
|
|
throw InvalidPositionException();
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
data[z * zstride + y * ystride + x] = n;
|
|
|
|
raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE);
|
2010-11-27 00:02:21 +01:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2022-10-05 13:55:33 +02:00
|
|
|
inline void setNode(v3s16 p, MapNode n)
|
2010-11-27 00:02:21 +01:00
|
|
|
{
|
|
|
|
setNode(p.X, p.Y, p.Z, n);
|
|
|
|
}
|
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
////
|
|
|
|
//// Non-checking variants of the above
|
|
|
|
////
|
2010-11-29 09:52:07 +01:00
|
|
|
|
2022-10-05 13:55:33 +02:00
|
|
|
inline MapNode getNodeNoCheck(s16 x, s16 y, s16 z)
|
2010-11-29 09:52:07 +01:00
|
|
|
{
|
2015-05-18 04:14:26 +02:00
|
|
|
return data[z * zstride + y * ystride + x];
|
2010-11-29 09:52:07 +01:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2022-10-05 13:55:33 +02:00
|
|
|
inline MapNode getNodeNoCheck(v3s16 p)
|
2010-11-29 09:52:07 +01:00
|
|
|
{
|
2022-10-05 13:55:33 +02:00
|
|
|
return getNodeNoCheck(p.X, p.Y, p.Z);
|
2010-11-29 09:52:07 +01:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2022-10-05 13:55:33 +02:00
|
|
|
inline void setNodeNoCheck(s16 x, s16 y, s16 z, MapNode n)
|
2017-01-04 20:11:55 +01:00
|
|
|
{
|
2015-05-18 04:14:26 +02:00
|
|
|
data[z * zstride + y * ystride + x] = n;
|
|
|
|
raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_SET_NODE_NO_CHECK);
|
2010-11-29 09:52:07 +01:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2022-10-05 13:55:33 +02:00
|
|
|
inline void setNodeNoCheck(v3s16 p, MapNode n)
|
2010-11-29 09:52:07 +01:00
|
|
|
{
|
|
|
|
setNodeNoCheck(p.X, p.Y, p.Z, n);
|
|
|
|
}
|
|
|
|
|
2010-12-11 17:11:03 +01:00
|
|
|
// Copies data to VoxelManipulator to getPosRelative()
|
|
|
|
void copyTo(VoxelManipulator &dst);
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2011-02-01 02:06:02 +01:00
|
|
|
// Copies data from VoxelManipulator getPosRelative()
|
|
|
|
void copyFrom(VoxelManipulator &dst);
|
2010-11-27 00:02:21 +01:00
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
// Update day-night lighting difference flag.
|
|
|
|
// Sets m_day_night_differs to appropriate value.
|
|
|
|
// These methods don't care about neighboring blocks.
|
2012-03-28 23:28:48 +02:00
|
|
|
void actuallyUpdateDayNightDiff();
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
// Call this to schedule what the previous function does to be done
|
|
|
|
// when the value is actually needed.
|
2012-03-28 23:28:48 +02:00
|
|
|
void expireDayNightDiff();
|
2010-12-19 15:51:45 +01:00
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
inline bool getDayNightDiff()
|
2010-12-19 15:51:45 +01:00
|
|
|
{
|
2015-05-18 04:14:26 +02:00
|
|
|
if (m_day_night_differs_expired)
|
2012-03-28 23:28:48 +02:00
|
|
|
actuallyUpdateDayNightDiff();
|
2010-12-19 15:51:45 +01:00
|
|
|
return m_day_night_differs;
|
|
|
|
}
|
|
|
|
|
2022-11-03 17:35:31 +01:00
|
|
|
bool onObjectsActivation();
|
|
|
|
bool saveStaticObject(u16 id, const StaticObject &obj, u32 reason);
|
|
|
|
|
|
|
|
void step(float dtime, const std::function<bool(v3s16, MapNode, f32)> &on_timer_cb);
|
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
////
|
|
|
|
//// Timestamp (see m_timestamp)
|
|
|
|
////
|
|
|
|
|
|
|
|
// NOTE: BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
|
|
|
|
|
|
|
|
inline void setTimestamp(u32 time)
|
2011-05-22 16:00:09 +02:00
|
|
|
{
|
|
|
|
m_timestamp = time;
|
2015-05-18 04:14:26 +02:00
|
|
|
raiseModified(MOD_STATE_WRITE_AT_UNLOAD, MOD_REASON_SET_TIMESTAMP);
|
2011-05-22 16:00:09 +02:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline void setTimestampNoChangedFlag(u32 time)
|
2011-06-05 17:57:36 +02:00
|
|
|
{
|
|
|
|
m_timestamp = time;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline u32 getTimestamp()
|
2011-05-22 16:00:09 +02:00
|
|
|
{
|
|
|
|
return m_timestamp;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline u32 getDiskTimestamp()
|
2011-11-27 23:45:34 +01:00
|
|
|
{
|
|
|
|
return m_disk_timestamp;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
////
|
|
|
|
//// Usage timer (see m_usage_timer)
|
|
|
|
////
|
|
|
|
|
|
|
|
inline void resetUsageTimer()
|
2011-06-25 03:25:14 +02:00
|
|
|
{
|
|
|
|
m_usage_timer = 0;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline void incrementUsageTimer(float dtime)
|
2011-06-25 03:25:14 +02:00
|
|
|
{
|
|
|
|
m_usage_timer += dtime;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline float getUsageTimer()
|
2011-06-25 03:25:14 +02:00
|
|
|
{
|
|
|
|
return m_usage_timer;
|
|
|
|
}
|
2012-09-04 08:48:26 +02:00
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
////
|
|
|
|
//// Reference counting (see m_refcount)
|
|
|
|
////
|
|
|
|
|
|
|
|
inline void refGrab()
|
2012-09-04 08:48:26 +02:00
|
|
|
{
|
|
|
|
m_refcount++;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline void refDrop()
|
2012-09-04 08:48:26 +02:00
|
|
|
{
|
|
|
|
m_refcount--;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline int refGet()
|
2012-09-04 08:48:26 +02:00
|
|
|
{
|
|
|
|
return m_refcount;
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
////
|
|
|
|
//// Node Timers
|
|
|
|
////
|
|
|
|
|
2022-10-05 13:55:33 +02:00
|
|
|
inline NodeTimer getNodeTimer(v3s16 p)
|
2015-05-18 04:14:26 +02:00
|
|
|
{
|
2012-07-17 15:00:04 +02:00
|
|
|
return m_node_timers.get(p);
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2022-10-05 13:55:33 +02:00
|
|
|
inline void removeNodeTimer(v3s16 p)
|
2015-05-18 04:14:26 +02:00
|
|
|
{
|
2012-07-17 15:00:04 +02:00
|
|
|
m_node_timers.remove(p);
|
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2016-03-21 12:58:52 +01:00
|
|
|
inline void setNodeTimer(const NodeTimer &t)
|
2015-05-18 04:14:26 +02:00
|
|
|
{
|
2016-03-21 12:58:52 +01:00
|
|
|
m_node_timers.set(t);
|
2012-07-17 15:00:04 +02:00
|
|
|
}
|
2015-05-18 04:14:26 +02:00
|
|
|
|
|
|
|
inline void clearNodeTimers()
|
|
|
|
{
|
2012-07-17 15:00:04 +02:00
|
|
|
m_node_timers.clear();
|
|
|
|
}
|
2011-05-22 16:00:09 +02:00
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
////
|
|
|
|
//// Serialization
|
|
|
|
///
|
|
|
|
|
2011-05-22 16:00:09 +02:00
|
|
|
// These don't write or read version by itself
|
2012-01-21 00:11:44 +01:00
|
|
|
// Set disk to true for on-disk format, false for over-the-network format
|
2015-09-14 06:02:41 +02:00
|
|
|
// Precondition: version >= SER_FMT_VER_LOWEST_WRITE
|
2021-09-01 02:32:31 +02:00
|
|
|
void serialize(std::ostream &result, u8 version, bool disk, int compression_level);
|
2012-01-21 00:11:44 +01:00
|
|
|
// If disk == true: In addition to doing other things, will add
|
|
|
|
// unknown blocks from id-name mapping to wndef
|
|
|
|
void deSerialize(std::istream &is, u8 version, bool disk);
|
2010-12-11 17:11:03 +01:00
|
|
|
|
2017-03-19 08:44:29 +01:00
|
|
|
void serializeNetworkSpecific(std::ostream &os);
|
2013-08-01 22:51:36 +02:00
|
|
|
void deSerializeNetworkSpecific(std::istream &is);
|
2022-11-03 17:35:31 +01:00
|
|
|
|
|
|
|
bool storeActiveObject(u16 id);
|
|
|
|
// clearObject and return removed objects count
|
|
|
|
u32 clearObjects();
|
|
|
|
|
2011-01-30 00:44:54 +01:00
|
|
|
private:
|
2010-12-19 18:11:05 +01:00
|
|
|
/*
|
2011-01-30 00:44:54 +01:00
|
|
|
Private methods
|
2010-12-19 18:11:05 +01:00
|
|
|
*/
|
|
|
|
|
2012-01-21 00:11:44 +01:00
|
|
|
void deSerialize_pre22(std::istream &is, u8 version, bool disk);
|
|
|
|
|
2011-01-30 00:44:54 +01:00
|
|
|
public:
|
|
|
|
/*
|
|
|
|
Public member variables
|
|
|
|
*/
|
|
|
|
|
2011-05-22 16:00:09 +02:00
|
|
|
#ifndef SERVER // Only on client
|
2017-06-17 19:11:28 +02:00
|
|
|
MapBlockMesh *mesh = nullptr;
|
2011-01-30 00:44:54 +01:00
|
|
|
#endif
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2012-03-19 01:08:04 +01:00
|
|
|
NodeMetadataList m_node_metadata;
|
2011-04-10 03:15:10 +02:00
|
|
|
StaticObjectList m_static_objects;
|
2013-07-27 20:34:30 +02:00
|
|
|
|
2015-05-18 04:14:26 +02:00
|
|
|
static const u32 ystride = MAP_BLOCKSIZE;
|
|
|
|
static const u32 zstride = MAP_BLOCKSIZE * MAP_BLOCKSIZE;
|
|
|
|
|
2015-05-31 06:23:10 +02:00
|
|
|
static const u32 nodecount = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
|
|
|
|
|
2018-07-21 12:07:43 +02:00
|
|
|
//// ABM optimizations ////
|
|
|
|
// Cache of content types
|
2023-12-12 15:30:26 +01:00
|
|
|
// This is actually a set but for the small sizes we have a vector should be
|
|
|
|
// more efficient.
|
|
|
|
std::vector<content_t> contents;
|
2018-07-21 12:07:43 +02:00
|
|
|
// True if content types are cached
|
|
|
|
bool contents_cached = false;
|
|
|
|
// True if we never want to cache content types for this block
|
|
|
|
bool do_not_cache_contents = false;
|
2023-01-06 22:31:06 +01:00
|
|
|
// marks the sides which are opaque: 00+Z-Z+Y-Y+X-X
|
|
|
|
u8 solid_sides {0};
|
2018-07-21 12:07:43 +02:00
|
|
|
|
2011-01-30 00:44:54 +01:00
|
|
|
private:
|
|
|
|
/*
|
|
|
|
Private member variables
|
|
|
|
*/
|
|
|
|
|
2010-12-11 17:11:03 +01:00
|
|
|
// Position in blocks on parent
|
|
|
|
v3s16 m_pos;
|
2011-11-14 20:41:30 +01:00
|
|
|
|
2015-07-29 10:49:40 +02:00
|
|
|
/* This is the precalculated m_pos_relative value
|
|
|
|
* This caches the value, improving performance by removing 3 s16 multiplications
|
|
|
|
* at runtime on each getPosRelative call
|
|
|
|
* For a 5 minutes runtime with valgrind this removes 3 * 19M s16 multiplications
|
|
|
|
* The gain can be estimated in Release Build to 3 * 100M multiply operations for 5 mins
|
|
|
|
*/
|
|
|
|
v3s16 m_pos_relative;
|
|
|
|
|
2023-12-12 15:03:34 +01:00
|
|
|
/*
|
|
|
|
* Note that this is not an inline array because that has implications on
|
|
|
|
* heap fragmentation (the array is exactly 16K), CPU caches and/or
|
|
|
|
* optimizability of algorithms working on this array.
|
|
|
|
*/
|
|
|
|
MapNode *const data; // of `nodecount` elements
|
|
|
|
|
2011-11-14 20:41:30 +01:00
|
|
|
IGameDef *m_gamedef;
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2010-12-11 17:11:03 +01:00
|
|
|
/*
|
|
|
|
- On the server, this is used for telling whether the
|
2011-06-25 03:25:14 +02:00
|
|
|
block has been modified from the one on disk.
|
2011-01-30 00:44:54 +01:00
|
|
|
- On the client, this is used for nothing.
|
2010-12-11 17:11:03 +01:00
|
|
|
*/
|
2017-06-17 19:11:28 +02:00
|
|
|
u32 m_modified = MOD_STATE_WRITE_NEEDED;
|
|
|
|
u32 m_modified_reason = MOD_REASON_INITIAL;
|
2011-01-30 00:44:54 +01:00
|
|
|
|
2010-12-11 17:11:03 +01:00
|
|
|
/*
|
2011-01-30 00:44:54 +01:00
|
|
|
When propagating sunlight and the above block doesn't exist,
|
|
|
|
sunlight is assumed if this is false.
|
|
|
|
|
|
|
|
In practice this is set to true if the block is completely
|
|
|
|
undeground with nothing visible above the ground except
|
|
|
|
caves.
|
2010-12-11 17:11:03 +01:00
|
|
|
*/
|
2017-06-17 19:11:28 +02:00
|
|
|
bool is_underground = false;
|
2011-01-30 00:44:54 +01:00
|
|
|
|
2016-10-27 23:25:44 +02:00
|
|
|
/*!
|
|
|
|
* Each bit indicates if light spreading was finished
|
|
|
|
* in a direction. (Because the neighbor could also be unloaded.)
|
2017-04-13 10:19:46 +02:00
|
|
|
* Bits (most significant first):
|
|
|
|
* nothing, nothing, nothing, nothing,
|
|
|
|
* night X-, night Y-, night Z-, night Z+, night Y+, night X+,
|
|
|
|
* day X-, day Y-, day Z-, day Z+, day Y+, day X+.
|
2011-01-30 00:44:54 +01:00
|
|
|
*/
|
2017-06-17 19:11:28 +02:00
|
|
|
u16 m_lighting_complete = 0xFFFF;
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2010-12-19 15:51:45 +01:00
|
|
|
// Whether day and night lighting differs
|
2017-06-17 19:11:28 +02:00
|
|
|
bool m_day_night_differs = false;
|
|
|
|
bool m_day_night_differs_expired = true;
|
2011-06-25 03:25:14 +02:00
|
|
|
|
2023-12-12 15:43:39 +01:00
|
|
|
// see isOrphan()
|
|
|
|
bool m_orphan = false;
|
|
|
|
// Whether mapgen has generated the content of this block (persisted)
|
2017-06-17 19:11:28 +02:00
|
|
|
bool m_generated = false;
|
2015-05-18 04:14:26 +02:00
|
|
|
|
2011-05-22 16:00:09 +02:00
|
|
|
/*
|
|
|
|
When block is removed from active blocks, this is set to gametime.
|
|
|
|
Value BLOCK_TIMESTAMP_UNDEFINED=0xffffffff means there is no timestamp.
|
|
|
|
*/
|
2017-06-17 19:11:28 +02:00
|
|
|
u32 m_timestamp = BLOCK_TIMESTAMP_UNDEFINED;
|
2011-11-27 23:45:34 +01:00
|
|
|
// The on-disk (or to-be on-disk) timestamp value
|
2017-06-17 19:11:28 +02:00
|
|
|
u32 m_disk_timestamp = BLOCK_TIMESTAMP_UNDEFINED;
|
2011-06-25 03:25:14 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
When the block is accessed, this is set to 0.
|
|
|
|
Map will unload the block when this reaches a timeout.
|
|
|
|
*/
|
2017-06-17 19:11:28 +02:00
|
|
|
float m_usage_timer = 0;
|
2012-09-04 08:48:26 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
Reference count; currently used for determining if this block is in
|
|
|
|
the list of blocks to be drawn.
|
|
|
|
*/
|
2017-06-17 19:11:28 +02:00
|
|
|
int m_refcount = 0;
|
2022-10-09 17:55:07 +02:00
|
|
|
|
2022-11-03 17:35:31 +01:00
|
|
|
NodeTimerList m_node_timers;
|
2010-11-27 00:02:21 +01:00
|
|
|
};
|
|
|
|
|
2015-02-17 15:28:49 +01:00
|
|
|
typedef std::vector<MapBlock*> MapBlockVect;
|
|
|
|
|
2015-09-15 18:37:58 +02:00
|
|
|
inline bool objectpos_over_limit(v3f p)
|
|
|
|
{
|
2021-12-17 17:21:14 +01:00
|
|
|
const float max_limit_bs = (MAX_MAP_GENERATION_LIMIT + 0.5f) * BS;
|
2017-03-13 22:35:29 +01:00
|
|
|
return p.X < -max_limit_bs ||
|
|
|
|
p.X > max_limit_bs ||
|
|
|
|
p.Y < -max_limit_bs ||
|
|
|
|
p.Y > max_limit_bs ||
|
|
|
|
p.Z < -max_limit_bs ||
|
|
|
|
p.Z > max_limit_bs;
|
2015-09-15 18:37:58 +02:00
|
|
|
}
|
|
|
|
|
2017-03-13 22:35:29 +01:00
|
|
|
inline bool blockpos_over_max_limit(v3s16 p)
|
|
|
|
{
|
|
|
|
const s16 max_limit_bp = MAX_MAP_GENERATION_LIMIT / MAP_BLOCKSIZE;
|
|
|
|
return p.X < -max_limit_bp ||
|
|
|
|
p.X > max_limit_bp ||
|
|
|
|
p.Y < -max_limit_bp ||
|
|
|
|
p.Y > max_limit_bp ||
|
|
|
|
p.Z < -max_limit_bp ||
|
|
|
|
p.Z > max_limit_bp;
|
|
|
|
}
|
2016-12-27 18:00:47 +01:00
|
|
|
|
2010-11-27 00:02:21 +01:00
|
|
|
/*
|
|
|
|
Returns the position of the block where the node is located
|
|
|
|
*/
|
2022-10-05 13:55:33 +02:00
|
|
|
inline v3s16 getNodeBlockPos(v3s16 p)
|
2010-11-27 00:02:21 +01:00
|
|
|
{
|
|
|
|
return getContainerPos(p, MAP_BLOCKSIZE);
|
|
|
|
}
|
|
|
|
|
2022-10-05 13:55:33 +02:00
|
|
|
inline void getNodeBlockPosWithOffset(v3s16 p, v3s16 &block, v3s16 &offset)
|
2015-01-13 15:19:54 +01:00
|
|
|
{
|
|
|
|
getContainerPosWithOffset(p, MAP_BLOCKSIZE, block, offset);
|
|
|
|
}
|
|
|
|
|
2011-07-24 11:09:33 +02:00
|
|
|
/*
|
|
|
|
Get a quick string to describe what a block actually contains
|
|
|
|
*/
|
|
|
|
std::string analyze_block(MapBlock *block);
|