MTSR/minetest_modding_book
4
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Objects, Players, and Entities - Italian translation added

Browse Source
This commit is contained in:
Marco 2020-07-03 16:05:18 +02:00 committed by rubenwardy
parent 35d9bf5a91
commit af9e25f026
1 changed files with 111 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

269
_it/map/objects.md
View File

@ -1,132 +1,105 @@
--- ---
title: Objects, Players, and Entities title: Oggetti, giocatori e entità
layout: default layout: default
root: ../.. root: ../..
idx: 3.4 idx: 3.4
description: Using an ObjectRef description: Alla scopera degli ObjectRef
degrad: degrad:
level: warning level: warning
title: Degrees and Radians title: Gradi e radianti
message: Attachment rotation is set in degrees, whereas object rotation is in radians. message: La rotazione dell'oggetto figlio è in gradi, mentre quella dell'oggetto è in radianti.
Make sure to convert to the correct angle measurement. Assicurati di usare il metodo di misura corretto.
--- ---
## Introduction <!-- omit in toc --> ## Introduzione <!-- omit in toc -->
In this chapter, you will learn how to manipulate objects and how to define your In questo capitolo imparerai come manipolare gli oggetti e come definirne di tuoi.
own.
- [What are Objects, Players, and Entities?](#what-are-objects-players-and-entities) - [Cosa sono gli oggetti, i giocatori e le entità?](#cosa-sono-gli-oggetti-i-giocatori-e-le-entita)
- [Position and Velocity](#position-and-velocity) - [Posizione e velocità](#posizione-e-velocita)
- [Object Properties](#object-properties) - [Proprietà degli oggetti](#proprieta-degli-oggetti)
- [Entities](#entities) - [Entità](#entita)
- [Attachments](#attachments) - [Oggetti figli](#oggetti-figli)
- [Your Turn](#your-turn) - [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 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.
independently of the node grid and has properties such as velocity and scale. 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.
Objects aren't items, and they have their own separate registration system.
There are a few differences between Players and Entities. Ci sono alcune differenze tra giocatori ed entità.
The biggest one is that Players are player-controlled, whereas Entities are mod-controlled. La più grande è che i primi sono controllati da chi gioca, mentre le seconde sono controllate dalle mod.
This means that the velocity of a player cannot be set by mods - players are client-side, 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.
and entities are server-side. 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.
Another difference is that Players will cause map blocks to be loaded, whereas Entities
will just be saved and become inactive.
This distinction is muddied by the fact that Entities are controlled using a table Questa distinzione è resa meno chiara dal fatto che le entità sono controllate tramite una Tabella di Entità Lua che vedremo qui sotto.
which is referred to as a Lua entity, as discussed later.
## 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 ```lua
local object = minetest.get_player_by_name("bob") local giocatore = minetest.get_player_by_name("bob")
local pos = object:get_pos() local pos = giocatore:get_pos()
object:set_pos({ x = pos.x, y = pos.y + 1, z = pos.z }) 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 `set_pos` imposta la posizione seduta stante, senza animazione.
smoothly animate an object to the new position, you should use `move_to`. Se invece si desidera animare il movimento dell'oggetto verso la nuova posizione, si dovrebbe usare `move_to`.
This, unfortunately, only works for entities. Questo, tuttavia, funziona soltanto per le entità.
```lua ```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. Una cosa importante da tenere a mente quando si lavora con le entità è la latenza di rete.
In an ideal world, messages about entity movements would arrive immediately, 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.
in the correct order, and with a similar interval as to how you sent them. Tuttavia, a meno che tu non stia giocando in locale, questo non è un mondo ideale.
However, unless you're in singleplayer, this isn't an ideal world. Le informazioni ci mettono un attimo ad arrivare: per esempio i `set_pos` potrebbero non arrivare in ordine, saltando alcune chiamate.
Messages will take a while to arrive. Position messages may arrive out of order, O lo spazio da coprire di un `move_to` potrebbe non essere suddiviso perfettamente, rendendo l'animazione meno fluida.
resulting in some `set_pos` calls being skipped as there's no point going to Tutto ciò ha come risultato il client che vede cose leggermente diverse dal server, che è una cosa di cui dovresti essere consapevole.
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.
## Object Properties ## Proprietà degli oggetti
Object properties are used to tell the client how to render and deal with an Le proprietà degli oggetti sono usate per comunicare al client come renderizzare e gestire un oggetto.
object. It's not possible to define custom properties, because the properties are Non è possibile definire delle proprietà personalizzate, perché le proprietà sono per definizione fatte per essere usate dall'engine.
for the engine to use, by definition.
Unlike nodes, objects have a dynamic rather than set appearance. Al contrario dei nodi, gli oggetti hanno un comportamento dinamico.
You can change how an object looks, among other things, at any time by updating Si può per esempio cambiare il loro aspetto in qualsiasi momento, aggiornandone le proprietà:
its properties.
```lua ```lua
object:set_properties({ oggetto:set_properties({
visual = "mesh", visual = "mesh",
mesh = "character.b3d", mesh = "omino.b3d",
textures = {"character_texture.png"}, textures = {"omino_texture.png"},
visual_size = {x=1, y=1}, visual_size = {x=1, y=1},
}) })
``` ```
The updated properties will be sent to all players in range. Le proprietà aggiornate verranno inviate a tutti i giocatori nelle vicinanze.
This is very useful to get a large amount of variety very cheaply, such as having Questo è molto utile per avere una vasto ammontare di varietà a basso costo, uno fra tanti l'avere diverse skin per giocatore.
different skins per-player.
As shown in the next section, entities can have initial properties Come mostrato nella prossima sezione, le entità possono avere delle proprietà iniziali, che andranno dichiarate nella loro definizione.
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.
## Entities ## Entità
An Entity has a definition table that resembles an item definition table. Un'entità ha una tabella di definizione che ricorda quella degli oggetti (intesi come *items*).
This table can contain callback methods, initial object properties, and custom Questa tabella può contenere metodi di callback, proprietà iniziali e membri personalizzati.
members.
However, entities differ in one very important way from items. When an entity is 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.
emerged (ie: loaded or created), a new table is created for that entity that Ci si riferisce solitamente a questa nuova tabella con Tabella di Entità Lua e può essere usata per immagazzinare variabili per quella specifica entità.
*inherits* from the definition table using metatables.
This new table is commonly referred to as a Lua Entity table.
Metatables are an important Lua feature that you will need Le metatabelle rappresentano un aspetto importante di Lua, che bisogna tenere bene a mente in quanto sono una parte essenziale del linguaggio.
to be aware of, as it is an essential part of the Lua language.
In layman's terms, a metatable allows you to control how the table behaves when In parole povere, le metatabelle permettono di controllare come si comporta una tabella quando viene usata una certa sintassi in Lua.
using certain Lua syntax. The most common use of metatables is the ability to use 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.
another table as a prototype, defaulting to the other table's properties and methods when
they do not exist in the current table.
Say you want to access member X on table A. If table A has that member, then Mettiamo che si voglia accedere al campo X della tabella A.
it will be returned as normal. However, if the table doesn't have that member but Se la tabella A ha quel campo, allora ritornerà normalmente.
it does have a metatable could table B, then table B will be checked to see if it 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.
has that member.
<!--table A is a metatable of table B, then table
B will have all the properties and methods of table A if the derived table doesn't
have any itself.-->
```lua ```lua
local MyEntity = { local MiaEntita = {
initial_properties = { initial_properties = {
hp_max = 1, hp_max = 1,
physical = true, physical = true,
@ -139,36 +112,32 @@ local MyEntity = {
initial_sprite_basepos = {x = 0, y = 0}, initial_sprite_basepos = {x = 0, y = 0},
}, },
message = "Default message", messaggio = "Messaggio predefinito",
} }
function MyEntity:set_message(msg) function MiaEntita:imposta_messaggio(msg)
self.message = msg self.messaggio = msg
end end
``` ```
When an entity has emerged, a table is created for it by copying everything from Sia la tabella di un ObjectRef che quella di un'entità forniscono modi per ottenerne la controparte:
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:
```lua ```lua
local entity = object:get_luaentity() local entita = oggetto:get_luaentity()
local object = entity.object local oggetto = entita.object
print("entity is at " .. minetest.pos_to_string(object:get_pos())) print("L'entità si trova a " .. minetest.pos_to_string(oggetto:get_pos()))
``` ```
There are a number of available callbacks for use with entities. Ci sono diversi callback disponibili da usare per le entità.
A complete list can be found in [lua_api.txt]({{ page.root }}/lua_api.html#registered-entities). Una lista completa può essere trovata in [lua_api.txt]({{ page.root }}/lua_api.html#registered-entities).
```lua ```lua
function MyEntity:on_step(dtime) function MiaEntita:on_step(dtime)
local pos = self.object:get_pos() local pos = self.oggetto:get_pos()
local pos_down = vector.subtract(pos, vector.new(0, 1, 0)) local pos_giu = vector.subtract(pos, vector.new(0, 1, 0))
local delta 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) delta = vector.new(0, -1, 0)
elseif minetest.get_node(pos).name == "air" then elseif minetest.get_node(pos).name == "air" then
delta = vector.new(0, 0, 1) delta = vector.new(0, 0, 1)
@ -178,104 +147,88 @@ function MyEntity:on_step(dtime)
delta = vector.multiply(delta, dtime) delta = vector.multiply(delta, dtime)
self.object:move_to(vector.add(pos, delta)) self.oggetto:move_to(vector.add(pos, delta))
end end
function MyEntity:on_punch(hitter) function MiaEntita:on_punch(hitter)
minetest.chat_send_player(hitter:get_player_name(), self.message) minetest.chat_send_player(hitter:get_player_name(), self.message)
end end
``` ```
Now, if you were to spawn and use this entity, you'd notice that the message 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.
would be forgotten when the entity becomes inactive then active again. Questo succede perché il messaggio non è salvato.
This is because the message isn't saved. Al posto di salvare tutto nella tabella dell'entità, Minetest ti permette di scegliere come salvare le cose.
Rather than saving everything in the entity table, Minetest gives you control over Questo succede nella *Staticdata*, una stringa che contiene tutte le informazioni personalizzate che si vogliono ricordare.
how to save things.
Staticdata is a string which contains all the custom information that
needs to stored.
```lua ```lua
function MyEntity:get_staticdata() function MiaEntita:get_staticdata()
return minetest.write_json({ return minetest.write_json({
message = self.message, messaggio = self.messaggio,
}) })
end end
function MyEntity:on_activate(staticdata, dtime_s) function MiaEntita:on_activate(staticdata, dtime_s)
if staticdata ~= "" and staticdata ~= nil then if staticdata ~= "" and staticdata ~= nil then
local data = minetest.parse_json(staticdata) or {} local data = minetest.parse_json(staticdata) or {}
self:set_message(data.message) self:imposta_messaggio(data.messaggio)
end end
end end
``` ```
Minetest may call `get_staticdata()` as many times as it wants and at any time. Minetest può chiamare `get_staticdata()` quando e quante volte vuole.
This is because Minetest doesn't wait for a MapBlock to become inactive to save Questo perché non aspetta che un Blocco Mappa diventi inattivo per salvarlo, in quanto comporterebbe una perdita di informazioni.
it, as this would result in data loss. MapBlocks are saved roughly every 18 I Blocchi Mappa sono salvati circa ogni 18 secondi, quindi dovresti notare un simile intervallo per la chiamata a `get_staticdata()`.
seconds, so you should notice a similar interval for `get_staticdata()` being called.
`on_activate()`, on the other hand, will only be called when an entity becomes `on_activate()`, d'altro canto, viene chiamato solo quando un'entità diventa attiva o nel Blocco Mappa appena caricato o quando spawna.
active either from the MapBlock becoming active or from the entity spawning. Questo significa che il suo staticdata inizialmente potrebbe essere vuoto (dato l'intervallo di 18 secondi).
This means that staticdata could be empty.
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 ```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 ```lua
local pos = { x = 1, y = 2, z = 3 } 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. Il terzo parametro è lo staticdata inziale.
To set the message, you can use the entity table method: Per impostare il messaggio, puoi usare la Tabella di Entità Lua:
```lua ```lua
obj:get_luaentity():set_message("hello!") oggetto:get_luaentity():imposta_messaggio("ciao!")
``` ```
Players with the *give* [privilege](../players/privileges.html) can ## Oggetti figli
use a [chat command](../players/chat.html) to spawn entities:
/spawnentity mymod:entity 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.
## 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.
```lua ```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 Il `get_pos()` di un oggetto ritornerà sempre la sua posizione globale, a prescindere dal fatto che sia figlio o meno.
matter whether it is attached or not. `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.
`set_attach` takes a relative position, but not as you'd expect. Quindi, `0,5,0` sarà metà nodo in alto rispetto al genitore.
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.
{% include notice.html notice=page.degrad %} {% include notice.html notice=page.degrad %}
For 3D models with animations, the bone argument is used to attach the entity Per i modelli 3D animati, il parametro `bone` (osso) è usato per collegare un'entità a un osso.
to a bone. 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.
3D animations are based on skeletons - a network of bones in the model where Il collegamento a un osso è utile se si vuole per esempio far impugnare qualcosa al personaggio:
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:
```lua ```lua
obj:set_attach(player, oggetto:set_attach(player,
"Arm_Right", -- default bone "Braccio destro", -- osso predefinito
{x=0.2, y=6.5, z=3}, -- default position {x=0.2, y=6.5, z=3}, -- posizione predefinita
{x=-100, y=225, z=90}) -- default rotation {x=-100, y=225, z=90}) -- rotazione predefinita
``` ```
## Your Turn ## Il tuo turno
* Make a windmill by combining nodes and an entity. * Fai un mulino combinando dei nodi con un'entità.
* Make a mob of your choice (using just the entity API, and without using any other mods). * Crea un mostro di tua scelta (usando l'API delle entità, e senza usare altre mod).