aboutsummaryrefslogtreecommitdiff
path: root/src/database/database.h
blob: b7d5519350441a8e8e37cec08e8cd65319723881 (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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/*
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.
*/

#pragma once

#include <set>
#include <string>
#include <vector>
#include "irr_v3d.h"
#include "irrlichttypes.h"
#include "util/basic_macros.h"

class Database
{
public:
	virtual void beginSave() = 0;
	virtual void endSave() = 0;
	virtual bool initialized() const { return true; }
};

class MapDatabase : public Database
{
public:
	virtual ~MapDatabase() = default;

	virtual bool saveBlock(const v3s16 &pos, const std::string &data) = 0;
	virtual void loadBlock(const v3s16 &pos, std::string *block) = 0;
	virtual bool deleteBlock(const v3s16 &pos) = 0;

	static s64 getBlockAsInteger(const v3s16 &pos);
	static v3s16 getIntegerAsBlock(s64 i);

	virtual void listAllLoadableBlocks(std::vector<v3s16> &dst) = 0;
};

class PlayerSAO;
class RemotePlayer;

class PlayerDatabase
{
public:
	virtual ~PlayerDatabase() = default;

	virtual void savePlayer(RemotePlayer *player) = 0;
	virtual bool loadPlayer(RemotePlayer *player, PlayerSAO *sao) = 0;
	virtual bool removePlayer(const std::string &name) = 0;
	virtual void listPlayers(std::vector<std::string> &res) = 0;
};

struct AuthEntry
{
	u64 id;
	std::string name;
	std::string password;
	std::vector<std::string> privileges;
	s64 last_login;
};

class AuthDatabase
{
public:
	virtual ~AuthDatabase() = default;

	virtual bool getAuth(const std::string &name, AuthEntry &res) = 0;
	virtual bool saveAuth(const AuthEntry &authEntry) = 0;
	virtual bool createAuth(AuthEntry &authEntry) = 0;
	virtual bool deleteAuth(const std::string &name) = 0;
	virtual void listNames(std::vector<std::string> &res) = 0;
	virtual void reload() = 0;
};
m"> */ void blit_back_with_light(ServerMap *map, MMVManip *vm, std::map<v3s16, MapBlock*> *modified_blocks); /*! * Corrects the light in a map block. * For server use only. * * \param block the block to update */ void repair_block_light(ServerMap *map, MapBlock *block, std::map<v3s16, MapBlock*> *modified_blocks); /*! * This class iterates trough voxels that intersect with * a line. The collision detection does not see nodeboxes, * every voxel is a cube and is returned. * This iterator steps to all nodes exactly once. */ struct VoxelLineIterator { public: //! Starting position of the line in world coordinates. v3f m_start_position; //! Direction and length of the line in world coordinates. v3f m_line_vector; /*! * Each component stores the next smallest positive number, by * which multiplying the line's vector gives a vector that ends * on the intersection of two nodes. */ v3f m_next_intersection_multi { 10000.0f, 10000.0f, 10000.0f }; /*! * Each component stores the smallest positive number, by which * m_next_intersection_multi's components can be increased. */ v3f m_intersection_multi_inc { 10000.0f, 10000.0f, 10000.0f }; /*! * Direction of the line. Each component can be -1 or 1 (if a * component of the line's vector is 0, then there will be 1). */ v3s16 m_step_directions { 1, 1, 1 }; //! Position of the current node. v3s16 m_current_node_pos; //! Index of the current node s16 m_current_index = 0; //! Position of the start node. v3s16 m_start_node_pos; //! Index of the last node s16 m_last_index; /*! * Creates a voxel line iterator with the given line. * @param start_position starting point of the line * in voxel coordinates * @param line_vector length and direction of the * line in voxel coordinates. start_position+line_vector * is the end of the line */ VoxelLineIterator(const v3f &start_position,const v3f &line_vector); /*! * Steps to the next voxel. * Updates m_current_node_pos and * m_previous_node_pos. * Note that it works even if hasNext() is false, * continuing the line as a ray. */ void next(); /*! * Returns true if the next voxel intersects the given line. */ inline bool hasNext() const { return m_current_index < m_last_index; } /*! * Returns how many times next() must be called until * voxel==m_current_node_pos. * If voxel does not intersect with the line, * the result is undefined. */ s16 getIndex(v3s16 voxel); }; } // namespace voxalgo