From af9e25f0264d4d52c254ff1e5588e14718c58709 Mon Sep 17 00:00:00 2001 From: Marco <4279489-marco_a@users.noreply.gitlab.com> Date: Fri, 3 Jul 2020 16:05:18 +0200 Subject: [PATCH] Objects, Players, and Entities - Italian translation added --- _it/map/objects.md | 269 +++++++++++++++++++-------------------------- 1 file changed, 111 insertions(+), 158 deletions(-) diff --git a/_it/map/objects.md b/_it/map/objects.md index b9fe91f..657fb40 100644 --- a/_it/map/objects.md +++ b/_it/map/objects.md @@ -1,132 +1,105 @@ --- -title: Objects, Players, and Entities +title: Oggetti, giocatori e entità layout: default root: ../.. idx: 3.4 -description: Using an ObjectRef +description: Alla scopera degli ObjectRef degrad: level: warning - title: Degrees and Radians - message: Attachment rotation is set in degrees, whereas object rotation is in radians. - Make sure to convert to the correct angle measurement. + title: Gradi e radianti + message: La rotazione dell'oggetto figlio è in gradi, mentre quella dell'oggetto è in radianti. + Assicurati di usare il metodo di misura corretto. --- -## Introduction +## Introduzione -In this chapter, you will learn how to manipulate objects and how to define your -own. +In questo capitolo imparerai come manipolare gli oggetti e come definirne di tuoi. -- [What are Objects, Players, and Entities?](#what-are-objects-players-and-entities) -- [Position and Velocity](#position-and-velocity) -- [Object Properties](#object-properties) -- [Entities](#entities) -- [Attachments](#attachments) -- [Your Turn](#your-turn) +- [Cosa sono gli oggetti, i giocatori e le entità?](#cosa-sono-gli-oggetti-i-giocatori-e-le-entita) +- [Posizione e velocità](#posizione-e-velocita) +- [Proprietà degli oggetti](#proprieta-degli-oggetti) +- [Entità](#entita) +- [Oggetti figli](#oggetti-figli) +- [Il tuo turno](#il-tuo-turno) -## What are Objects, Players, and Entities? +## Cosa sono gli oggetti, i giocatori e le entità? -Players and Entities are both types of Objects. An Object is something that can move -independently of the node grid and has properties such as velocity and scale. -Objects aren't items, and they have their own separate registration system. +Giocatori e entità sono entrambi tipi di oggetti (ObjectRef, quindi di nuovo un riferimento). Un oggetto è qualcosa che si può muovere indipendentemente dalla griglia di nodi e che ha proprietà come velocità e scala. +Attenzione, tuttavia, a non confonderli con gli oggetti nel senso di "cose che possono essere messe in un inventario" (in inglese hanno infatti nomi diversi: *objects* e *items*), anche perché hanno un sistema di registrazione tutto loro. -There are a few differences between Players and Entities. -The biggest one is that Players are player-controlled, whereas Entities are mod-controlled. -This means that the velocity of a player cannot be set by mods - players are client-side, -and entities are server-side. -Another difference is that Players will cause map blocks to be loaded, whereas Entities -will just be saved and become inactive. +Ci sono alcune differenze tra giocatori ed entità. +La più grande è che i primi sono controllati da chi gioca, mentre le seconde sono controllate dalle mod. +Ciò significa che, per esempio, la velocità di un giocatore non può essere modificata dalle mod - i giocatori appartengono al lato client, mentre le entità al lato server. +Un'altra differenza è che i giocatori fanno caricare i Blocchi Mappa che li circondano, le entità invece no: quest'ultime vengono salvate e diventano inattive quando il Blocco Mappa in cui si trovano viene rimosso dalla memoria. -This distinction is muddied by the fact that Entities are controlled using a table -which is referred to as a Lua entity, as discussed later. +Questa distinzione è resa meno chiara dal fatto che le entità sono controllate tramite una Tabella di Entità Lua che vedremo qui sotto. -## Position and Velocity +## Posizione e velocità -`get_pos` and `set_pos` exist to allow you to get and set an entity's position. +`get_pos` e `set_pos` permettono di ottenere e impostare la posizione di un oggetto. ```lua -local object = minetest.get_player_by_name("bob") -local pos = object:get_pos() -object:set_pos({ x = pos.x, y = pos.y + 1, z = pos.z }) +local giocatore = minetest.get_player_by_name("bob") +local pos = giocatore:get_pos() +giocatore:set_pos({ x = pos.x, y = pos.y + 1, z = pos.z }) ``` -`set_pos` immediately sets the position, with no animation. If you'd like to -smoothly animate an object to the new position, you should use `move_to`. -This, unfortunately, only works for entities. +`set_pos` imposta la posizione seduta stante, senza animazione. +Se invece si desidera animare il movimento dell'oggetto verso la nuova posizione, si dovrebbe usare `move_to`. +Questo, tuttavia, funziona soltanto per le entità. ```lua -object:move_to({ x = pos.x, y = pos.y + 1, z = pos.z }) +miaentita:move_to({ x = pos.x, y = pos.y + 1, z = pos.z }) ``` -An important thing to think about when dealing with entities is network latency. -In an ideal world, messages about entity movements would arrive immediately, -in the correct order, and with a similar interval as to how you sent them. -However, unless you're in singleplayer, this isn't an ideal world. -Messages will take a while to arrive. Position messages may arrive out of order, -resulting in some `set_pos` calls being skipped as there's no point going to -a position older than the current known position. -Moves may not be similarly spaced, which makes it difficult to use them for animation. -All this results in the client seeing different things to the server, which is something -you need to be aware of. +Una cosa importante da tenere a mente quando si lavora con le entità è la latenza di rete. +In un mondo ideale, le informazioni riguardo i movimenti delle entità arriverebbero subito, nell'ordine corretto e a intervalli simili a come sono stati inviati. +Tuttavia, a meno che tu non stia giocando in locale, questo non è un mondo ideale. +Le informazioni ci mettono un attimo ad arrivare: per esempio i `set_pos` potrebbero non arrivare in ordine, saltando alcune chiamate. +O lo spazio da coprire di un `move_to` potrebbe non essere suddiviso perfettamente, rendendo l'animazione meno fluida. +Tutto ciò ha come risultato il client che vede cose leggermente diverse dal server, che è una cosa di cui dovresti essere consapevole. -## Object Properties +## Proprietà degli oggetti -Object properties are used to tell the client how to render and deal with an -object. It's not possible to define custom properties, because the properties are -for the engine to use, by definition. +Le proprietà degli oggetti sono usate per comunicare al client come renderizzare e gestire un oggetto. +Non è possibile definire delle proprietà personalizzate, perché le proprietà sono per definizione fatte per essere usate dall'engine. -Unlike nodes, objects have a dynamic rather than set appearance. -You can change how an object looks, among other things, at any time by updating -its properties. +Al contrario dei nodi, gli oggetti hanno un comportamento dinamico. +Si può per esempio cambiare il loro aspetto in qualsiasi momento, aggiornandone le proprietà: ```lua -object:set_properties({ +oggetto:set_properties({ visual = "mesh", - mesh = "character.b3d", - textures = {"character_texture.png"}, + mesh = "omino.b3d", + textures = {"omino_texture.png"}, visual_size = {x=1, y=1}, }) ``` -The updated properties will be sent to all players in range. -This is very useful to get a large amount of variety very cheaply, such as having -different skins per-player. +Le proprietà aggiornate verranno inviate a tutti i giocatori nelle vicinanze. +Questo è molto utile per avere una vasto ammontare di varietà a basso costo, uno fra tanti l'avere diverse skin per giocatore. -As shown in the next section, entities can have initial properties -provided in their definition. -The default Player properties are defined in the engine, however, so you'll -need to use `set_properties()` in `on_joinplayer` to set the properties for newly -joined players. +Come mostrato nella prossima sezione, le entità possono avere delle proprietà iniziali, che andranno dichiarate nella loro definizione. -## Entities +## Entità -An Entity has a definition table that resembles an item definition table. -This table can contain callback methods, initial object properties, and custom -members. +Un'entità ha una tabella di definizione che ricorda quella degli oggetti (intesi come *items*). +Questa tabella può contenere metodi di callback, proprietà iniziali e membri personalizzati. -However, entities differ in one very important way from items. When an entity is -emerged (ie: loaded or created), a new table is created for that entity that -*inherits* from the definition table using metatables. -This new table is commonly referred to as a Lua Entity table. +Tuttavia, c'è una differenza sostanziale tra le due; perché quando un'entità appare (come quando viene creata o caricata) una nuova tabella viene generata per quell'entità, *ereditando* le proprietà dalla tabella originaria tramite una metatabella. +Ci si riferisce solitamente a questa nuova tabella con Tabella di Entità Lua e può essere usata per immagazzinare variabili per quella specifica entità. -Metatables are an important Lua feature that you will need -to be aware of, as it is an essential part of the Lua language. +Le metatabelle rappresentano un aspetto importante di Lua, che bisogna tenere bene a mente in quanto sono una parte essenziale del linguaggio. -In layman's terms, a metatable allows you to control how the table behaves when -using certain Lua syntax. The most common use of metatables is the ability to use -another table as a prototype, defaulting to the other table's properties and methods when -they do not exist in the current table. +In parole povere, le metatabelle permettono di controllare come si comporta una tabella quando viene usata una certa sintassi in Lua. +Vengono usate soprattutto per la loro abilità di usare un'altra tabella come prototipo, fungendo da valori di base di quest'ultima quando essa non contiene le proprietà e i metodi richiesti. -Say you want to access member X on table A. If table A has that member, then -it will be returned as normal. However, if the table doesn't have that member but -it does have a metatable could table B, then table B will be checked to see if it -has that member. - - +Mettiamo che si voglia accedere al campo X della tabella A. +Se la tabella A ha quel campo, allora ritornerà normalmente. +Tuttavia, se X non esiste ma esiste una metatabella B associata ad A, B verrà ispezionata alla ricerca di un eventuale X prima di ritornare (eventualmente) nil. ```lua -local MyEntity = { +local MiaEntita = { initial_properties = { hp_max = 1, physical = true, @@ -139,36 +112,32 @@ local MyEntity = { initial_sprite_basepos = {x = 0, y = 0}, }, - message = "Default message", + messaggio = "Messaggio predefinito", } -function MyEntity:set_message(msg) - self.message = msg +function MiaEntita:imposta_messaggio(msg) + self.messaggio = msg end ``` -When an entity has emerged, a table is created for it by copying everything from -its type table. -This table can be used to store variables for that particular entity. - -Both an ObjectRef and an entity table provide ways to get the counterpart: +Sia la tabella di un ObjectRef che quella di un'entità forniscono modi per ottenerne la controparte: ```lua -local entity = object:get_luaentity() -local object = entity.object -print("entity is at " .. minetest.pos_to_string(object:get_pos())) +local entita = oggetto:get_luaentity() +local oggetto = entita.object +print("L'entità si trova a " .. minetest.pos_to_string(oggetto:get_pos())) ``` -There are a number of available callbacks for use with entities. -A complete list can be found in [lua_api.txt]({{ page.root }}/lua_api.html#registered-entities). +Ci sono diversi callback disponibili da usare per le entità. +Una lista completa può essere trovata in [lua_api.txt]({{ page.root }}/lua_api.html#registered-entities). ```lua -function MyEntity:on_step(dtime) - local pos = self.object:get_pos() - local pos_down = vector.subtract(pos, vector.new(0, 1, 0)) +function MiaEntita:on_step(dtime) + local pos = self.oggetto:get_pos() + local pos_giu = vector.subtract(pos, vector.new(0, 1, 0)) local delta - if minetest.get_node(pos_down).name == "air" then + if minetest.get_node(pos_giu).name == "air" then delta = vector.new(0, -1, 0) elseif minetest.get_node(pos).name == "air" then delta = vector.new(0, 0, 1) @@ -178,104 +147,88 @@ function MyEntity:on_step(dtime) delta = vector.multiply(delta, dtime) - self.object:move_to(vector.add(pos, delta)) + self.oggetto:move_to(vector.add(pos, delta)) end -function MyEntity:on_punch(hitter) +function MiaEntita:on_punch(hitter) minetest.chat_send_player(hitter:get_player_name(), self.message) end ``` -Now, if you were to spawn and use this entity, you'd notice that the message -would be forgotten when the entity becomes inactive then active again. -This is because the message isn't saved. -Rather than saving everything in the entity table, Minetest gives you control over -how to save things. -Staticdata is a string which contains all the custom information that -needs to stored. +Ora, se si volesse spawnare e usare questa entità, si noterà che il messaggio andrebbe perduto quando l'entità diventa inattiva per poi ritornare attiva. +Questo succede perché il messaggio non è salvato. +Al posto di salvare tutto nella tabella dell'entità, Minetest ti permette di scegliere come salvare le cose. +Questo succede nella *Staticdata*, una stringa che contiene tutte le informazioni personalizzate che si vogliono ricordare. ```lua -function MyEntity:get_staticdata() +function MiaEntita:get_staticdata() return minetest.write_json({ - message = self.message, + messaggio = self.messaggio, }) end -function MyEntity:on_activate(staticdata, dtime_s) +function MiaEntita:on_activate(staticdata, dtime_s) if staticdata ~= "" and staticdata ~= nil then local data = minetest.parse_json(staticdata) or {} - self:set_message(data.message) + self:imposta_messaggio(data.messaggio) end end ``` -Minetest may call `get_staticdata()` as many times as it wants and at any time. -This is because Minetest doesn't wait for a MapBlock to become inactive to save -it, as this would result in data loss. MapBlocks are saved roughly every 18 -seconds, so you should notice a similar interval for `get_staticdata()` being called. +Minetest può chiamare `get_staticdata()` quando e quante volte vuole. +Questo perché non aspetta che un Blocco Mappa diventi inattivo per salvarlo, in quanto comporterebbe una perdita di informazioni. +I Blocchi Mappa sono salvati circa ogni 18 secondi, quindi dovresti notare un simile intervallo per la chiamata a `get_staticdata()`. -`on_activate()`, on the other hand, will only be called when an entity becomes -active either from the MapBlock becoming active or from the entity spawning. -This means that staticdata could be empty. +`on_activate()`, d'altro canto, viene chiamato solo quando un'entità diventa attiva o nel Blocco Mappa appena caricato o quando spawna. +Questo significa che il suo staticdata inizialmente potrebbe essere vuoto (dato l'intervallo di 18 secondi). -Finally, you need to register the type table using the aptly named `register_entity`. +Infine, c'è bisogno di registrare la tabella usando `register_entity`. ```lua -minetest.register_entity("mymod:entity", MyEntity) +minetest.register_entity("miamod:entita", MiaEntita) ``` -The entity can be spawned by a mod like so: +L'entità può essere spawnata da una mod nel seguente modo: ```lua local pos = { x = 1, y = 2, z = 3 } -local obj = minetest.add_entity(pos, "mymod:entity", nil) +local oggetto = minetest.add_entity(pos, "miamod:entita", nil) ``` -The third parameter is the initial staticdata. -To set the message, you can use the entity table method: +Il terzo parametro è lo staticdata inziale. +Per impostare il messaggio, puoi usare la Tabella di Entità Lua: ```lua -obj:get_luaentity():set_message("hello!") +oggetto:get_luaentity():imposta_messaggio("ciao!") ``` -Players with the *give* [privilege](../players/privileges.html) can -use a [chat command](../players/chat.html) to spawn entities: +## Oggetti figli - /spawnentity mymod:entity - -## Attachments - -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. +Gli oggetti figli (*attachments*) si muovono quando il genitore - l'oggetto al quale sono legati - viene mosso. +Un oggetto può possedere un numero illimitato di figli, ma non più di un genitore. ```lua -child:set_attach(parent, bone, position, rotation) +figlio:set_attach(parent, bone, position, rotation) ``` -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. +Il `get_pos()` di un oggetto ritornerà sempre la sua posizione globale, a prescindere dal fatto che sia figlio o meno. +`set_attach` prende invece una posizione relativa, ma non è quello che credi: la posizione del figlio è relativa a quella del genitore *amplificata quest'ultima* di 10 volte. +Quindi, `0,5,0` sarà metà nodo in alto rispetto al genitore. {% 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: +Per i modelli 3D animati, il parametro `bone` (osso) è usato per collegare un'entità a un osso. +Le animazioni 3D sono basate su degli scheletri - una rete di ossa nel modello dove ogni osso può avere una posizione e rotazione per cambiare il modello, tipo per muovere un braccio. +Il collegamento a un osso è utile se si vuole per esempio far impugnare qualcosa al personaggio: ```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 +oggetto:set_attach(player, + "Braccio destro", -- osso predefinito + {x=0.2, y=6.5, z=3}, -- posizione predefinita + {x=-100, y=225, z=90}) -- rotazione predefinita ``` -## Your Turn +## Il tuo turno -* 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). +* Fai un mulino combinando dei nodi con un'entità. +* Crea un mostro di tua scelta (usando l'API delle entità, e senza usare altre mod).