Mirrorlandia_minetest/minetest
1
0
Fork 1
mirror of https://github.com/minetest/minetest.git synced 2024-12-22 22:22:23 +01:00
Code Issues Packages Projects Releases Wiki Activity

DOCS: replace Minetest -> Luanti, minetest. -> core. (#15292)

Browse Source 
Co-authored-by: grorp <gregor.parzefall@posteo.de>
This commit is contained in:
Zughy 2024-10-22 23:05:41 +02:00 committed by GitHub
parent aa273119f2
commit d52e4cdbdb
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
23 changed files with 873 additions and 865 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
README.md
View File

@ -1,13 +1,13 @@
Minetest
========
Luanti (formerly Minetest)
==========================
![Build Status](https://github.com/minetest/minetest/workflows/build/badge.svg)
[![Translation status](https://hosted.weblate.org/widgets/minetest/-/svg-badge.svg)](https://hosted.weblate.org/engage/minetest/?utm_source=widget)
[![License](https://img.shields.io/badge/license-LGPLv2.1%2B-blue.svg)](https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html)
Minetest is a free open-source voxel game engine with easy modding and game creation.
Luanti is a free open-source voxel game engine with easy modding and game creation.
Copyright (C) 2010-2022 Perttu Ahola <celeron55@gmail.com>
Copyright (C) 2010-2024 Perttu Ahola <celeron55@gmail.com>
and contributors (see source file comments and the version control log)
Table of Contents
@ -106,7 +106,7 @@ Configuration file
------------------
- Default location:
`user/minetest.conf`
- This file is created by closing Minetest for the first time.
- This file is created by closing Luanti for the first time.
- A specific file can be specified on the command line:
`--config <path-to-file>`
- A run-in-place build will look for the configuration file in

22
doc/android.md
View File

@ -1,9 +1,9 @@
# Minetest Android build
All Minetest builds, including the Android variant, are based on the same code.
# Luanti Android build
All Luanti builds, including the Android variant, are based on the same code.
However, additional Java code is used for proper Android integration.
## Controls
Compared to Minetest binaries for PC, the Android port has limited functionality
Compared to Luanti binaries for PC, the Android port has limited functionality
due to limited capabilities of common devices. What can be done is described below:
While you're playing the game normally (that is, no menu or inventory is
@ -35,7 +35,7 @@ When a menu or inventory is displayed:
* Complicated control can be difficult or impossible on Android device
## File Path
There are some settings especially useful for Android users. The Minetest-wide
There are some settings especially useful for Android users. The Luanti-wide
configuration file can usually be found at:
* Before 5.4.2:
@ -58,7 +58,7 @@ Mobile device generally have less RAM than PC, this setting limit how many mapbl
this setting limit max FPS (Frame per second). Default value is 60, which lowest Android device screen refresh rate commonly found, but if you're using an device have lower refresh rate, change this
## Requirements
The minimal and recommended system requirements for Minetest are listed below.
The minimal and recommended system requirements for Luanti are listed below.
### CPU
Supported architectures:
@ -67,7 +67,7 @@ Supported architectures:
3. x86
4. x86_64
CPU architectures similar to ARM or x86 might run Minetest but are not tested.
CPU architectures similar to ARM or x86 might run Luanti but are not tested.
### Minimum
1. Graphics API: OpenGL ES 1.0
@ -89,9 +89,9 @@ some shader settings cannot be used on OpenGL ES.
Changing the graphic driver setting to OpenGL will result in undesirable behavior.
## Building Requirements
In order to build, your PC has to be set up to build Minetest in the usual
manner (see the regular Minetest documentation for how to get this done).
In addition to what is required for Minetest in general, you will need the
In order to build, your PC has to be set up to build Luanti in the usual
manner (see the regular Luanti documentation for how to get this done).
In addition to what is required for Luanti in general, you will need the
following software packages. The version number in parenthesis denotes the
version that was tested at the time this README was drafted; newer/older
versions may or may not work.
@ -104,7 +104,7 @@ Additionally, you'll need to have an Internet connection available on the
build system, as the Android build will download some source packages.
## Build
The new build system Minetest Android is fully functional and is designed to
The new build system Luanti Android is fully functional and is designed to
speed up and simplify the work, as well as adding the possibility of
cross-platform build.
You can use `./gradlew assemblerelease` or `./gradlew assembledebug` from the
@ -120,7 +120,7 @@ automatically. Or you can create a `local.properties` file and specify
- choose one yourself.
* Once your keystore is setup, enter the android subdirectory and create a new
file "ant.properties" there. Add following lines to that file:
file "ant.properties" there. Add the following lines to that file:
> key.store=<path to your keystore>
> key.alias=Minetest

4
doc/breakages.md
View File

@ -1,4 +1,4 @@
# Minetest Major Breakages List
# Luanti Major Breakages List
This document contains a list of breaking changes to be made in the next major version.
This list is largely advisory and items may be reevaluated once the time comes.
@ -8,7 +8,7 @@ This list is largely advisory and items may be reevaluated once the time comes.
* remove player gravity multiplier (*2)
* `get_sky()` returns a table (without arg)
* `game.conf` name/id mess
* remove `depends.txt` / `description.txt` (would simplify ContentDB and Minetest code a little)
* remove `depends.txt` / `description.txt` (would simplify ContentDB and Luanti code a little)
* rotate moon texture by 180°, making it coherent with the sun
* https://github.com/minetest/minetest/pull/11902
* remove undocumented `set_physics_override(num, num, num)`

8
doc/builtin_entities.md
View File

@ -1,12 +1,12 @@
# Builtin Entities
Minetest registers two entities by default: Falling nodes and dropped items.
Luanti registers two entities by default: Falling nodes and dropped items.
This document describes how they behave and what you can do with them.
## Falling node (`__builtin:falling_node`)
This entity is created by `minetest.check_for_falling` in place of a node
This entity is created by `core.check_for_falling` in place of a node
with the special group `falling_node=1`. Falling nodes can also be created
artificially with `minetest.spawn_falling_node`.
artificially with `core.spawn_falling_node`.
Needs manual initialization when spawned using `/spawnentity`.
@ -81,7 +81,7 @@ Common cases that spawn a dropped item:
* Item dropped by player
* The root node of a node with the group `attached_node=1` is removed
* `minetest.add_item` is called
* `core.add_item` is called
Needs manual initialization when spawned using `/spawnentity`.

249
doc/client_lua_api.md
View File

@ -1,5 +1,10 @@
Minetest Lua Client Modding API Reference 5.10.0
================================================
Luanti Lua Client Modding API Reference 5.10.0
==============================================
**WARNING**: if you're looking for the `minetest` namespace (e.g. `minetest.something`),
it's now called `core` due to the renaming of Luanti (formerly Minetest).
`minetest` will keep existing as an alias, so that old code won't break.
* More information at <http://www.minetest.net/>
* Developer Wiki: <http://dev.minetest.net/>
@ -8,11 +13,11 @@ Introduction
** WARNING: The client API is currently unstable, and may break/change without warning. **
Content and functionality can be added to Minetest by using Lua
Content and functionality can be added to Luanti by using Lua
scripting in run-time loaded mods.
A mod is a self-contained bunch of scripts, textures and other related
things that is loaded by and interfaces with Minetest.
things that is loaded by and interfaces with Luanti.
Transferring client-sided mods from the server to the client is planned, but not implemented yet.
@ -97,7 +102,7 @@ The location of this directory.
An (optional) settings file that provides meta information about the mod.
* `name`: The mod name. Allows Minetest to determine the mod name even if the
* `name`: The mod name. Allows Luanti to determine the mod name even if the
folder is wrongly named.
* `description`: Description of mod to be shown in the Mods tab of the main
menu.
@ -109,7 +114,7 @@ An (optional) settings file that provides meta information about the mod.
### `init.lua`
The main Lua script. Running this script should register everything it
wants to register. Subsequent execution depends on minetest calling the
wants to register. Subsequent execution depends on Luanti calling the
registered callbacks.
**NOTE**: Client mods currently can't provide textures, sounds, or models by
@ -247,39 +252,39 @@ Helper functions
* e.g. `string:split("a,b", ",") == {"a","b"}`
* `string:trim()`
* e.g. `string.trim("\n \t\tfoo bar\t ") == "foo bar"`
* `minetest.wrap_text(str, limit)`: returns a string
* `core.wrap_text(str, limit)`: returns a string
* Adds new lines to the string to keep it within the specified character limit
* limit: Maximal amount of characters in one line
* `minetest.pos_to_string({x=X,y=Y,z=Z}, decimal_places))`: returns string `"(X,Y,Z)"`
* `core.pos_to_string({x=X,y=Y,z=Z}, decimal_places))`: returns string `"(X,Y,Z)"`
* Convert position to a printable string
Optional: 'decimal_places' will round the x, y and z of the pos to the given decimal place.
* `minetest.string_to_pos(string)`: returns a position
* `core.string_to_pos(string)`: returns a position
* Same but in reverse. Returns `nil` if the string can't be parsed to a position.
* `minetest.string_to_area("(X1, Y1, Z1) (X2, Y2, Z2)")`: returns two positions
* `core.string_to_area("(X1, Y1, Z1) (X2, Y2, Z2)")`: returns two positions
* Converts a string representing an area box into two positions
* `minetest.is_yes(arg)`
* `core.is_yes(arg)`
* returns whether `arg` can be interpreted as yes
* `minetest.is_nan(arg)`
* `core.is_nan(arg)`
* returns true when the passed number represents NaN.
* `table.copy(table)`: returns a table
* returns a deep copy of `table`
Minetest namespace reference
------------------------------
'core' namespace reference
--------------------------
### Utilities
* `minetest.get_current_modname()`: returns the currently loading mod's name, when we are loading a mod
* `minetest.get_modpath(modname)`: returns virtual path of given mod including
* `core.get_current_modname()`: returns the currently loading mod's name, when we are loading a mod
* `core.get_modpath(modname)`: returns virtual path of given mod including
the trailing separator. This is useful to load additional Lua files
contained in your mod:
e.g. `dofile(minetest.get_modpath(minetest.get_current_modname()) .. "stuff.lua")`
* `minetest.get_language()`: returns two strings
e.g. `dofile(core.get_modpath(core.get_current_modname()) .. "stuff.lua")`
* `core.get_language()`: returns two strings
* the current gettext locale
* the current language code (the same as used for client-side translations)
* `minetest.get_version()`: returns a table containing components of the
* `core.get_version()`: returns a table containing components of the
engine version. Components:
* `project`: Name of the project, eg, "Minetest"
* `project`: Name of the project, eg, "Luanti"
* `string`: Simple version, eg, "1.2.3-dev"
* `hash`: Full git version (only set if available), eg, "1.2.3-dev-01234567-dirty"
Use this for informational purposes only. The information in the returned
@ -287,85 +292,85 @@ Minetest namespace reference
reliable or verifiable. Compatible forks will have a different name and
version entirely. To check for the presence of engine features, test
whether the functions exported by the wanted features exist. For example:
`if minetest.check_for_falling then ... end`.
* `minetest.sha1(data, [raw])`: returns the sha1 hash of data
`if core.check_for_falling then ... end`.
* `core.sha1(data, [raw])`: returns the sha1 hash of data
* `data`: string of data to hash
* `raw`: return raw bytes instead of hex digits, default: false
* `minetest.colorspec_to_colorstring(colorspec)`: Converts a ColorSpec to a
* `core.colorspec_to_colorstring(colorspec)`: Converts a ColorSpec to a
ColorString. If the ColorSpec is invalid, returns `nil`.
* `colorspec`: The ColorSpec to convert
* `minetest.get_csm_restrictions()`: returns a table of `Flags` indicating the
* `core.get_csm_restrictions()`: returns a table of `Flags` indicating the
restrictions applied to the current mod.
* If a flag in this table is set to true, the feature is RESTRICTED.
* Possible flags: `load_client_mods`, `chat_messages`, `read_itemdefs`,
`read_nodedefs`, `lookup_nodes`, `read_playerinfo`
* `minetest.urlencode(str)`: Encodes non-unreserved URI characters by a
* `core.urlencode(str)`: Encodes non-unreserved URI characters by a
percent sign followed by two hex digits. See
[RFC 3986, section 2.3](https://datatracker.ietf.org/doc/html/rfc3986#section-2.3).
### Logging
* `minetest.debug(...)`
* Equivalent to `minetest.log(table.concat({...}, "\t"))`
* `minetest.log([level,] text)`
* `core.debug(...)`
* Equivalent to `core.log(table.concat({...}, "\t"))`
* `core.log([level,] text)`
* `level` is one of `"none"`, `"error"`, `"warning"`, `"action"`,
`"info"`, or `"verbose"`. Default is `"none"`.
### Global callback registration functions
Call these functions only at load time!
* `minetest.register_globalstep(function(dtime))`
* `core.register_globalstep(function(dtime))`
* Called every client environment step
* `dtime` is the time since last execution in seconds.
* `minetest.register_on_mods_loaded(function())`
* `core.register_on_mods_loaded(function())`
* Called just after mods have finished loading.
* `minetest.register_on_shutdown(function())`
* `core.register_on_shutdown(function())`
* Called before client shutdown
* **Warning**: If the client terminates abnormally (i.e. crashes), the registered
callbacks **will likely not be run**. Data should be saved at
semi-frequent intervals as well as on server shutdown.
* `minetest.register_on_receiving_chat_message(function(message))`
* `core.register_on_receiving_chat_message(function(message))`
* Called always when a client receive a message
* Return `true` to mark the message as handled, which means that it will not be shown to chat
* `minetest.register_on_sending_chat_message(function(message))`
* `core.register_on_sending_chat_message(function(message))`
* Called always when a client sends a message from chat
* Return `true` to mark the message as handled, which means that it will not be sent to server
* `minetest.register_chatcommand(cmd, chatcommand definition)`
* Adds definition to minetest.registered_chatcommands
* `minetest.unregister_chatcommand(name)`
* `core.register_chatcommand(cmd, chatcommand definition)`
* Adds definition to core.registered_chatcommands
* `core.unregister_chatcommand(name)`
* Unregisters a chatcommands registered with register_chatcommand.
* `minetest.register_on_chatcommand(function(command, params))`
* Called always when a chatcommand is triggered, before `minetest.registered_chatcommands`
* `core.register_on_chatcommand(function(command, params))`
* Called always when a chatcommand is triggered, before `core.registered_chatcommands`
is checked to see if the command exists, but after the input is parsed.
* Return `true` to mark the command as handled, which means that the default
handlers will be prevented.
* `minetest.register_on_hp_modification(function(hp))`
* `core.register_on_hp_modification(function(hp))`
* Called when server modified player's HP
* `minetest.register_on_damage_taken(function(hp))`
* `core.register_on_damage_taken(function(hp))`
* Called when the local player take damages
* `minetest.register_on_formspec_input(function(formname, fields))`
* `core.register_on_formspec_input(function(formname, fields))`
* Called when a button is pressed in the local player's inventory form
* Newest functions are called first
* If function returns `true`, remaining functions are not called
* `minetest.register_on_dignode(function(pos, node))`
* `core.register_on_dignode(function(pos, node))`
* Called when the local player digs a node
* Newest functions are called first
* If any function returns true, the node isn't dug
* `minetest.register_on_punchnode(function(pos, node))`
* `core.register_on_punchnode(function(pos, node))`
* Called when the local player punches a node
* Newest functions are called first
* If any function returns true, the punch is ignored
* `minetest.register_on_placenode(function(pointed_thing, node))`
* `core.register_on_placenode(function(pointed_thing, node))`
* Called when a node has been placed
* `minetest.register_on_item_use(function(item, pointed_thing))`
* `core.register_on_item_use(function(item, pointed_thing))`
* Called when the local player uses an item.
* Newest functions are called first.
* If any function returns true, the item use is not sent to server.
* `minetest.register_on_modchannel_message(function(channel_name, sender, message))`
* `core.register_on_modchannel_message(function(channel_name, sender, message))`
* Called when an incoming mod channel message is received
* You must have joined some channels before, and server must acknowledge the
join request.
* If message comes from a server mod, `sender` field is an empty string.
* `minetest.register_on_modchannel_signal(function(channel_name, signal))`
* `core.register_on_modchannel_signal(function(channel_name, signal))`
* Called when a valid incoming mod channel signal is received
* Signal id permit to react to server mod channel events
* Possible values are:
@ -375,54 +380,54 @@ Call these functions only at load time!
3: leave_failed
4: event_on_not_joined_channel
5: state_changed
* `minetest.register_on_inventory_open(function(inventory))`
* `core.register_on_inventory_open(function(inventory))`
* Called when the local player open inventory
* Newest functions are called first
* If any function returns true, inventory doesn't open
### Sounds
* `minetest.sound_play(spec, parameters)`: returns a handle
* `core.sound_play(spec, parameters)`: returns a handle
* `spec` is a `SimpleSoundSpec`
* `parameters` is a sound parameter table
* `handle:stop()` or `minetest.sound_stop(handle)`
* `handle` is a handle returned by `minetest.sound_play`
* `handle:fade(step, gain)` or `minetest.sound_fade(handle, step, gain)`
* `handle` is a handle returned by `minetest.sound_play`
* `handle:stop()` or `core.sound_stop(handle)`
* `handle` is a handle returned by `core.sound_play`
* `handle:fade(step, gain)` or `core.sound_fade(handle, step, gain)`
* `handle` is a handle returned by `core.sound_play`
* `step` determines how fast a sound will fade.
Negative step will lower the sound volume, positive step will increase
the sound volume.
* `gain` the target gain for the fade.
### Timing
* `minetest.after(time, func, ...)`
* `core.after(time, func, ...)`
* Call the function `func` after `time` seconds, may be fractional
* Optional: Variable number of arguments that are passed to `func`
* Jobs set for earlier times are executed earlier. If multiple jobs expire
at exactly the same time, then they expire in the order in which they were
registered. This basically just applies to jobs registered on the same
step with the exact same delay.
* `minetest.get_us_time()`
* `core.get_us_time()`
* Returns time with microsecond precision. May not return wall time.
* `minetest.get_timeofday()`
* `core.get_timeofday()`
* Returns the time of day: `0` for midnight, `0.5` for midday
### Map
* `minetest.get_node_or_nil(pos)`
* `core.get_node_or_nil(pos)`
* Returns the node at the given position as table in the format
`{name="node_name", param1=0, param2=0}`, returns `nil`
for unloaded areas or flavor limited areas.
* `minetest.get_node_light(pos, timeofday)`
* `core.get_node_light(pos, timeofday)`
* Gets the light value at the given position. Note that the light value
"inside" the node at the given position is returned, so you usually want
to get the light value of a neighbor.
* `pos`: The position where to measure the light.
* `timeofday`: `nil` for current time, `0` for night, `0.5` for day
* Returns a number between `0` and `15` or `nil`
* `minetest.find_node_near(pos, radius, nodenames, [search_center])`: returns pos or `nil`
* `core.find_node_near(pos, radius, nodenames, [search_center])`: returns pos or `nil`
* `radius`: using a maximum metric
* `nodenames`: e.g. `{"ignore", "group:tree"}` or `"default:dirt"`
* `search_center` is an optional boolean (default: `false`)
If true `pos` is also checked for the nodes
* `minetest.find_nodes_in_area(pos1, pos2, nodenames, [grouped])`
* `core.find_nodes_in_area(pos1, pos2, nodenames, [grouped])`
* `pos1` and `pos2` are the min and max positions of the area to search.
* `nodenames`: e.g. `{"ignore", "group:tree"}` or `"default:dirt"`
* If `grouped` is true the return value is a table indexed by node name
@ -432,91 +437,91 @@ Call these functions only at load time!
second value: Table with the count of each node with the node name
as index
* Area volume is limited to 4,096,000 nodes
* `minetest.find_nodes_in_area_under_air(pos1, pos2, nodenames)`: returns a
* `core.find_nodes_in_area_under_air(pos1, pos2, nodenames)`: returns a
list of positions.
* `nodenames`: e.g. `{"ignore", "group:tree"}` or `"default:dirt"`
* Return value: Table with all node positions with a node air above
* Area volume is limited to 4,096,000 nodes
* `minetest.line_of_sight(pos1, pos2)`: returns `boolean, pos`
* `core.line_of_sight(pos1, pos2)`: returns `boolean, pos`
* Checks if there is anything other than air between pos1 and pos2.
* Returns false if something is blocking the sight.
* Returns the position of the blocking node when `false`
* `pos1`: First position
* `pos2`: Second position
* `minetest.raycast(pos1, pos2, objects, liquids)`: returns `Raycast`
* `core.raycast(pos1, pos2, objects, liquids)`: returns `Raycast`
* Creates a `Raycast` object.
* `pos1`: start of the ray
* `pos2`: end of the ray
* `objects`: if false, only nodes will be returned. Default is `true`.
* `liquids`: if false, liquid nodes won't be returned. Default is `false`.
* `minetest.find_nodes_with_meta(pos1, pos2)`
* `core.find_nodes_with_meta(pos1, pos2)`
* Get a table of positions of nodes that have metadata within a region
{pos1, pos2}.
* `minetest.get_meta(pos)`
* `core.get_meta(pos)`
* Get a `NodeMetaRef` at that position
* `minetest.get_node_level(pos)`
* `core.get_node_level(pos)`
* get level of leveled node (water, snow)
* `minetest.get_node_max_level(pos)`
* `core.get_node_max_level(pos)`
* get max available level for leveled node
### Player
* `minetest.send_chat_message(message)`
* `core.send_chat_message(message)`
* Act as if `message` was typed by the player into the terminal.
* `minetest.run_server_chatcommand(cmd, param)`
* Alias for `minetest.send_chat_message("/" .. cmd .. " " .. param)`
* `minetest.clear_out_chat_queue()`
* `core.run_server_chatcommand(cmd, param)`
* Alias for `core.send_chat_message("/" .. cmd .. " " .. param)`
* `core.clear_out_chat_queue()`
* Clears the out chat queue
* `minetest.localplayer`
* `core.localplayer`
* Reference to the LocalPlayer object. See [`LocalPlayer`](#localplayer) class reference for methods.
### Privileges
* `minetest.get_privilege_list()`
* `core.get_privilege_list()`
* Returns a list of privileges the current player has in the format `{priv1=true,...}`
* `minetest.string_to_privs(str)`: returns `{priv1=true,...}`
* `minetest.privs_to_string(privs)`: returns `"priv1,priv2,..."`
* `core.string_to_privs(str)`: returns `{priv1=true,...}`
* `core.privs_to_string(privs)`: returns `"priv1,priv2,..."`
* Convert between two privilege representations
### Client Environment
* `minetest.get_player_names()`
* `core.get_player_names()`
* Returns list of player names on server (nil if CSM_RF_READ_PLAYERINFO is enabled by server)
* `minetest.disconnect()`
* `core.disconnect()`
* Disconnect from the server and exit to main menu.
* Returns `false` if the client is already disconnecting otherwise returns `true`.
* `minetest.get_server_info()`
* `core.get_server_info()`
* Returns [server info](#server-info).
### Storage API
* `minetest.get_mod_storage()`:
* `core.get_mod_storage()`:
* returns reference to mod private `StorageRef`
* must be called during mod load time
### Mod channels
![Mod channels communication scheme](docs/mod channels.png)
* `minetest.mod_channel_join(channel_name)`
* `core.mod_channel_join(channel_name)`
* Client joins channel `channel_name`, and creates it, if necessary. You
should listen from incoming messages with `minetest.register_on_modchannel_message`
should listen from incoming messages with `core.register_on_modchannel_message`
call to receive incoming messages. Warning, this function is asynchronous.
### Particles
* `minetest.add_particle(particle definition)`
* `core.add_particle(particle definition)`
* `minetest.add_particlespawner(particlespawner definition)`
* `core.add_particlespawner(particlespawner definition)`
* Add a `ParticleSpawner`, an object that spawns an amount of particles over `time` seconds
* Returns an `id`, and -1 if adding didn't succeed
* `minetest.delete_particlespawner(id)`
* Delete `ParticleSpawner` with `id` (return value from `minetest.add_particlespawner`)
* `core.delete_particlespawner(id)`
* Delete `ParticleSpawner` with `id` (return value from `core.add_particlespawner`)
### Misc.
* `minetest.parse_json(string[, nullvalue])`: returns something
* `core.parse_json(string[, nullvalue])`: returns something
* Convert a string containing JSON data into the Lua equivalent
* `nullvalue`: returned in place of the JSON null; defaults to `nil`
* On success returns a table, a string, a number, a boolean or `nullvalue`
* On failure outputs an error message and returns `nil`
* Example: `parse_json("[10, {\"a\":false}]")`, returns `{10, {a = false}}`
* `minetest.write_json(data[, styled])`: returns a string or `nil` and an error message
* `core.write_json(data[, styled])`: returns a string or `nil` and an error message
* Convert a Lua table into a JSON string
* styled: Outputs in a human-readable format if this is set, defaults to false
* Unserializable things like functions and userdata are saved as null.
@ -525,18 +530,18 @@ Call these functions only at load time!
2. You cannot mix string and integer keys.
This is due to the fact that JSON has two distinct array and object values.
* Example: `write_json({10, {a = false}})`, returns `"[10, {\"a\": false}]"`
* `minetest.serialize(table)`: returns a string
* `core.serialize(table)`: returns a string
* Convert a table containing tables, strings, numbers, booleans and `nil`s
into string form readable by `minetest.deserialize`
into string form readable by `core.deserialize`
* Example: `serialize({foo='bar'})`, returns `'return { ["foo"] = "bar" }'`
* `minetest.deserialize(string)`: returns a table
* Convert a string returned by `minetest.deserialize` into a table
* `core.deserialize(string)`: returns a table
* Convert a string returned by `core.deserialize` into a table
* `string` is loaded in an empty sandbox environment.
* Will load functions, but they cannot access the global environment.
* Example: `deserialize('return { ["foo"] = "bar" }')`, returns `{foo='bar'}`
* Example: `deserialize('print("foo")')`, returns `nil` (function call fails)
* `error:[string "print("foo")"]:1: attempt to call global 'print' (a nil value)`
* `minetest.compress(data, method, ...)`: returns `compressed_data`
* `core.compress(data, method, ...)`: returns `compressed_data`
* Compress a string of data.
* `method` is a string identifying the compression method to be used.
* Supported compression methods:
@ -548,50 +553,50 @@ Call these functions only at load time!
* Zstandard: `level` - Compression level. Integer or `nil`. Default `3`.
Note any supported Zstandard compression level could be used here,
but these are subject to change between Zstandard versions.
* `minetest.decompress(compressed_data, method, ...)`: returns data
* `core.decompress(compressed_data, method, ...)`: returns data
* Decompress a string of data using the algorithm specified by `method`.
* See documentation on `minetest.compress()` for supported compression
* See documentation on `core.compress()` for supported compression
methods.
* `...` indicates method-specific arguments. Currently, no methods use this
* `minetest.rgba(red, green, blue[, alpha])`: returns a string
* `core.rgba(red, green, blue[, alpha])`: returns a string
* Each argument is an 8 Bit unsigned integer
* Returns the ColorString from rgb or rgba values
* Example: `minetest.rgba(10, 20, 30, 40)`, returns `"#0A141E28"`
* `minetest.encode_base64(string)`: returns string encoded in base64
* Example: `core.rgba(10, 20, 30, 40)`, returns `"#0A141E28"`
* `core.encode_base64(string)`: returns string encoded in base64
* Encodes a string in base64.
* `minetest.decode_base64(string)`: returns string or nil on failure
* `core.decode_base64(string)`: returns string or nil on failure
* Padding characters are only supported starting at version 5.4.0, where
5.5.0 and newer perform proper checks.
* Decodes a string encoded in base64.
* `minetest.gettext(string)` : returns string
* `core.gettext(string)` : returns string
* look up the translation of a string in the gettext message catalog
* `fgettext_ne(string, ...)`
* call minetest.gettext(string), replace "$1"..."$9" with the given
* call core.gettext(string), replace "$1"..."$9" with the given
extra arguments and return the result
* `fgettext(string, ...)` : returns string
* same as fgettext_ne(), but calls minetest.formspec_escape before returning result
* `minetest.pointed_thing_to_face_pos(placer, pointed_thing)`: returns a position
* same as fgettext_ne(), but calls core.formspec_escape before returning result
* `core.pointed_thing_to_face_pos(placer, pointed_thing)`: returns a position
* returns the exact position on the surface of a pointed node
* `minetest.global_exists(name)`
* `core.global_exists(name)`
* Checks if a global variable has been set, without triggering a warning.
### UI
* `minetest.ui.minimap`
* `core.ui.minimap`
* Reference to the minimap object. See [`Minimap`](#minimap) class reference for methods.
* If client disabled minimap (using enable_minimap setting) this reference will be nil.
* `minetest.camera`
* `core.camera`
* Reference to the camera object. See [`Camera`](#camera) class reference for methods.
* `minetest.show_formspec(formname, formspec)` : returns true on success
* `core.show_formspec(formname, formspec)` : returns true on success
* Shows a formspec to the player
* `minetest.display_chat_message(message)` returns true on success
* `core.display_chat_message(message)` returns true on success
* Shows a chat message to the current player.
Setting-related
---------------
* `minetest.settings`: Settings object containing all of the settings from the
* `core.settings`: Settings object containing all of the settings from the
main config file (`minetest.conf`). Check lua_api.md for class reference.
* `minetest.setting_get_pos(name)`: Loads a setting from the main settings and
* `core.setting_get_pos(name)`: Loads a setting from the main settings and
parses it as a position (in the format `(1,2,3)`). Returns a position or nil.
Class reference
@ -821,7 +826,7 @@ It can be created via `Settings(filename)`.
### NodeMetaRef
Node metadata: reference extra data and functionality stored in a node.
Can be obtained via `minetest.get_meta(pos)`.
Can be obtained via `core.get_meta(pos)`.
#### Methods
* `get_string(name)`
@ -847,7 +852,7 @@ The map is loaded as the ray advances. If the map is modified after the
`Raycast` is created, the changes may or may not have an effect on the object.
It can be created via `Raycast(pos1, pos2, objects, liquids)` or
`minetest.raycast(pos1, pos2, objects, liquids)` where:
`core.raycast(pos1, pos2, objects, liquids)` where:
* `pos1`: start of the ray
* `pos2`: end of the ray
@ -861,9 +866,9 @@ It can be created via `Raycast(pos1, pos2, objects, liquids)` or
-----------------
### Definitions
* `minetest.get_node_def(nodename)`
* `core.get_node_def(nodename)`
* Returns [node definition](#node-definition) table of `nodename`
* `minetest.get_item_def(itemstring)`
* `core.get_item_def(itemstring)`
* Returns item definition table of `itemstring`
#### Node Definition
@ -967,7 +972,7 @@ It can be created via `Raycast(pos1, pos2, objects, liquids)` or
```lua
{
address = "minetest.example.org", -- The domain name/IP address of a remote server or "" for a local server.
address = "luanti.example.org", -- The domain name/IP address of a remote server or "" for a local server.
ip = "203.0.113.156", -- The IP address of the server.
port = 30000, -- The port the client is connected to.
protocol_version = 30 -- Will not be accurate at start up as the client might not be connected to the server yet, in that case it will be 0.
@ -983,23 +988,23 @@ Escape sequences
Most text can contain escape sequences that can for example color the text.
There are a few exceptions: tab headers, dropdowns and vertical labels can't.
The following functions provide escape sequences:
* `minetest.get_color_escape_sequence(color)`:
* `core.get_color_escape_sequence(color)`:
* `color` is a [ColorString](#colorstring)
* The escape sequence sets the text color to `color`
* `minetest.colorize(color, message)`:
* `core.colorize(color, message)`:
* Equivalent to:
`minetest.get_color_escape_sequence(color) ..
`core.get_color_escape_sequence(color) ..
message ..
minetest.get_color_escape_sequence("#ffffff")`
* `minetest.get_background_escape_sequence(color)`
core.get_color_escape_sequence("#ffffff")`
* `core.get_background_escape_sequence(color)`
* `color` is a [ColorString](#colorstring)
* The escape sequence sets the background of the whole text element to
`color`. Only defined for item descriptions and tooltips.
* `minetest.strip_foreground_colors(str)`
* `core.strip_foreground_colors(str)`
* Removes foreground colors added by `get_color_escape_sequence`.
* `minetest.strip_background_colors(str)`
* `core.strip_background_colors(str)`
* Removes background colors added by `get_background_escape_sequence`.
* `minetest.strip_colors(str)`
* `core.strip_colors(str)`
* Removes all color escape sequences.
`ColorString`

10
doc/compiling/README.md
View File

@ -1,4 +1,4 @@
# Compiling Minetest
# Compiling Luanti
- [Compiling on GNU/Linux](linux.md)
- [Compiling on Windows](windows.md)
@ -9,8 +9,8 @@
General options and their default values:
BUILD_CLIENT=TRUE - Build Minetest client
BUILD_SERVER=FALSE - Build Minetest server
BUILD_CLIENT=TRUE - Build Luanti client
BUILD_SERVER=FALSE - Build Luanti server
BUILD_UNITTESTS=TRUE - Build unittest sources
BUILD_BENCHMARKS=FALSE - Build benchmark sources
BUILD_DOCUMENTATION=TRUE - Build doxygen documentation
@ -38,11 +38,11 @@ General options and their default values:
ENABLE_SYSTEM_JSONCPP=ON - Use JsonCPP from system
RUN_IN_PLACE=FALSE - Create a portable install (worlds, settings etc. in current directory)
ENABLE_UPDATE_CHECKER=TRUE - Whether to enable update checks by default
INSTALL_DEVTEST=FALSE - Whether the Development Test game should be installed alongside Minetest
INSTALL_DEVTEST=FALSE - Whether the Development Test game should be installed alongside Luanti
USE_GPROF=FALSE - Enable profiling using GProf
BUILD_WITH_TRACY=FALSE - Fetch and build with the Tracy profiler client
FETCH_TRACY_GIT_TAG=master - Git tag for fetching Tracy client. Match with your server (gui) version
VERSION_EXTRA= - Text to append to version (e.g. VERSION_EXTRA=foobar -> Minetest 0.4.9-foobar)
VERSION_EXTRA= - Text to append to version (e.g. VERSION_EXTRA=foobar -> Luanti 5.10.0-foobar)
Library specific options:

4
doc/compiling/windows.md
View File

@ -29,7 +29,7 @@ There are other optional libraries, but they are not tested if they can build an
Use `--triplet` to specify the target triplet, e.g. `x64-windows` or `x86-windows`.
## Compile Minetest
## Compile Luanti
### a) Using the vcpkg toolchain and CMake GUI
@ -46,7 +46,7 @@ Use `--triplet` to specify the target triplet, e.g. `x64-windows` or `x86-window
11. If there are any errors, solve them and hit **Configure**
12. Click **Generate**
13. Click **Open Project**
14. Compile Minetest inside Visual studio.
14. Compile Luanti inside Visual studio.
### b) Using the vcpkg toolchain and the commandline

2
doc/developing/README.md
View File

@ -6,7 +6,7 @@ Some important development docs are found in the wiki: https://dev.minetest.net/
Notable pages:
- [Releasing Minetest](https://dev.minetest.net/Releasing_Minetest)
- [Releasing Luanti](https://dev.minetest.net/Releasing_Minetest)
- [Engine translations](https://dev.minetest.net/Translation#Maintaining_engine_translations)
- [Changelog](https://dev.minetest.net/Changelog)
- [Organisation](https://dev.minetest.net/Organisation)

2
doc/developing/android.md
View File

@ -21,7 +21,7 @@ After that installing it will work:
adb install -r -d ./app-arm64-v8a-release-unsigned.apk
```
## How to get debug output from Minetest on Android
## How to get debug output from Luanti on Android
In case debug.txt isn't enough (e.g. when debugging a crash), you can get debug
output using logcat:

14
doc/developing/misc.md
View File

@ -1,10 +1,10 @@
# Miscellaneous
## Profiling Minetest on Linux with perf
## Profiling Luanti on Linux with perf
We will be using a tool called "perf", which you can get by installing `perf` or `linux-perf` or `linux-tools-common`.
To get usable results you need to build Minetest with debug symbols
To get usable results you need to build Luanti with debug symbols
(`-DCMAKE_BUILD_TYPE=RelWithDebInfo` or `-DCMAKE_BUILD_TYPE=Debug`).
Run the client (or server) like this and do whatever you wanted to test:
@ -48,20 +48,20 @@ It allows one to annotate important functions and generate traces, where one can
see when each individual function call happened, and how long it took.
Tracy can also record when frames, e.g. server step, start and end, and inspect
frames that took longer than usual. Minetest already contains annotations for
frames that took longer than usual. Luanti already contains annotations for
its frames.
See also [Tracy's official documentation](https://github.com/wolfpld/tracy/releases/latest/download/tracy.pdf).
### Installing
Tracy consists of a client (Minetest) and a server (the gui).
Tracy consists of a client (Luanti) and a server (the gui).
Install the server, e.g. using your package manager.
### Building
Build Minetest with `-DDBUILD_WITH_TRACY=1`, this will fetch Tracy for building
Build Luanti with `-DDBUILD_WITH_TRACY=1`, this will fetch Tracy for building
the Tracy client. And use `FETCH_TRACY_GIT_TAG` to get a version matching your
Tracy server, e.g. `-DFETCH_TRACY_GIT_TAG=v0.11.0` if it's `0.11.0`.
@ -74,7 +74,7 @@ See Tracy's documentation for more build options.
### Using in C++
Start the Tracy server and Minetest. You should see Minetest in the menu.
Start the Tracy server and Luanti. You should see Luanti in the menu.
To actually get useful traces, you have to annotate functions with `ZoneScoped`
macros and recompile. Please refer to Tracy's official documentation.
@ -82,7 +82,7 @@ macros and recompile. Please refer to Tracy's official documentation.
### Using in Lua
Tracy also supports Lua.
If built with Tracy, Minetest loads its API in the global `tracy` table.
If built with Tracy, Luanti loads its API in the global `tracy` table.
See Tracy's official documentation for more information.
Note: The whole Tracy Lua API is accessible to all mods. And we don't check if it

6
doc/developing/os-compatibility.md
View File

@ -2,7 +2,7 @@ OS/library compatibility policy
===============================
This document describes how we decide which minimum versions of operating systems, C++ standards,
libraries, build tools (CMake) or compilers Minetest requires.
libraries, build tools (CMake) or compilers Luanti requires.
Most important is that we do not increase our minimum requirements without a reason or use case.
A reason can be as simple as "cleaning up legacy support code", but it needs to exist.
@ -54,7 +54,7 @@ OpenGL ES 2.0 is supported for the sake of mobile platforms.
It has been [proposed](https://irc.minetest.net/minetest-dev/2022-08-18) moving to OpenGL 2.x or 3.0 with shaders required.
General **system requirements** are not bounded either.
Being able to play Minetest on a recent low-end phone is a reasonable target.
Being able to play Luanti on a recent low-end phone is a reasonable target.
## On totality
@ -71,7 +71,7 @@ Sound is optional at build-time but nobody would call an engine build without so
In general also consider:
* Is the proposition important enough to warrant a new dependency?
* Can we make it easier for users to build the library together with Minetest?
* Can we make it easier for users to build the library together with Luanti?
* Maybe even vendor the library?
* Or could the engine include a transparent fallback implementation?

8
doc/direction.md
View File

@ -1,4 +1,4 @@
# Minetest Direction Document
# Luanti Direction Document
## 1. Long-term Roadmap
@ -12,7 +12,7 @@ following documents:
## 2. Medium-term Roadmap
These are the current medium-term goals for Minetest development, in no
These are the current medium-term goals for Luanti development, in no
particular order.
These goals were created from the top points in a
@ -42,7 +42,7 @@ alternative libraries to replace Irrlicht functionality as needed
### 2.2 Internal code refactoring
To ensure sustainable development, Minetest's code needs to be
To ensure sustainable development, Luanti's code needs to be
[refactored and improved](https://github.com/minetest/minetest/pulls?q=is%3Aopen+sort%3Aupdated-desc+label%3A%22Code+quality%22+).
This will remove code rot and allow for more efficient development.
@ -54,7 +54,7 @@ be a replacement for HUDs, allowing for a unified API.
A [new mainmenu](https://github.com/minetest/minetest/issues/6733) is needed to
improve user experience. First impressions matter, and the current main menu
doesn't do a very good job at selling Minetest or explaining what it is.
doesn't do a very good job at selling Luanti or explaining what it is.
A new main menu should promote games to users, allowing Minetest Game to no
longer be bundled by default.

2
doc/docker_server.md
View File

@ -1,6 +1,6 @@
# Docker Server
We provide Minetest server Docker images using the GitHub container registry.
We provide Luanti server Docker images using the GitHub container registry.
Images are built on each commit and available using the following tag scheme:

6
doc/ides/jetbrains.md
View File

@ -8,7 +8,7 @@ The IDE will open the folder and display the open project wizard:
![Open Project Wizard](images/jetbrains_open_project_wizard_profiles.png)
CLion try to determine a base configuration, but Minetest define it's own presets for easier setup. So you need to
CLion try to determine a base configuration, but Luanti define it's own presets for easier setup. So you need to
delete the `Debug` profile with the `-` sign and close the dialog.
You should notice a notification telling you 4 presets have been loaded in the bottom right corner.
@ -61,7 +61,7 @@ Then, the process is roughly similar to Linux, you just need to pick `Visual Stu
[Vcpkg](https://vcpkg.io) is the recommended way of installing Minetest dependencies.
[Vcpkg](https://vcpkg.io) is the recommended way of installing Luanti dependencies.
You need to let CLion know about a `vcpkg` installation to let the bundled CMake use the dependencies seamlessly and get
IDE integration. (Require CLion 2023 or later)
@ -70,7 +70,7 @@ Go to `View > Tool Windows > Vcpkg` and click the add button. I will open a popu
installation. By default it will download a new one that you can use to install your dependencies, but if you already
have one installed or you do not plan on using CLion only then install Vcpkg by hand and select your installation
directory. Don't forget to check `Add vcpkg installation to existing CMake profiles`. If you haven't already installed
Minetest dependencies in your vcpkg installation, you can do it right from CLion's Vcpkg tool window.
Luanti dependencies in your vcpkg installation, you can do it right from CLion's Vcpkg tool window.
![Jetbrains Vcpkg](images/jetbrains_vcpkg.png)

2
doc/ides/visual_studio.md
View File

@ -2,6 +2,6 @@
From the Visual Studio installer, you need to install the `Desktop development with C++` Workload. You need to make sure the `C++ CMake tools for Windows` component is included in the installation details panel.
You need to install [Vcpkg](https://vcpkg.io) and install Minetest dependencies as stated in the compilation documentation.
You need to install [Vcpkg](https://vcpkg.io) and install Luanti dependencies as stated in the compilation documentation.
For the packages to be discoverable and used by Visual Studio, you need to run `vcpkg integrate install`.

6
doc/ides/vscode.md
View File

@ -9,7 +9,7 @@ extension pack manually by downloading the VSIX files and going to `Extensions >
CMake support for VSCode uses CMake presets provided by the project by default.
When you open the Minetest folder with VSCode, you should get a quick pick asking you for the default preset.
When you open the Luanti folder with VSCode, you should get a quick pick asking you for the default preset.
![VSCode CMake Preset Selection](images/vscode_cmake_preset_selection.png)
@ -34,9 +34,9 @@ Under Windows, the recommended compiler is the [Visual Studio](https://visualstu
From the Visual Studio installer, you need to install the `Desktop development with C++` Workload.
[Vcpkg](https://vcpkg.io) is the recommended way of installing Minetest dependencies.
[Vcpkg](https://vcpkg.io) is the recommended way of installing Luanti dependencies.
Follow the official documentation to install it and install Minetest dependencies as explained in [Windows compilation process](../compiling/windows.md).
Follow the official documentation to install it and install Luanti dependencies as explained in [Windows compilation process](../compiling/windows.md).
You need to let CMake know about the `vcpkg` installation in VSCode.

1341
doc/lua_api.md
View File

File diff suppressed because it is too large Load Diff

12
doc/menu_lua_api.md
View File

@ -1,5 +1,5 @@
Minetest Lua Mainmenu API Reference 5.10.0
=========================================
Luanti Lua Mainmenu API Reference 5.10.0
========================================
Introduction
-------------
@ -128,7 +128,7 @@ HTTP Requests
* returns `HTTPApiTable` containing http functions.
* The returned table contains the functions `fetch_sync`, `fetch_async` and
`fetch_async_get` described below.
* Function only exists if minetest server was built with cURL support.
* Function only exists if Luanti server was built with cURL support.
* `HTTPApiTable.fetch_sync(HTTPRequest req)`: returns HTTPRequestResult
* Performs given request synchronously
* `HTTPApiTable.fetch_async(HTTPRequest req)`: returns handle
@ -155,7 +155,7 @@ Used by `HTTPApiTable.fetch` and `HTTPApiTable.fetch_async`.
-- If post_data is not specified, a GET request is performed instead.
user_agent = "ExampleUserAgent",
-- Optional, if specified replaces the default minetest user agent with
-- Optional, if specified replaces the default Luanti user agent with
-- given string
extra_headers = { "Accept-Language: en-us", "Accept-Charset: utf-8" },
@ -257,7 +257,7 @@ GUI
y = 577,
},
-- Estimated maximum formspec size before Minetest will start shrinking the
-- Estimated maximum formspec size before Luanti will start shrinking the
-- formspec to fit. For a fullscreen formspec, use this formspec size and
-- `padding[0,0]`. `bgcolor[;true]` is also recommended.
max_formspec_size = {
@ -295,7 +295,7 @@ Package - content which is downloadable from the content db, may or may not be i
* `core.get_modpaths()` (possible in async calls)
* returns table of virtual path to global modpaths, where mods have been installed
The difference with `core.get_modpath` is that no mods should be installed in these
directories by Minetest -- they might be read-only.
directories by Luanti -- they might be read-only.
Ex:

2
doc/mkdocs/build.sh
View File

@ -4,7 +4,7 @@
cat ../lua_api.md | csplit -sz -f docs/section - '/^=/-1' '{*}'
cat > mkdocs.yml << EOF
site_name: Minetest API Documentation
site_name: Luanti API Documentation
theme:
name: readthedocs
highlightjs: False

4
doc/protocol.txt
View File

@ -1,4 +1,4 @@
Minetest protocol (incomplete, early draft):
Luanti protocol (incomplete, early draft):
Updated 2011-06-18
A custom protocol over UDP.
@ -70,7 +70,7 @@ function check_if_minetestserver_up($host, $port)
return false;
}
- Here's a Python script for checking if a minetest server is up, confirmed working
- Here's a Python script for checking if a Luanti server is up, confirmed working
#!/usr/bin/env python3
import sys, time, socket

10
doc/texture_packs.md
View File

@ -1,4 +1,4 @@
Minetest Texture Pack Reference
Luanti Texture Pack Reference
===============================
Texture packs allow you to replace textures provided by a mod with your own
@ -25,7 +25,7 @@ texture pack. The name must not be “base”.
### `texture_pack.conf`
A key-value config file with the following keys:
* `name`: The texture pack name. Allows Minetest to determine the texture pack name even if
* `name`: The texture pack name. Allows Luanti to determine the texture pack name even if
the folder is wrongly named.
* `title` - human-readable title
* `description` - short description, shown in the content tab
@ -107,9 +107,9 @@ by texture packs. All existing fallback textures can be found in the directory
* `progress_bar.png`: foreground texture of the loading screen's progress bar
* `progress_bar_bg.png`: background texture of the loading screen's progress bar
* `moon.png`: texture of the moon. Default texture is generated by Minetest
* `moon.png`: texture of the moon. Default texture is generated by Luanti
* `moon_tonemap.png`: tonemap to be used when `moon.png` was found
* `sun.png`: texture of the sun. Default texture is generated by Minetest
* `sun.png`: texture of the sun. Default texture is generated by Luanti
* `sun_tonemap.png`: tonemap to be used when `sun.png` was found
* `sunrisebg.png`: shown sky texture when the sun rises
@ -226,7 +226,7 @@ The special* targets only apply to specific drawtypes:
Designing leaves textures for the leaves rendering options
----------------------------------------------------------
Minetest has three modes for rendering leaves nodes if the node has the
Luanti has three modes for rendering leaves nodes if the node has the
`allfaces_optional` drawtype.
### Fancy

12
doc/world_format.md
View File

@ -1,4 +1,4 @@
# Minetest World Format 22...29
# Luanti World Format 22...29
This applies to a world format carrying the block serialization version
22...27, used at least in
@ -249,14 +249,14 @@ Example content:
# Map File Format
Minetest maps consist of `MapBlock`s, chunks of 16x16x16 nodes.
Luanti maps consist of `MapBlock`s, chunks of 16x16x16 nodes.
In addition to the bulk node data, `MapBlock`s stored on disk also contain
other things.
## History
Initially, Minetest stored maps in a format called the "sectors" format.
Initially, Luanti stored maps in a format called the "sectors" format.
It was a directory/file structure like this:
sectors2/XXX/ZZZ/YYYY
@ -265,7 +265,7 @@ For example, the `MapBlock` at `(0, 1, -2)` was this file:
sectors2/000/ffd/0001
Eventually Minetest outgrew this directory structure, as filesystems were
Eventually Luanti outgrew this directory structure, as filesystems were
struggling under the number of files and directories.
Large servers seriously needed a new format, and thus the base of the
@ -370,7 +370,7 @@ See below for description.
* Indicates if the light is correct at the sides of a map block.
Lighting may not be correct if the light changed, but a neighbor
block was not loaded at that time.
If these flags are false, Minetest will automatically recompute light
If these flags are false, Luanti will automatically recompute light
when both this block and its required neighbor are loaded.
* The bit order is:
@ -383,7 +383,7 @@ See below for description.
to indicate if direct sunlight spreading is finished.
* Example: if the block at `(0, 0, 0)` has `lighting_complete = 0b1111111111111110`,
Minetest will correct lighting in the day light bank when the block at
Luanti will correct lighting in the day light bank when the block at
`(1, 0, 0)` is also loaded.
Timestamp and node ID mappings were introduced in map format version 29.

2
misc/redirect.html
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Minetest API documentation</title>
<title>Luanti API documentation</title>
<link rel="canonical" href="https://api.minetest.netURL">
<meta http-equiv="refresh" content="0; url=https://api.minetest.netURL">