minetest.register node/de

From Minetest Developer Wiki
Jump to: navigation, search
Language: English  • Deutsch

Die folgende Übersetzung ist entweder noch nicht übersetzt oder sehr schlecht, z.B mit DeepL oder Google translate. Bitte hilf die Übersetzung fertig zu kriegen!



Registriert einen neuen Block mit dem Namen "name". The node properties are specified in the Node definition (see below).

Beachte, dass der Block nicht sofort "erstellt" wird, sondern in der Liste minetest.registered_nodes gespeichert wird, die bearbeitet wird, wenn alle Mods geladen sind.

Contents

Syntax

minetest.register_node("name", {node definition})

Block Definition

The node definition is a regular Lua table:

minetest.registered_nodes["<node name>"].<field>

Gültige Felder sind:

  • drawtype - Gibt an, wie die Game Engine den Block zeichnen soll. Weitere Informationen finden Sie unter Node Drawtypes.
  • visual_scale - Gibt den Maßstab an, in dem das Element beim in der Hand halten gezeichnet wird. Der Standardwert ist 1,0 (Normalskala). 2.0 ist doppelt so groß, 0.5 ist halb so groß, und so weiter.
  • tiles - Gibt die textures an, die für die Flächen des Blocks verwendet werden. Es ist ein Array (Tabelle) von entweder einem oder sechs Elementen. Wenn nur eine Textur benötigt wird, kann sie direkt als String (Zeichenkette) anstelle einer Tabelle angegeben werden. Die Texturen werden als String (Zeichenkette)n entweder als "texturename.png" oder "texturename" angegeben. Die Reihenfolge der Texturen ist +Y, -Y, +X, -X, -X, +Z, -Z, -Z. Auf Englisch: oben, unten, rechts, links, links, hinten, vorne.
  • special_tiles - Gibt bestimmte Texturen an, die in Dingen wie Texturanimationen verwendet werden. Ich brauche eine Erweiterung.
  • use_texture_alpha - Setzt dies auf true für den zu verwendenden Alpha-Kanal der Textur.
  • alpha - Alpha-Wert (Transparenz) des Blocks, wobei 255 vollständig undurchsichtig und 0 vollständig transparent ist. Die dazwischen liegenden Werte geben eine teilweise Transparenz an. Dies hat nur Auswirkungen auf die flüssigen Block.
  • post_effect_color - Wann immer sich ein Spieler "innerhalb" des Blocks befindet, wird der Bildschirm mit dieser Farbe getönt. Sie wird als Tabelle mit den Feldern'r','g','b' und'a' angegeben, die die Komponenten Rot, Grün und Blau sowie die Effekttransparenz (Alpha) darstellen. Zum Beispiel:
     enclose="none">{ r=255, g=0, b=0, a=128 }
    .
  • inventory_image - Diese texture wird für jeden Zustand verwendet, außer wenn sie in der Welt platziert wird (d.h. sie wird im Inventar verwendet und wenn sie fallen gelassen wird). Wenn undefiniert (nil), wird ein Bild automatisch aus Kacheln erstellt.
  • wield_image - Die texture, die anstelle der Handtextur angezeigt werden soll, wenn der Block ausgefahren wird. Wenn undefiniert (nil), wird das inventory_image verwendet.
  • paramtype - Gibt an, was der param1 des Blocks halten soll. Mögliche Werte sind:
    • none - Die Engine verwendet das Feld param1 nicht, und es ist frei, es für andere Zwecke zu verwenden.
    • light - Der in param1 gespeicherte Wert ist die Lichtmenge mit und ohne Sonne in den oberen bzw. unteren 4 Bit.
  • paramtype2 - Gibt an, was der param2 des Blocks halten soll. Mögliche Werte sind:
    • wallmounted - param2 Feld enthält die Wand, an der dieser Block "mounted" ist. Siehe minetest.dir_to_wallmounted(dir).
    • facedir - param2 Feld enthält die Blickrichtung des Blocks. Erforderlich, um Block je nach Richtung des Spielers ausrichten zu können. minetest.dir_to_facedir(dir).
  • is_ground_content - - Wenn das true ist, werden Höhlen dies durchschneiden. Standardmäßig ist es true.
  • sunlight_propagates - Wenn true, wird das Sonnenlicht unendlich lange durchgehen. Standard ist false.
  • walkable - Wenn true, kollidieren Objekte mit dem Block. Standard ist true.
  • pointable - Wenn true, kann auf. Standard ist true.
  • diggable - Wenn false, kann nie gegraben werden. Standard ist true.
  • climbablear - Wenn true, kann auf (Leiter) geklettert werden. Standard ist false.
  • buildable_to - Wenn true, können platzierte Block diesen Block ersetzen. Standard ist false.
  • drop - Ein einzelnes ItemStack, das beim Ausgraben des Blocks fallen gelassen wird, oder eine Liste von Elementsätzen, aus denen zufällig ausgewählt werden kann. Stellen Sie ihn auf {}, um den Drop zu deaktivieren. Standard ist der Name des Blocks. Siehe unten für weitere Details.
  • stack_max - Maximale Anzahl dieses Elements (und nicht des abgelegten) in einem Stapel. Der Standardwert ist 99.
  • liquidtype - "none"/"source"/"source"/"flowing".
  • liquid_alternative_flowing - Fließende Version der Quellflüssigkeit
  • liquid_alternative_source - Quellversion der strömenden Flüssigkeit
  • liquid_viscosity - Höhere Viskosität bedeutet langsamere Strömung (max. 7)
  • liquid_renewable - Wenn true, wird beim Platzieren von zwei oder mehr Quellen, so dass Luft zwischen ihnen ist, eine neue Flüssigkeitsquelle erstellt.
  • light_sourcelle - Menge des vom Block emittierten Lichts, wobei 0 kein Licht und 14 sonnenlichtähnliches Licht ist.
  • damage_per_second - Wenn sich der Spieler im Block befindet, wird dieser Schaden verursacht. Dies wird z.B. von der Lava genutzt.
  • node_box - Siehe Node boxes]].
  • selection_box - Siehe Node boxes]].
  • collision_box
  • legacy_facedir_simple - Unterstützt Maps, die im und vor Januar 2012 erstellt wurden.
  • legacy_wallmounted - Unterstützt Maps, die im und vor Januar 2012 erstellt wurden.
  • sounds - Eine Tabelle, die angibt, welcher Sound abgespielt werden soll, wenn einige Ereignisse auftreten. Weitere Informationen findest du unter SimpleSoundSpec. Die folgenden Ereignisse sind für Block definiert:
    • footstepitt - Wird gespielt, wenn ein Spieler auf dem Block läuft.
    • dig - Wird abgespielt, während der Spieler den Block durchsucht. Wenn es "__group" als Wert angegeben ist, verwendet es die Option


