Source code for miney.node

import miney
from typing import Union
from copy import deepcopy

[docs]class Node: """ Manipulate and get information's about nodes. **Node manipulation is currently tested for up to 25.000 nodes, more optimization will come later** """ def __init__(self, mt: miney.Minetest): = mt self._types_cache = """ local nodes = {} for name, def in pairs(minetest.registered_nodes) do table.insert(nodes, name) end return nodes """ ) self._types = TypeIterable(self, self._types_cache) @property def type(self) -> 'TypeIterable': """ All available node types in the game, sorted by categories. In the end it just returns the corresponding minetest type string, so `mt.node.types.default.dirt` returns the string 'default:dirt'. It's a nice shortcut in REPL, cause with auto completion you have only pressed 2-4 keys to get to your type. :Examples: Directly access a type: >>> mt.node.type.default.dirt 'default:dirt' Iterate over all available types: >>> for node_type in mt.node.type: >>> print(node_type) default:pine_tree default:dry_grass_5 farming:desert_sand_soil ... (there should be over 400 different types) >>> print(len(mt.node.type)) 421 Get a list of all types: >>> list(mt.node.type) ['default:pine_tree', 'default:dry_grass_5', 'farming:desert_sand_soil', ... Add 99 dirt to player "IloveDirt"'s inventory: >>> mt.player.IloveDirt.inventory.add(mt.node.type.default.dirt, 99) :rtype: :class:`TypeIterable` :return: :class:`TypeIterable` object with categories. Look at the examples above for usage. """ return self._types
[docs] def set(self, nodes: Union[dict, list], name: str = None, offset: dict = None) -> None: """ Set a single or multiple nodes at given position to another node type (something like You can get a list of all available nodes with :attr:`~miney.Minetest.node.type` A node is defined as a dict with these keys: * "x", "y", and "z" keys to define the absolute position * "name" for a the node type like "default:dirt" (you can also get that from mt.node.type.default.dirt). Dicts without name will be set as "air" * some other optional minetest parameters **The nodes parameter can be a single dict with the above parameters or a list of these dicts for bulk spawning.** :Examples: Set a single node over : >>> mt.node.set(mt.player[0].nodes, mt.node) :param nodes: A dict or a list of dicts with node definitions :param name: a type name like "default:dirt" as string or from :attr:`~miney.Minetest.node.type`. This overrides node names defined in the :attr:`nodes` dict :param offset: A dict with "x", "y", "z" keys. All node positions will be added with this values. """ _nodes = deepcopy(nodes) if offset: if not all(pos in ['x', 'y', 'z'] for pos in offset): raise ValueError("offset parameter dict needs y, x and z keys") # Set a single node if type(_nodes) is dict: if offset: _nodes["x"] = _nodes["x"] + offset["x"] _nodes["y"] = _nodes["y"] + offset["y"] _nodes["z"] = _nodes["z"] + offset["z"] if name: _nodes["name"] = name"minetest.set_node({}, {{name=\"{_nodes['name']}\"}})") # Set many blocks elif type(_nodes) is list: lua = "" # Loop over nodes, modify name/type, position/offset and generate lua code for node in _nodes: # default name to 'air' if "name" not in node and not name: node["name"] = "air" if name: if "name" not in node or (node["name"] != "air" and node["name"] != "ignore"): node["name"] = name if offset: node["x"] = node["x"] + offset["x"] node["y"] = node["y"] + offset["y"] node["z"] = node["z"] + offset["z"] if node["name"] != "ignore": lua = lua + f"minetest.set_node(" \ f"{{'x': node['x'], 'y': node['y'], 'z': node['z']})}, " \ f"{{name=\"{node['name']}\"}})\n"
[docs] def get(self, position: dict, position2: dict = None, relative: bool = True, offset: dict = None) -> Union[dict, list]: """ Get the node at given position. It returns a dict with the node definition. This contains the "x", "y", "z", "param1", "param2" and "name" keys, where "name" is the node type like "default:dirt". If also position2 is given, this function returns a list of dicts with node definitions. This list contains a cuboid of definitions with the diagonal between position and position2. You can get a list of all available node types with :attr:`~miney.Minetest.node.type`. :param position: A dict with x,y,z keys :param position2: Another point, to get multiple nodes as a list :param relative: Return relative or absolute positions :param offset: A dict with "x", "y", "z" keys. All node positions will be added with this values. :return: The node type on this position """ if type(position) is dict and not position2: # for a single node _position = deepcopy(position) if offset: _position["x"] = _position["x"] + offset["x"] _position["y"] = _position["y"] + offset["y"] _position["z"] = _position["z"] + offset["z"] node ="return minetest.get_node({})") node["x"] = position["x"] node["y"] = position["y"] node["z"] = position["z"] return node elif type(position) is dict and type(position2) is dict: # Multiple nodes _position = deepcopy(position) _position2 = deepcopy(position2) if offset: _position["x"] = _position["x"] + offset["x"] _position["y"] = _position["y"] + offset["y"] _position["z"] = _position["z"] + offset["z"] _position2["x"] = _position2["x"] + offset["x"] _position2["y"] = _position2["y"] + offset["y"] _position2["z"] = _position2["z"] + offset["z"] nodes_relative = """ node["x"] = x - start_x node["y"] = y - start_y node["z"] = z - start_z """ nodes_absolute = """ node["x"] = x node["y"] = y node["z"] = z """ return f""" pos1 = {} pos2 = {} minetest.load_area(pos1, pos2) nodes = {{}} if pos1.x <= pos2.x then start_x = pos1.x end_x = pos2.x else start_x = pos2.x end_x = pos1.x end if pos1.y <= pos2.y then start_y = pos1.y end_y = pos2.y else start_y = pos2.y end_y = pos1.y end if pos1.z <= pos2.z then start_z = pos1.z end_z = pos2.z else start_z = pos2.z end_z = pos1.z end for x = start_x, end_x do for y = start_y, end_y do for z = start_z, end_z do node = minetest.get_node({{x = x, y = y, z = z}}) {nodes_relative if relative else nodes_absolute} nodes[#nodes+1] = node -- append node end end end return nodes""", timeout=180)
def __repr__(self): return '<minetest node functions>'
class TypeIterable: """Node type, implemented as iterable for easy autocomplete in the interactive shell""" def __init__(self, parent, nodes_types=None): self.__parent = parent if nodes_types: # get type categories list type_categories = {} for ntype in nodes_types: if ":" in ntype: type_categories[ntype.split(":")[0]] = ntype.split(":")[0] for tc in dict.fromkeys(type_categories): self.__setattr__(tc, TypeIterable(parent)) # values to categories for ntype in nodes_types: if ":" in ntype: self.__getattribute__(ntype.split(":")[0]).__setattr__(ntype.split(":")[1], ntype) else: self.__setattr__(ntype, ntype) # for 'air' and 'ignore' def __iter__(self): # todo: list(mt.node.type.default) should return only default group return iter(self.__parent._types_cache) def __getitem__(self, item_key): if type(self.__parent) is not type(self): # if we don't have a category below return self.__getattribute__(item_key) if item_key in self.__parent.node_types: return item_key else: if type(item_key) == int: return self.__parent.node_types[item_key] raise IndexError("unknown node type") def __len__(self): return len(self.__parent._types_cache)