Erste Korrekturen
This commit is contained in:
jjk1
debiankaios
parent
498669e55a
commit
6667fa8c89
@ -13,6 +13,7 @@ idx: 0.1
|
||||
<span>von <a href="https://rubenwardy.com" rel="author">rubenwardy</a></span>
|
||||
<span>Editiert von <a href="http://rc.minetest.tv/">Shara</a></span>
|
||||
<span>Übersetzt von von <a href="http://debiankaios.de/">debiankaios</a></span>
|
||||
<span>Korrekturgelessen von <a href="https://jojokorpi.ddns.net/">jjk1</a></span>
|
||||
</header>
|
||||
|
||||
## Einleitung
|
||||
@ -30,7 +31,7 @@ oder [in HTML form downloadbar](https://gitlab.com/rubenwardy/minetest_modding_b
|
||||
Haben Sie einen Fehler bemerkt oder möchten Sie ein Feedback geben? Teilen Sie mir das bitte mit.
|
||||
|
||||
* Erstelle eine [GitLab Issue](https://gitlab.com/rubenwardy/minetest_modding_book/-/issues).
|
||||
* Poste es in der [Forum Topic](https://forum.minetest.net/viewtopic.php?f=14&t=10729).
|
||||
* Poste es im [Forum Topic](https://forum.minetest.net/viewtopic.php?f=14&t=10729).
|
||||
* [Kontaktiere mich](https://rubenwardy.com/contact/).
|
||||
* Lust Mitzumachen?
|
||||
[Read the README](https://gitlab.com/rubenwardy/minetest_modding_book/-/blob/master/README.md).
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
---
|
||||
title: Block und Item Callbacks
|
||||
title: Node und Item Callbacks
|
||||
layout: default
|
||||
root: ../..
|
||||
idx: 2.15
|
||||
@ -8,11 +8,11 @@ description: Erfahren sie über callbacks, Aktionen, und Ereignissen, einschlie
|
||||
|
||||
## Einleitung <!-- omit in toc -->
|
||||
|
||||
Minetest verwendet hauptsächlich ein Callback-basiertes Modding-Design. Ein Rückruf ist eine Funktion
|
||||
Minetest verwendet hauptsächlich ein Callback-basiertes Modding-Design. Ein Callback ist eine Funktion,
|
||||
die Sie an eine API übergeben und die aufgerufen wird, wenn ein Ereignis eintritt. Zum Beispiel können Sie
|
||||
eine Funktion `on_punch` in einer Node-Definition angeben, die aufgerufen wird, wenn ein Spieler
|
||||
einen Knoten anstößt. Es gibt auch globale Callbacks wie
|
||||
`minetest.register_on_punchnode`, um Ereignisse für alle Knoten zu empfangen.
|
||||
einen Node anstößt. Es gibt auch globale Callbacks wie
|
||||
`minetest.register_on_punchnode`, um Ereignisse für alle Nodes zu empfangen.
|
||||
|
||||
- [Item Callbacks](#item-callbacks)
|
||||
- [on_use](#on_use)
|
||||
@ -20,30 +20,30 @@ einen Knoten anstößt. Es gibt auch globale Callbacks wie
|
||||
- [on_drop](#on_drop)
|
||||
- [after_use](#after_use)
|
||||
- [item_place vs place_item](#item_place-vs-place_item)
|
||||
- [Block Callbacks](#block-callbacks)
|
||||
- [Rechtsklick und Platzieren eines Blockes](#rechtsklick-und-platzieren-eines-blockes)
|
||||
- [Node Callbacks](#node-callbacks)
|
||||
- [Rechtsklick und Platzieren eines Nodes](#rechtsklick-und-platzieren-eines-nodes)
|
||||
- [Schlagen und abbauen](#schlagen-und-abbauen)
|
||||
- [...und mehr!](#und-mehr)
|
||||
|
||||
|
||||
## Item Callbacks
|
||||
|
||||
Wenn ein Spieler einen Block, einen Handwerksgegenstand oder ein Werkzeug in seinem Inventar hat, kann er folgende Ereignisse auslösen
|
||||
Wenn ein Spieler einen Node, einen Handwerksgegenstand oder ein Werkzeug in seinem Inventar hat, kann er folgende Ereignisse auslösen
|
||||
bestimmte Ereignisse:
|
||||
|
||||
| Callback | Standard-Bindung | Standard Wert |
|
||||
|------------------|-------------------------------|----------------------------------------------|
|
||||
| on_use | links-click | nil |
|
||||
| on_place | rechts-click auf einen Block | `minetest.item_place` |
|
||||
| on_secondary_use | rechts-click auf keinen Block | `minetest.item_secondary_use` (does nothing) |
|
||||
| on_place | rechts-click auf einen Node | `minetest.item_place` |
|
||||
| on_secondary_use | rechts-click auf keinen Node | `minetest.item_secondary_use` (does nothing) |
|
||||
| on_drop | Q | `minetest.item_drop` |
|
||||
| after_use | Abbauen eines Blockes | nil |
|
||||
| after_use | Abbauen eines Nodes | nil |
|
||||
|
||||
|
||||
### on_use
|
||||
|
||||
Mit einem Verwendungsrückruf wird verhindert, dass das Item zum abbauen von Blöcken verwendet wird. Eine häufige
|
||||
Verwendung des Verwendungsrückrufs ist für Lebensmittel:
|
||||
Mit einem on_use Callback wird verhindert, dass das Item zum abbauen von Blöcken verwendet wird. Eine häufige
|
||||
Verwendung des on_use Callback ist für Lebensmittel:
|
||||
|
||||
```lua
|
||||
minetest.register_craftitem("meinemod:matschekuchen", {
|
||||
@ -58,7 +58,7 @@ Punkte, die durch den Verzehr dieser Nahrung geheilt werden. Jedes Herzsymbol, d
|
||||
zwei Hitpoints wert. Ein Spieler kann in der Regel bis zu 10 Herzen haben, was gleichbedeutend ist mit
|
||||
20 Hitpoints.
|
||||
|
||||
minetest.item_eat() ist eine Funktion, die eine Funktion zurückgibt und diese als on_use-Rückruf. Das bedeutet, dass der obige Code dem hier entspricht:
|
||||
minetest.item_eat() ist eine Funktion, die eine Funktion zurückgibt und diese als on_use Callback. Das bedeutet, dass der obige Code dem hier entspricht:
|
||||
|
||||
```lua
|
||||
minetest.register_craftitem("meinemod:matschekuchen", {
|
||||
@ -76,29 +76,29 @@ Wenn man versteht, wie item_eat funktioniert, indem es einfach eine Funktion zur
|
||||
### on_place und on_secondary_use
|
||||
|
||||
Der Unterschied zwischen `on_place` und `on_secondary_use` ist, dass `on_place` aufgerufen wird,
|
||||
wenn der Spieler auf einen Knoten zeigt und `on_secondary_use`, wenn der
|
||||
wenn der Spieler auf einen Node zeigt und `on_secondary_use`, wenn der
|
||||
Spieler dies nicht tut.
|
||||
|
||||
Beide Callbacks werden für alle Arten von Items aufgerufen. `on_place` ist standardmäßig auf die
|
||||
Funktion `minetest.item_place`, die den Aufruf des `on_rightclick`
|
||||
Callback des angezeigten Knotens aufruft oder den geschwungenen Gegenstand platziert, wenn es ein Knoten ist.
|
||||
Callback des angezeigten Nodes aufruft oder das gehaltene Item platziert, wenn es ein Node ist.
|
||||
|
||||
|
||||
### on_drop
|
||||
|
||||
on_drop wird aufgerufen, wenn der Spieler einen Gegenstand fallen lassen will, zum Beispiel mit
|
||||
die Abwurftaste (Q) oder durch Ziehen außerhalb des Inventars. Es wird standardmäßig die Funktion
|
||||
`minetest.item_drop`, die das Fallenlassen des Gegenstandes übernimmt.
|
||||
der Abwurftaste (Q) oder durch herausziehen aus dem Inventar. Es wird standardmäßig die Funktion
|
||||
`minetest.item_drop` verwendet, die das Fallenlassen des Gegenstandes übernimmt.
|
||||
|
||||
|
||||
### after_use
|
||||
|
||||
`after_use` wird beim abbauen eines Blockes aufgerufen und ermöglicht es Ihnen, dass die Art der Abnutzung
|
||||
`after_use` wird beim abbauen eines Nodes aufgerufen und ermöglicht es Ihnen, dass die Art der Abnutzung
|
||||
auf ein Werkzeug angewendet wird. Wenn after_use nicht existiert, dann ist es das gleiche wie:
|
||||
|
||||
```lua
|
||||
after_use = function(itemstack, benutzer, block, abbauparams)
|
||||
itemstack:add_wear(abbauparams.wear)
|
||||
after_use = function(itemstack, user, node, digparams)
|
||||
itemstack:add_wear(digparams.wear)
|
||||
return itemstack
|
||||
end
|
||||
```
|
||||
@ -106,7 +106,7 @@ end
|
||||
|
||||
## item_place vs place_item
|
||||
|
||||
Die API von Minetest enthält viele verschiedene integrierte Callback-Implementierungen, zur Benutzung von ihnen. Diese Rückrufe werden mit dem Elementtyp zuerst benannt, zum Beispiel,
|
||||
Die API von Minetest enthält viele verschiedene integrierte Callback-Implementierungen, die Sie verwenden können. Diese Callbacks werden mit dem Elementtyp zuerst benannt, zum Beispiel,
|
||||
`minetest.item_place` und `minetest.node_dig`. Einige Callback-Implementierungen werden
|
||||
direkt verwendet, während einige Funktionen sind, die den Rückruf zurückgeben:
|
||||
|
||||
@ -124,74 +124,74 @@ haben aber das Verb vorangestellt. Beispiele sind `minetest.place_item` und
|
||||
ähnlichen Effekt wie Spieler.
|
||||
|
||||
|
||||
## Block Callbacks
|
||||
## Node Callbacks
|
||||
|
||||
Wenn sich ein Block in einem Inventar befindet, verwendet er, wie oben beschrieben, Item Callbacks. Wenn
|
||||
ein Knoten in der Welt platziert ist, verwendet er Block Callbacks. Es gibt eine ganze Menge von
|
||||
Block Callbacks, zu viele, um sie in diesem Buch zu besprechen. Allerdings werden einige von ihnen
|
||||
später in diesem Buch besprochen.
|
||||
Wenn sich ein Node in einem Inventar befindet, verwendet er, wie oben beschrieben, Item Callback. Wenn
|
||||
ein Node in der Welt platziert ist, verwendet er Node Callbacks. Es gibt eine ganze Menge von
|
||||
Node Callbacks, zu viele, um sie in diesem Buch zu behandeln. Allerdings werden einige von ihnen
|
||||
später in diesem Buch behandelt.
|
||||
|
||||
Einige der Rückrufe beziehen sich auf Blockoperationen wie das Platzieren und
|
||||
Entfernen aus der Welt. Es ist wichtig zu beachten, dass Blockoperationen-Callbacks
|
||||
wie diese nicht von bulk changes aufgerufen werden - also solchen, die eine große Anzahl von
|
||||
Blöcken auf einmal setzen - aus Leistungsgründen nicht aufgerufen werden. Daher kann man sich nicht darauf verlassen, dass diese
|
||||
Rückrufe immer aufgerufen werden.
|
||||
Einige der Callbacks beziehen sich auf Nodeoperationen wie das Platzieren und
|
||||
Entfernen aus der Welt. Es ist wichtig zu beachten, dass Nodeoperationen-Callbacks
|
||||
wie diese aus Leistungsgründen nicht von bulk changes - also solchen, die eine große Anzahl von
|
||||
Blöcken auf einmal setzen - aufgerufen werden. Daher kann man sich nicht darauf verlassen, dass diese
|
||||
Callbacks immer aufgerufen werden.
|
||||
|
||||
|
||||
### Rechtsklick und Platzieren eines Blockes
|
||||
### Rechtsklick und Platzieren eines Nodes
|
||||
|
||||
Wenn der Benutzer mit der rechten Maustaste auf ein Element klickt, während er auf einen Block zeigt, wird der Callback des Elements
|
||||
`on_place`-Callback aufgerufen. Standardmäßig ist dieser auf `minetest.item_place` gesetzt.
|
||||
Wenn der gezeigte Knoten einen `on_rightclick` Callback hat und sneak (shift) gehalten wird,
|
||||
Wenn der Benutzer mit der rechten Maustaste auf ein Item klickt, während er auf einen Node zeigt, wird der Callback
|
||||
`on_place` des Items aufgerufen. Standardmäßig ist dieser auf `minetest.item_place` gesetzt.
|
||||
Wenn der gezeigte Node einen `on_rightclick` Callback hat und sneak (shift) gehalten wird,
|
||||
dann wird der `on_rightclick` Callback aufgerufen. Andernfalls wird `minetest.item_place`
|
||||
den Knoten platzieren.
|
||||
den Node platzieren.
|
||||
|
||||
Das Platzieren eines Blockes ruft sowohl `on_construct` als auch `after_place_node` auf.
|
||||
`on_construct` wird von jedem Block-Plazier-Ereignis aufgerufen, das nicht in Bulk war und wird nur
|
||||
die Position und den Wert des Blockes gegeben. `after_place_node` wird nur von node
|
||||
Das Platzieren eines Nodes ruft sowohl `on_construct` als auch `after_place_node` auf.
|
||||
`on_construct` wird von jedem Node-Platzier-Ereignis aufgerufen, das nicht in Bulk war und es wird nur
|
||||
die Position und den Wert des Nodes gegeben. `after_place_node` wird nur von node
|
||||
place aufgerufen und hat daher mehr Informationen - wie den Placer und den Itemstack.
|
||||
|
||||
Es ist wichtig zu wissen, dass Spieler nicht die einzigen Objekte sind, die
|
||||
Blöcke platzieren können; es ist üblich, dass auch Mobs und Mods Blöcke platzieren können. Um dies zu berücksichtigen,
|
||||
`Placer` kann ein Spieler, eine Entity oder nil sein.
|
||||
Blöcke platzieren können; es ist üblich, dass auch Mobs und Mods Blöcke platzieren können. `Placer` kann ein Spieler, eine Entity oder nil sein.
|
||||
|
||||
```lua
|
||||
minetest.register_node("meinemod:meinblock", {
|
||||
on_rightclick = function(pos, block, clicker, itemstack, angeschautes_ding)
|
||||
minetest.register_node("mymod:mynode", {
|
||||
on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
|
||||
if clicker:is_player() then
|
||||
minetest.chat_send_player(clicker:get_player_name(), "Hallo Welt!")
|
||||
end
|
||||
end,
|
||||
on_construct = function(pos, block)
|
||||
on_construct = function(pos, node)
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("infotext", "Mein Block!")
|
||||
end,
|
||||
after_place_node = function(pos, plazierer, itemstack, angeschautes_ding)
|
||||
-- Stellen Sie sicher, dass Sie den Plazierer überprüfen
|
||||
if plazierer and plazierer:is_player() then
|
||||
after_place_node = function(pos, placer, itemstack, pointed_thing)
|
||||
-- Überprüfen des Platzierers
|
||||
if placer and placer:is_player() then
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("besitzer", plazierer:get_player_name())
|
||||
meta:set_string("owner", placer:get_player_name())
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
```
|
||||
|
||||
### Schlagen und abbauen
|
||||
|
||||
Schlagen bedeutet, dass der Spieler kurz mit der linken Maustaste klickt. Wenn der benutze Gegenstand
|
||||
einen `on_use` Callback hat, wird dieser aufgerufen. Andernfalls wird der `on_punch`
|
||||
Callback auf dem angezeigten Block aufgerufen.
|
||||
Callback auf dem angezeigten Node aufgerufen.
|
||||
|
||||
Wenn der Spieler versucht, einen Block abzubauen, wird der `on_dig` Callback auf dem Knoten aufgerufen.
|
||||
Wenn der Spieler versucht, einen Node abzubauen, wird der `on_dig` Callback auf dem Node aufgerufen.
|
||||
Dieser ist standardmäßig auf `minetest.node_dig` eingestellt, der den Gebietsschutz prüft, das
|
||||
das Werkzeug verschleißt, den Block entfernt und den `after_dig_node` Callback ausführt.
|
||||
das Werkzeug verschleißt, den Node entfernt und den `after_dig_node` Callback ausführt.
|
||||
|
||||
|
||||
```lua
|
||||
minetest.register_node("meinemod:meinblock", {
|
||||
on_punch = function(pos, block, schlaeger, angeschautes_ding) -- ä wird außer in strings und Kommentaren zu ae
|
||||
if schlaeger:is_player() then
|
||||
minetest.chat_send_player(clicker:get_player_name(), "Au!")
|
||||
minetest.register_node("meinemod:meinnode", {
|
||||
on_punch = function(pos, node, puncher, pointed_thing)
|
||||
if puncher:is_player() then
|
||||
minetest.chat_send_player(puncher:get_player_name(), "Au!")
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
@ -9,17 +9,16 @@ redirect_from: /de/chapters/creating_textures.html
|
||||
|
||||
## Einleitung <!-- omit in toc -->
|
||||
|
||||
Die Fähigkeit, Texturen zu erstellen und zu optimieren, ist eine sehr nützliche Fähigkeit bei der
|
||||
Entwicklung für Minetest.
|
||||
Es gibt viele Techniken, die für die Arbeit an Pixel-Art-Texturen relevant sind,
|
||||
Bei der Entwicklung für Minetest ist es sehr nützlich, Texturen zu erstellen und optimieren zu können.
|
||||
Es gibt viele Techniken, die für die Arbeit an Pixel-Art-Texturen relevant sind
|
||||
und das Verständnis dieser Techniken wird
|
||||
die Qualität der von Ihnen erstellten Texturen erheblich verbessern.
|
||||
|
||||
Detaillierte Ansätze zur Erstellung guter Pixelkunst liegen außerhalb des Rahmens
|
||||
Detaillierte Ansätze zur Erstellung guter Pixel-Art liegen außerhalb des Rahmens
|
||||
dieses Buches, stattdessen werden nur die wichtigsten Grundtechniken
|
||||
behandelt werden.
|
||||
Es sind viele [gute Online-Tutorials](http://www.photonstorm.com/art/tutorials-art/16x16-pixel-art-tutorial)
|
||||
zur Verfügung, die die Pixelkunst viel detaillierter behandeln.
|
||||
zur Verfügung, die die Pixel-Art viel detaillierter behandeln.
|
||||
|
||||
- [Techniken](#techniken)
|
||||
- [Nutzung des Stiftes](#nutzung-des-stiftes)
|
||||
@ -36,7 +35,7 @@ zur Verfügung, die die Pixelkunst viel detaillierter behandeln.
|
||||
### Nutzung des Stiftes
|
||||
|
||||
Das Stiftwerkzeug ist in den meisten Editoren verfügbar. Wenn es auf die kleinste Größe eingestellt ist,
|
||||
können Sie damit ein Pixel nach dem anderen bearbeiten, ohne andere Teile des Bildes zu
|
||||
können Sie damit einen Pixel nach dem anderen bearbeiten, ohne andere Teile des Bildes zu
|
||||
ändern. Indem Sie die Pixel einzeln bearbeiten, schaffen Sie klare
|
||||
und scharfe Texturen ohne ungewollte Unschärfen. Außerdem bietet es Ihnen ein hohes
|
||||
Maß an Präzision und Kontrolle.
|
||||
@ -49,38 +48,37 @@ korrekt aus.
|
||||
|
||||
<!-- IMAGE NEEDED - cobblestone that tiles correctly -->
|
||||
|
||||
Wenn Sie die Kanten nicht richtig anpassen, ist das Ergebnis weit weniger ansprechend
|
||||
ansehnlich.
|
||||
Wenn Sie die Kanten nicht richtig anpassen, ist das Ergebnis weit weniger ansprechend.
|
||||
|
||||
<!-- IMAGE NEEDED - node that doesn't tile correctly -->
|
||||
|
||||
### Transparenz
|
||||
|
||||
Transparenz ist wichtig bei der Erstellung von Texturen für fast alle Craftitems
|
||||
und einige Knoten, wie z. B. Glas.
|
||||
und einige Nodes, wie z. B. Glas.
|
||||
Nicht alle Editoren unterstützen Transparenz, also stellen Sie sicher, dass Sie einen
|
||||
Editor, der für die Texturen, die Sie erstellen möchten, geeignet ist.
|
||||
|
||||
### Farbpaletten
|
||||
|
||||
Die Verwendung einer einheitlichen Farbpalette ist ein einfacher Weg, um Ihre Kunst viel besser aussehen zu lassen.
|
||||
Es ist eine gute Idee, eine Palette mit einer begrenzten Anzahl von Farben zu verwenden, vielleicht 32
|
||||
höchstens. Vorgefertigte Paletten finden Sie unter
|
||||
Die Verwendung einer einheitlichen Farbpalette ist ein einfacher Weg, um Ihre Texturen viel besser aussehen zu lassen.
|
||||
Es ist eine gute Idee, eine Palette mit einer begrenzten Anzahl von Farben zu verwenden, vielleicht höchstens 32.
|
||||
Vorgefertigte Paletten finden Sie unter
|
||||
[lospec.com](https://lospec.com/palette-list).
|
||||
|
||||
## Editore
|
||||
|
||||
### MS Paint
|
||||
|
||||
MS Paint ist ein einfacher Editor, der für einfache Texturen Design nützlich sein kann;
|
||||
MS Paint ist ein einfacher Editor, der für einfaches Texturendesign nützlich sein kann;
|
||||
allerdings unterstützt er keine Transparenz.
|
||||
Dies spielt normalerweise keine Rolle, wenn Sie Texturen für die Seiten von Knotenpunkten erstellen,
|
||||
Dies spielt normalerweise keine Rolle, wenn Sie Texturen für die Seiten von Nodes erstellen,
|
||||
aber wenn Sie Transparenz in Ihren Texturen benötigen, sollten Sie einen
|
||||
anderen Editor wählen.
|
||||
|
||||
### Aseprite / LibreSprite
|
||||
|
||||
[Aseprite](https://www.aseprite.org/) ist ein proprietärer Pixelkunst-Editor.
|
||||
[Aseprite](https://www.aseprite.org/) ist ein proprietärer Pixel-Art-Editor.
|
||||
Er enthält standardmäßig eine Menge nützlicher Funktionen wie Farbpaletten und
|
||||
Animationswerkzeuge.
|
||||
|
||||
@ -99,4 +97,4 @@ Bei der Verwendung von GIMP kann das Bleistift-Werkzeug aus der Toolbox ausgewä
|
||||
<img src="{{ page.root }}//static/pixel_art_gimp_pencil.png" alt="Pencil in GIMP">
|
||||
</figure>
|
||||
|
||||
Es ist außerdem ratsam, das Kontrollkästchen Harte Kante für das Radiergummi-Werkzeug zu aktivieren.
|
||||
Es ist außerdem ratsam, das Kontrollkästchen "Harte Kanten" für das Radiergummi-Werkzeug zu aktivieren.
|
||||
|
||||
@ -3,7 +3,7 @@ title: ItemStacks und Inventare
|
||||
layout: default
|
||||
root: ../..
|
||||
idx: 2.4
|
||||
description: Manipuliere InvRefs und ItemStacks
|
||||
description: Manipulieren von InvRefs und ItemStacks
|
||||
redirect_from:
|
||||
- /de/chapters/inventories.html
|
||||
- /de/chapters/itemstacks.html
|
||||
@ -14,7 +14,7 @@ redirect_from:
|
||||
## Einleitung <!-- omit in toc -->
|
||||
|
||||
In diesem Kapitel werden Sie lernen, wie man Inventare verwendet und manipuliert, egal
|
||||
ob es sich um ein Spielerinventar, ein Blockinventar oder ein freistehendes Inventar handelt.
|
||||
ob es sich um ein Spielerinventar, ein Nodeinventar oder ein freistehendes Inventar handelt.
|
||||
|
||||
- [Was sind ItemStacks und Inventare?](#was-sind-itemstacks-und-inventare)
|
||||
- [ItemStacks](#itemstacks)
|
||||
@ -37,7 +37,7 @@ Ein *Inventar* ist eine Sammlung von *Inventarlisten*, von denen jede
|
||||
ein 2D-Gitter aus ItemStacks ist.
|
||||
Inventarlisten werden im Kontext von Inventaren einfach *Listen* genannt.
|
||||
Der Sinn eines Inventars ist es, mehrere Raster zu ermöglichen, wenn Spieler
|
||||
und Blöcke nur maximal ein Inventar haben.
|
||||
und Nodes nur maximal ein Inventar haben.
|
||||
|
||||
## ItemStacks
|
||||
|
||||
@ -46,7 +46,7 @@ ItemStacks haben vier Komponenten: name, count, wear und metadata.
|
||||
Der Itemname kann der Itemname eines registrierten Items, ein Alias oder ein
|
||||
unbekannter Itemname sein.
|
||||
Unbekannte Items treten häufig auf, wenn Benutzer Mods deinstallieren oder wenn Mods
|
||||
Items ohne Vorsichtsmaßnahmen entfernen, z. B. durch die Registrierung von Aliasen.
|
||||
Items ohne Vorsichtsmaßnahmen, z. B. durch die Registrierung von Aliasen, entfernen.
|
||||
|
||||
```lua
|
||||
print(stack:get_name())
|
||||
@ -57,7 +57,7 @@ if not stack:is_known() then
|
||||
end
|
||||
```
|
||||
|
||||
Der Anzahl wird immer 0 oder größer sein.
|
||||
Die Anzahl wird immer 0 oder größer sein.
|
||||
Bei normalem Spielverlauf sollte die Anzahl nicht größer sein als die maximale
|
||||
Stackgröße des Gegenstands - `stack_max`.
|
||||
Allerdings können Admin-Befehle und fehlerhafte Mods dazu führen, dass Stacks die maximale Größe überschreiten.
|
||||
@ -88,30 +88,29 @@ ItemStack({ name = "default:wood", count = 10 })
|
||||
|
||||
Item-Metadaten sind ein unbegrenzter Schlüssel-Wert-Speicher für Daten über das Item.
|
||||
Schlüssel-Wert bedeutet, dass Sie einen Namen (den sogenannten key) verwenden, um auf die Daten (den sogenannten value) zuzugreifen.
|
||||
Einige Schlüssel haben eine besondere Bedeutung, wie z. B. `Beschreibung`, die verwendet wird, um eine pro Stack
|
||||
Beschreibung.
|
||||
Einige Keys haben eine besondere Bedeutung, wie z. B. `description`, welches für eine per-Item-Beschreibung verwendet wird.
|
||||
Dies wird im Kapitel über Metadaten und Speicherung ausführlicher behandelt.
|
||||
|
||||
## Inventarstandorte
|
||||
|
||||
Ein Inventarstandort ist der Ort und die Art und Weise, wie das Inventar gespeichert wird.
|
||||
Es gibt drei Arten von Inventarstandorten: Spieler, Blöcke und freistehend.
|
||||
Es gibt drei Arten von Inventarstandorten: Spieler, Nodes und freistehend.
|
||||
Ein Inventar ist direkt an einen und nur einen Ort gebunden - eine Aktualisierung des
|
||||
Inventars wird es sofort aktualisieren.
|
||||
|
||||
Blockinventare beziehen sich auf die Position eines bestimmten Blockes, z. B. einer Truhe.
|
||||
Der Block muss geladen werden, da er in den [Block-Metadaten](../map/storage.html#metadata) gespeichert ist.
|
||||
Nodeinventare beziehen sich auf die Position eines bestimmten Nodes, z. B. einer Truhe.
|
||||
Der Node muss geladen werden, da er in den [Node-Metadaten](../map/storage.html#metadata) gespeichert ist.
|
||||
|
||||
```lua
|
||||
local inv = minetest.get_inventory({ type="node", pos={x=1, y=2, z=3} })
|
||||
```
|
||||
|
||||
Auf diese Weise erhält man eine *Inventar-Referenz*, allgemein als *InvRef* bezeichnet.
|
||||
Auf diese Weise erhält man eine *Inventar-Referenz*, auch als *InvRef* bekannt.
|
||||
Inventar-Referenzen werden verwendet, um ein Inventar zu manipulieren.
|
||||
*Referenz* bedeutet, dass die Daten nicht tatsächlich in diesem Objekt gespeichert sind,
|
||||
sondern das Objekt aktualisiert die Daten direkt an Ort und Stelle.
|
||||
|
||||
Der Standort eines Inventarverweises kann wie folgt ermittelt werden:
|
||||
Der Standort eines Inventar-Referenz kann wie folgt ermittelt werden:
|
||||
|
||||
```lua
|
||||
local location = inv:get_location()
|
||||
@ -126,7 +125,7 @@ local inv = minetest.get_inventory({ type="player", name="spieler1" })
|
||||
local inv = player:get_inventory()
|
||||
```
|
||||
|
||||
Ein freistehendes Inventar ist ein Inventar, das unabhängig von Spielern oder Blöcken ist.
|
||||
Ein freistehendes Inventar ist ein Inventar, das unabhängig von Spielern oder Nodes ist.
|
||||
Freistehende Inventare werden auch nicht bei einem Neustart gespeichert.
|
||||
|
||||
```lua
|
||||
@ -146,26 +145,27 @@ Das zweite Argument nimmt eine Tabelle von Callbacks entgegen, die verwendet wer
|
||||
um zu steuern, wie Spieler mit dem Inventar interagieren:
|
||||
|
||||
```lua
|
||||
-- Eingabe nur freistehendes Inventar
|
||||
minetest.create_detached_inventory("inventar_name", {
|
||||
allow_move = function(inv, von_liste, von_index, zu_liste, zu_index, anzahl, player)
|
||||
return anzahl -- erlaubt bewegen
|
||||
-- Nur-Eingabefähiges freistehendes Inventar
|
||||
minetest.create_detached_inventory("inventory_name", {
|
||||
allow_move = function(inv, from_list, from_index, to_list, to_index, count, player)
|
||||
return count -- erlaubt bewegen
|
||||
end,
|
||||
|
||||
allow_put = function(inv, listenname, index, stack, spieler)
|
||||
return stack:get_count() -- erlaubt setzen
|
||||
allow_put = function(inv, listname, index, stack, player)
|
||||
return stack:get_count() -- erlaubt ablegen
|
||||
end,
|
||||
|
||||
allow_take = function(inv, listenname, index, stack, spieler)
|
||||
return 0 -- erlaubt es nicht zu nehmen
|
||||
allow_take = function(inv, listname, index, stack, player)
|
||||
return 0 -- erlaubt Nehmen nicht
|
||||
end,
|
||||
|
||||
on_put = function(inv, listenname, index, stack, spieler)
|
||||
minetest.chat_send_all(spieler:get_player_name() ..
|
||||
on_put = function(inv, listname, index, stack, player)
|
||||
minetest.chat_send_all(player:get_player_name() ..
|
||||
" gab " .. stack:to_string() ..
|
||||
" zu der Spendenkiste von " .. minetest.pos_to_string(spieler:get_pos()))
|
||||
" In die Spendenkiste von " .. minetest.pos_to_string(player:get_pos()))
|
||||
end,
|
||||
})
|
||||
|
||||
```
|
||||
|
||||
Berechtigungsaufrufe - d.h. diejenigen, die mit `allow_` beginnen - geben die Anzahl
|
||||
@ -177,7 +177,7 @@ Im Gegensatz dazu haben Aktionsrückrufe - beginnend mit `on_` - keinen Rückgab
|
||||
|
||||
Inventarlisten sind ein Konzept, das es ermöglicht, mehrere Raster an einem einzigen Ort zu speichern.
|
||||
Dies ist besonders nützlich für den Spieler, da es eine Reihe von allgemeinen Listen
|
||||
gibt die alle Spiele haben, wie das *Hauptinventar* und die *Handwerksplätze*.
|
||||
gibt, die alle Spiele haben, wie das *Hauptinventar* und die *Craftingplätze*.
|
||||
|
||||
### Größe und Breite
|
||||
|
||||
@ -222,7 +222,7 @@ end
|
||||
### Zu einer Liste hinzufügen
|
||||
|
||||
`add_item` fügt Items zu einer Liste hinzu (in diesem Fall `"main"`). Im folgenden
|
||||
Beispiel, wird auch die maximale Stackgröße beachtet:
|
||||
Beispiel wird auch die maximale Stackgröße beachtet:
|
||||
|
||||
```lua
|
||||
local stack = ItemStack("default:stone 99")
|
||||
@ -244,7 +244,7 @@ print("Nahm " .. genommen:get_count())
|
||||
|
||||
### Stacks manipulieren
|
||||
|
||||
Sie können einzelne Stacks ändern, indem Sie sie zuerst erhalten:
|
||||
Sie können einzelne Stacks ändern, indem Sie sie zuerst auswählen:
|
||||
|
||||
```lua
|
||||
local stack = inv:get_stack(listenname, 0)
|
||||
@ -294,8 +294,8 @@ local max_nutzungen = 10
|
||||
stack:add_wear(65535 / (max_nutzungen - 1))
|
||||
```
|
||||
|
||||
Beim abbauen eines Blockes kann die Abnutzung des Werkzeugs von dem Block abhängen
|
||||
der gegraben wird. Daher variiert max_nutzungen je nachdem, was gegraben wird.
|
||||
Beim abbauen eines Nodes kann die Abnutzung des Werkzeugs von dem Node abhängen,
|
||||
der abgebaut wird. Daher variiert max_nutzungen je nachdem, was abgebaut wird.
|
||||
|
||||
## Lua Tabellen
|
||||
|
||||
@ -336,8 +336,7 @@ Die Tabelle der Listen, die von `get_lists()` zurückgegeben wird, wird in diese
|
||||
`get_list()` gibt eine einzelne Liste zurück, die lediglich eine Liste von ItemStacks ist.
|
||||
|
||||
Ein wichtiger Punkt ist, dass die obigen Set-Methoden die Größe der Listen nicht verändern.
|
||||
Das bedeutet, dass Sie eine Liste löschen können, indem Sie sie auf eine leere Tabelle setzen, und sie wird nicht
|
||||
verkleinert:
|
||||
Das bedeutet, dass Sie eine Liste löschen können, indem Sie sie auf eine leere Tabelle setzen, ohne dass sie verkleinert wird:
|
||||
|
||||
```lua
|
||||
inv:set_list("main", {})
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
---
|
||||
title: Block Zeichnungstypen
|
||||
title: Node Zeichnungstypen
|
||||
layout: default
|
||||
root: ../..
|
||||
idx: 2.3
|
||||
@ -9,29 +9,29 @@ redirect_from: /de/chapters/node_drawtypes.html
|
||||
|
||||
## Einleitung <!-- omit in toc -->
|
||||
|
||||
Die Methode, mit der ein Block gezeichnet wird, wird als *Zeichnungstyp* bezeichnet. Es gibt viele
|
||||
verfügbare Zeichnungstypen. Das Verhalten eines Zeichnungstyp kann gesteuert werden
|
||||
durch Angabe von Eigenschaften in der Blocktypdefinition gesteuert werden. Diese Eigenschaften
|
||||
sind für alle Instanzen dieses Knotens festgelegt. Es ist möglich, einige Eigenschaften
|
||||
pro Knoten zu steuern, indem man etwas namens `param2` verwendet.
|
||||
Die Methode, mit der ein Node gezeichnet wird, wird als *Zeichnungstyp* bezeichnet. Es gibt viele
|
||||
verfügbare Zeichnungstypen. Das Verhalten eines Zeichnungstyps kann
|
||||
durch Angabe von Eigenschaften in der Nodetypdefinition gesteuert werden. Diese Eigenschaften
|
||||
sind für alle Instanzen dieses Nodes festgelegt. Es ist möglich, einige Eigenschaften
|
||||
pro Node zu steuern, indem man `param2` verwendet.
|
||||
|
||||
Im vorigen Kapitel wurde das Konzept der Blöcke und Items eingeführt, aber eine
|
||||
vollständige Definition eines Blockes wurde nicht gegeben. Die Minetest-Welt ist ein 3D-Gitter aus
|
||||
Positionen. Jede Position wird als Block bezeichnet und besteht aus dem Blocktyp
|
||||
Im vorigen Kapitel wurde das Konzept der Nodes und Items eingeführt, aber eine
|
||||
vollständige Definition eines Nodes wurde nicht gegeben. Die Minetest-Welt ist ein 3D-Gitter aus
|
||||
Positionen. Jede Position wird als Node bezeichnet und besteht aus dem Nodetyp
|
||||
(Name) und zwei Parametern (param1 und param2). Die Funktion
|
||||
`minetest.register_node` (übersetzt `minetest.registriere_Block`)ist ein wenig irreführend, da sie nicht wirklich
|
||||
einen Knoten registriert - sie registriert einen neuen *Typ* von Block.
|
||||
`minetest.register_node` (übersetzt `minetest.registriere_node`)ist ein wenig irreführend, da sie nicht wirklich
|
||||
einen Node registriert - sie registriert einen neuen *Typ* von Node.
|
||||
|
||||
Die Blockparameter werden verwendet, um zu steuern, wie ein Block individuell gerendert wird.
|
||||
`param1` wird verwendet, um die Beleuchtung eines Blockes zu speichern, und die Bedeutung von
|
||||
`param2` hängt von der Eigenschaft `paramtype2` der Blocktypdefinition ab.
|
||||
Die Nodeparameter werden zum steuern, wie ein Nde individuell gerendert wird, verwendet.
|
||||
`param1` wird verwendet, um die Beleuchtung eines Nodes zu speichern, und die Bedeutung von
|
||||
`param2` hängt von der Eigenschaft `paramtype2` der Nodetypdefinition ab.
|
||||
|
||||
- [Würfelförmiger Block: Normale und allfaces](#würfelförmiger-block-normale-und-allfaces)
|
||||
- [Glasartige Blöcke](#glasartige-blöcke)
|
||||
- [Würfelförmiger Node: Normale und allfaces](#würfelförmiger-node-normale-und-allfaces)
|
||||
- [Glasartige Nodes](#glasartige-nodes)
|
||||
- [Glasartig gerahmt](#glasartig-gerahmt)
|
||||
- [Airlike Nodes](#airlike-nodes)
|
||||
- [Lighting and Sunlight Propagation](#lighting-and-sunlight-propagation)
|
||||
- [Flüssige Blöcke](#flüssige-blöcke)
|
||||
- [Flüssige Nodes](#flüssige-nodes)
|
||||
- [Nodeboxen](#nodeboxen)
|
||||
- [Wandgehaltene Nodeboxen](#wandgehaltene-nodeboxen)
|
||||
- [Mesh Nodes](#mesh-nodes)
|
||||
@ -41,7 +41,7 @@ Die Blockparameter werden verwendet, um zu steuern, wie ein Block individuell ge
|
||||
- [Mehr Zeichnungstypen](#mehr-zeichnungstypen)
|
||||
|
||||
|
||||
## Würfelförmiger Block: Normale und allfaces
|
||||
## Würfelförmiger Node: Normale und allfaces
|
||||
|
||||
<figure class="right_image">
|
||||
<img src="{{ page.root }}//static/drawtype_normal.png" alt="Normaler Zeichnungstyp">
|
||||
@ -50,14 +50,14 @@ Die Blockparameter werden verwendet, um zu steuern, wie ein Block individuell ge
|
||||
</figcaption>
|
||||
</figure>
|
||||
|
||||
Der Zeichnungstyp normal wird normalerweise zum Rendern eines Würfelförmigen Blockes verwendet.
|
||||
Wenn die Seite eines normalen Blockes an einer festen Seite anliegt, wird diese Seite nicht gerendert,
|
||||
Der Zeichnungstyp normal wird typischerweise zum Rendern eines Würfelförmigen Nodes verwendet.
|
||||
Wenn die Seite eines normalen Nodes an einer festen Seite anliegt, wird diese Seite nicht gerendert,
|
||||
was zu einem großen Leistungsgewinn führt.
|
||||
|
||||
Im Gegensatz dazu wird der Zeichnungstyp allfaces immer noch die Innenseite darstellen, wenn er auf einen
|
||||
soliden Block ist. Dies ist gut für Blöcke mit teilweise transparenten Seiten, wie z.B. den
|
||||
Blatt-Block. Sie können den allfaces_optional drawtype verwenden, um den Benutzern die Möglichkeit zu geben, die
|
||||
langsamere Zeichnen auszuschalten, in diesem Fall verhält er sich wie ein normaler Block.
|
||||
soliden Node ist. Dies ist gut für Nodes mit teilweise transparenten Seiten, wie z.B. den
|
||||
Blatt-Node. Sie können den allfaces_optional drawtype verwenden, um den Benutzern die Möglichkeit zu geben, die
|
||||
langsamere Zeichnen auszuschalten, in diesem Fall verhält er sich wie ein normaler Node.
|
||||
|
||||
```lua
|
||||
minetest.register_node("meinemod:diamant", {
|
||||
@ -77,11 +77,11 @@ Hinweis: Der normale Zeichentyp ist der Standard-Zeichentyp, Sie müssen ihn als
|
||||
angeben.
|
||||
|
||||
|
||||
## Glasartige Blöcke
|
||||
## Glasartige Nodes
|
||||
|
||||
Der Unterschied zwischen glasartigen(glasslike) und normalen Blöcken besteht darin, dass die Platzierung eines glasartigen Blockes
|
||||
neben einem normalen Block platziert wird, nicht dazu führt, dass die Seite des normalen Blockes ausgeblendet wird.
|
||||
Dies ist nützlich, weil glasartige Block dazu neigen, transparent zu sein, und daher die Verwendung eines normalen
|
||||
Der Unterschied zwischen glasartigen(glasslike) und normalen Nodes besteht darin, dass die Platzierung eines glasartigen Nodes
|
||||
neben einem normalen Node, nicht dazu führt, dass die Seite des normalen Nodes ausgeblendet wird.
|
||||
Dies ist nützlich, weil glasartige Nodes in der Regel transparent sind und daher die Verwendung eines normalen
|
||||
Drawtype dazu führen würde, dass man durch die Welt hindurchsehen kann.
|
||||
|
||||
<figure>
|
||||
@ -106,8 +106,8 @@ minetest.register_node("default:obsidian_glass", {
|
||||
|
||||
### Glasartig gerahmt
|
||||
|
||||
Dies führt dazu, dass die Kante des Blockes mit einem 3D-Effekt um das ganze Ding herumgeht und nicht
|
||||
als um einzelne Block, wie im Folgenden dargestellt:
|
||||
Dies führt dazu, dass die Kante des Nodes mit einem 3D-Effekt um das ganze Ding herumgeht und nicht
|
||||
um einen einzelnen Node, wie im Folgenden dargestellt:
|
||||
|
||||
<figure>
|
||||
<img src="{{ page.root }}//static/drawtype_glasslike_framed.png" alt="Glasartig gerahmt Ränder">
|
||||
@ -116,8 +116,8 @@ als um einzelne Block, wie im Folgenden dargestellt:
|
||||
</figcaption>
|
||||
</figure>
|
||||
|
||||
Sie können den Zeichnungstyp `glasslike_framed_optional` verwenden, um dem Benutzer die Möglichkeit zu geben, *opt-in*
|
||||
in das gerahmte Erscheinungsbild.
|
||||
Sie können den Zeichnungstyp `glasslike_framed_optional` verwenden, um dem Benutzer die Möglichkeit zu geben,
|
||||
das gerahmte Erscheinungsbild manuell zu aktivieren.
|
||||
|
||||
```lua
|
||||
minetest.register_node("default:glass", {
|
||||
@ -126,16 +126,16 @@ minetest.register_node("default:glass", {
|
||||
tiles = {"default_glass.png", "default_glass_detail.png"},
|
||||
inventory_image = minetest.inventorycube("default_glass.png"),
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true, -- Sonnenlicht kann durch den Block scheinen
|
||||
sunlight_propagates = true, -- Sonnenlicht kann durch den Node scheinen
|
||||
groups = {cracky = 3, oddly_breakable_by_hand = 3},
|
||||
sounds = default.node_sound_glass_defaults()
|
||||
})
|
||||
```
|
||||
|
||||
|
||||
## Luftartige Blöcke
|
||||
## Luftartige Nodes
|
||||
|
||||
Diese Blöcke werden nicht gerendert und haben daher keine Texturen.
|
||||
Diese Nodes werden nicht gerendert und haben daher keine Texturen.
|
||||
|
||||
```lua
|
||||
minetest.register_node("meineluft:luft", {
|
||||
@ -144,11 +144,11 @@ minetest.register_node("meineluft:luft", {
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true,
|
||||
|
||||
walkable = false, -- Würde den Spieler mit dem Luftblock kollidieren lassen
|
||||
pointable = false, -- Sie können den Block nicht auswählen
|
||||
diggable = false, -- Sie können den Block nicht abbauen
|
||||
buildable_to = true, -- Blöcke können diesen Block ersetzen
|
||||
-- (Sie können einen Block platzieren und den Luftblock
|
||||
walkable = false, -- Würde den Spieler mit dem Luftnode kollidieren lassen
|
||||
pointable = false, -- Sie können den Node nicht auswählen
|
||||
diggable = false, -- Sie können den Node nicht abbauen
|
||||
buildable_to = true, -- Nodes können diesen Node ersetzen
|
||||
-- (Sie können einen Node platzieren und den Luftnode
|
||||
-- entfernen die früher einmal da waren)
|
||||
|
||||
air_equivalent = true,
|
||||
@ -160,12 +160,12 @@ minetest.register_node("meineluft:luft", {
|
||||
|
||||
## Beleuchtung und Sonnenlichtausbreitung
|
||||
|
||||
Die Beleuchtung eines Blockes wird in param1 gespeichert. Um herauszufinden, wie man die
|
||||
Seite eines Blockes zu schattieren hat, wird der Lichtwert des benachbarten Blockes verwendet.
|
||||
Aus diesem Grund haben solide Blöcke keine Lichtwerte, da sie das Licht blockieren.
|
||||
Die Beleuchtung eines Nodes wird in param1 gespeichert. Um herauszufinden, wie man die
|
||||
Seite eines Nodes zu schattieren hat, wird der Lichtwert des benachbarten Nodes verwendet.
|
||||
Aus diesem Grund haben solide Nodes keine Lichtwerte, da sie das Licht blockieren.
|
||||
|
||||
Standardmäßig lässt ein Blocktyp nicht zu, dass Licht in Blockinstanzen gespeichert wird.
|
||||
Es ist normalerweise wünschenswert, dass einige Blöcke wie Glas und Luft in der Lage sind
|
||||
Standardmäßig lässt ein Nodetyp nicht zu, dass Licht in Nodeinstanzen gespeichert wird.
|
||||
Es ist normalerweise wünschenswert, dass einige Nodes wie Glas und Luft in der Lage sind,
|
||||
Licht durchzulassen. Zu diesem Zweck müssen zwei Eigenschaften definiert werden:
|
||||
|
||||
```lua
|
||||
@ -174,9 +174,9 @@ sunlight_propagates = true,
|
||||
```
|
||||
|
||||
Die erste Zeile bedeutet, dass param1 in der Tat den Lichtwert speichert.
|
||||
Die zweite Zeile bedeutet, dass das Sonnenlicht diesen Knoten durchlaufen sollte, ohne an Wert zu verlieren.
|
||||
Die zweite Zeile bedeutet, dass das Sonnenlicht diesen Node durchlaufen sollte, ohne an Wert zu verlieren.
|
||||
|
||||
## Flüssige Blöcke
|
||||
## Flüssige Nodes
|
||||
|
||||
<figure class="right_image">
|
||||
<img src="{{ page.root }}//static/drawtype_liquid.png" alt="Flüssigkeiten Zeichnungstyp">
|
||||
@ -185,7 +185,7 @@ Die zweite Zeile bedeutet, dass das Sonnenlicht diesen Knoten durchlaufen sollte
|
||||
</figcaption>
|
||||
</figure>
|
||||
|
||||
Jede Art von Flüssigkeit erfordert zwei Blockdefinitionen - eine für die Flüssigkeitsquelle und
|
||||
Jede Art von Flüssigkeit erfordert zwei Nodedefinitionen - eine für die Flüssigkeitsquelle und
|
||||
eine weitere für die fließende Flüssigkeit.
|
||||
|
||||
```lua
|
||||
@ -221,12 +221,12 @@ minetest.register_node("default:water_source", {
|
||||
},
|
||||
|
||||
--
|
||||
-- Behavior
|
||||
-- Verhalten
|
||||
--
|
||||
walkable = false, -- Der Spieler fällt durch
|
||||
pointable = false, -- Der Spieler kann es nicht auswählen
|
||||
diggable = false, -- Der Spieler kann es nicht abbauen
|
||||
buildable_to = true, -- Blöcke können diesen Block ersetzen
|
||||
buildable_to = true, -- Nodes können diesen Node ersetzen
|
||||
|
||||
alpha = 160,
|
||||
|
||||
@ -253,7 +253,7 @@ minetest.register_node("default:water_source", {
|
||||
})
|
||||
```
|
||||
|
||||
Fließende Blöcke haben eine ähnliche Definition, allerdings mit einem anderen Namen und einer anderen Animation.
|
||||
Fließende Nodes haben eine ähnliche Definition, allerdings mit einem anderen Namen und einer anderen Animation.
|
||||
Siehe `default:water_flowing` in der Standard-Mod in `minetest_game` für ein vollständiges Beispiel.
|
||||
|
||||
## Nodeboxen
|
||||
@ -265,7 +265,7 @@ Siehe `default:water_flowing` in der Standard-Mod in `minetest_game` für ein vo
|
||||
</figcaption>
|
||||
</figure>
|
||||
|
||||
Mit Nodeboxen können Sie einen Block erstellen, der nicht würfelförmig ist, sondern
|
||||
Mit Nodeboxen können Sie einen Node erstellen, der nicht würfelförmig ist, sondern
|
||||
aus beliebig vielen Quadern besteht.
|
||||
|
||||
```lua
|
||||
@ -289,13 +289,13 @@ Der wichtigste Teil ist die Nodebox-Tabelle:
|
||||
{-0.5, 0, 0, 0.5, 0.5, 0.5}
|
||||
```
|
||||
|
||||
Jede Zeile ist ein Quader, der zu einem einzigen Blockpunkt verbunden ist.
|
||||
Jede Zeile ist ein Quader, der zu einem einzigen Nodepunkt verbunden ist.
|
||||
Die ersten drei Zahlen sind die Koordinaten (von -0,5 bis einschließlich 0,5) der
|
||||
der unteren, vorderen, linken Ecke, die letzten drei Zahlen sind die gegenüberliegende Ecke.
|
||||
Sie haben die Form X, Y, Z, wobei Y für oben steht.
|
||||
|
||||
Du kannst den [NodeBoxEditor](https://forum.minetest.net/viewtopic.php?f=14&t=2840) benutzen um
|
||||
Erstellen Sie Nodeboxen durch Ziehen der Kanten, das ist anschaulicher als die Arbeit von Hand.
|
||||
Sie können den [NodeBoxEditor](https://forum.minetest.net/viewtopic.php?f=14&t=2840) benutzen um
|
||||
Nodeboxen durch Ziehen der Kanten zu erstellen. Das ist anschaulicher als die Arbeit von Hand.
|
||||
|
||||
|
||||
### Wandgehaltene Nodeboxen
|
||||
@ -308,17 +308,17 @@ minetest.register_node("default:sign_wall", {
|
||||
node_box = {
|
||||
type = "wallmounted",
|
||||
|
||||
-- Ceiling
|
||||
-- Decke
|
||||
wall_top = {
|
||||
{-0.4375, 0.4375, -0.3125, 0.4375, 0.5, 0.3125}
|
||||
},
|
||||
|
||||
-- Floor
|
||||
-- Boden
|
||||
wall_bottom = {
|
||||
{-0.4375, -0.5, -0.3125, 0.4375, -0.4375, 0.3125}
|
||||
},
|
||||
|
||||
-- Wall
|
||||
-- Wand
|
||||
wall_side = {
|
||||
{-0.5, -0.3125, -0.4375, -0.4375, 0.3125, 0.4375}
|
||||
}
|
||||
@ -328,7 +328,7 @@ minetest.register_node("default:sign_wall", {
|
||||
|
||||
## Mesh Nodes
|
||||
|
||||
Nodeboxen sind zwar im Allgemeinen einfacher zu erstellen, doch sind sie insofern eingeschränkt, als
|
||||
Nodeboxen sind zwar im Allgemeinen einfacher zu erstellen, doch sind sie insofern eingeschränkt, als dass
|
||||
sie nur aus Quadern bestehen können. Nodeboxen sind außerdem nicht optimiert;
|
||||
Innenflächen werden auch dann noch gerendert, wenn sie vollständig ausgeblendet sind.
|
||||
|
||||
@ -336,7 +336,7 @@ Eine Fläche ist eine ebene Oberfläche in einem Mesh(Netz). Eine innere Fläche
|
||||
verschiedenen Nodeboxen überlappen, wodurch Teile des Nodebox-Modells
|
||||
unsichtbar sind, aber dennoch gerendert werden.
|
||||
|
||||
So können Sie ein mesh node registrieren:
|
||||
So können Sie ein Mesh Node registrieren:
|
||||
|
||||
```lua
|
||||
minetest.register_node("mymod:meshy", {
|
||||
@ -354,14 +354,14 @@ minetest.register_node("mymod:meshy", {
|
||||
|
||||
Vergewissern Sie sich, dass das Mesh in einem `models`-Verzeichnis verfügbar ist.
|
||||
Meistens sollte sich das Mesh im eigenen Mod-Ordner befinden, aber es ist auch in Ordnung, wenn
|
||||
ein Mesh zu verwenden, das von einem anderen Mod bereitgestellt wird, von dem du abhängig bist. Zum Beispiel kann ein Mod, der
|
||||
ein Mesh zu verwenden, das von einer anderen Mod bereitgestellt wird, von dem sie abhängig ist. Zum Beispiel kann eine Mod, die
|
||||
weitere Möbeltypen hinzufügt, das Modell einer grundlegenden
|
||||
Möbel-Mod sein.
|
||||
|
||||
|
||||
## Signlike Nodes
|
||||
|
||||
Signlike nodes sind flache Knoten, die an den Seiten anderer Knoten angebracht werden können.
|
||||
Signlike Nodes sind flache Nodes, die an den Seiten anderer Nodes angebracht werden können.
|
||||
Trotz des Namens dieses Zeichentyps verwenden Schilder in der Regel nicht signlike,
|
||||
sondern verwenden stattdessen den Zeichnungstyp `Nodebox`, um einen 3D-Effekt zu erzielen. Der Zeichentyp `signlike`
|
||||
wird jedoch häufig von Leitern verwendet.
|
||||
@ -391,7 +391,7 @@ minetest.register_node("default:ladder_wood", {
|
||||
</figcaption>
|
||||
</figure>
|
||||
|
||||
Plantlike Nodes ziehen ihre Kacheln in einem X-ähnlichen Muster.
|
||||
Plantlike Nodes zeichnen ihre Kacheln in einem X-ähnlichen Muster.
|
||||
|
||||
```lua
|
||||
minetest.register_node("default:papyrus", {
|
||||
@ -409,8 +409,7 @@ minetest.register_node("default:papyrus", {
|
||||
|
||||
## Firelike Nodes
|
||||
|
||||
Firelike ist ähnlich zu plantlike, mit der Ausnahme, dass es so konzipiert ist für
|
||||
Wände und Decken.
|
||||
Firelike ist ähnlich zu plantlike, mit der Ausnahme, dass es so konmzipiert ist, dass es auch an Wänden und Decken haften kann.
|
||||
|
||||
<figure>
|
||||
<img src="{{ page.root }}//static/drawtype_firelike.png" alt="Firelike nodes">
|
||||
@ -435,8 +434,8 @@ Dies ist keine vollständige Liste, es gibt noch weitere Arten:
|
||||
* Fencelike
|
||||
* Plantlike rooted - für Unterwasser-Pflanzen
|
||||
* Raillike - für Schienen
|
||||
* Torchlike - für 2D Wand/Boden/Decken-Blöcke.
|
||||
Die Fackeln in Minetest Game verwenden zwei verschiedene Block-Definitionen von
|
||||
* Torchlike - für 2D Wand/Boden/Decken-Nodes.
|
||||
Die Fackeln in Minetest Game verwenden zwei verschiedene Node-Definitionen von
|
||||
mesh nodes (default:torch und default:torch_wall).
|
||||
|
||||
Und lese immer [Lua API dokumentation](https://minetest.gitlab.io/minetest/nodes/#node-drawtypes)
|
||||
|
||||
@ -1,25 +1,23 @@
|
||||
---
|
||||
title: Blöcke, Items und Craften
|
||||
title: Nodes, Items und Craften
|
||||
layout: default
|
||||
root: ../..
|
||||
idx: 2.1
|
||||
description: Benutze register_node, register_item und register_craft um zu lernen wie man Blöcke, Items und Rezepte erstellen.
|
||||
description: Benutze register_node, register_item und register_craft um zu lernen, wie man Nodes, Items und Rezepte erstellt.
|
||||
redirect_from: /de/chapters/nodes_items_crafting.html
|
||||
---
|
||||
|
||||
## Einführung <!-- omit in toc -->
|
||||
|
||||
Neue Blöcke, Craftitems und Rezepte zu erstellen,
|
||||
Neue Nodes, Craftitems und Rezepte zu erstellen
|
||||
sind Grundlagen von vielen Mods
|
||||
|
||||
- [Was sind Blöcke und Craftitems?](#was-sind-blöcke-und-craftitems)
|
||||
- [Was sind Nodes und Craftitems?](#was-sind-nodes-und-craftitems)
|
||||
- [Items erstellen](#items-erstellen)
|
||||
- [Itemnamen](#itemnamen)
|
||||
- [Itemaliase](#itemaliase)
|
||||
- [Texturen](#texturen)
|
||||
- [Erstellen von Basis-Blöcken](#erstellen-von-basis-blöcken)
|
||||
- [Aktionen und Callbacks](#aktionen-und-callbacks)
|
||||
- [on_use](#onuse)
|
||||
- [Erstellen von Basis-Nodes](#erstellen-von-basis-nodes)
|
||||
- [Crafting](#crafting)
|
||||
- [Shaped](#shaped)
|
||||
- [Shapeless](#shapeless)
|
||||
@ -27,19 +25,19 @@ sind Grundlagen von vielen Mods
|
||||
- [Gruppen](#gruppen)
|
||||
- [Werkzeuge, Fähigkeiten und Grabungstypen](#werkzeuge-fähigkeiten-und-grabungstypen)
|
||||
|
||||
## Was sind Blöcke und Craftitems?
|
||||
## Was sind Nodes und Craftitems?
|
||||
|
||||
Blöcke, Craftitems und tools sind alles Items. Ein Items ist etwas das im Inventar gefunden werden kann - Sogar wenn es nicht im normalen gameplay nicht möglich ist.
|
||||
Nodes, Craftitems und Tools sind alles Items. Ein Item ist etwas, das im Inventar gefunden werden kann - sogar wenn es im normalen Gameplay nicht möglich ist.
|
||||
|
||||
Ein Block ist ein Item das plaziert werden kann oder in der Welt gefunden werden kann. Jede Position muss belegt werden mit ein und nur einen Block - Scheinbare leere Position sind normalerweise Luftblöcke.
|
||||
Ein Node ist ein Item, das platziert oder in der Welt gefunden werden kann. Jede Position muss belegt werden mit einem und nur einem Node - scheinbar leere Position sind normalerweise Luftblöcke.
|
||||
|
||||
Ein Craftitem kann nicht plazier werden man kann es nur im Inventar finden oder als gedropptes Item in der Welt.
|
||||
Ein Craftitem kann nicht platziert werden. Man kann es nur im Inventar finden oder als gedropptes Item in der Welt.
|
||||
|
||||
Ein Werkzeug hat die Fähigkeit sich abzunutzen und hat normalerweise nicht standardmäßige Abbaufähigkeiten. In Zukunft we Craftitems und Werkzeuge wahrscheinlich verschmelzen weil die Unterscheidung zwinschen ihnen eher ausgedacht ist.
|
||||
Ein Werkzeug hat die Fähigkeit sich abzunutzen und hat normalerweise nicht standardmäßige Abbaufähigkeiten. In Zukunft werden Craftitems und Werkzeuge wahrscheinlich verschmelzen, weil die Unterscheidung zwischen ihnen eher ausgedacht ist.
|
||||
|
||||
## Items erstellen
|
||||
|
||||
Item Definitionen bestehen aus einen *Itemnamen* und einer *Definitions Tabelle*. Die Definitions Tabelle beinhaltet Attribute welche das Verhalten eines Items beinflussen.
|
||||
Itemdefinitionen bestehen aus einen *Itemnamen* und einer *Definitionstabelle*. Die Definitionstabellen beinhalten Attribute, welche das Verhalten eines Items beeinflussen.
|
||||
|
||||
```lua
|
||||
minetest.register_craftitem("modname:itemname", {
|
||||
@ -50,15 +48,15 @@ minetest.register_craftitem("modname:itemname", {
|
||||
|
||||
### Itemnamen
|
||||
|
||||
jedes Item hat ein Itemnamen welches auf sich verweist, es sollte folgendes Format haben:
|
||||
jedes Item hat einen Itemnamen, welches auf sich verweist. Er sollte folgendes Format haben:
|
||||
|
||||
modname:itemname
|
||||
|
||||
### Itemaliase
|
||||
Items können auch *Aliase* haben die auf ihren Namen zeigen. Ein *Alias* ist ein nachgemachter Item Name der dazu führt, dass die Egine alle Aliase so behandelt als wären es Itemnamen. Da sind zwei verbreitete Varianten um das zu nutzen:
|
||||
Items können auch *Aliase* haben, die auf ihren Namen zeigen. Ein *Alias* ist ein nachgemachter Itemname, der dazu führt, dass die Engine alle Aliase so behandelt als wären es Itemnamen. Es gibt hierfür zwei verbreitete Anwendungsmöglichkeiten:
|
||||
|
||||
* Umbenannte entfernte Items in etwas anderes umzubenennen. Es kann Unbekannte Items in der Welt oder im Inventar geben, wenn ein Gegenstand ohne Korrektur aus einen Mod entfernt wird.
|
||||
* Ein Abkürzung hinzufügen. `/giveme dirt` ist einfacher als `/giveme default:dirt`.
|
||||
* Umbenennen von entfernten Items. Es kann unbekannte Items in der Welt oder im Inventar geben, wenn ein Gegenstand ohne Korrektur aus einen Mod entfernt wird.
|
||||
* Hinzufügen von Abkürzungen. `/giveme dirt` ist einfacher als `/giveme default:dirt`.
|
||||
|
||||
Ein Itemalias zu erstellen ist richtig einfach. Ein guter Weg um sich die Reinfolge von der Argumenten zu merken ist `von → zu` wo *von* der alias ist und *zu* das Orginal.
|
||||
|
||||
@ -75,17 +73,17 @@ itemname = minetest.registered_aliases[itemname] or itemname
|
||||
|
||||
### Texturen
|
||||
|
||||
Texturen solten in den textures/ Pfad mit Namen im Format plaziert werden
|
||||
Texturen solten in den textures/ Pfad mit Namen im Format
|
||||
`modname_itemname.png`.\\
|
||||
JPEG texturen werden unterstüzt, aber sie unterstüzen keine tranperenz und haben generell
|
||||
schlechte qualität und niedrige Auflösung.
|
||||
Es ist oft besser das PNG format zu benutzen.
|
||||
platziert werden. JPEG Texturen werden unterstüzt, aber sie unterstützen keine Transparenz und haben generell
|
||||
schlechte Qualität und eine niedrige Auflösung.
|
||||
Es ist oft besser das PNG Format zu benutzen.
|
||||
|
||||
Texturen in Minetest sind in der Regel 16 mal 16 Pixel.
|
||||
Sie können in jeder Auflösung sein, es wird jedoch empfohlen, dass sie in der Größenordnung von 2 liegen, beispielsweise 16, 32, 64 oder 128.
|
||||
Das liegt daran, dass andere Auflösungen auf älteren Geräten möglicherweise nicht korrekt unterstützt werden. was zu einer geringeren Leistung führt.
|
||||
Das liegt daran, dass andere Auflösungen auf älteren Geräten möglicherweise nicht korrekt unterstützt werden, was zu einer geringeren Leistung führt.
|
||||
|
||||
## Erstellen von Basis-Blöcken
|
||||
## Erstellen von Basis-Nodes
|
||||
```lua
|
||||
minetest.register_node("meinemod:diamant", {
|
||||
description = "Alien Diamanten",
|
||||
@ -94,15 +92,14 @@ minetest.register_node("meinemod:diamant", {
|
||||
groups = {cracky=3, stone=1}
|
||||
})
|
||||
```
|
||||
Die Eigenschaft `tiles` ist eine Tabelle mit Texturnamen, die der Blöcken verwenden wird.
|
||||
Die Eigenschaft `tiles` ist eine Tabelle mit Texturnamen, die der Node verwenden wird.
|
||||
Wenn es nur eine Textur gibt, wird diese Textur auf jeder Seite verwendet.
|
||||
Um eine andere Textur pro Seite zu erhalten, geben Sie die Namen von 6 Texturen in dieser Reihenfolge an:
|
||||
|
||||
oben (+Y), unten (-Y), rechts (+X), links (-X), hinten (+Z), vorne (-Z).
|
||||
(+Y, -Y, +X, -X, +Z, -Z)
|
||||
|
||||
Denken Sie daran, dass +Y in Minetest nach oben zeigt, wie es in der
|
||||
3D-Computergrafiken.
|
||||
Denken Sie daran, dass +Y in Minetest nach oben zeigt, wie es in den meisten 3D-Computerspielen der Fall ist.
|
||||
|
||||
```lua
|
||||
minetest.register_node("meinemod:diamant", {
|
||||
@ -122,55 +119,11 @@ minetest.register_node("meinemod:diamant", {
|
||||
})
|
||||
```
|
||||
|
||||
Mit dem Attribut `is_ground_content` können Höhlen über dem Stein erzeugt werden. Dies ist wichtig für jeden Knoten, der während der Kartenerstellung unterirdisch platziert werden kann. Höhlen werden aus der Welt herausgeschnitten, nachdem alle anderen Knoten in einem Gebiet generiert wurden.
|
||||
|
||||
## Aktionen und Callbacks
|
||||
|
||||
Minetest verwendet hauptsächlich ein Callback-basiertes Modding-Design.
|
||||
Callbacks können in der Objektdefinitionstabelle platziert werden, um eine Reaktion auf
|
||||
verschiedene Benutzerereignisse vorzuruffen.
|
||||
|
||||
### on_use
|
||||
|
||||
Normalerweise wird der Verwendungsrückruf ausgelöst, wenn ein Spieler mit der linken Maustaste auf einen Gegenstand klickt.
|
||||
Ein Verwendungs-Callback verhindert, dass der Gegenstand zum Graben von Knoten verwendet wird.
|
||||
Eine häufige Verwendung des Callback ist für Nahrung:
|
||||
|
||||
```lua
|
||||
minetest.register_craftitem("meinemod:schlammkuchen", {
|
||||
description = "Alien Schlamm Kuchen",
|
||||
inventory_image = "meinessen_schlammkuchen.png",
|
||||
on_use = minetest.item_eat(20),
|
||||
})
|
||||
```
|
||||
|
||||
Die Zahl, die an die Funktion minetest.item_eat übergeben wird, ist die Anzahl der halben Herzen
|
||||
die durch den Verzehr dieses Lebensmittels geheilt werden.
|
||||
Jedes Herzsymbol, das der Spieler hat, sind zwei halbe Herzen wert.
|
||||
Ein Spieler kann normalerweise bis zu 10 Herzen haben, was 20 halbe Herzen entspricht.
|
||||
Die halben Herzen müssen keine ganzen Zahlen sein, sondern können auch Dezimalzahlen sein.
|
||||
|
||||
minetest.item_eat() ist eine Funktion, die eine Funktion zurückgibt, die sie
|
||||
als on_use-Callback.
|
||||
Das bedeutet, dass der obige Code ungefähr so aussieht:
|
||||
|
||||
```lua
|
||||
minetest.register_craftitem("meinemod:schlammkuchen", {
|
||||
description = "Alien Schlamm Kuchen",
|
||||
inventory_image = "meinessen_schlammkuchen.png",
|
||||
on_use = function(...)
|
||||
return minetest.do_item_eat(20, nil, ...)
|
||||
end,
|
||||
})
|
||||
```
|
||||
|
||||
Wenn man versteht, wie item_eat funktioniert, indem es einfach eine Funktion zurückgibt, ist es
|
||||
ist es möglich, die Funktion so zu ändern, dass sie ein komplexeres Verhalten zeigt, z. B. das Abspielen eines benutzerdefinierten Sounds.
|
||||
Mit dem Attribut `is_ground_content` können Höhlen über dem Stein erzeugt werden. Dies ist wichtig für jeden Node, der während der Kartenerstellung unterirdisch platziert werden kann. Höhlen werden aus der Welt herausgeschnitten, nachdem alle anderen Nodes in einem Gebiet generiert wurden.
|
||||
|
||||
## Crafting
|
||||
|
||||
Es gibt verschiedene Arten von Bastelrezepten, die durch die Eigenschaft `Typ` angezeigt werden
|
||||
Eigenschaft angezeigt.
|
||||
Es gibt verschiedene Arten von Craftingrezepten, die durch die Eigenschaft `type` angezeigt werden.
|
||||
|
||||
* shaped - Die Zutaten müssen sich an der richtigen Stelle befinden.
|
||||
* shapeless - Es spielt keine Rolle, wo sich die Zutaten befinden,
|
||||
@ -179,14 +132,13 @@ Eigenschaft angezeigt.
|
||||
* fuel - Definiert Gegenstände, die in Öfen verbrannt werden können.
|
||||
* tool_repair - Definiert Gegenstände, die mit Werkzeugen repariert werden können.
|
||||
|
||||
Handwerksrezepte sind keine Gegenstände, daher verwenden sie keine Gegenstandsnamen zur eindeutigen
|
||||
identifizieren.
|
||||
Craftingrezepte sind keine Gegenstände, daher verwenden sie keine eindeutigen Itemnamen um sie zu identifizieren.
|
||||
|
||||
### Shaped
|
||||
|
||||
Shaped Rezepte sind Rezepte, bei denen die Zutaten in der richtigen Form oder
|
||||
Shaped Rezepte sind Rezepte, bei denen die Zutaten die richtige Form oder das richtige
|
||||
Muster haben müssen, um zu funktionieren. In dem folgenden Beispiel müssen die Fragmente in einem
|
||||
stuhlähnlichen Muster liegen, damit das Handwerk funktioniert.
|
||||
stuhlähnlichen Muster liegen, damit das Crafting funktioniert.
|
||||
|
||||
```lua
|
||||
minetest.register_craft({
|
||||
@ -203,8 +155,8 @@ minetest.register_craft({
|
||||
Zu beachten ist auch die leere Spalte auf der rechten Seite.
|
||||
Das bedeutet, dass rechts von der Form eine leere Spalte vorhanden sein *muss*, sonst
|
||||
wird dies nicht funktionieren.
|
||||
Wenn diese leere Spalte nicht erforderlich sein sollte, können die leeren Zeichenfolgen weggelassen werden
|
||||
so weggelassen werden:
|
||||
Wenn diese leere Spalte nicht erforderlich sein sollte, können die leeren Strings
|
||||
folgendermaßen weggelassen werden:
|
||||
|
||||
```lua
|
||||
minetest.register_craft({
|
||||
@ -218,8 +170,8 @@ minetest.register_craft({
|
||||
})
|
||||
```
|
||||
|
||||
Das Feld "Typ" wird für geformte Handwerke nicht benötigt, da "geformt" der
|
||||
Standard-Handwerkstyp ist.
|
||||
Das Feld "type" wird für Shaped Rezepte nicht benötigt, da "shaped" der
|
||||
Standard-Craftingtyp ist.
|
||||
|
||||
### Shapeless
|
||||
|
||||
@ -253,17 +205,17 @@ minetest.register_craft({
|
||||
})
|
||||
```
|
||||
|
||||
Der einzige wirklich Unterschied im Code ist, dass das Rezept nur ein Item beinhaltet
|
||||
im Vergleich zu einer Tabelle (zwischen geschweiften Klammern).
|
||||
Sie haben optional auch einen "cooktime" parameter, welcher
|
||||
Der einzige wirklich Unterschied im Code ist, dass das Rezept nur ein Item
|
||||
im Vergleich zu einer Tabelle (zwischen geschweiften Klammern) beinhaltet.
|
||||
Sie haben optional auch einen "cooktime" Parameter, welcher
|
||||
definiert wie lange die Items zu kochen brauchen.
|
||||
Wenn dies nicht gesetzt ist, ist der Standard 3.
|
||||
|
||||
Das Rezepz oben funktioniert, wenn der Kohle Block im Input-Slotm ist,
|
||||
Das Rezept oben funktioniert, wenn der Kohleblock im Input-Slot ist,
|
||||
mit irgendeiner Form von Brennstoff darunter.
|
||||
Es stell nach 10 Sekunden ein Diamant-Fragment her!
|
||||
Es stellt nach 10 Sekunden ein Diamant-Fragment her!
|
||||
|
||||
Dieser Typ ist eine Ergänzung zum Kochtyp, da er definiert
|
||||
Dieser Typ ist eine Ergänzung zum Kochtyp, da er definiert,
|
||||
was in Öfen und anderen Kochgeräten aus Mods verbrannt werden kann.
|
||||
|
||||
```lua
|
||||
@ -280,12 +232,8 @@ Der Diamant ist also 300 Sekunden lang als Brennstoff verwendbar!
|
||||
## Gruppen
|
||||
|
||||
Items können Mitglieder von vielen Gruppen sein und Gruppen können viele Mitglieder haben.
|
||||
Gruppen sind definiert die `groups`-Eigenschaft in der Definitions-Tabelle zu benutzen
|
||||
und haben einen
|
||||
|
||||
Items can be members of many groups and groups can have many members.
|
||||
Groups are defined using the `groups` property in the definition table
|
||||
and have an dazugehörig Wert.
|
||||
Gruppen werden durch die Verwendung der `groups`-Eigenschaft in der Definitions-Tabelle definiert
|
||||
und haben einen dazugehörigen Wert.
|
||||
|
||||
```lua
|
||||
groups = {cracky = 3, wood = 1}
|
||||
@ -293,8 +241,8 @@ groups = {cracky = 3, wood = 1}
|
||||
|
||||
Es gibt mehrere Gründe für die Verwendung von Gruppen.
|
||||
Erstens werden Gruppen verwendet, um Eigenschaften wie Abbautyp und Entflammbarkeit zu beschreiben.
|
||||
Zweitens können Gruppen in einem Handwerksrezept anstelle eines Gegenstandsnamens verwendet werden, damit
|
||||
ein beliebiger Gegenstand aus der Gruppe verwendet werden kann.
|
||||
Zweitens können Gruppen in einem Handwerksrezept anstelle eines Itemnamens verwendet werden, damit
|
||||
ein beliebiges Item aus der Gruppe verwendet werden kann.
|
||||
|
||||
```lua
|
||||
minetest.register_craft({
|
||||
@ -310,18 +258,18 @@ Dig types are groups which are used to define how strong a node is when dug
|
||||
with different tools.
|
||||
|
||||
|
||||
Grabungstypen sind Gruppen, die dazu dienen, zu definieren wie stark ein Block ist, wenn er
|
||||
Grabungstypen sind Gruppen, die dazu benutzt werden, um zu definieren wie stark ein Node ist, wenn er
|
||||
von verschiedenen Werkzeugen abgebaut wird.
|
||||
Eine Grabtypgruppe mit einem höheren Wert bedeutet, dass der Blockes leichter
|
||||
Eine Grabtypgruppe mit einem höheren Wert bedeutet, dass der Node leichter
|
||||
und schneller abzubauen ist.
|
||||
Es ist möglich, mehrere Grabtypen zu kombinieren, um eine effizientere Nutzung
|
||||
von mehreren Werkzeugtypen zu erzielen.
|
||||
Ein Block ohne Grabtypen kann mit keinem Werkzeug gegraben werden.
|
||||
Ein Node ohne Grabtypen kann mit keinem Werkzeug abgebaut werden.
|
||||
|
||||
|
||||
| Gruppe | Bestes Werkzeug | Beschreibung |
|
||||
|---------|-----------------|-------------|
|
||||
| crumbly | Spaten | Erde, Sand |
|
||||
| crumbly | Schaufel | Erde, Sand |
|
||||
| cracky | Spitzhacke | Zähes (aber brüchiges) Material wie Stein |
|
||||
| snappy | *irgendeins* | Kann mit feinen Werkzeugen geschnitten werden;<br>z.B. Blätter, kleine Pflanzen, Draht, Metallbleche |
|
||||
| choppy | Axt | Kann mit scharfer Gewalt geschnitten werden, z. B. Bäume, Holzbretter |
|
||||
@ -334,11 +282,11 @@ Jedes Werkzeug hat eine Werkzeugfähigkeit.
|
||||
Eine Fähigkeit umfasst eine Liste der unterstützten Grabtypen und die zugehörigen Eigenschaften
|
||||
für jeden Typ, wie z. B. die Grabungszeiten und der Grad der Abnutzung.
|
||||
Werkzeuge können auch eine maximal unterstützte Härte für jeden Typ haben, was es ermöglicht
|
||||
schwächere Werkzeuge daran zu hindern, härtere Knoten zu graben.
|
||||
Es ist sehr üblich, dass Werkzeuge alle Grabtypen in ihren Fähigkeiten enthalten,
|
||||
schwächere Werkzeuge daran zu hindern, härtere Nodes zu graben.
|
||||
Es ist sehr üblich, dass Werkzeuge alle Grabtypen in ihren Fähigkeiten enthalten.
|
||||
Die weniger geeigneten haben dabei sehr ineffiziente Eigenschaften.
|
||||
Wenn der Gegenstand, den ein Spieler gerade trägt, keine explizite Werkzeug
|
||||
Fähigkeit hat, dann wird stattdessen die Fähigkeit der aktuellen Hand verwendet.
|
||||
Wenn der Gegenstand, den ein Spieler gerade trägt, keine explizite Werkzeugfähigkeit
|
||||
hat, dann wird stattdessen die Fähigkeit der aktuellen Hand verwendet.
|
||||
|
||||
```lua
|
||||
minetest.register_tool("meinemod:werkzeug", {
|
||||
@ -359,6 +307,6 @@ minetest.register_tool("meinemod:werkzeug", {
|
||||
})
|
||||
```
|
||||
|
||||
Groupcaps ist die Liste der unterstützten Grabungstypen für Grabungsknoten.
|
||||
Schadensgruppen dienen zur Steuerung der Art und Weise, wie Werkzeuge Objekte beschädigen; dies wird
|
||||
Groupcaps ist die Liste der unterstützten Grabungstypen für Grabungsnodes.
|
||||
Schadensgruppen (Damage Groups) dienen zur Steuerung der Art und Weise, wie Werkzeuge Objekte beschädigen; dies wird
|
||||
später im Kapitel Objekte, Spieler und Entities behandelt werden.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user