Wield Image Durchsichtigkeit

Wenn ein Inventarbild oder ein explizites Nutzungsbild von der Engine ausgewählt wird, um es in der First-Person-Ansicht auf dem Client anzuzeigen, wird eine gewisse Verarbeitung durchgeführt, um es tatsächlich auf dem Bildschirm anzuzeigen. Das Spiel nimmt die äußersten rechten Pixel im Bild, die nicht 100% transparent sind (alpha=0) und dupliziert sie mehrmals nach rechts, um dem Bild ein "3D"-Aussehen zu verleihen. Dies kann zu Artefakten führen, wenn die rechten Pixel teilweise transparent sind, oder wenn Anti-Aliasing dazu führt, dass "einige" der Pixel teilweise transparent sind.


Sie können jedoch einen Trick anwenden, um diese Funktion effektiv auszuschalten: Fügen Sie rechts von allen "echten" Pixeln in Ihrem Bild einige eigene Pixel hinzu und machen Sie sie sehr nah an die vollständige Transparenz (Alpha=1, wenn Alpha von 0 bis 255 reicht, oder Alpha=0.005, wenn Alpha von 0,0 bis 1,0 reicht, oder alpha = 0,5%, wenn Alpha von 0% bis 100% reicht; Alpha und Opazität sind im Allgemeinen austauschbare Begriffe in Bildbearbeitungsprogrammen, so dass das Setzen der Opazität einer Ebene in GIMP auf 0,5% dies für alle vollständig undurchsichtigen Pixel in der Ebene bewirkt). Dadurch werden diese für das Auge unsichtbaren Pufferpixel anstelle der "echten" Pixel Ihres Bildes dupliziert. Dies ermöglicht es Ihnen, die volle Kontrolle über die Bilder der wielded Elemente zu haben und sogar Anti-Aliasing für sie zu verwenden.

Textur Alpha-Kanal verwenden

