Finished objects.md

_de/map/objects.md

@@ -21,8 +21,8 @@ definiert.
 - [Objekt-Eigenschaften](#objekt-eigenschaften)
 - [Entities](#entities)
 - [Leben und Schaden](#leben-und-schaden)
-- [Attachments](#attachments)
-- [Your Turn](#your-turn)
+- [Anhänge](#anhänge)
+- [Sie sind dran](#sie-sind-dran)
 
 ## Was sind Objekte, Spieler, und Entities?
 
@@ -282,76 +282,76 @@ Im obigen Beispiel erleidet das Objekt 90 % `fleshy` Schadens und 50 % des
 Wenn ein Spieler ein Objekt schlägt, stammen die Schadensgruppen von dem Gegenstand, das er 
 gerade trägt. In anderen Fällen entscheiden die Mods, welche Schadensgruppen verwendet werden.
 
-### Example Damage Calculation
+### Beispiel für die Schadensberechnung
 
-Let's punch the `target` object:
+Schlagen wir das Objekt `target`:
 
 ```lua
-local tool_capabilities = {
+local werkzeug_faehigkeiten = {
     full_punch_interval = 0.8,
     damage_groups = { fleshy = 5, choppy = 10 },
 
-    -- This is only used for digging nodes, but is still required
+    -- Dies wird nur für das abbauen von Nodes verwendet, ist aber dennoch erforderlich
     max_drop_level=1,
     groupcaps={
         fleshy={times={[1]=2.5, [2]=1.20, [3]=0.35}, uses=30, maxlevel=2},
     },
 }
 
-local time_since_last_punch = tool_capabilities.full_punch_interval
-target:punch(object, time_since_last_punch, tool_capabilities)
+local zeit_seit_letzten_schlag = werkzeug_faehigkeiten.full_punch_interval
+target:punch(object, zeit_seit_letzten_schlag, werkzeug_faehigkeiten)
 ```
 
-Now, let's work out what the damage will be. The punch's damage groups are
-`fleshy=5` and `choppy=10`, and `target` will take 90% damage from fleshy and 0%
-from choppy.
+Berechnen wir nun, wie hoch der Schaden sein wird. Die Schadensgruppen des Schlags sind
+`fleshy=5` und `choppy=10`, und die Zielperson erleidet 90% Schaden durch fleshy und 0%
+von choppy.
 
-First, we multiply the damage groups by the vulnerability and sum the result.
-We then multiply by a number between 0 or 1 depending on the `time_since_last_punch`.
+Zuerst multiplizieren wir die Schadensgruppen mit der Verwundbarkeit und addieren das Ergebnis.
+Dann multiplizieren wir mit einer Zahl zwischen 0 oder 1, abhängig von der `zeit_seit_letzten_schlag`.
 
 ```lua
-= (5*90/100 + 10*0/100) * limit(time_since_last_punch / full_punch_interval, 0, 1)
+= (5*90/100 + 10*0/100) * limit(zeit_seit_letzten_schlag / full_punch_interval, 0, 1)
 = (5*90/100 + 10*0/100) * 1
 = 4.5
 ```
 
-As HP is an integer, the damage is rounded to 5 points.
+Da die HP eine ganze Zahl sind, wird der Schaden auf 5 Lebenspunkte gerundet.
 
 
 
-## Attachments
+## Anhänge
 
-Attached objects will move when the parent - the object they are attached to -
-is moved. An attached object is said to be a child of the parent.
-An object can have an unlimited number of children, but at most one parent.
+Angehängte Objekte bewegen sich, wenn das übergeordnete Objekt - also das Objekt, an das sie angehängt sind -
+bewegt wird. Ein angefügtes Objekt ist ein Kind des übergeordneten Objekts.
+Ein Objekt kann eine unbegrenzte Anzahl von Kindern haben, aber höchstens ein Elternteil.
 
 ```lua
-child:set_attach(parent, bone, position, rotation)
+kind:set_attach(elternteil, knochen, position, drehung)
 ```
 
-An object's `get_pos()` will always return the global position of the object, no
-matter whether it is attached or not.
-`set_attach` takes a relative position, but not as you'd expect.
-The attachment position is relative to the parent's origin as scaled up by 10 times.
-So, `0,5,0` would be half a node above the parent's origin.
+Die Funktion `get_pos()` eines Objekts gibt immer die globale Position des Objekts zurück,
+unabhängig davon, ob es angehängt ist oder nicht.
+`set_attach` nimmt eine relative Position, aber nicht so, wie man es erwarten würde.
+Die Anhängeposition ist relativ zum Ursprung des Elternobjekts und wird um das 10-fache vergrößert.
+Also wäre "0,5,0" ein halber Node über dem Ursprung des Elternobjekts.
 
 {% include notice.html notice=page.degrad %}
 
-For 3D models with animations, the bone argument is used to attach the entity
-to a bone.
-3D animations are based on skeletons - a network of bones in the model where
-each bone can be given a position and rotation to change the model, for example,
-to move the arm.
-Attaching to a bone is useful if you want to make a character hold something:
+Bei 3D-Modellen mit Animationen wird das Argument knochen verwendet, um das Entity
+an einen Knochen zu binden.
+3D-Animationen basieren auf Skeletten - einem Netzwerk von Knochen im Modell, bei dem
+jedem Knochen eine Position und Drehung zugewiesen werden kann, um das Modell zu verändern, z. B,
+um den Arm zu bewegen.
+Das Anhängen an einen Knochen ist nützlich, wenn Sie eine Figur etwas halten lassen wollen:
 
 ```lua
-obj:set_attach(player,
-    "Arm_Right",           -- default bone
-    {x=0.2, y=6.5, z=3},   -- default position
-    {x=-100, y=225, z=90}) -- default rotation
+obj:set_attach(spieler,
+    "Arm_Right",           -- normaler Knochen
+    {x=0.2, y=6.5, z=3},   -- normale Position
+    {x=-100, y=225, z=90}) -- normale Drehung
 ```
 
-## Your Turn
+## Sie sind dran
 
-* Make a windmill by combining nodes and an entity.
-* Make a mob of your choice (using just the entity API, and without using any other mods).
+* Erstelle eine Windmühle, indem du Nodes und eine Entity kombinierst.
+* Erstelle einen Mob deiner Wahl (nur mit der Entity-API und ohne andere Mods zu verwenden).

_de/wörterbuch.txt

@@ -1,8 +1,10 @@
 Active Block Modifiers = Aktive Mapblock Modifikatoren
 Armor Groups = Armor Groups
+Attachment = Anhang
 block = Mapblock
 bulk = bulk
 Chapter = Kapitel
+child = Kind
 Cubic Nodes = Würfelförmiger Block
 craft slots = Handwerksplätze
 Damage = Schaden
@@ -57,6 +59,7 @@ Node inventory  = Blockinventar
 node timer = Blocktimer
 Object properties = Objekt-Eigenschaften
 path = Verzeichnis
+parent = Elternteil
 placer = plazierer
 player inventory = Spielerinventar
 player reference = Spielerreferenz