Block placement constraints implemented. Closed #137.

Author: Unarelith

docs/lua-api-block.md

@@ -208,6 +208,21 @@ name = "Cobblestone"
 
 This label is the name that will appear everywhere in the game.
 
+### `placement_constraints`
+
+Constraints for the placement of the block.
+
+Example:
+```lua
+placement_constraints = {
+	-- ensure that the block below is farmland
+	[{0, 0, -1}] = {
+		block = "default:farmland",
+		is_whitelist = true
+	}
+}
+```
+
 ### `states`
 
 Optional table containing block state definitions.

mods/default/blocks.lua

@@ -364,6 +364,7 @@ mod:block {
 	is_opaque = false,
 	groups = {
 		om_material_dirt = 1,
+		om_farmland = 1
 	},
 
 	states = {
@@ -395,6 +396,13 @@ mod:block {
 	inventory_image = "nether_wart.png",
 	hardness = 0,
 
+	placement_constraints = {
+		[{0, 0, -1}] = {
+			block = "default:soul_sand",
+			is_whitelist = true
+		}
+	},
+
 	bounding_box = {0, 0, 0, 1, 1, 4.0 / 16.0},
 	draw_offset = {0, 0, -1.0 / 16.0},
 
@@ -436,6 +444,13 @@ mod:block {
 	inventory_image = "seeds_wheat.png",
 	hardness = 0,
 
+	placement_constraints = {
+		[{0, 0, -1}] = {
+			block = "default:farmland",
+			is_whitelist = true
+		}
+	},
+
 	bounding_box = {0, 0, 0, 1, 1, 1.0 / 16.0},
 	draw_offset = {0, 0, -1.0 / 16.0},
 

source/client/hud/BlockCursor.cpp

@@ -107,7 +107,7 @@ void BlockCursor::onEvent(const SDL_Event &event, const Hotbar &hotbar) {
 					const BlockState &newBlockState = newBlock.getState(0); // FIXME: Get state from item stack
 					gk::FloatBox boundingBox = newBlockState.boundingBox() + gk::Vector3f(x - m_player.x(), y - m_player.y(), z - m_player.z());
 					gk::FloatBox playerBoundingBox = m_player.hitbox();
-					if (!boundingBox.intersects(playerBoundingBox)) {
+					if (!boundingBox.intersects(playerBoundingBox) && newBlock.placementConstraints().check(m_world, {x, y, z})) {
 						u32 block = hotbar.currentItem().id();
 						if (newBlock.isRotatable()) {
 							u16 data = m_player.getOppositeDirection() & 0x3;

source/common/world/Block.cpp

@@ -49,13 +49,15 @@ const TilesDef &Block::tiles(u16 stateID) const {
 
 void Block::serialize(sf::Packet &packet) const {
 	packet << u32(m_id) << m_stringID << m_canUpdate << m_canBeActivated
-		<< m_isRotatable << m_groups << m_states << m_param << m_customParamBits;
+		<< m_isRotatable << m_groups << m_states << m_param << m_customParamBits
+		<< m_placementConstraints;
 }
 
 void Block::deserialize(sf::Packet &packet) {
 	u32 id;
 	packet >> id >> m_stringID >> m_canUpdate >> m_canBeActivated
-		>> m_isRotatable >> m_groups >> m_states >> m_param >> m_customParamBits;
+		>> m_isRotatable >> m_groups >> m_states >> m_param >> m_customParamBits
+		>> m_placementConstraints;
 	m_id = id;
 
 	for (auto &it : m_states) {

source/common/world/Block.hpp

@@ -39,6 +39,7 @@
 #include <gk/graphics/Color.hpp>
 
 #include "BlockParam.hpp"
+#include "BlockPlacementConstraints.hpp"
 #include "BlockState.hpp"
 #include "ItemStack.hpp"
 #include "TilesDef.hpp"
@@ -91,6 +92,9 @@ class Block : public gk::ISerializable {
 		u8 customParamBits() const { return m_customParamBits; }
 		void setCustomParamBits(u8 customParamBits) { m_customParamBits = customParamBits; }
 
+		BlockPlacementConstraints &placementConstraints() { return m_placementConstraints; }
+		const BlockPlacementConstraints &placementConstraints() const { return m_placementConstraints; }
+
 		static void initUsertype(sol::state &lua);
 
 	protected:
@@ -112,6 +116,8 @@ class Block : public gk::ISerializable {
 		BlockParam m_param{*this};
 
 		u8 m_customParamBits = 0;
+
+		BlockPlacementConstraints m_placementConstraints;
 };
 
 #endif // BLOCK_HPP_

source/common/world/BlockPlacementConstraints.cpp

@@ -0,0 +1,55 @@
+/*
+ * =====================================================================================
+ *
+ *  OpenMiner
+ *
+ *  Copyright (C) 2018-2020 Unarelith, Quentin Bazin <[email protected]>
+ *  Copyright (C) 2019-2020 the OpenMiner contributors (see CONTRIBUTORS.md)
+ *
+ *  This file is part of OpenMiner.
+ *
+ *  OpenMiner 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.
+ *
+ *  OpenMiner 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 OpenMiner; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * =====================================================================================
+ */
+#include "BlockPlacementConstraints.hpp"
+#include "Registry.hpp"
+#include "World.hpp"
+
+bool BlockPlacementConstraints::check(const World &world, const gk::Vector3i &pos) const {
+	bool isValid = true;
+	for (auto &it : m_constraints) {
+		const Block &block = Registry::getInstance().getBlockFromStringID(it.blockID);
+		u16 blockIDToCheck = world.getBlock(
+			pos.x + it.blockOffset.x,
+			pos.y + it.blockOffset.y,
+			pos.z + it.blockOffset.z);
+		const Block &blockToCheck = Registry::getInstance().getBlock(blockIDToCheck);
+		bool isSameBlock = (block.id() == blockToCheck.id());
+		if ((it.isWhitelist && !isSameBlock) || (!it.isWhitelist && isSameBlock))
+			isValid = false;
+	}
+
+	return isValid;
+}
+
+void BlockPlacementConstraints::serialize(sf::Packet &packet) const {
+	packet << m_constraints;
+}
+
+void BlockPlacementConstraints::deserialize(sf::Packet &packet) {
+	packet >> m_constraints;
+}
+

source/common/world/BlockPlacementConstraints.hpp

@@ -0,0 +1,61 @@
+/*
+ * =====================================================================================
+ *
+ *  OpenMiner
+ *
+ *  Copyright (C) 2018-2020 Unarelith, Quentin Bazin <[email protected]>
+ *  Copyright (C) 2019-2020 the OpenMiner contributors (see CONTRIBUTORS.md)
+ *
+ *  This file is part of OpenMiner.
+ *
+ *  OpenMiner 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.
+ *
+ *  OpenMiner 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 OpenMiner; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * =====================================================================================
+ */
+#ifndef BLOCKPLACEMENTCONSTRAINTS_HPP_
+#define BLOCKPLACEMENTCONSTRAINTS_HPP_
+
+#include <vector>
+
+#include <gk/core/ISerializable.hpp>
+#include <gk/core/Vector3.hpp>
+
+#include "NetworkUtils.hpp"
+
+struct BlockPlacementConstraint : public gk::ISerializable {
+	gk::Vector3i blockOffset{0, 0, 0};
+	std::string blockID;
+	bool isWhitelist = true;
+
+	void serialize(sf::Packet &packet) const override { packet << blockOffset << blockID << isWhitelist; }
+	void deserialize(sf::Packet &packet) override { packet >> blockOffset >> blockID >> isWhitelist; }
+};
+
+class World;
+
+class BlockPlacementConstraints : public gk::ISerializable {
+	public:
+		bool check(const World &world, const gk::Vector3i &pos) const;
+
+		void addConstraint(const BlockPlacementConstraint &constraint) { m_constraints.emplace_back(constraint); }
+
+		void serialize(sf::Packet &packet) const override;
+		void deserialize(sf::Packet &packet) override;
+
+	private:
+		std::vector<BlockPlacementConstraint> m_constraints;
+};
+
+#endif // BLOCKPLACEMENTCONSTRAINTS_HPP_

source/server/lua/loader/LuaBlockLoader.cpp

@@ -26,6 +26,7 @@
  */
 #include <gk/core/Debug.hpp>
 
+#include "BlockPlacementConstraints.hpp"
 #include "LuaBlockLoader.hpp"
 #include "LuaMod.hpp"
 #include "Registry.hpp"
@@ -77,6 +78,7 @@ void LuaBlockLoader::loadBlockState(BlockState &state, const sol::table &table,
 	loadBoundingBox(state, table);
 	loadItemDrop(state, table);
 	loadColorMultiplier(state, table);
+	loadPlacementConstraints(block, table);
 
 	loadStates(block, state, table);
 }
@@ -213,6 +215,39 @@ inline void LuaBlockLoader::loadStates(ServerBlock &block, BlockState &state, co
 	}
 }
 
+inline void LuaBlockLoader::loadPlacementConstraints(ServerBlock &block, const sol::table &table) const {
+	sol::object constraintsObject = table["placement_constraints"];
+	if (constraintsObject.valid()) {
+		if (constraintsObject.get_type() == sol::type::table) {
+			sol::table constraintsTable = constraintsObject.as<sol::table>();
+			for (auto &constraintsObject : constraintsTable) {
+				BlockPlacementConstraint constraint;
+
+				sol::optional<sol::table> blockOffset = constraintsObject.first.as<sol::table>();
+				if (blockOffset != sol::nullopt) {
+					constraint.blockOffset.x = blockOffset.value().get<u32>(1);
+					constraint.blockOffset.y = blockOffset.value().get<u32>(2);
+					constraint.blockOffset.z = blockOffset.value().get<u32>(3);
+				}
+				else
+					gkError() << "For block" << block.stringID() << ": 'placement_constraints' offset is wrong";
+
+				sol::optional<sol::table> constraintTable = constraintsObject.second.as<sol::table>();
+				if (constraintTable != sol::nullopt) {
+					constraint.blockID = constraintTable.value()["block"].get<std::string>();
+					constraint.isWhitelist = constraintTable.value()["is_whitelist"].get<bool>();
+				}
+				else
+					gkError() << "For block" << block.stringID() << ": 'placement_constraints' table is wrong";
+
+				block.placementConstraints().addConstraint(constraint);
+			}
+		}
+		else
+			gkError() << "For block" << block.stringID() << ": 'placement_constraints' must be a table";
+	}
+}
+
 inline void LuaBlockLoader::loadGroups(ServerBlock &block, const sol::table &table, Item *item) const {
 	sol::object groupsObject = table["groups"];
 	if (groupsObject.valid()) {

source/server/lua/loader/LuaBlockLoader.hpp

@@ -48,6 +48,7 @@ class LuaBlockLoader {
 		void loadItemDrop(BlockState &state, const sol::table &table) const;
 		void loadColorMultiplier(BlockState &state, const sol::table &table) const;
 		void loadStates(ServerBlock &block, BlockState &state, const sol::table &table) const;
+		void loadPlacementConstraints(ServerBlock &block, const sol::table &table) const;
 		void loadGroups(ServerBlock &block, const sol::table &table, Item *item = nullptr) const;
 		void loadParams(ServerBlock &block) const;