Muss mit einem Drawtyp verwendet werden, der keine Rückseitenabschneidung durchführt.
Es gibt derzeit zwei bekannte, schwer zu lösende Probleme mit dieser Funktion.
Wenn die Shader aktiviert sind, werden die Flächen anderer transparenter Block je nach Betrachtungswinkel manchmal nicht gezeichnet. Dies ist besonders auffällig, wenn sich eine Flüssigkeit hinter einem Block befindet, der den Alpha-Kanal der Textur verwendet.
Bei deaktivierten Shadern werden transparente Objekte, die weiter von der Kamera entfernt sind und verschlossen werden sollen, mit diesem Attribut über den Block gezogen. Dies wird durch die fehlende Transparenz-Sortierung verursacht und ist auch die Ursache dafür, dass Wasser vor Wolken gezogen wird.

More on drop

Der Drop wird nach dem Zufallsprinzip aus einer Menge ausgewählt. In diesem Fall wird die maximale Anzahl der zu dropenden Item-Sätze in max_items angegeben und die Elemente, die auszuwählen sind, werden innerhalb von items definiert. Jedes Element wird durch eine Liste von ItemStack definiert, eine optionale Rarität, die die umgekehrte Chance ist, dass dieses Set ausgewählt wird, und eine optionale Liste von Werkzeugen, die verwendet werden können oder nicht (mit dem Präfix ~). (Sehr schlechte Übersetzung, bitte ändern, weil ich es auf Englisch selber nicht verstanden habe)

drop = {
	max_items = 1, -- Nur ein Set von Items wird gedroppt
	items = {
			{
			items = {'default:flint 2', 'default:gravel'},
			rarity = 16, -- has 1 chance over 16 to be picked
			tools = {'default:pick_steel', 'default:pick_diamond'} -- can only be picked with one of these tools
			}, 
		{items = {'default:gravel'}}
	}
}


The above example with result if digging with a default:pick_steel to either 2 flints and one gravel (first item set, max_items is reached) or only one gravel (the second set). If max items was 2 or more it could be 2 flints and 2 gravels (both sets), or only one gravel (the first set wasn't picked by chance).

Primary Callbacks

When the following methods are defined in the node definition, the core engine will call them as callback methods as a result of direct events in the game such as a player punching the node or the node being added to the environment. Much of the default behavior of the game, such as adding a node to the environment when it is "placed", or adding an entity for an item when it is "dropped" can be replaced by overriding these callback methods. See src/scriptapi.cpp for more info.

on_construct

on_construct = function(pos)

Node Constructor. This function is called after putting the node in the world. It can be used to set up the node's metadata.

on_destruct

on_destruct = function(pos)

Node destructor. This function is called before removing the node.

  • pos Position of the node being destroyed.

after_destruct

after_destruct = function(pos, oldnode)

Node destructor. This function is called after removing the node.

  • pos Position the destroyed node occupied.
  • oldnode — A reference to the node that has been removed (TODO: verify this from C++ source; no documentation or examples are evident).

on_place

on_place = function(itemstack, placer, pointed_thing)

Called when a player places a node in-world. Returns itemstack modified according to the logic of the method (e.g. with one node removed from the count).

Default: Reference to minetest.item_place which:

  1. Checks whether the destination can be built to (contains no node or one with the buildable_to flag turned on).
  2. Sets param2 for "facedir" or "wallmounted" type nodes.
  3. Adds the node to the environment using minetest.add_node(...).
  4. Calls the after_place_node(...) and game-wide on_placement (see minetest.register_on_placenode) callbacks.
  5. Returns itemstack with one node removed.

Parameters are:

  • itemstack — The ItemStack that contains the node being placed.
  • placer — The Player object for the player placing the node.
  • pointed_thing — The pointed_thing acting as a reference for where to place the node (i.e. what the player's crosshair is pointing at).

on_drop

on_drop = function(itemstack, dropper, pos)

Called when a player drops a node item (as in drops its stack on the ground—with the Q button by default—not placing it in-world as a node). Returns itemstack modified according to the logic of the method (e.g. emptied of all contents).

Default: Reference to minetest.item_drop which calculates a point 1m in front of the camera, places an item entity (type "__builtin:item") there using minetest.add_item(...), and gives it a small "push" away from the camera using LuaEntitySAO.setvelocity(...).

  • itemstack — The ItemStack that contains the node being dropped.
  • dropper — The Player object for the player dropping the node.
  • pos — The position of the player dropping the node item. Note that this is not the place where the item is dropped in-world; it is up to this method to calculate that based on factors like which way the player is looking.

on_use

on_use = function(itemstack, player, pointed_thing)

Called when player wields and uses the node item. Returns itemstack modified according to the logic of the method, or nil if no item is to be removed from inventory.

Default: nil (not called)

  • itemstack — The ItemStack that contains the node being used.
  • player — The Player object for the player using the node item.
  • pointed_thing — The pointed_thing acting as a reference for where the player's crosshair is pointing.

on_punch

on_punch = function(pos, node, player, pointed_thing)

Called when node is punched by player or using minetest.punch_node(...).

Default: Reference to minetest.node_punch(pos, node, player, pointed_thing), which calls minetest.register_on_punchnode() callbacks.

  • pos Position of the node being punched.
  • node — Copy of the node being punched.
  • player — Reference to an object indicating who or what is punching the node.
  • pointed_thing — Copy of pointed_thing (only in 0.4.10+).

on_dig

on_dig = function(pos, node, player)

Called when node is dug by player or using minetest.dig_node(...).

Default: Reference to minetest.node_dig(pos, node, player), which:

  1. Checks node.diggable and calls can_dig(pos, player) (if defined).
  2. Adds wear to the player's wielded item, if any.
  3. Handles node drops.
  4. Removes the node from the environment with minetest.remove_node(pos).
  5. Calls after_dig_node (if defined) and game-wide on_dignodes (see minetest.register_on_dignode) callbacks.

Parameters are:

  • pos Position of the node being punched.
  • node — Reference to the node being dug.
  • player — Reference to an ObjectRef indicating who or what doing the digging.

on_timer

on_timer = function(pos, elapsed)

Called by node timers. Should return a boolean indicating whether to run the timer for another cycle using the same timeout value.

  • pos Position of the node for which the timer has elapsed.
  • elapsed — Total time that has passed since the timer was started.

on_receive_fields

on_receive_fields = function(pos, formname, fields, sender)

Called when a UI form on a node (e.g. sign text input) returns data. See formspec and NodeMetaRef.

  • pos Position of the node whose form fields are submitted.
  • formname — (TODO: Check meaning and use, because its only used by minetest.show_formspec(playername, formname, formspec) and minetest.register_on_player_receive_fields(func(player, formname, fields)))
  • fields — The names and values of the form's fields, as a table: {name1 = value1, name2 = value2, ...}
  • sender — Reference to a Player object indicating who submitted the form.

allow_metadata_inventory_move

allow_metadata_inventory_move = function(pos, from_list, from_index, to_list, to_index, count, player)

Called when a player attempts to move an item or items from one inventory slot to another within the node's inventory. Should return the actual number of items allowed to move from 0 (if the move is not allowed) to count (if all items may be moved), inclusive.

Example: Used by locked chests to ensure only the owner can modify them.

  • pos — The position of the node whose inventory is being modified.
  • from_list — The inventory list from which the item or items are being moved (e.g. "fuel", "dst", or "src" for a furnace in the default game).
  • from_index — The index of the slot from which the item or items are being moved within from_list.
  • to_list — The inventory list to which the item or items are being moved (e.g. "fuel", "dst", or "src" for a furnace in the default game).
  • to_index — The index of the slot to which the item or items are being moved within to_list.
  • count — The number of items the player is attempting to move.
  • player — The player attempting to modify the node inventory.

allow_metadata_inventory_put

allow_metadata_inventory_put = function(pos, listname, index, stack, player)

Called when a player attempts to move an item or items into the node's inventory from another inventory (e.g. the player's own inventory). Should return either -1 to allow all items to be moved but leave the node inventory unchanged, or the actual number of items allowed to move from 0 (if the move is not allowed) to count (if all items may be moved), inclusive.

Example: Used by locked chests to ensure only the owner can modify them.

  • pos — The position of the node whose inventory is being modified.
  • listname — The inventory list to which the item or items are being moved (e.g. "fuel", "dst", or "src" for a furnace in the default game).
  • index — The index of the slot to which the item or items are being moved within listname.
  • stack — Reference to an ItemStack describing what player is attempting to move.
  • player — The player attempting to modify the node inventory.

allow_metadata_inventory_take

allow_metadata_inventory_take = function(pos, listname, index, stack, player)

Called when a player attempts to move an item or items out of the node's inventory to another inventory (e.g. the player's own inventory). Should return either -1 to allow all items to be moved but leave the node inventory unchanged (copy items out), or the actual number of items allowed to move from 0 (if the move is not allowed) to count (if all items may be moved), inclusive.

Example: Used by locked chests to ensure only the owner can modify them.

  • pos — The position of the node whose inventory is being modified.
  • listname — The inventory list from which the item or items are being moved (e.g. "fuel", "dst", or "src" for a furnace in the default game).
  • index — The index of the slot from which the item or items are being moved within listname.
  • stack — Reference to an ItemStack describing what player is attempting to move.
  • player — The player attempting to modify the node inventory.

on_metadata_inventory_move

on_metadata_inventory_move = function(pos, from_list, from_index, to_list, to_index, count, player)

Callback called after a player has moved an item or items from one inventory slot to another within the node's inventory. Called after allow_metadata_inventory_move(pos, from_list, from_index, to_list, to_index, count, player) if the inventory move is allowed, with identical arguments except for a count updated to reflect the actual allowed number of items.

on_metadata_inventory_put

on_metadata_inventory_put = function(pos, listname, index, stack, player)

Callback called after a player has moved an item or items into the node's inventory from another inventory (e.g. the player's own inventory). Called after allow_metadata_inventory_put(pos, listname, index, stack, player) if the inventory move is allowed, with identical arguments except for a stack updated to reflect the actual allowed number of items.

on_metadata_inventory_take

on_metadata_inventory_take = function(pos, listname, index, stack, player)

Callback called after a player has moved an item or items out of the node's inventory to another inventory (e.g. the player's own inventory). Called after allow_metadata_inventory_take(pos, listname, index, stack, player) if the inventory move is allowed, with identical arguments except for a stack updated to reflect the actual allowed number of items.

Secondary Callbacks

Rather than being used by the core game engine itself the following callbacks are called indirectly by the default implementations of the above primary callbacks, so installing a callback for the primary events may result in these methods not being called. For example, if you implement on_place with a custom event handler callback, then after_place_node will not be called unless you explicitly call it, since it is the default on_place callback (minetest.item_place) that calls after_place_node. The default implementation of these secondary callbacks for a new node type does nothing (though several node types used by the default game mods do install behavior; e.g. chests). This means overriding them for your custom node simply adds new behavior instead of replacing existing default behavior. See builtin/item.lua for more info.

after_place_node

after_place_node = function(pos, placer, itemstack, pointed_thing)

Called after constructing node when node was placed using minetest.item_place_node(...) / minetest.place_node(...) (for example, locked chests use this to determine the owner).

Return a true value to indicate modification of itemstack (if any) has been handled by the callback. Otherwise (return nothing, <code>false</code>, or nil) the caller will remove one item from itemstack. Note that it is not generally possible for one global on_placenode callback to know what values were returned by others or by this callback (one should thus be careful to avoid double-removal of items).

can_dig

can_dig = function(pos, player)

Called by minetest.node_dig(...) / minetest.node_dig(...) to determine if player can dig the node in its current state. Returns a boolean (true if node can be dug).

Example: Chests and furnaces use this to allow digging only if they are empty.

  • pos Position of the node to be dug.
  • player — Reference to an object indicating who or what is trying to dig the node.

after_dig_node

after_dig_node = function(pos, oldnode, oldmetadata, digger)

Called after node is destroyed as a result of minetest.node_dig(...) / minetest.node_dig(...).

  • pos Position of node that was dug.
  • oldnode — Copy of old node
  • oldmetadata — Copy of old metadata in table format.
  • digger — Reference to an object.

on_rightclick

on_rightclick = function(pos, node, player, itemstack, pointed_thing)

When defined (not nil), this method is called by minetest.on_place(...) instead of minetest.item_place_node(...). Returns itemstack modified according to the logic of the method (e.g. with one node removed from the count). This function does not get triggered by clients prior and including 0.4.16 if the "formspec" node metadata field is set.

Default: nil (not defined; try to place a node instead)

  • posPosition of the node that was right-clicked on.
  • node — Node that was right-clicked on.
  • player — Reference to the Player who right-clicked on the node.
  • itemstack — The item (stack) wielded by the player when right-clicking.
  • pointed_thing pointed_thing. Can be nil if called by a mod

Unclassified Callbacks

These callbacks have been mentioned very briefly in the game documentation (e.g. in lua_api.txt), but few details are available other than a hint at their design and purpose, so it is unknown where they fit in the scheme of engine vs. mod code.

on_blast

on_blast = function(pos, intensity)

If defined, called when an explosion touches the node, instead of removing the node. It should be used by mods.

  • pos — The position of the node being affected the the explosion.
  • intensity — Describes the intensity of the blast affecting the node. According the lua_api.txt: 1.0 = mid range of regular TNT


Mbox important.png This article is incomplete.
Please help expand this article to include more useful information.
Personal tools
Namespaces

Variants
Actions
Navigation
API
Toolbox