Elkien3/citysim_game
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
Elkien3 2018-08-21 16:19:07 -05:00
parent 5dd02d6ff0
commit 191d684c6f
3835 changed files with 236123 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
.luacheckrc Normal file
View File

@ -0,0 +1,21 @@
unused_args = false
allow_defined_top = true
read_globals = {
"DIR_DELIM",
"minetest", "core",
"dump",
"vector",
"VoxelManip", "VoxelArea",
"PseudoRandom", "ItemStack",
"Settings",
"unpack",
-- Silence "accessing undefined field copy of global table".
table = { fields = { "copy" } }
}
-- Overwrites minetest.handle_node_drops
files["mods/creative/init.lua"].globals = { "minetest" }
-- Don't report on legacy definitions of globals.
files["mods/default/legacy.lua"].global = false

12
.travis.yml Normal file
View File

@ -0,0 +1,12 @@
language: generic
sudo: false
addons:
apt:
packages:
- luarocks
before_install:
- luarocks install --local luacheck
script:
- $HOME/.luarocks/bin/luacheck --no-color ./mods
notifications:
email: false

519
LICENSE.txt Normal file
View File

@ -0,0 +1,519 @@
License of media (textures and sounds)
--------------------------------------
Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
See README.txt in each mod directory for information about other authors.
Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
http://creativecommons.org/licenses/by-sa/3.0/
License of menu/header.png
Copyright (C) 2015 paramat CC BY-SA 3.0
License of source code
----------------------
Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
See README.txt in each mod directory for information about other authors.
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

28
README.txt Normal file
View File

@ -0,0 +1,28 @@
Minetest Game [minetest_game]
=============================
The main subgame for the Minetest engine
========================================
To use this subgame with the Minetest engine, insert this repository as
/games/minetest_game
The Minetest engine can be found in:
https://github.com/minetest/minetest/
Compatibility
--------------
The Minetest Game github master HEAD is generally compatible with the github
master HEAD of the Minetest engine.
Additionally, when the Minetest engine is tagged to be a certain version (eg.
0.4.10), Minetest Game is tagged with the version too.
When stable releases are made, Minetest Game is packaged and made available in
http://minetest.net/download
and in case the repository has grown too much, it may be reset. In that sense,
this is not a "real" git repository. (Package maintainers please note!)
Licensing
---------
See LICENSE.txt

1
game.conf Normal file
View File

@ -0,0 +1 @@
name = Minetest Game

866
game_api.txt Normal file
View File

@ -0,0 +1,866 @@
Minetest Game API
=================
GitHub Repo: https://github.com/minetest/minetest_game
Introduction
------------
The Minetest Game subgame offers multiple new possibilities in addition to the Minetest engine's built-in API,
allowing you to add new plants to farming mod, buckets for new liquids, new stairs and custom panes.
For information on the Minetest API, visit https://github.com/minetest/minetest/blob/master/doc/lua_api.txt
Please note:
* [XYZ] refers to a section the Minetest API
* [#ABC] refers to a section in this document
* [pos] refers to a position table `{x = -5, y = 0, z = 200}`
Bucket API
----------
The bucket API allows registering new types of buckets for non-default liquids.
bucket.register_liquid(
"default:lava_source", -- name of the source node
"default:lava_flowing", -- name of the flowing node
"bucket:bucket_lava", -- name of the new bucket item (or nil if liquid is not takeable)
"bucket_lava.png", -- texture of the new bucket item (ignored if itemname == nil)
"Lava Bucket", -- text description of the bucket item
{lava_bucket = 1}, -- groups of the bucket item, OPTIONAL
false -- force-renew, OPTIONAL. Force the liquid source to renew if it has
-- a source neighbour, even if defined as 'liquid_renewable = false'.
-- Needed to avoid creating holes in sloping rivers.
)
The filled bucket item is returned to the player that uses an empty bucket pointing to the given liquid source.
When punching with an empty bucket pointing to an entity or a non-liquid node, the on_punch of the entity or node will be triggered.
Beds API
--------
beds.register_bed(
"beds:bed", -- Bed name
def -- See [#Bed definition]
)
* `beds.read_spawns() ` Returns a table containing players respawn positions
* `beds.kick_players()` Forces all players to leave bed
* `beds.skip_night()` Sets world time to morning and saves respawn position of all players currently sleeping
### Bed definition
{
description = "Simple Bed",
inventory_image = "beds_bed.png",
wield_image = "beds_bed.png",
tiles = {
bottom = {'Tile definition'}, -- the tiles of the bottom part of the bed.
top = {Tile definition} -- the tiles of the bottom part of the bed.
},
nodebox = {
bottom = 'regular nodebox', -- bottom part of bed (see [Node boxes])
top = 'regular nodebox', -- top part of bed (see [Node boxes])
},
selectionbox = 'regular nodebox', -- for both nodeboxes (see [Node boxes])
recipe = { -- Craft recipe
{"group:wool", "group:wool", "group:wool"},
{"group:wood", "group:wood", "group:wood"}
}
}
Creative API
------------
Use `creative.register_tab(name, title, items)` to add a tab with filtered items.
For example,
creative.register_tab("tools", "Tools", minetest.registered_tools)
is used to show all tools. Name is used in the sfinv page name, title is the
human readable title.
`is_enabled_for` is used to check whether a player is in creative mode:
creative.is_enabled_for(name)
Override this to allow per-player game modes.
The contents of `creative.formspec_add` is appended to every creative inventory
page. Mods can use it to add additional formspec elements onto the default
creative inventory formspec to be drawn after each update.
Doors API
---------
The doors mod allows modders to register custom doors and trapdoors.
`doors.register_door(name, def)`
* Registers new door
* `name` Name for door
* `def` See [#Door definition]
`doors.register_trapdoor(name, def)`
* Registers new trapdoor
* `name` Name for trapdoor
* `def` See [#Trapdoor definition]
`doors.register_fencegate(name, def)`
* Registers new fence gate
* `name` Name for fence gate
* `def` See [#Fence gate definition]
`doors.get(pos)`
* `pos` A position as a table, e.g `{x = 1, y = 1, z = 1}`
* Returns an ObjectRef to a door, or nil if the position does not contain a door
### Methods
:open(player) -- Open the door object, returns if door was opened
:close(player) -- Close the door object, returns if door was closed
:toggle(player) -- Toggle the door state, returns if state was toggled
:state() -- returns the door state, true = open, false = closed
the "player" parameter can be omitted in all methods. If passed then
the usual permission checks will be performed to make sure the player
has the permissions needed to open this door. If omitted then no
permission checks are performed.
### Door definition
description = "Door description",
inventory_image = "mod_door_inv.png",
groups = {choppy = 2},
tiles = {"mod_door.png"}, -- UV map.
recipe = craftrecipe,
sounds = default.node_sound_wood_defaults(), -- optional
sound_open = sound play for open door, -- optional
sound_close = sound play for close door, -- optional
protected = false, -- If true, only placer can open the door (locked for others)
### Trapdoor definition
description = "Trapdoor description",
inventory_image = "mod_trapdoor_inv.png",
groups = {choppy = 2},
tile_front = "doors_trapdoor.png", -- the texture for the front and back of the trapdoor
tile_side = "doors_trapdoor_side.png", -- the tiles of the four side parts of the trapdoor
sounds = default.node_sound_wood_defaults(), -- optional
sound_open = sound play for open door, -- optional
sound_close = sound play for close door, -- optional
protected = false, -- If true, only placer can open the door (locked for others)
### Fence gate definition
description = "Wooden Fence Gate",
texture = "default_wood.png", -- `backface_culling` will automatically be
-- set to `true` if not specified.
material = "default:wood",
groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2},
sounds = default.node_sound_wood_defaults(), -- optional
Fence API
---------
Allows creation of new fences with "fencelike" drawtype.
`default.register_fence(name, item definition)`
Registers a new fence. Custom fields texture and material are required, as
are name and description. The rest is optional. You can pass most normal
nodedef fields here except drawtype. The fence group will always be added
for this node.
### fence definition
name = "default:fence_wood",
description = "Wooden Fence",
texture = "default_wood.png",
material = "default:wood",
groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2},
sounds = default.node_sound_wood_defaults(),
Walls API
---------
The walls API allows easy addition of stone auto-connecting wall nodes.
walls.register(name, desc, texture, mat, sounds)
^ name = "walls:stone_wall". Node name.
^ desc = "A Stone wall"
^ texture = "default_stone.png"
^ mat = "default:stone". Used to auto-generate crafting recipe.
^ sounds = sounds: see [#Default sounds]
Farming API
-----------
The farming API allows you to easily register plants and hoes.
`farming.register_hoe(name, hoe definition)`
* Register a new hoe, see [#hoe definition]
`farming.register_plant(name, Plant definition)`
* Register a new growing plant, see [#Plant definition]
`farming.registered_plants[name] = definition`
* Table of registered plants, indexed by plant name
### Hoe Definition
{
description = "", -- Description for tooltip
inventory_image = "unknown_item.png", -- Image to be used as wield- and inventory image
max_uses = 30, -- Uses until destroyed
material = "", -- Material for recipes
recipe = { -- Craft recipe, if material isn't used
{"air", "air", "air"},
{"", "group:stick"},
{"", "group:stick"},
}
}
### Plant definition
{
description = "", -- Description of seed item
inventory_image = "unknown_item.png", -- Image to be used as seed's wield- and inventory image
steps = 8, -- How many steps the plant has to grow, until it can be harvested
-- ^ Always provide a plant texture for each step, format: modname_plantname_i.png (i = stepnumber)
minlight = 13, -- Minimum light to grow
maxlight = default.LIGHT_MAX -- Maximum light to grow
}
Fire API
--------
New node def property:
`on_burn(pos)`
* Called when fire attempts to remove a burning node.
* `pos` Position of the burning node.
`on_ignite(pos, igniter)`
* Called when Flint and steel (or a mod defined ignitor) is used on a node.
Defining it may prevent the default action (spawning flames) from triggering.
* `pos` Position of the ignited node.
* `igniter` Player that used the tool, when available.
Give Initial Stuff API
----------------------
`give_initial_stuff.give(player)`
^ Give initial stuff to "player"
`give_initial_stuff.add(stack)`
^ Add item to the initial stuff
^ Stack can be an ItemStack or a item name eg: "default:dirt 99"
^ Can be called after the game has loaded
`give_initial_stuff.clear()`
^ Removes all items from the initial stuff
^ Can be called after the game has loaded
`give_initial_stuff.get_list()`
^ returns list of item stacks
`give_initial_stuff.set_list(list)`
^ List of initial items with numeric indices.
`give_initial_stuff.add_from_csv(str)`
^ str is a comma separated list of initial stuff
^ Adds items to the list of items to be given
TNT API
----------
`tnt.register_tnt(definition)`
^ Register a new type of tnt.
* `name` The name of the node. If no prefix is given `tnt` is used.
* `description` A description for your TNT.
* `radius` The radius within which the TNT can destroy nodes. The default is 3.
* `damage_radius` The radius within which the TNT can damage players and mobs. By default it is twice the `radius`.
* `disable_drops` Disable drops. By default it is set to false.
* `ignore_protection` Don't check `minetest.is_protected` before removing a node.
* `ignore_on_blast` Don't call `on_blast` even if a node has one.
* `tiles` Textures for node
* `side` Side tiles. By default the name of the tnt with a suffix of `_side.png`.
* `top` Top tile. By default the name of the tnt with a suffix of `_top.png`.
* `bottom` Bottom tile. By default the name of the tnt with a suffix of `_bottom.png`.
* `burning` Top tile when lit. By default the name of the tnt with a suffix of `_top_burning_animated.png".
`tnt.boom(position[, definition])`
^ Create an explosion.
* `position` The center of explosion.
* `definition` The TNT definion as passed to `tnt.register` with the following addition:
* `explode_center` false by default which removes TNT node on blast, when true will explode center node.
`tnt.burn(position, [nodename])`
^ Ignite node at position, triggering its `on_ignite` callback (see fire mod).
If no such callback exists, fallback to turn tnt group nodes to their
"_burning" variant.
nodename isn't required unless already known.
To make dropping items from node inventories easier, you can use the
following helper function from 'default':
default.get_inventory_drops(pos, inventory, drops)
^ Return drops from node inventory "inventory" in drops.
* `pos` - the node position
* `inventory` - the name of the inventory (string)
* `drops` - an initialized list
The function returns no values. The drops are returned in the `drops`
parameter, and drops is not reinitialized so you can call it several
times in a row to add more inventory items to it.
`on_blast` callbacks:
Both nodedefs and entitydefs can provide an `on_blast()` callback
`nodedef.on_blast(pos, intensity)`
^ Allow drop and node removal overriding
* `pos` - node position
* `intensity` - TNT explosion measure. larger or equal to 1.0
^ Should return a list of drops (e.g. {"default:stone"})
^ Should perform node removal itself. If callback exists in the nodedef
^ then the TNT code will not destroy this node.
`entitydef.on_blast(luaobj, damage)`
^ Allow TNT effects on entities to be overridden
* `luaobj` - LuaEntityRef of the entity
* `damage` - suggested HP damage value
^ Should return a list of (bool do_damage, bool do_knockback, table drops)
* `do_damage` - if true then TNT mod wil damage the entity
* `do_knockback` - if true then TNT mod will knock the entity away
* `drops` - a list of drops, e.g. {"wool:red"}
Screwdriver API
---------------
The screwdriver API allows you to control a node's behaviour when a screwdriver is used on it.
To use it, add the `on_screwdriver` function to the node definition.
`on_rotate(pos, node, user, mode, new_param2)`
* `pos` Position of the node that the screwdriver is being used on
* `node` that node
* `user` The player who used the screwdriver
* `mode` screwdriver.ROTATE_FACE or screwdriver.ROTATE_AXIS
* `new_param2` the new value of param2 that would have been set if on_rotate wasn't there
* return value: false to disallow rotation, nil to keep default behaviour, true to allow
it but to indicate that changed have already been made (so the screwdriver will wear out)
* use `on_rotate = false` to always disallow rotation
* use `on_rotate = screwdriver.rotate_simple` to allow only face rotation
Sethome API
-----------
The sethome API adds three global functions to allow mods to read a players home position,
set a players home position and teleport a player to home position.
`sethome.get(name)`
* `name` Player who's home position you wish to get
* return value: false if no player home coords exist, position table if true
`sethome.set(name, pos)`
* `name` Player who's home position you wish to set
* `pos` Position table containing coords of home position
* return value: false if unable to set and save new home position, otherwise true
`sethome.go(name)`
* `name` Player you wish to teleport to their home position
* return value: false if player cannot be sent home, otherwise true
Sfinv API
---------
### sfinv Methods
**Pages**
* sfinv.set_page(player, pagename) - changes the page
* sfinv.get_homepage_name(player) - get the page name of the first page to show to a player
* sfinv.register_page(name, def) - register a page, see section below
* sfinv.override_page(name, def) - overrides fields of an page registered with register_page.
* Note: Page must already be defined, (opt)depend on the mod defining it.
* sfinv.set_player_inventory_formspec(player) - (re)builds page formspec
and calls set_inventory_formspec().
* sfinv.get_formspec(player, context) - builds current page's formspec
**Contexts**
* sfinv.get_or_create_context(player) - gets the player's context
* sfinv.set_context(player, context)
**Theming**
* sfinv.make_formspec(player, context, content, show_inv, size) - adds a theme to a formspec
* show_inv, defaults to false. Whether to show the player's main inventory
* size, defaults to `size[8,8.6]` if not specified
* sfinv.get_nav_fs(player, context, nav, current_idx) - creates tabheader or ""
### sfinv Members
* pages - table of pages[pagename] = def
* pages_unordered - array table of pages in order of addition (used to build navigation tabs).
* contexts - contexts[playername] = player_context
* enabled - set to false to disable. Good for inventory rehaul mods like unified inventory
### Context
A table with these keys:
* page - current page name
* nav - a list of page names
* nav_titles - a list of page titles
* nav_idx - current nav index (in nav and nav_titles)
* any thing you want to store
* sfinv will clear the stored data on log out / log in
### sfinv.register_page
sfinv.register_page(name, def)
def is a table containing:
* `title` - human readable page name (required)
* `get(self, player, context)` - returns a formspec string. See formspec variables. (required)
* `is_in_nav(self, player, context)` - return true to show in the navigation (the tab header, by default)
* `on_player_receive_fields(self, player, context, fields)` - on formspec submit.
* `on_enter(self, player, context)` - called when the player changes pages, usually using the tabs.
* `on_leave(self, player, context)` - when leaving this page to go to another, called before other's on_enter
### get formspec
Use sfinv.make_formspec to apply a layout:
return sfinv.make_formspec(player, context, [[
list[current_player;craft;1.75,0.5;3,3;]
list[current_player;craftpreview;5.75,1.5;1,1;]
image[4.75,1.5;1,1;gui_furnace_arrow_bg.png^[transformR270]
listring[current_player;main]
listring[current_player;craft]
image[0,4.25;1,1;gui_hb_bg.png]
image[1,4.25;1,1;gui_hb_bg.png]
image[2,4.25;1,1;gui_hb_bg.png]
image[3,4.25;1,1;gui_hb_bg.png]
image[4,4.25;1,1;gui_hb_bg.png]
image[5,4.25;1,1;gui_hb_bg.png]
image[6,4.25;1,1;gui_hb_bg.png]
image[7,4.25;1,1;gui_hb_bg.png]
]], true)
See above (methods section) for more options.
### Customising themes
Simply override this function to change the navigation:
function sfinv.get_nav_fs(player, context, nav, current_idx)
return "navformspec"
end
And override this function to change the layout:
function sfinv.make_formspec(player, context, content, show_inv, size)
local tmp = {
size or "size[8,8.6]",
theme_main,
sfinv.get_nav_fs(player, context, context.nav_titles, context.nav_idx),
content
}
if show_inv then
tmp[4] = theme_inv
end
return table.concat(tmp, "")
end
Stairs API
----------
The stairs API lets you register stairs and slabs and ensures that they are registered the same way as those
delivered with Minetest Game, to keep them compatible with other mods.
`stairs.register_stair(subname, recipeitem, groups, images, description, sounds)`
* Registers a stair.
* `subname`: Basically the material name (e.g. cobble) used for the stair name. Nodename pattern: "stairs:stair_subname"
* `recipeitem`: Item used in the craft recipe, e.g. "default:cobble", may be `nil`
* `groups`: see [Known damage and digging time defining groups]
* `images`: see [Tile definition]
* `description`: used for the description field in the stair's definition
* `sounds`: see [#Default sounds]
`stairs.register_slab(subname, recipeitem, groups, images, description, sounds)`
* Registers a slabs
* `subname`: Basically the material name (e.g. cobble) used for the stair name. Nodename pattern: "stairs:stair_subname"
* `recipeitem`: Item used in the craft recipe, e.g. "default:cobble"
* `groups`: see [Known damage and digging time defining groups]
* `images`: see [Tile definition]
* `description`: used for the description field in the stair's definition
* `sounds`: see [#Default sounds]
`stairs.register_stair_and_slab(subname, recipeitem, groups, images, desc_stair, desc_slab, sounds)`
* A wrapper for stairs.register_stair and stairs.register_slab
* Uses almost the same arguments as stairs.register_stair
* `desc_stair`: Description for stair node
* `desc_slab`: Description for slab node
Xpanes API
----------
Creates panes that automatically connect to each other
`xpanes.register_pane(subname, def)`
* `subname`: used for nodename. Result: "xpanes:subname" and "xpanes:subname_{2..15}"
* `def`: See [#Pane definition]
### Pane definition
{
textures = {"texture for sides", (unused), "texture for top and bottom"}, -- More tiles aren't supported
groups = {group = rating}, -- Uses the known node groups, see [Known damage and digging time defining groups]
sounds = SoundSpec, -- See [#Default sounds]
recipe = {{"","","","","","","","",""}}, -- Recipe field only
}
Raillike definitions
--------------------
The following nodes use the group `connect_to_raillike` and will only connect to
raillike nodes within this group and the same group value.
Use `minetest.raillike_group(<Name>)` to get the group value.
| Node type | Raillike group name
|-----------------------|---------------------
| default:rail | "rail"
| tnt:gunpowder | "gunpowder"
| tnt:gunpowder_burning | "gunpowder"
Example:
If you want to add a new rail type and want it to connect with default:rail,
add `connect_to_raillike=minetest.raillike_group("rail")` into the `groups` table
of your node.
Default sounds
--------------
Sounds inside the default table can be used within the sounds field of node definitions.
* `default.node_sound_defaults()`
* `default.node_sound_stone_defaults()`
* `default.node_sound_dirt_defaults()`
* `default.node_sound_sand_defaults()`
* `default.node_sound_wood_defaults()`
* `default.node_sound_leaves_defaults()`
* `default.node_sound_glass_defaults()`
* `default.node_sound_metal_defaults()`
Default constants
-----------------
`default.LIGHT_MAX` The maximum light level (see [Node definition] light_source)
Player API
----------
The player API can register player models and update the player's appearence
`default.player_register_model(name, def)`
* Register a new model to be used by players.
* name: model filename such as "character.x", "foo.b3d", etc.
* def: See [#Model definition]
`default.registered_player_models[name]`
* Get a model's definition
* see [#Model definition]
`default.player_set_model(player, model_name)`
* Change a player's model
* `player`: PlayerRef
* `model_name`: model registered with player_register_model()
`default.player_set_animation(player, anim_name [, speed])`
* Applies an animation to a player
* anim_name: name of the animation.
* speed: frames per second. If nil, default from the model is used
`default.player_set_textures(player, textures)`
* Sets player textures
* `player`: PlayerRef
* `textures`: array of textures, If `textures` is nil, the default textures from the model def are used
default.player_get_animation(player)
* Returns a table containing fields `model`, `textures` and `animation`.
* Any of the fields of the returned table may be nil.
* player: PlayerRef
### Model Definition
{
animation_speed = 30, -- Default animation speed, in FPS.
textures = {"character.png", }, -- Default array of textures.
visual_size = {x = 1, y = 1}, -- Used to scale the model.
animations = {
-- <anim_name> = {x = <start_frame>, y = <end_frame>},
foo = {x = 0, y = 19},
bar = {x = 20, y = 39},
-- ...
},
}
Leafdecay
---------
To enable leaf decay for leaves when a tree is cut down by a player,
register the tree with the default.register_leafdecay(leafdecaydef)
function.
If `param2` of any registered node is ~= 0, the node will always be
preserved. Thus, if the player places a node of that kind, you will
want to set `param2 = 1` or so.
The function `default.after_place_leaves` can be set as
`after_place_node of a node` to set param2 to 1 if the player places
the node (should not be used for nodes that use param2 otherwise
(e.g. facedir)).
If the node is in the `leafdecay_drop` group then it will always be
dropped as an item.
`default.register_leafdecay(leafdecaydef)`
`leafdecaydef` is a table, with following members:
{
trunks = {"default:tree"}, -- nodes considered trunks
leaves = {"default:leaves", "default:apple"},
-- nodes considered for removal
radius = 3, -- radius to consider for searching
}
Note: all the listed nodes in `trunks` have their `on_after_destruct`
callback overridden. All the nodes listed in `leaves` have their
`on_timer` callback overridden.
Dyes
----
To make recipes that will work with any dye ever made by anybody, define
them based on groups. You can select any group of groups, based on your need for
amount of colors.
### Color groups
Base color groups:
* `basecolor_white`
* `basecolor_grey`
* `basecolor_black`
* `basecolor_red`
* `basecolor_yellow`
* `basecolor_green`
* `basecolor_cyan`
* `basecolor_blue`
* `basecolor_magenta`
Extended color groups ( * means also base color )
* `excolor_white` *
* `excolor_lightgrey`
* `excolor_grey` *
* `excolor_darkgrey`
* `excolor_black` *
* `excolor_red` *
* `excolor_orange`
* `excolor_yellow` *
* `excolor_lime`
* `excolor_green` *
* `excolor_aqua`
* `excolor_cyan` *
* `excolor_sky_blue`
* `excolor_blue` *
* `excolor_violet`
* `excolor_magenta` *
* `excolor_red_violet`
The whole unifieddyes palette as groups:
* `unicolor_<excolor>`
For the following, no white/grey/black is allowed:
* `unicolor_medium_<excolor>`
* `unicolor_dark_<excolor>`
* `unicolor_light_<excolor>`
* `unicolor_<excolor>_s50`
* `unicolor_medium_<excolor>_s50`
* `unicolor_dark_<excolor>_s50`
Example of one shapeless recipe using a color group:
minetest.register_craft({
type = "shapeless",
output = '<mod>:item_yellow',
recipe = {'<mod>:item_no_color', 'group:basecolor_yellow'},
})
### Color lists
* `dye.basecolors` are an array containing the names of available base colors
* `dye.excolors` are an array containing the names of the available extended colors
Trees
-----
* `default.grow_tree(pos, is_apple_tree)`
* Grows a mgv6 tree or apple tree at pos
* `default.grow_jungle_tree(pos)`
* Grows a mgv6 jungletree at pos
* `default.grow_pine_tree(pos)`
* Grows a mgv6 pinetree at pos
* `default.grow_new_apple_tree(pos)`
* Grows a new design apple tree at pos
* `default.grow_new_jungle_tree(pos)`
* Grows a new design jungle tree at pos
* `default.grow_new_pine_tree(pos)`
* Grows a new design pine tree at pos
* `default.grow_new_snowy_pine_tree(pos)`
* Grows a new design snowy pine tree at pos
* `default.grow_new_acacia_tree(pos)`
* Grows a new design acacia tree at pos
* `default.grow_new_aspen_tree(pos)`
* Grows a new design aspen tree at pos
* `default.grow_bush(pos)`
* Grows a bush at pos
* `default.grow_acacia_bush(pos)`
* Grows an acaia bush at pos
Carts
-----
carts.register_rail(
"mycarts:myrail", -- Rail name
nodedef, -- standard nodedef
railparams -- rail parameter struct (optional)
)
railparams = {
on_step(obj, dtime), -- Event handler called when
-- cart is on rail
acceleration, -- integer acceleration factor (negative
-- values to brake)
}
The event handler is called after all default calculations
are made, so the custom on_step handler can override things
like speed, acceleration, player attachment. The handler will
likely be called many times per second, so the function needs
to make sure that the event is handled properly.
Key API
-------
The key API allows mods to add key functionality to nodes that have
ownership or specific permissions. Using the API will make it so
that a node owner can use skeleton keys on their nodes to create keys
for that node in that location, and give that key to other players,
allowing them some sort of access that they otherwise would not have
due to node protection.
To make your new nodes work with the key API, you need to register
two callback functions in each nodedef:
`on_key_use(pos, player)`
* Is called when a player right-clicks (uses) a normal key on your
* node.
* `pos` - position of the node
* `player` - PlayerRef
* return value: none, ignored
The `on_key_use` callback should validate that the player is wielding
a key item with the right key meta secret. If needed the code should
deny access to the node functionality.
If formspecs are used, the formspec callbacks should duplicate these
checks in the metadata callback functions.
`on_skeleton_key_use(pos, player, newsecret)`
* Is called when a player right-clicks (uses) a skeleton key on your
* node.
* `pos` - position of the node
* `player` - PlayerRef
* `newsecret` - a secret value(string)
* return values:
* `secret` - `nil` or the secret value that unlocks the door
* `name` - a string description of the node ("a locked chest")
* `owner` - name of the node owner
The `on_skeleton_key_use` function should validate that the player has
the right permissions to make a new key for the item. The newsecret
value is useful if the node has no secret value. The function should
store this secret value somewhere so that in the future it may compare
key secrets and match them to allow access. If a node already has a
secret value, the function should return that secret value instead
of the newsecret value. The secret value stored for the node should
not be overwritten, as this would invalidate existing keys.
Aside from the secret value, the function should retun a descriptive
name for the node and the owner name. The return values are all
encoded in the key that will be given to the player in replacement
for the wielded skeleton key.
if `nil` is returned, it is assumed that the wielder did not have
permissions to create a key for this node, and no key is created.

BIN
menu/header.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.9 KiB

BIN
menu/icon.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.9 KiB

0
minetest.conf Normal file
View File

53
minetest.conf.example Normal file
View File

@ -0,0 +1,53 @@
# This file contains settings of Minetest Game that can be changed in minetest.conf
# By default, all the settings are commented and not functional.
# Uncomment settings by removing the preceding #.
# Whether creative mode (fast digging of all blocks, unlimited resources) should be enabled
#creative_mode = false
# Sets the behaviour of the inventory items when a player dies.
# "bones": Store all items inside a bone node but drop items if inside protected area
# "drop": Drop all items on the ground
# "keep": Player keeps all items
#bones_mode = "bones"
# The time in seconds after which the bones of a dead player can be looted by everyone
# 0 to disable
#share_bones_time = 1200
# How much earlier the bones of a dead player can be looted by
# everyone if the player dies in a protected area they don't own.
# 0 to disable. By default it is "share_bones_time" divide by four.
#share_bones_time_early = 300
# Whether fire should be enabled. If disabled, 'basic flame' nodes will disappear.
# 'permanent flame' nodes will remain with either setting.
#enable_fire = true
# Enable flame sound.
#flame_sound = true
# Whether lavacooling should be enabled.
#enable_lavacooling = true
# Whether the stuff in initial_stuff should be given to new players
#give_initial_stuff = false
#initial_stuff = default:pick_steel,default:axe_steel,default:shovel_steel,default:torch 99,default:cobble 99
# Whether the TNT mod should be enabled
#enable_tnt = <true in singleplayer, false in multiplayer>
# The radius of a TNT explosion
#tnt_radius = 3
# Enable the stairs mod ABM that replaces the old 'upside down'
# stair and slab nodes in old maps with the new param2 versions.
#enable_stairs_replace_abm = false
# Whether you allow respawning in beds
# Default value is true
#enable_bed_respawn = true
# Whether players can skip night by sleeping
# Default value is true
#enable_bed_night_skip = true

11
mods/3d_armor-version-0.4.11/.gitignore vendored Normal file
View File

@ -0,0 +1,11 @@
## Generic ignorable patterns and files
*~
.*.swp
*bak*
tags
*.vim
armor.conf
## Eclipse project files & directories
.project
.settings

9
mods/3d_armor-version-0.4.11/3d_armor/LICENSE.txt Normal file
View File

@ -0,0 +1,9 @@
[mod] 3d Armor [3d_armor]
=========================
License Source Code: (C) 2012-2017 Stuart Jones - LGPL v2.1
License Textures: Copyright (C) 2017 davidthecreator - CC-BY-SA 3.0
https://github.com/daviddoesminetest/3d-armors-new-textures

191
mods/3d_armor-version-0.4.11/3d_armor/README.txt Normal file
View File

@ -0,0 +1,191 @@
[mod] Visible Player Armor [3d_armor]
=====================================
Depends: default
Recommends: sfinv, unified_inventory or smart_inventory (use only one to avoid conflicts)
Supports: player_monoids and armor_monoid
Adds craftable armor that is visible to other players. Each armor item worn contributes to
a player's armor group level making them less vulnerable to weapons.
Armor takes damage when a player is hurt but also offers a percentage chance of healing.
Overall level is boosted by 10% when wearing a full matching set.
Fire protection added by TenPlus1 when using crystal armor if Ethereal mod active, level 1
protects against torches, level 2 for crystal spike, level 3 for fire, level 5 for lava.
Armor Configuration
-------------------
Override the following default settings by adding them to your minetest.conf file.
-- Set false to disable individual armor materials.
armor_material_wood = true
armor_material_cactus = true
armor_material_steel = true
armor_material_bronze = true
armor_material_diamond = true
armor_material_gold = true
armor_material_mithril = true
armor_material_crystal = true
-- Increase this if you get initialization glitches when a player first joins.
armor_init_delay = 1
-- Number of initialization attempts.
-- Use in conjunction with armor_init_delay if initialization problems persist.
armor_init_times = 1
-- Increase this if armor is not getting into bones due to server lag.
armor_bones_delay = 1
-- How often player armor items are updated.
armor_update_time = 1
-- Drop armor when a player dies.
-- Uses bones mod if present, otherwise items are dropped around the player.
armor_drop = true
-- Pulverise armor when a player dies, overrides armor_drop.
armor_destroy = false
-- You can use this to increase or decrease overall armor effectiveness,
-- eg: level_multiplier = 0.5 will reduce armor level by half.
armor_level_multiplier = 1
-- You can use this to increase or decrease overall armor healing,
-- eg: armor_heal_multiplier = 0 will disable healing altogether.
armor_heal_multiplier = 1
-- Enable water protection (periodically restores breath when activated)
armor_water_protect = true
-- Enable fire protection (defaults true if using ethereal mod)
armor_fire_protect = false
-- Enable punch damage effects.
armor_punch_damage = true
-- Enable migration of old armor inventories
armor_migrate_old_inventory = true
API
---
Armor Registration:
armor:register_armor(name, def)
Wrapper function for `minetest.register_tool`, while registering armor as
a tool item is still supported, this may be deprecated in future so new code
should use this method.
Additional fields supported by 3d_armor:
texture = <filename>
preview = <filename>
armor_groups = <table>
damage_groups = <table>
reciprocate_damage = <bool>
on_equip = <function>
on_unequip = <function>
on_destroy = <function>
on_damage = <function>
on_punched = <function>
armor:register_armor_group(group, base)
Example:
armor:register_armor_group("radiation", 100)
armor:register_armor("mod_name:speed_boots", {
description = "Speed Boots",
inventory_image = "mod_name_speed_boots_inv.png",
texture = "mod_name_speed_boots.png",
preview = "mod_name_speed_boots_preview.png",
groups = {armor_feet=1, armor_use=500, physics_speed=1.2, flammable=1},
armor_groups = {fleshy=10, radiation=10},
damage_groups = {cracky=3, snappy=3, choppy=3, crumbly=3, level=1},
reciprocate_damage = true,
on_destroy = function(player, index, stack)
local pos = player:getpos()
if pos then
minetest.sound_play({
name = "mod_name_break_sound",
pos = pos,
gain = 0.5,
})
end
end,
})
See armor.lua, technic_armor and shields mods for more examples.
Default groups:
Elements: armor_head, armor_torso, armor_legs, armor_feet
Attributes: armor_heal, armor_fire, armor_water
Physics: physics_jump, physics_speed, physics_gravity
Durability: armor_use, flammable
Notes:
Elements may be modified by dependent mods, eg shields adds armor_shield.
Attributes and physics values are 'stackable', durability is determined
by the level of armor_use, total uses == approx (65535/armor_use), non-fleshy
damage groups need to be defined in the tool/weapon used against the player.
Reciprocal tool damage will be done only by the first armor inventory item
with `reciprocate_damage = true`
Armor Functions:
armor:set_player_armor(player)
Primarily an internal function but can be called externally to apply any
changes that might not otherwise get handled.
armor:punch(player, hitter, time_from_last_punch, tool_capabilities)
Used to apply damage to all equipped armor based on the damage groups of
each individual item.`hitter`, `time_from_last_punch` and `tool_capabilities`
are optional but should be valid if included.
armor:damage(player, index, stack, use)
Adds wear to a single armor itemstack, triggers `on_damage` callbacks and
updates the necessary inventories. Also handles item destruction callbacks
and so should NOT be called from `on_unequip` to avoid an infinite loop.
Item Callbacks:
on_equip = func(player, index, stack)
on_unequip = func(player, index, stack)
on_destroy = func(player, index, stack)
on_damage = func(player, index, stack)
on_punched = func(player, hitter, time_from_last_punch, tool_capabilities)
Notes:
`on_punched` is called every time a player is punched or takes damage, `hitter`,
`time_from_last_punch` and `tool_capabilities` can be `nil` and will be in the
case of fall damage, etc. When fire protection is enabled, hitter == "fire"
in the event of fire damage. Return `false` to override armor damage effects.
When armor is destroyed `stack` will contain a copy of the previous stack.
Global Callbacks:
armor:register_on_update(func(player))
armor:register_on_equip(func(player, index, stack))
armor:register_on_unequip(func(player, index, stack))
armor:register_on_destroy(func(player, index, stack))
Global Callback Example:
armor:register_on_update(function(player)
print(player:get_player_name().." armor updated!")
end)

535
mods/3d_armor-version-0.4.11/3d_armor/api.lua Normal file
View File

@ -0,0 +1,535 @@
-- support for i18n
local S = armor_i18n.gettext
local skin_previews = {}
local use_player_monoids = minetest.global_exists("player_monoids")
local use_armor_monoid = minetest.global_exists("armor_monoid")
local armor_def = setmetatable({}, {
__index = function()
return setmetatable({
groups = setmetatable({}, {
__index = function()
return 0
end})
}, {
__index = function()
return 0
end
})
end,
})
local armor_textures = setmetatable({}, {
__index = function()
return setmetatable({}, {
__index = function()
return "blank.png"
end
})
end
})
armor = {
timer = 0,
elements = {"head", "torso", "legs", "feet"},
physics = {"jump", "speed", "gravity"},
attributes = {"heal", "fire", "water"},
formspec = "image[2.5,0;2,4;armor_preview]"..
default.gui_bg..
default.gui_bg_img..
default.gui_slots..
default.get_hotbar_bg(0, 4.7)..
"list[current_player;main;0,4.7;8,1;]"..
"list[current_player;main;0,5.85;8,3;8]",
def = armor_def,
textures = armor_textures,
default_skin = "character",
materials = {
wood = "group:wood",
cactus = "default:cactus",
steel = "default:steel_ingot",
bronze = "default:bronze_ingot",
diamond = "default:diamond",
gold = "default:gold_ingot",
mithril = "moreores:mithril_ingot",
crystal = "ethereal:crystal_ingot",
},
fire_nodes = {
{"default:lava_source", 5, 8},
{"default:lava_flowing", 5, 8},
{"fire:basic_flame", 3, 4},
{"fire:permanent_flame", 3, 4},
{"ethereal:crystal_spike", 2, 1},
{"ethereal:fire_flower", 2, 1},
{"default:torch", 1, 1},
{"default:torch_ceiling", 1, 1},
{"default:torch_wall", 1, 1},
},
registered_groups = {["fleshy"]=100},
registered_callbacks = {
on_update = {},
on_equip = {},
on_unequip = {},
on_damage = {},
on_destroy = {},
},
migrate_old_inventory = true,
version = "0.4.11",
}
armor.config = {
init_delay = 2,
init_times = 10,
bones_delay = 1,
update_time = 1,
drop = minetest.get_modpath("bones") ~= nil,
destroy = false,
level_multiplier = 1,
heal_multiplier = 1,
material_wood = true,
material_cactus = true,
material_steel = true,
material_bronze = true,
material_diamond = true,
material_gold = true,
material_mithril = true,
material_crystal = true,
water_protect = true,
fire_protect = minetest.get_modpath("ethereal") ~= nil,
punch_damage = true,
}
-- Armor Registration
armor.register_armor = function(self, name, def)
minetest.register_tool(name, def)
end
armor.register_armor_group = function(self, group, base)
base = base or 100
self.registered_groups[group] = base
if use_armor_monoid then
armor_monoid.register_armor_group(group, base)
end
end
-- Armor callbacks
armor.register_on_update = function(self, func)
if type(func) == "function" then
table.insert(self.registered_callbacks.on_update, func)
end
end
armor.register_on_equip = function(self, func)
if type(func) == "function" then
table.insert(self.registered_callbacks.on_equip, func)
end
end
armor.register_on_unequip = function(self, func)
if type(func) == "function" then
table.insert(self.registered_callbacks.on_unequip, func)
end
end
armor.register_on_damage = function(self, func)
if type(func) == "function" then
table.insert(self.registered_callbacks.on_damage, func)
end
end
armor.register_on_destroy = function(self, func)
if type(func) == "function" then
table.insert(self.registered_callbacks.on_destroy, func)
end
end
armor.run_callbacks = function(self, callback, player, index, stack)
if stack then
local def = stack:get_definition() or {}
if type(def[callback]) == "function" then
def[callback](player, index, stack)
end
end
local callbacks = self.registered_callbacks[callback]
if callbacks then
for _, func in pairs(callbacks) do
func(player, index, stack)
end
end
end
armor.update_player_visuals = function(self, player)
if not player then
return
end
local name = player:get_player_name()
if self.textures[name] then
default.player_set_textures(player, {
self.textures[name].skin,
self.textures[name].armor,
self.textures[name].wielditem,
})
end
self:run_callbacks("on_update", player)
end
armor.set_player_armor = function(self, player)
local name, armor_inv = self:get_valid_player(player, "[set_player_armor]")
if not name then
return
end
local state = 0
local count = 0
local material = {count=1}
local preview = armor:get_preview(name)
local texture = "3d_armor_trans.png"
local skintexture = armor:get_player_skin(name)
local textures = {}
local physics = {}
local attributes = {}
local levels = {}
local groups = {}
local change = {}
for _, phys in pairs(self.physics) do
physics[phys] = 1
end
for _, attr in pairs(self.attributes) do
attributes[attr] = 0
end
for group, _ in pairs(self.registered_groups) do
change[group] = 1
levels[group] = 0
end
local list = armor_inv:get_list("armor")
if type(list) ~= "table" then
return
end
for i, stack in pairs(list) do
if stack:get_count() == 1 then
local def = stack:get_definition()
for _, element in pairs(self.elements) do
if def.groups["armor_"..element] then
if def.armor_groups then
for group, level in pairs(def.armor_groups) do
if levels[group] then
levels[group] = levels[group] + level
end
end
else
local level = def.groups["armor_"..element]
levels["fleshy"] = levels["fleshy"] + level
end
break
end
-- DEPRECATED, use armor_groups instead
if def.groups["armor_radiation"] and levels["radiation"] then
levels["radiation"] = def.groups["armor_radiation"]
end
end
local item = stack:get_name()
local tex = def.texture or item:gsub("%:", "_")
tex = tex:gsub(".png$", "")
local prev = def.preview or tex.."_preview"
prev = prev:gsub(".png$", "")
if def.groups["clothing"] then
skintexture = skintexture.."^"..tex..".png"
else
texture = texture.."^"..tex..".png"
end
preview = preview.."^"..prev..".png"
state = state + stack:get_wear()
count = count + 1
for _, phys in pairs(self.physics) do
local value = def.groups["physics_"..phys] or 0
physics[phys] = physics[phys] + value
end
for _, attr in pairs(self.attributes) do
local value = def.groups["armor_"..attr] or 0
attributes[attr] = attributes[attr] + value
end
local mat = string.match(item, "%:.+_(.+)$")
if material.name then
if material.name == mat then
material.count = material.count + 1
end
else
material.name = mat
end
end
end
for group, level in pairs(levels) do
if level > 0 then
level = level * armor.config.level_multiplier
if material.name and material.count == #self.elements then
level = level * 1.1
end
end
local base = self.registered_groups[group]
self.def[name].groups[group] = level
if level > base then
level = base
end
groups[group] = base - level
change[group] = groups[group] / base
end
for _, attr in pairs(self.attributes) do
self.def[name][attr] = attributes[attr]
end
for _, phys in pairs(self.physics) do
self.def[name][phys] = physics[phys]
end
if use_armor_monoid then
armor_monoid.monoid:add_change(player, change, "3d_armor:armor")
else
player:set_armor_groups(groups)
end
if use_player_monoids then
player_monoids.speed:add_change(player, physics.speed,
"3d_armor:physics")
player_monoids.jump:add_change(player, physics.jump,
"3d_armor:physics")
player_monoids.gravity:add_change(player, physics.gravity,
"3d_armor:physics")
else
player:set_physics_override(physics)
end
self.textures[name].armor = texture
self.textures[name].skin = skintexture
self.textures[name].preview = preview
self.def[name].level = self.def[name].groups.fleshy or 0
self.def[name].state = state
self.def[name].count = count
self:update_player_visuals(player)
end
armor.punch = function(self, player, hitter, time_from_last_punch, tool_capabilities)
local name, armor_inv = self:get_valid_player(player, "[punch]")
if not name then
return
end
local state = 0
local count = 0
local recip = true
local default_groups = {cracky=3, snappy=3, choppy=3, crumbly=3, level=1}
local list = armor_inv:get_list("armor")
for i, stack in pairs(list) do
if stack:get_count() == 1 then
local name = stack:get_name()
local use = minetest.get_item_group(name, "armor_use") or 0
local damage = use > 0
local def = stack:get_definition() or {}
if type(def.on_punched) == "function" then
damage = def.on_punched(player, hitter, time_from_last_punch,
tool_capabilities) ~= false and damage == true
end
if damage == true and tool_capabilities then
local damage_groups = def.damage_groups or default_groups
local level = damage_groups.level or 0
local groupcaps = tool_capabilities.groupcaps or {}
local uses = 0
damage = false
for group, caps in pairs(groupcaps) do
local maxlevel = caps.maxlevel or 0
local diff = maxlevel - level
if diff == 0 then
diff = 1
end
if diff > 0 and caps.times then
local group_level = damage_groups[group]
if group_level then
local time = caps.times[group_level]
if time then
local dt = time_from_last_punch or 0
if dt > time / diff then
if caps.uses then
uses = caps.uses * math.pow(3, diff)
end
damage = true
break
end
end
end
end
end
if damage == true and recip == true and hitter and
def.reciprocate_damage == true and uses > 0 then
local item = hitter:get_wielded_item()
if item and item:get_name() ~= "" then
item:add_wear(65535 / uses)
hitter:set_wielded_item(item)
end
-- reciprocate tool damage only once
recip = false
end
end
if damage == true and hitter == "fire" then
damage = minetest.get_item_group(name, "flammable") > 0
end
if damage == true then
self:damage(player, i, stack, use)
end
state = state + stack:get_wear()
count = count + 1
end
end
self.def[name].state = state
self.def[name].count = count
end
armor.damage = function(self, player, index, stack, use)
local old_stack = ItemStack(stack)
stack:add_wear(use)
self:run_callbacks("on_damage", player, index, stack)
self:set_inventory_stack(player, index, stack)
if stack:get_count() == 0 then
self:run_callbacks("on_unequip", player, index, old_stack)
self:run_callbacks("on_destroy", player, index, old_stack)
self:set_player_armor(player)
end
end
armor.get_player_skin = function(self, name)
if (self.skin_mod == "skins" or self.skin_mod == "simple_skins") and skins.skins[name] then
return skins.skins[name]..".png"
elseif self.skin_mod == "u_skins" and u_skins.u_skins[name] then
return u_skins.u_skins[name]..".png"
elseif self.skin_mod == "wardrobe" and wardrobe.playerSkins and wardrobe.playerSkins[name] then
return wardrobe.playerSkins[name]
end
return armor.default_skin..".png"
end
armor.add_preview = function(self, preview)
skin_previews[preview] = true
end
armor.get_preview = function(self, name)
local preview = string.gsub(armor:get_player_skin(name), ".png", "_preview.png")
if skin_previews[preview] then
return preview
end
return "character_preview.png"
end
armor.get_armor_formspec = function(self, name, listring)
if armor.def[name].init_time == 0 then
return "label[0,0;Armor not initialized!]"
end
local formspec = armor.formspec..
"list[detached:"..name.."_armor;armor;0,0.5;2,3;]"
if listring == true then
formspec = formspec.."listring[current_player;main]"..
"listring[detached:"..name.."_armor;armor]"
end
formspec = formspec:gsub("armor_preview", armor.textures[name].preview)
formspec = formspec:gsub("armor_level", armor.def[name].level)
for _, attr in pairs(self.attributes) do
formspec = formspec:gsub("armor_attr_"..attr, armor.def[name][attr])
end
for group, _ in pairs(self.registered_groups) do
formspec = formspec:gsub("armor_group_"..group,
armor.def[name].groups[group])
end
return formspec
end
armor.serialize_inventory_list = function(self, list)
local list_table = {}
for _, stack in ipairs(list) do
table.insert(list_table, stack:to_string())
end
return minetest.serialize(list_table)
end
armor.deserialize_inventory_list = function(self, list_string)
local list_table = minetest.deserialize(list_string)
local list = {}
for _, stack in ipairs(list_table or {}) do
table.insert(list, ItemStack(stack))
end
return list
end
armor.load_armor_inventory = function(self, player)
local msg = "[load_armor_inventory]"
local name = player:get_player_name()
if not name then
minetest.log("warning", S("3d_armor: Player name is nil @1", msg))
return
end
local armor_inv = minetest.get_inventory({type="detached", name=name.."_armor"})
if not armor_inv then
minetest.log("warning", S("3d_armor: Detached armor inventory is nil @1", msg))
return
end
local armor_list_string = player:get_attribute("3d_armor_inventory")
if armor_list_string then
armor_inv:set_list("armor", self:deserialize_inventory_list(armor_list_string))
return true
end
end
armor.save_armor_inventory = function(self, player)
local msg = "[save_armor_inventory]"
local name = player:get_player_name()
if not name then
minetest.log("warning", S("3d_armor: Player name is nil @1", msg))
return
end
local armor_inv = minetest.get_inventory({type="detached", name=name.."_armor"})
if not armor_inv then
minetest.log("warning", S("3d_armor: Detached armor inventory is nil @1", msg))
return
end
player:set_attribute("3d_armor_inventory", self:serialize_inventory_list(armor_inv:get_list("armor")))
end
armor.update_inventory = function(self, player)
-- DEPRECATED: Legacy inventory support
end
armor.set_inventory_stack = function(self, player, i, stack)
local msg = "[set_inventory_stack]"
local name = player:get_player_name()
if not name then
minetest.log("warning", S("3d_armor: Player name is nil @1", msg))
return
end
local armor_inv = minetest.get_inventory({type="detached", name=name.."_armor"})
if not armor_inv then
minetest.log("warning", S("3d_armor: Detached armor inventory is nil @1", msg))
return
end
armor_inv:set_stack("armor", i, stack)
self:save_armor_inventory(player)
end
armor.get_valid_player = function(self, player, msg)
msg = msg or ""
if not player then
minetest.log("warning", S("3d_armor: Player reference is nil @1", msg))
return
end
local name = player:get_player_name()
if not name then
minetest.log("warning", S("3d_armor: Player name is nil @1", msg))
return
end
local inv = minetest.get_inventory({type="detached", name=name.."_armor"})
if not inv then
minetest.log("warning", S("3d_armor: Detached armor inventory is nil @1", msg))
return
end
return name, inv
end
armor.drop_armor = function(pos, stack)
local node = minetest.get_node_or_nil(pos)
if node then
local obj = minetest.add_item(pos, stack)
if obj then
obj:setvelocity({x=math.random(-1, 1), y=5, z=math.random(-1, 1)})
end
end
end

65
mods/3d_armor-version-0.4.11/3d_armor/armor.conf.example Normal file
View File

@ -0,0 +1,65 @@
-- DEPRECATED, will not be supported in future versions
-- See README.txt for new configuration options.
-- Armor Configuration (defaults)
-- You can remove any unwanted armor materials from this table.
-- Note that existing armor that is removed will show up as an unknown item.
ARMOR_MATERIALS = {
wood = "group:wood",
cactus = "default:cactus",
steel = "default:steel_ingot",
bronze = "default:bronze_ingot",
diamond = "default:diamond",
gold = "default:gold_ingot",
mithril = "moreores:mithril_ingot",
crystal = "ethereal:crystal_ingot",
}
-- Enable fire protection (defaults true if using ethereal mod)
ARMOR_FIRE_PROTECT = false
-- Fire protection nodes, (name, protection level, damage)
ARMOR_FIRE_NODES = {
{"default:lava_source", 5, 4},
{"default:lava_flowing", 5, 4},
{"fire:basic_flame", 3, 4},
{"fire:permanent_flame", 3, 4},
{"ethereal:crystal_spike", 2, 1},
{"ethereal:fire_flower", 2, 1},
{"default:torch", 1, 1},
}
-- Increase this if you get initialization glitches when a player first joins.
ARMOR_INIT_DELAY = 1
-- Number of initialization attempts.
-- Use in conjunction with ARMOR_INIT_DELAY if initialization problems persist.
ARMOR_INIT_TIMES = 1
-- Increase this if armor is not getting into bones due to server lag.
ARMOR_BONES_DELAY = 1
-- How often player armor/wield items are updated.
ARMOR_UPDATE_TIME = 1
-- Drop armor when a player dies.
-- Uses bones mod if present, otherwise items are dropped around the player.
ARMOR_DROP = true
-- Pulverise armor when a player dies, overrides ARMOR_DROP.
ARMOR_DESTROY = false
-- You can use this to increase or decrease overall armor effectiveness,
-- eg: ARMOR_LEVEL_MULTIPLIER = 0.5 will reduce armor level by half.
ARMOR_LEVEL_MULTIPLIER = 1
-- You can use this to increase or decrease overall armor healing,
-- eg: ARMOR_HEAL_MULTIPLIER = 0 will disable healing altogether.
ARMOR_HEAL_MULTIPLIER = 1
-- You can use this to increase or decrease overall armor radiation protection,
-- eg: ARMOR_RADIATION_MULTIPLIER = 0 will completely disable radiation protection.
-- Note: patched technic mod is required
ARMOR_RADIATION_MULTIPLIER = 1

346
mods/3d_armor-version-0.4.11/3d_armor/armor.lua Normal file
View File

@ -0,0 +1,346 @@
-- support for i18n
local S = armor_i18n.gettext
armor:register_armor("3d_armor:helmet_admin", {
description = S("Admin Helmet"),
inventory_image = "3d_armor_inv_helmet_admin.png",
armor_groups = {fleshy=100},
groups = {armor_head=1, armor_heal=100, armor_use=0, armor_water=1,
not_in_creative_inventory=1},
on_drop = function(itemstack, dropper, pos)
return
end,
})
armor:register_armor("3d_armor:chestplate_admin", {
description = S("Admin Chestplate"),
inventory_image = "3d_armor_inv_chestplate_admin.png",
armor_groups = {fleshy=100},
groups = {armor_torso=1, armor_heal=100, armor_use=0,
not_in_creative_inventory=1},
on_drop = function(itemstack, dropper, pos)
return
end,
})
armor:register_armor("3d_armor:leggings_admin", {
description = S("Admin Leggings"),
inventory_image = "3d_armor_inv_leggings_admin.png",
armor_groups = {fleshy=100},
groups = {armor_legs=1, armor_heal=100, armor_use=0,
not_in_creative_inventory=1},
on_drop = function(itemstack, dropper, pos)
return
end,
})
armor:register_armor("3d_armor:boots_admin", {
description = S("Admin Boots"),
inventory_image = "3d_armor_inv_boots_admin.png",
armor_groups = {fleshy=100},
groups = {armor_feet=1, armor_heal=100, armor_use=0,
not_in_creative_inventory=1},
on_drop = function(itemstack, dropper, pos)
return
end,
})
minetest.register_alias("adminboots", "3d_armor:boots_admin")
minetest.register_alias("adminhelmet", "3d_armor:helmet_admin")
minetest.register_alias("adminchestplate", "3d_armor:chestplate_admin")
minetest.register_alias("adminleggings", "3d_armor:leggings_admin")
if armor.materials.wood then
armor:register_armor("3d_armor:helmet_wood", {
description = S("Wood Helmet"),
inventory_image = "3d_armor_inv_helmet_wood.png",
groups = {armor_head=1, armor_heal=0, armor_use=2000, flammable=1},
armor_groups = {fleshy=5},
damage_groups = {cracky=3, snappy=2, choppy=3, crumbly=2, level=1},
})
armor:register_armor("3d_armor:chestplate_wood", {
description = S("Wood Chestplate"),
inventory_image = "3d_armor_inv_chestplate_wood.png",
groups = {armor_torso=1, armor_heal=0, armor_use=2000, flammable=1},
armor_groups = {fleshy=10},
damage_groups = {cracky=3, snappy=2, choppy=3, crumbly=2, level=1},
})
armor:register_armor("3d_armor:leggings_wood", {
description = S("Wood Leggings"),
inventory_image = "3d_armor_inv_leggings_wood.png",
groups = {armor_legs=1, armor_heal=0, armor_use=2000, flammable=1},
armor_groups = {fleshy=10},
damage_groups = {cracky=3, snappy=2, choppy=3, crumbly=2, level=1},
})
armor:register_armor("3d_armor:boots_wood", {
description = S("Wood Boots"),
inventory_image = "3d_armor_inv_boots_wood.png",
armor_groups = {fleshy=5},
damage_groups = {cracky=3, snappy=2, choppy=3, crumbly=2, level=1},
groups = {armor_feet=1, armor_heal=0, armor_use=2000, flammable=1},
})
end
if armor.materials.cactus then
armor:register_armor("3d_armor:helmet_cactus", {
description = S("Cactus Helmet"),
inventory_image = "3d_armor_inv_helmet_cactus.png",
groups = {armor_head=1, armor_heal=0, armor_use=1000},
armor_groups = {fleshy=5},
damage_groups = {cracky=3, snappy=3, choppy=2, crumbly=2, level=1},
})
armor:register_armor("3d_armor:chestplate_cactus", {
description = S("Cactus Chestplate"),
inventory_image = "3d_armor_inv_chestplate_cactus.png",
groups = {armor_torso=1, armor_heal=0, armor_use=1000},
armor_groups = {fleshy=10},
damage_groups = {cracky=3, snappy=3, choppy=2, crumbly=2, level=1},
})
armor:register_armor("3d_armor:leggings_cactus", {
description = S("Cactus Leggings"),
inventory_image = "3d_armor_inv_leggings_cactus.png",
groups = {armor_legs=1, armor_heal=0, armor_use=1000},
armor_groups = {fleshy=10},
damage_groups = {cracky=3, snappy=3, choppy=2, crumbly=2, level=1},
})
armor:register_armor("3d_armor:boots_cactus", {
description = S("Cactus Boots"),
inventory_image = "3d_armor_inv_boots_cactus.png",
groups = {armor_feet=1, armor_heal=0, armor_use=1000},
armor_groups = {fleshy=5},
damage_groups = {cracky=3, snappy=3, choppy=2, crumbly=2, level=1},
})
end
if armor.materials.steel then
armor:register_armor("3d_armor:helmet_steel", {
description = S("Steel Helmet"),
inventory_image = "3d_armor_inv_helmet_steel.png",
groups = {armor_head=1, armor_heal=0, armor_use=800,
physics_speed=-0.01, physics_gravity=0.01},
armor_groups = {fleshy=10},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
armor:register_armor("3d_armor:chestplate_steel", {
description = S("Steel Chestplate"),
inventory_image = "3d_armor_inv_chestplate_steel.png",
groups = {armor_torso=1, armor_heal=0, armor_use=800,
physics_speed=-0.04, physics_gravity=0.04},
armor_groups = {fleshy=15},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
armor:register_armor("3d_armor:leggings_steel", {
description = S("Steel Leggings"),
inventory_image = "3d_armor_inv_leggings_steel.png",
groups = {armor_legs=1, armor_heal=0, armor_use=800,
physics_speed=-0.03, physics_gravity=0.03},
armor_groups = {fleshy=15},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
armor:register_armor("3d_armor:boots_steel", {
description = S("Steel Boots"),
inventory_image = "3d_armor_inv_boots_steel.png",
groups = {armor_feet=1, armor_heal=0, armor_use=800,
physics_speed=-0.01, physics_gravity=0.01},
armor_groups = {fleshy=10},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
end
if armor.materials.bronze then
armor:register_armor("3d_armor:helmet_bronze", {
description = S("Bronze Helmet"),
inventory_image = "3d_armor_inv_helmet_bronze.png",
groups = {armor_head=1, armor_heal=6, armor_use=400,
physics_speed=-0.01, physics_gravity=0.01},
armor_groups = {fleshy=10},
damage_groups = {cracky=3, snappy=2, choppy=2, crumbly=1, level=2},
})
armor:register_armor("3d_armor:chestplate_bronze", {
description = S("Bronze Chestplate"),
inventory_image = "3d_armor_inv_chestplate_bronze.png",
groups = {armor_torso=1, armor_heal=6, armor_use=400,
physics_speed=-0.04, physics_gravity=0.04},
armor_groups = {fleshy=15},
damage_groups = {cracky=3, snappy=2, choppy=2, crumbly=1, level=2},
})
armor:register_armor("3d_armor:leggings_bronze", {
description = S("Bronze Leggings"),
inventory_image = "3d_armor_inv_leggings_bronze.png",
groups = {armor_legs=1, armor_heal=6, armor_use=400,
physics_speed=-0.03, physics_gravity=0.03},
armor_groups = {fleshy=15},
damage_groups = {cracky=3, snappy=2, choppy=2, crumbly=1, level=2},
})
armor:register_armor("3d_armor:boots_bronze", {
description = S("Bronze Boots"),
inventory_image = "3d_armor_inv_boots_bronze.png",
groups = {armor_feet=1, armor_heal=6, armor_use=400,
physics_speed=-0.01, physics_gravity=0.01},
armor_groups = {fleshy=10},
damage_groups = {cracky=3, snappy=2, choppy=2, crumbly=1, level=2},
})
end
if armor.materials.diamond then
armor:register_armor("3d_armor:helmet_diamond", {
description = S("Diamond Helmet"),
inventory_image = "3d_armor_inv_helmet_diamond.png",
groups = {armor_head=1, armor_heal=12, armor_use=200},
armor_groups = {fleshy=15},
damage_groups = {cracky=2, snappy=1, choppy=1, level=3},
})
armor:register_armor("3d_armor:chestplate_diamond", {
description = S("Diamond Chestplate"),
inventory_image = "3d_armor_inv_chestplate_diamond.png",
groups = {armor_torso=1, armor_heal=12, armor_use=200},
armor_groups = {fleshy=20},
damage_groups = {cracky=2, snappy=1, choppy=1, level=3},
})
armor:register_armor("3d_armor:leggings_diamond", {
description = S("Diamond Leggings"),
inventory_image = "3d_armor_inv_leggings_diamond.png",
groups = {armor_legs=1, armor_heal=12, armor_use=200},
armor_groups = {fleshy=20},
damage_groups = {cracky=2, snappy=1, choppy=1, level=3},
})
armor:register_armor("3d_armor:boots_diamond", {
description = S("Diamond Boots"),
inventory_image = "3d_armor_inv_boots_diamond.png",
groups = {armor_feet=1, armor_heal=12, armor_use=200},
armor_groups = {fleshy=15},
damage_groups = {cracky=2, snappy=1, choppy=1, level=3},
})
end
if armor.materials.gold then
armor:register_armor("3d_armor:helmet_gold", {
description = S("Gold Helmet"),
inventory_image = "3d_armor_inv_helmet_gold.png",
groups = {armor_head=1, armor_heal=6, armor_use=300,
physics_speed=-0.02, physics_gravity=0.02},
armor_groups = {fleshy=10},
damage_groups = {cracky=1, snappy=2, choppy=2, crumbly=3, level=2},
})
armor:register_armor("3d_armor:chestplate_gold", {
description = S("Gold Chestplate"),
inventory_image = "3d_armor_inv_chestplate_gold.png",
groups = {armor_torso=1, armor_heal=6, armor_use=300,
physics_speed=-0.05, physics_gravity=0.05},
armor_groups = {fleshy=15},
damage_groups = {cracky=1, snappy=2, choppy=2, crumbly=3, level=2},
})
armor:register_armor("3d_armor:leggings_gold", {
description = S("Gold Leggings"),
inventory_image = "3d_armor_inv_leggings_gold.png",
groups = {armor_legs=1, armor_heal=6, armor_use=300,
physics_speed=-0.04, physics_gravity=0.04},
armor_groups = {fleshy=15},
damage_groups = {cracky=1, snappy=2, choppy=2, crumbly=3, level=2},
})
armor:register_armor("3d_armor:boots_gold", {
description = S("Gold Boots"),
inventory_image = "3d_armor_inv_boots_gold.png",
groups = {armor_feet=1, armor_heal=6, armor_use=300,
physics_speed=-0.02, physics_gravity=0.02},
armor_groups = {fleshy=10},
damage_groups = {cracky=1, snappy=2, choppy=2, crumbly=3, level=2},
})
end
if armor.materials.mithril then
armor:register_armor("3d_armor:helmet_mithril", {
description = S("Mithril Helmet"),
inventory_image = "3d_armor_inv_helmet_mithril.png",
groups = {armor_head=1, armor_heal=12, armor_use=100},
armor_groups = {fleshy=15},
damage_groups = {cracky=2, snappy=1, level=3},
})
armor:register_armor("3d_armor:chestplate_mithril", {
description = S("Mithril Chestplate"),
inventory_image = "3d_armor_inv_chestplate_mithril.png",
groups = {armor_torso=1, armor_heal=12, armor_use=100},
armor_groups = {fleshy=20},
damage_groups = {cracky=2, snappy=1, level=3},
})
armor:register_armor("3d_armor:leggings_mithril", {
description = S("Mithril Leggings"),
inventory_image = "3d_armor_inv_leggings_mithril.png",
groups = {armor_legs=1, armor_heal=12, armor_use=100},
armor_groups = {fleshy=20},
damage_groups = {cracky=2, snappy=1, level=3},
})
armor:register_armor("3d_armor:boots_mithril", {
description = S("Mithril Boots"),
inventory_image = "3d_armor_inv_boots_mithril.png",
groups = {armor_feet=1, armor_heal=12, armor_use=100},
armor_groups = {fleshy=15},
damage_groups = {cracky=2, snappy=1, level=3},
})
end
if armor.materials.crystal then
armor:register_armor("3d_armor:helmet_crystal", {
description = S("Crystal Helmet"),
inventory_image = "3d_armor_inv_helmet_crystal.png",
groups = {armor_head=1, armor_heal=12, armor_use=100, armor_fire=1},
armor_groups = {fleshy=15},
damage_groups = {cracky=2, snappy=1, level=3},
})
armor:register_armor("3d_armor:chestplate_crystal", {
description = S("Crystal Chestplate"),
inventory_image = "3d_armor_inv_chestplate_crystal.png",
groups = {armor_torso=1, armor_heal=12, armor_use=100, armor_fire=1},
armor_groups = {fleshy=20},
damage_groups = {cracky=2, snappy=1, level=3},
})
armor:register_armor("3d_armor:leggings_crystal", {
description = S("Crystal Leggings"),
inventory_image = "3d_armor_inv_leggings_crystal.png",
groups = {armor_legs=1, armor_heal=12, armor_use=100, armor_fire=1},
armor_groups = {fleshy=20},
damage_groups = {cracky=2, snappy=1, level=3},
})
armor:register_armor("3d_armor:boots_crystal", {
description = S("Crystal Boots"),
inventory_image = "3d_armor_inv_boots_crystal.png",
groups = {armor_feet=1, armor_heal=12, armor_use=100, physics_speed=1,
physics_jump=0.5, armor_fire=1},
armor_groups = {fleshy=15},
damage_groups = {cracky=2, snappy=1, level=3},
})
end
for k, v in pairs(armor.materials) do
minetest.register_craft({
output = "3d_armor:helmet_"..k,
recipe = {
{v, v, v},
{v, "", v},
{"", "", ""},
},
})
minetest.register_craft({
output = "3d_armor:chestplate_"..k,
recipe = {
{v, "", v},
{v, v, v},
{v, v, v},
},
})
minetest.register_craft({
output = "3d_armor:leggings_"..k,
recipe = {
{v, v, v},
{v, "", v},
{v, "", v},
},
})
minetest.register_craft({
output = "3d_armor:boots_"..k,
recipe = {
{v, "", v},
{v, "", v},
},
})
end

79
mods/3d_armor-version-0.4.11/3d_armor/crafting_guide.txt Normal file
View File

@ -0,0 +1,79 @@
3d_armor -- Crafting Guide
--------------------------
Helmets:
+---+---+---+
| X | X | X |
+---+---+---+
| X | | X |
+---+---+---+
| | | |
+---+---+---+
[3d_armor:helmet_wood] X = [default:wood]
[3d_armor:helmet_cactus] X = [default:cactus]
[3d_armor:helmet_steel] X = [default:steel_ingot]
[3d_armor:helmet_bronze] X = [default:bronze_ingot]
[3d_armor:helmet_diamond] X = [default:diamond]
[3d_armor:helmet_gold] X = [default:gold_ingot]
[3d_armor:helmet_mithril] X = [moreores:mithril_ingot] *
[3d_armor:helmet_crystal] X = [ethereal:crystal_ingot] **
Chestplates:
+---+---+---+
| X | | X |
+---+---+---+
| X | X | X |
+---+---+---+
| X | X | X |
+---+---+---+
[3d_armor:chestplate_wood] X = [default:wood]
[3d_armor:chestplate_cactus] X = [default:cactus]
[3d_armor:chestplate_steel] X = [default:steel_ingot]
[3d_armor:chestplate_bronze] X = [default:bronze_ingot]
[3d_armor:chestplate_diamond] X = [default:diamond]
[3d_armor:chestplate_gold] X = [default:gold_ingot]
[3d_armor:chestplate_mithril] X = [moreores:mithril_ingot] *
[3d_armor:chestplate_crystal] X = [ethereal:crystal_ingot] **
Leggings:
+---+---+---+
| X | X | X |
+---+---+---+
| X | | X |
+---+---+---+
| X | | X |
+---+---+---+
[3d_armor:leggings_wood] X = [default:wood]
[3d_armor:leggings_cactus] X = [default:cactus]
[3d_armor:leggings_steel] X = [default:steel_ingot]
[3d_armor:leggings_bronze] X = [default:bronze_ingot]
[3d_armor:leggings_diamond] X = [default:diamond]
[3d_armor:leggings_gold] X = [default:gold_ingot]
[3d_armor:leggings_mithril] X = [moreores:mithril_ingot] *
[3d_armor:leggings_crystal] X = [ethereal:crystal_ingot] **
Boots:
+---+---+---+
| X | | X |
+---+---+---+
| X | | X |
+---+---+---+
[3d_armor:boots_wood] X = [default:wood]
[3d_armor:boots_cactus] X = [default:cactus]
[3d_armor:boots_steel] X = [default:steel_ingot]
[3d_armor:boots_bronze] X = [default:bronze_ingot
[3d_armor:boots_diamond] X = [default:diamond]
[3d_armor:boots_gold] X = [default:gold_ingot]
[3d_armor:boots_mithril] X = [moreores:mithril_ingot] *
[3d_armor:boots_crystal] X = [ethereal:crystal_ingot] **
* Requires moreores mod by Calinou - https://forum.minetest.net/viewtopic.php?id=549
** Requires ethereal mod by Chinchow & TenPlus1 - https://github.com/tenplus1/ethereal

7
mods/3d_armor-version-0.4.11/3d_armor/depends.txt Normal file
View File

@ -0,0 +1,7 @@
default
player_monoids?
armor_monoid?
fire?
ethereal?
bakedclay?
intllib?

1
mods/3d_armor-version-0.4.11/3d_armor/description.txt Normal file
View File

@ -0,0 +1 @@
Adds craftable armor that is visible to other players.

418
mods/3d_armor-version-0.4.11/3d_armor/init.lua Normal file
View File

@ -0,0 +1,418 @@
-- support for i18n
armor_i18n = { }
local MP = minetest.get_modpath(minetest.get_current_modname())
armor_i18n.gettext, armor_i18n.ngettext = dofile(MP.."/intllib.lua")
-- escaping formspec
armor_i18n.fgettext = function(...) return minetest.formspec_escape(armor_i18n.gettext(...)) end
-- local functions
local S = armor_i18n.gettext
local F = armor_i18n.fgettext
local modname = minetest.get_current_modname()
local modpath = minetest.get_modpath(modname)
local worldpath = minetest.get_worldpath()
local last_punch_time = {}
local pending_players = {}
local timer = 0
dofile(modpath.."/api.lua")
-- Legacy Config Support
local input = io.open(modpath.."/armor.conf", "r")
if input then
dofile(modpath.."/armor.conf")
input:close()
input = nil
end
input = io.open(worldpath.."/armor.conf", "r")
if input then
dofile(worldpath.."/armor.conf")
input:close()
input = nil
end
for name, _ in pairs(armor.config) do
local global = "ARMOR_"..name:upper()
if minetest.global_exists(global) then
armor.config[name] = _G[global]
end
end
if minetest.global_exists("ARMOR_MATERIALS") then
armor.materials = table.copy(ARMOR_MATERIALS)
end
if minetest.global_exists("ARMOR_FIRE_NODES") then
armor.fire_nodes = table.copy(ARMOR_FIRE_NODES)
end
-- Load Configuration
for name, config in pairs(armor.config) do
local setting = minetest.settings:get("armor_"..name)
if type(config) == "number" then
setting = tonumber(setting)
elseif type(config) == "boolean" then
setting = minetest.settings:get_bool("armor_"..name)
end
if setting ~= nil then
armor.config[name] = setting
end
end
for material, _ in pairs(armor.materials) do
local key = "material_"..material
if armor.config[key] == false then
armor.materials[material] = nil
end
end
-- Mod Compatibility
if minetest.get_modpath("technic") then
armor.formspec = armor.formspec..
"label[5,2.5;"..F("Radiation")..": armor_group_radiation]"
armor:register_armor_group("radiation")
end
local skin_mods = {"skins", "u_skins", "simple_skins", "wardrobe"}
for _, mod in pairs(skin_mods) do
local path = minetest.get_modpath(mod)
if path then
local dir_list = minetest.get_dir_list(path.."/textures")
for _, fn in pairs(dir_list) do
if fn:find("_preview.png$") then
armor:add_preview(fn)
end
end
armor.skin_mod = mod
end
end
if not minetest.get_modpath("moreores") then
armor.materials.mithril = nil
end
if not minetest.get_modpath("ethereal") then
armor.materials.crystal = nil
end
--dofile(modpath.."/armor.lua")
-- Armor Initialization
armor.formspec = armor.formspec..
"label[5,1;"..F("Level")..": armor_level]"..
"label[5,1.5;"..F("Heal")..": armor_attr_heal]"
if armor.config.fire_protect then
armor.formspec = armor.formspec.."label[5,2;"..F("Fire")..": armor_fire]"
end
armor:register_on_destroy(function(player, index, stack)
local name = player:get_player_name()
local def = stack:get_definition()
if name and def and def.description then
minetest.chat_send_player(name, S("Your @1 got destroyed!", def.description))
end
end)
local function init_player_armor(player)
local name = player:get_player_name()
local pos = player:getpos()
if not name or not pos then
return false
end
local armor_inv = minetest.create_detached_inventory(name.."_armor", {
on_put = function(inv, listname, index, stack, player)
armor:save_armor_inventory(player)
armor:run_callbacks("on_equip", player, index, stack)
armor:set_player_armor(player)
end,
on_take = function(inv, listname, index, stack, player)
armor:save_armor_inventory(player)
armor:run_callbacks("on_unequip", player, index, stack)
armor:set_player_armor(player)
end,
on_move = function(inv, from_list, from_index, to_list, to_index, count, player)
armor:save_armor_inventory(player)
armor:set_player_armor(player)
end,
allow_put = function(inv, listname, index, stack, player)
local def = stack:get_definition() or {}
local allowed = 0
for _, element in pairs(armor.elements) do
if def.groups["armor_"..element] then
allowed = 1
for i = 1, 6 do
local item = inv:get_stack("armor", i):get_name()
if minetest.get_item_group(item, "armor_"..element) == def.groups["armor_"..element] then
return 0
end
end
end
end
return allowed
end,
allow_take = function(inv, listname, index, stack, player)
return stack:get_count()
end,
allow_move = function(inv, from_list, from_index, to_list, to_index, count, player)
return count
end,
}, name)
armor_inv:set_size("armor", 6)
if not armor:load_armor_inventory(player) and armor.migrate_old_inventory then
local player_inv = player:get_inventory()
player_inv:set_size("armor", 6)
for i=1, 6 do
local stack = player_inv:get_stack("armor", i)
armor_inv:set_stack("armor", i, stack)
end
armor:save_armor_inventory(player)
player_inv:set_size("armor", 0)
end
for i=1, 6 do
local stack = armor_inv:get_stack("armor", i)
armor:run_callbacks("on_equip", player, i, stack)
end
armor.def[name] = {
init_time = minetest.get_gametime(),
level = 0,
state = 0,
count = 0,
groups = {},
}
for _, phys in pairs(armor.physics) do
armor.def[name][phys] = 1
end
for _, attr in pairs(armor.attributes) do
armor.def[name][attr] = 0
end
for group, _ in pairs(armor.registered_groups) do
armor.def[name].groups[group] = 0
end
local skin = armor:get_player_skin(name)
armor.textures[name] = {
skin = skin,
armor = "3d_armor_trans.png",
wielditem = "3d_armor_trans.png",
preview = armor.default_skin.."_preview.png",
}
local texture_path = minetest.get_modpath("player_textures")
if texture_path then
local dir_list = minetest.get_dir_list(texture_path.."/textures")
for _, fn in pairs(dir_list) do
if fn == "player_"..name..".png" then
armor.textures[name].skin = fn
break
end
end
end
armor:set_player_armor(player)
return true
end
-- Armor Player Model
default.player_register_model("3d_armor_character.b3d", {
animation_speed = 30,
textures = {
armor.default_skin..".png",
"3d_armor_trans.png",
"3d_armor_trans.png",
},
animations = {
stand = {x=0, y=79},
lay = {x=162, y=166},
walk = {x=168, y=187},
mine = {x=189, y=198},
walk_mine = {x=200, y=219},
sit = {x=81, y=160},
},
})
minetest.register_on_player_receive_fields(function(player, formname, fields)
local name = armor:get_valid_player(player, "[on_player_receive_fields]")
if not name then
return
end
for field, _ in pairs(fields) do
if string.find(field, "skins_set") then
minetest.after(0, function(player)
local skin = armor:get_player_skin(name)
armor.textures[name].skin = skin
armor:set_player_armor(player)
end, player)
end
end
end)
minetest.register_on_joinplayer(function(player)
default.player_set_model(player, "3d_armor_character.b3d")
minetest.after(0, function(player)
if init_player_armor(player) == false then
pending_players[player] = 0
end
end, player)
end)
minetest.register_on_leaveplayer(function(player)
local name = player:get_player_name()
if name then
armor.def[name] = nil
armor.textures[name] = nil
end
pending_players[player] = nil
end)
if armor.config.drop == true or armor.config.destroy == true then
minetest.register_on_dieplayer(function(player)
local name, armor_inv = armor:get_valid_player(player, "[on_dieplayer]")
if not name then
return
end
local drop = {}
for i=1, armor_inv:get_size("armor") do
local stack = armor_inv:get_stack("armor", i)
if stack:get_count() > 0 then
table.insert(drop, stack)
armor:set_inventory_stack(player, i, nil)
armor:run_callbacks("on_unequip", player, i, stack)
end
end
armor:set_player_armor(player)
local pos = player:getpos()
if pos and armor.config.destroy == false then
minetest.after(armor.config.bones_delay, function()
local meta = nil
local maxp = vector.add(pos, 8)
local minp = vector.subtract(pos, 8)
local bones = minetest.find_nodes_in_area(minp, maxp, {"bones:bones"})
for _, p in pairs(bones) do
local m = minetest.get_meta(p)
if m:get_string("owner") == name then
meta = m
break
end
end
if meta then
local inv = meta:get_inventory()
for _,stack in ipairs(drop) do
if inv:room_for_item("main", stack) then
inv:add_item("main", stack)
else
armor.drop_armor(pos, stack)
end
end
else
for _,stack in ipairs(drop) do
armor.drop_armor(pos, stack)
end
end
end)
end
end)
end
if armor.config.punch_damage == true then
minetest.register_on_punchplayer(function(player, hitter,
time_from_last_punch, tool_capabilities)
local name = player:get_player_name()
if name then
armor:punch(player, hitter, time_from_last_punch, tool_capabilities)
last_punch_time[name] = minetest.get_gametime()
end
end)
end
minetest.register_on_player_hpchange(function(player, hp_change)
if player and hp_change < 0 then
local name = player:get_player_name()
if name then
local heal = armor.def[name].heal
heal = heal * armor.config.heal_multiplier
if heal >= math.random(100) then
hp_change = 0
end
-- check if armor damage was handled by fire or on_punchplayer
local time = last_punch_time[name] or 0
if time == 0 or time + 1 < minetest.get_gametime() then
armor:punch(player)
end
end
end
return hp_change
end, true)
minetest.register_globalstep(function(dtime)
timer = timer + dtime
if timer > armor.config.init_delay then
for player, count in pairs(pending_players) do
local remove = init_player_armor(player) == true
pending_players[player] = count + 1
if remove == false and count > armor.config.init_times then
minetest.log("warning", S("3d_armor: Failed to initialize player"))
remove = true
end
if remove == true then
pending_players[player] = nil
end
end
timer = 0
end
end)
-- Fire Protection and water breating, added by TenPlus1
if armor.config.fire_protect == true then
-- override hot nodes so they do not hurt player anywhere but mod
for _, row in pairs(armor.fire_nodes) do
if minetest.registered_nodes[row[1]] then
minetest.override_item(row[1], {damage_per_second = 0})
end
end
else
print (S("[3d_armor] Fire Nodes disabled"))
end
if armor.config.water_protect == true or armor.config.fire_protect == true then
minetest.register_globalstep(function(dtime)
armor.timer = armor.timer + dtime
if armor.timer < armor.config.update_time then
return
end
for _,player in pairs(minetest.get_connected_players()) do
local name = player:get_player_name()
local pos = player:getpos()
local hp = player:get_hp()
if not name or not pos or not hp then
return
end
-- water breathing
if armor.config.water_protect == true then
if armor.def[name].water > 0 and
player:get_breath() < 10 then
player:set_breath(10)
end
end
-- fire protection
if armor.config.fire_protect == true then
local fire_damage = true
pos.y = pos.y + 1.4 -- head level
local node_head = minetest.get_node(pos).name
pos.y = pos.y - 1.2 -- feet level
local node_feet = minetest.get_node(pos).name
-- is player inside a hot node?
for _, row in pairs(armor.fire_nodes) do
-- check fire protection, if not enough then get hurt
if row[1] == node_head or row[1] == node_feet then
if fire_damage == true then
armor:punch(player, "fire")
last_punch_time[name] = minetest.get_gametime()
fire_damage = false
end
if hp > 0 and armor.def[name].fire < row[2] then
hp = hp - row[3] * armor.config.update_time
player:set_hp(hp)
break
end
end
end
end
end
armor.timer = 0
end)
end

45
mods/3d_armor-version-0.4.11/3d_armor/intllib.lua Normal file
View File

@ -0,0 +1,45 @@
-- Fallback functions for when `intllib` is not installed.
-- Code released under Unlicense <http://unlicense.org>.
-- Get the latest version of this file at:
-- https://raw.githubusercontent.com/minetest-mods/intllib/master/lib/intllib.lua
local function format(str, ...)
local args = { ... }
local function repl(escape, open, num, close)
if escape == "" then
local replacement = tostring(args[tonumber(num)])
if open == "" then
replacement = replacement..close
end
return replacement
else
return "@"..open..num..close
end
end
return (str:gsub("(@?)@(%(?)(%d+)(%)?)", repl))
end
local gettext, ngettext
if minetest.get_modpath("intllib") then
if intllib.make_gettext_pair then
-- New method using gettext.
gettext, ngettext = intllib.make_gettext_pair()
else
-- Old method using text files.
gettext = intllib.Getter()
end
end
-- Fill in missing functions.
gettext = gettext or function(msgid, ...)
return format(msgid, ...)
end
ngettext = ngettext or function(msgid, msgid_plural, n, ...)
return format(n==1 and msgid or msgid_plural, ...)
end
return gettext, ngettext

384
mods/3d_armor-version-0.4.11/3d_armor/locale/fr.po Normal file
View File

@ -0,0 +1,384 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: \n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-08-06 18:20+0200\n"
"PO-Revision-Date: 2017-08-06 18:20+0200\n"
"Last-Translator: fat115 <fat115@framasoft.org>\n"
"Language-Team: \n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 1.8.12\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
#: ../3d_armor/api.lua
msgid "3d_armor: Player name is nil @1"
msgstr "3d_armor : Nom du joueur non trouvé @1"
#: ../3d_armor/api.lua
msgid "3d_armor: Player inventory is nil @1"
msgstr "3d_armor : Inventaire du joueur non trouvé @1"
#: ../3d_armor/api.lua
msgid "3d_armor: Detached armor inventory is nil @1"
msgstr "3d_armor : Inventaire détaché pour l'armure non trouvé @1"
#: ../3d_armor/api.lua
msgid "3d_armor: Player reference is nil @1"
msgstr "3d_armor : Référence au joueur non trouvée @1"
#: ../3d_armor/armor.lua
msgid "Admin Helmet"
msgstr "Casque d'admin"
#: ../3d_armor/armor.lua
msgid "Admin Chestplate"
msgstr "Cuirasse d'admin"
#: ../3d_armor/armor.lua
msgid "Admin Leggings"
msgstr "Jambières d'admin"
#: ../3d_armor/armor.lua
msgid "Admin Boots"
msgstr "Bottes d'admin"
#: ../3d_armor/armor.lua
msgid "Wood Helmet"
msgstr "Casque en bois"
#: ../3d_armor/armor.lua
msgid "Wood Chestplate"
msgstr "Cuirasse en bois"
#: ../3d_armor/armor.lua
msgid "Wood Leggings"
msgstr "Jambières en bois"
#: ../3d_armor/armor.lua
msgid "Wood Boots"
msgstr "Bottes en bois"
#: ../3d_armor/armor.lua
msgid "Cactus Helmet"
msgstr "Casque en cactus"
#: ../3d_armor/armor.lua
msgid "Cactus Chestplate"
msgstr "Cuirasse en cactus"
#: ../3d_armor/armor.lua
msgid "Cactus Leggings"
msgstr "Jambières en cactus"
#: ../3d_armor/armor.lua
msgid "Cactus Boots"
msgstr "Bottes en cactus"
#: ../3d_armor/armor.lua
msgid "Steel Helmet"
msgstr "Casque en acier"
#: ../3d_armor/armor.lua
msgid "Steel Chestplate"
msgstr " = Cuirasse en acier"
#: ../3d_armor/armor.lua
msgid "Steel Leggings"
msgstr "Jambières en acier"
#: ../3d_armor/armor.lua
msgid "Steel Boots"
msgstr "Bottes en acier"
#: ../3d_armor/armor.lua
msgid "Bronze Helmet"
msgstr "Casque en bronze"
#: ../3d_armor/armor.lua
msgid "Bronze Chestplate"
msgstr "Cuirasse en bronze"
#: ../3d_armor/armor.lua
msgid "Bronze Leggings"
msgstr "Jambières en bronze"
#: ../3d_armor/armor.lua
msgid "Bronze Boots"
msgstr "Bottes en bronze"
#: ../3d_armor/armor.lua
msgid "Diamond Helmet"
msgstr "Casque en diamant"
#: ../3d_armor/armor.lua
msgid "Diamond Chestplate"
msgstr "Cuirasse en diamant"
#: ../3d_armor/armor.lua
msgid "Diamond Leggings"
msgstr "Jambières en diamant"
#: ../3d_armor/armor.lua
msgid "Diamond Boots"
msgstr "Bottes en diamant"
#: ../3d_armor/armor.lua
msgid "Gold Helmet"
msgstr "Casque en or"
#: ../3d_armor/armor.lua
msgid "Gold Chestplate"
msgstr "Cuirasse en or"
#: ../3d_armor/armor.lua
msgid "Gold Leggings"
msgstr "Jambières en or"
#: ../3d_armor/armor.lua
msgid "Gold Boots"
msgstr "Bottes en or"
#: ../3d_armor/armor.lua
msgid "Mithril Helmet"
msgstr "Casque en mithril"
#: ../3d_armor/armor.lua
msgid "Mithril Chestplate"
msgstr "Cuirasse en mithril"
#: ../3d_armor/armor.lua
msgid "Mithril Leggings"
msgstr "Jambières en mithril"
#: ../3d_armor/armor.lua
msgid "Mithril Boots"
msgstr "Bottes en mithril"
#: ../3d_armor/armor.lua
msgid "Crystal Helmet"
msgstr "Casque en cristal"
#: ../3d_armor/armor.lua
msgid "Crystal Chestplate"
msgstr "Cuirasse en cristal"
#: ../3d_armor/armor.lua
msgid "Crystal Leggings"
msgstr "Jambières en cristal"
#: ../3d_armor/armor.lua
msgid "Crystal Boots"
msgstr "Bottes en cristal"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Radiation"
msgstr "Radiation"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Level"
msgstr "Niveau"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Heal"
msgstr "Soins"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Fire"
msgstr "Fire"
#: ../3d_armor/init.lua
msgid "Your @1 got destroyed!"
msgstr "Une partie de votre armure a été détruite : @1 !"
#: ../3d_armor/init.lua
msgid "3d_armor: Failed to initialize player"
msgstr "3d_armor : Impossible d'initialiser le joueur"
#: ../3d_armor/init.lua
msgid "[3d_armor] Fire Nodes disabled"
msgstr "[3d_armor] Noeuds de type feu désactivés"
#: ../3d_armor_ip/init.lua
msgid "3d_armor_ip: Mod loaded but unused."
msgstr "3d_armor_ip : Mod chargé mais inutilisé."
#: ../3d_armor_ip/init.lua
msgid "Back"
msgstr "Retour"
#: ../3d_armor_ip/init.lua ../3d_armor_sfinv/init.lua ../3d_armor_ui/init.lua
msgid "Armor"
msgstr "Armure"
#: ../3d_armor_sfinv/init.lua
msgid "3d_armor_sfinv: Mod loaded but unused."
msgstr "3d_armor_sfinv : Mod chargé mais inutilisé."
#: ../3d_armor_stand/init.lua
msgid "Armor stand top"
msgstr "Haut de support d'armure"
#: ../3d_armor_stand/init.lua
msgid "Armor stand"
msgstr "Support d'armure"
#: ../3d_armor_stand/init.lua
msgid "Armor Stand"
msgstr "Support d'armure"
#: ../3d_armor_stand/init.lua
msgid "Locked Armor stand"
msgstr "Support d'armure verrouillé"
#: ../3d_armor_stand/init.lua
msgid "Armor Stand (owned by @1)"
msgstr "Support d'armure (propriété de @1)"
#: ../3d_armor_ui/init.lua
msgid "3d_armor_ui: Mod loaded but unused."
msgstr "3d_armor_ui : Mod chargé mais inutilisé."
#: ../3d_armor_ui/init.lua
msgid "3d Armor"
msgstr "Armure 3d"
#: ../3d_armor_ui/init.lua
msgid "Armor not initialized!"
msgstr "Armure non initialisée !"
#: ../hazmat_suit/init.lua
msgid "hazmat_suit: Mod loaded but unused."
msgstr "hazmat_suit : Mod chargé mais non utilisé."
#: ../hazmat_suit/init.lua
msgid "Hazmat Helmet"
msgstr "Casque 'Hazmat'"
#: ../hazmat_suit/init.lua
msgid "Hazmat Chestplate"
msgstr "Cuirasse 'Hazmat'"
#: ../hazmat_suit/init.lua
msgid "Hazmat Sleeve"
msgstr "Manches 'Hazmat'"
#: ../hazmat_suit/init.lua
msgid "Hazmat Leggins"
msgstr "Jambières 'Hazmat'"
#: ../hazmat_suit/init.lua
msgid "Hazmat Boots"
msgstr "Bottes 'Hazmat'"
#: ../hazmat_suit/init.lua
msgid "Hazmat Suit"
msgstr "Combinaison 'Hazmat'"
#: ../shields/init.lua
msgid "Admin Shield"
msgstr "Bouclier d'admin"
#: ../shields/init.lua
msgid "Wooden Shield"
msgstr "Bouclier en bois"
#: ../shields/init.lua
msgid "Enhanced Wood Shield"
msgstr "Bouclier en bois amélioré"
#: ../shields/init.lua
msgid "Cactus Shield"
msgstr "Bouclier en cactus"
#: ../shields/init.lua
msgid "Enhanced Cactus Shield"
msgstr "Bouclier en cactus amélioré"
#: ../shields/init.lua
msgid "Steel Shield"
msgstr "Bouclier en acier"
#: ../shields/init.lua
msgid "Bronze Shield"
msgstr "Bouclier en bronze"
#: ../shields/init.lua
msgid "Diamond Shield"
msgstr "Bouclier en diamant"
#: ../shields/init.lua
msgid "Gold Shield"
msgstr "Bouclier en or"
#: ../shields/init.lua
msgid "Mithril Shield"
msgstr "Bouclier en mithril"
#: ../shields/init.lua
msgid "Crystal Shield"
msgstr "Bouclier en cristal"
#: ../technic_armor/init.lua
msgid "technic_armor: Mod loaded but unused."
msgstr "technic_armor : Mod chargé mais non utilisé."
#: ../technic_armor/init.lua
msgid "Lead"
msgstr "plomb"
#: ../technic_armor/init.lua
msgid "Brass"
msgstr "laiton"
#: ../technic_armor/init.lua
msgid "Cast Iron"
msgstr "fonte"
#: ../technic_armor/init.lua
msgid "Carbon Steel"
msgstr "acier au carbone"
#: ../technic_armor/init.lua
msgid "Stainless Steel"
msgstr "acier inoxydable"
#: ../technic_armor/init.lua
msgid "Tin"
msgstr "étain"
#: ../technic_armor/init.lua
msgid "Silver"
msgstr "argent"
#: ../technic_armor/init.lua
msgid "Helmet"
msgstr "Casque"
#: ../technic_armor/init.lua
msgid "Chestplate"
msgstr "Cuirasse"
#: ../technic_armor/init.lua
msgid "Leggings"
msgstr "Jambières"
#: ../technic_armor/init.lua
msgid "Boots"
msgstr "Bottes"
#: ../technic_armor/init.lua
msgid "Shield"
msgstr "Bouclier"
#. Translators: @1 stands for material and @2 for part of the armor, so that you could use a conjunction if in your language part name comes first then material (e.g. in french 'Silver Boots' is translated in 'Bottes en argent' by using '@2 en @1' as translated string)
#: ../technic_armor/init.lua
msgid "@1 @2"
msgstr "@2 en @1"

384
mods/3d_armor-version-0.4.11/3d_armor/locale/it.po Normal file
View File

@ -0,0 +1,384 @@
# ITALIAN LOCALE FILE FOR THE 3D ARMOR MODULE
# Copyright (C) 2012-2017 Stuart Jones
# This file is distributed under the same license as the 3D ARMOR package.
# Hamlet <h4mlet@riseup.net>, 2017.
#
msgid ""
msgstr ""
"Project-Id-Version: Italian localization file for the 3D Armor module\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-08-06 18:20+0200\n"
"PO-Revision-Date: 2017-08-18 00:36+0100\n"
"Last-Translator: H4mlet <h4mlet@riseup.net>\n"
"Language-Team: ITALIANO\n"
"Language: it\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Generator: Poedit 1.6.10\n"
#: ../3d_armor/api.lua
msgid "3d_armor: Player name is nil @1"
msgstr "3d_armor: Il nome della/del gicatrice/tore è nullo @1"
#: ../3d_armor/api.lua
msgid "3d_armor: Player inventory is nil @1"
msgstr "3d_armor: L'inventario della/del giocatrice/tore è nullo @1"
#: ../3d_armor/api.lua
msgid "3d_armor: Detached armor inventory is nil @1"
msgstr "3d_armor: L'inventario staccato dell'armatura è nullo @1"
#: ../3d_armor/api.lua
msgid "3d_armor: Player reference is nil @1"
msgstr "3d_armor: Il riferimento alla/al giocatrice/tore è nullo @1"
#: ../3d_armor/armor.lua
msgid "Admin Helmet"
msgstr "Elmo dell'amministratrice/tore"
#: ../3d_armor/armor.lua
msgid "Admin Chestplate"
msgstr "Corazza dell'amministratrice/tore"
#: ../3d_armor/armor.lua
msgid "Admin Leggings"
msgstr "Gambali dell'amministratrice/tore"
#: ../3d_armor/armor.lua
msgid "Admin Boots"
msgstr "Stivali dell'amministratrice/tore"
#: ../3d_armor/armor.lua
msgid "Wood Helmet"
msgstr "Elmo di legno"
#: ../3d_armor/armor.lua
msgid "Wood Chestplate"
msgstr "Corazza di legno"
#: ../3d_armor/armor.lua
msgid "Wood Leggings"
msgstr "Gambali di legno"
#: ../3d_armor/armor.lua
msgid "Wood Boots"
msgstr "Stivali di legno"
#: ../3d_armor/armor.lua
msgid "Cactus Helmet"
msgstr "Elmo di cactus"
#: ../3d_armor/armor.lua
msgid "Cactus Chestplate"
msgstr "Corazza di cactus"
#: ../3d_armor/armor.lua
msgid "Cactus Leggings"
msgstr "Gambali di cactus"
#: ../3d_armor/armor.lua
msgid "Cactus Boots"
msgstr "Stivali di cactus"
#: ../3d_armor/armor.lua
msgid "Steel Helmet"
msgstr "Elmo di acciaio"
#: ../3d_armor/armor.lua
msgid "Steel Chestplate"
msgstr "Corazza di acciaio"
#: ../3d_armor/armor.lua
msgid "Steel Leggings"
msgstr "Gambali di acciaio"
#: ../3d_armor/armor.lua
msgid "Steel Boots"
msgstr "Stivali di acciaio"
#: ../3d_armor/armor.lua
msgid "Bronze Helmet"
msgstr "Elmo di bronzo"
#: ../3d_armor/armor.lua
msgid "Bronze Chestplate"
msgstr "Corazza di bronzo"
#: ../3d_armor/armor.lua
msgid "Bronze Leggings"
msgstr "Gambali di bronzo"
#: ../3d_armor/armor.lua
msgid "Bronze Boots"
msgstr "Stivali di bronzo"
#: ../3d_armor/armor.lua
msgid "Diamond Helmet"
msgstr "Elmo di diamante"
#: ../3d_armor/armor.lua
msgid "Diamond Chestplate"
msgstr "Corazza di diamante"
#: ../3d_armor/armor.lua
msgid "Diamond Leggings"
msgstr "Gambali di diamante"
#: ../3d_armor/armor.lua
msgid "Diamond Boots"
msgstr "Stivali di diamante"
#: ../3d_armor/armor.lua
msgid "Gold Helmet"
msgstr "Elmo d'oro"
#: ../3d_armor/armor.lua
msgid "Gold Chestplate"
msgstr "Corazza d'oro"
#: ../3d_armor/armor.lua
msgid "Gold Leggings"
msgstr "Gambali d'oro"
#: ../3d_armor/armor.lua
msgid "Gold Boots"
msgstr "Stivali d'oro"
#: ../3d_armor/armor.lua
msgid "Mithril Helmet"
msgstr "Elmo di mithril"
#: ../3d_armor/armor.lua
msgid "Mithril Chestplate"
msgstr "Corazza di mithril"
#: ../3d_armor/armor.lua
msgid "Mithril Leggings"
msgstr "Gambali di mithril"
#: ../3d_armor/armor.lua
msgid "Mithril Boots"
msgstr "Stivali di mithril"
#: ../3d_armor/armor.lua
msgid "Crystal Helmet"
msgstr "Elmo di cristallo"
#: ../3d_armor/armor.lua
msgid "Crystal Chestplate"
msgstr "Corazza di cristallo"
#: ../3d_armor/armor.lua
msgid "Crystal Leggings"
msgstr "Gambali di cristallo"
#: ../3d_armor/armor.lua
msgid "Crystal Boots"
msgstr "Stivali di cristallo"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Radiation"
msgstr "Radiazione"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Level"
msgstr "Livello"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Heal"
msgstr "Guarigione"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Fire"
msgstr "Fuoco"
#: ../3d_armor/init.lua
msgid "Your @1 got destroyed!"
msgstr "Il/i vostro/i @1 è/sono stato/i distrutto/i!"
#: ../3d_armor/init.lua
msgid "3d_armor: Failed to initialize player"
msgstr "3d_armor: Inizializzazione della/del giocatrice/tore fallita"
#: ../3d_armor/init.lua
msgid "[3d_armor] Fire Nodes disabled"
msgstr "[3d_armor] Nodi fuoco disabilitati"
#: ../3d_armor_ip/init.lua
msgid "3d_armor_ip: Mod loaded but unused."
msgstr "3d_armor_ip: Mod caricato ma inutilizzato."
#: ../3d_armor_ip/init.lua
msgid "Back"
msgstr "Indietro"
#: ../3d_armor_ip/init.lua ../3d_armor_sfinv/init.lua ../3d_armor_ui/init.lua
msgid "Armor"
msgstr "Armatura"
#: ../3d_armor_sfinv/init.lua
msgid "3d_armor_sfinv: Mod loaded but unused."
msgstr "3d_armor_sfinv: Mod caricato ma inutilizzato."
#: ../3d_armor_stand/init.lua
msgid "Armor stand top"
msgstr "Parte superiore del supporto per armatura"
#: ../3d_armor_stand/init.lua
msgid "Armor stand"
msgstr "Supporto per armatura"
#: ../3d_armor_stand/init.lua
msgid "Armor Stand"
msgstr "Supporto per armatura"
#: ../3d_armor_stand/init.lua
msgid "Locked Armor stand"
msgstr "Supporto per armatura chiuso a chiave"
#: ../3d_armor_stand/init.lua
msgid "Armor Stand (owned by @1)"
msgstr "Supporto per armatura (di proprietà di @1)"
#: ../3d_armor_ui/init.lua
msgid "3d_armor_ui: Mod loaded but unused."
msgstr "3d_armor_ui: Mod caricato ma inutilizzato."
#: ../3d_armor_ui/init.lua
msgid "3d Armor"
msgstr "Armatura 3D"
#: ../3d_armor_ui/init.lua
msgid "Armor not initialized!"
msgstr "Armatura non inizializzata!"
#: ../hazmat_suit/init.lua
msgid "hazmat_suit: Mod loaded but unused."
msgstr "hazmat_suit: Mod caricato ma inutilizzato."
#: ../hazmat_suit/init.lua
msgid "Hazmat Helmet"
msgstr "Elmo hazmat"
#: ../hazmat_suit/init.lua
msgid "Hazmat Chestplate"
msgstr "Corazza hazmat"
#: ../hazmat_suit/init.lua
msgid "Hazmat Sleeve"
msgstr "Manica hazmat"
#: ../hazmat_suit/init.lua
msgid "Hazmat Leggins"
msgstr "Gambali hazmat"
#: ../hazmat_suit/init.lua
msgid "Hazmat Boots"
msgstr "Stivali hazmat"
#: ../hazmat_suit/init.lua
msgid "Hazmat Suit"
msgstr "Completo hazmat"
#: ../shields/init.lua
msgid "Admin Shield"
msgstr "Scudo dell'amministratrice/tore"
#: ../shields/init.lua
msgid "Wooden Shield"
msgstr "Scudo di legno"
#: ../shields/init.lua
msgid "Enhanced Wood Shield"
msgstr "Scudo di legno migliorato"
#: ../shields/init.lua
msgid "Cactus Shield"
msgstr "Scudo di cactus"
#: ../shields/init.lua
msgid "Enhanced Cactus Shield"
msgstr "Scudo di cactus migliorato"
#: ../shields/init.lua
msgid "Steel Shield"
msgstr "Scudo di acciaio"
#: ../shields/init.lua
msgid "Bronze Shield"
msgstr "Scudo di bronzo"
#: ../shields/init.lua
msgid "Diamond Shield"
msgstr "Scudo di diamante"
#: ../shields/init.lua
msgid "Gold Shield"
msgstr "Scudo d'oro"
#: ../shields/init.lua
msgid "Mithril Shield"
msgstr "Scudo di mithril"
#: ../shields/init.lua
msgid "Crystal Shield"
msgstr "Scudo di cristallo"
#: ../technic_armor/init.lua
msgid "technic_armor: Mod loaded but unused."
msgstr "technic_armor: Mod caricato ma inutilizzato."
#: ../technic_armor/init.lua
msgid "Lead"
msgstr "Piombo"
#: ../technic_armor/init.lua
msgid "Brass"
msgstr "Ottone"
#: ../technic_armor/init.lua
msgid "Cast Iron"
msgstr "Ghisa"
#: ../technic_armor/init.lua
msgid "Carbon Steel"
msgstr "Acciaio al carbonio"
#: ../technic_armor/init.lua
msgid "Stainless Steel"
msgstr "Acciaio inossidabile"
#: ../technic_armor/init.lua
msgid "Tin"
msgstr "Stagno"
#: ../technic_armor/init.lua
msgid "Silver"
msgstr "Argento"
#: ../technic_armor/init.lua
msgid "Helmet"
msgstr "Elmo"
#: ../technic_armor/init.lua
msgid "Chestplate"
msgstr "Corazza"
#: ../technic_armor/init.lua
msgid "Leggings"
msgstr "Gambali"
#: ../technic_armor/init.lua
msgid "Boots"
msgstr "Stivali"
#: ../technic_armor/init.lua
msgid "Shield"
msgstr "Scudo"
#. Translators: @1 stands for material and @2 for part of the armor, so that you could use a conjunction if in your language part name comes first then material (e.g. in french 'Silver Boots' is translated in 'Bottes en argent' by using '@2 en @1' as translated string)
#: ../technic_armor/init.lua
msgid "@1 @2"
msgstr "@2 di @1"

386
mods/3d_armor-version-0.4.11/3d_armor/locale/ms.po Normal file
View File

@ -0,0 +1,386 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: \n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-08-06 18:20+0200\n"
"PO-Revision-Date: 2018-02-07 13:25+0800\n"
"Language-Team: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.0.6\n"
"Last-Translator: MuhdNurHidayat (MNH48) <mnh48mail@gmail.com>\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"Language: ms\n"
#: ../3d_armor/api.lua
msgid "3d_armor: Player name is nil @1"
msgstr "3d_armor: Nama pemain tiada nilai @1"
#: ../3d_armor/api.lua
msgid "3d_armor: Player inventory is nil @1"
msgstr "3d_armor: Inventori pemain tiada nilai @1"
#: ../3d_armor/api.lua
msgid "3d_armor: Detached armor inventory is nil @1"
msgstr "3d_armor: Inventori perisai terpisah tiada nilai @1"
#: ../3d_armor/api.lua
msgid "3d_armor: Player reference is nil @1"
msgstr "3d_armor: Rujukan pemain tiada nilai @1"
#: ../3d_armor/armor.lua
msgid "Admin Helmet"
msgstr "Helmet Pentadbir"
#: ../3d_armor/armor.lua
msgid "Admin Chestplate"
msgstr "Perisai Dada Pentadbir"
#: ../3d_armor/armor.lua
msgid "Admin Leggings"
msgstr "Perisai Kaki Pentadbir"
#: ../3d_armor/armor.lua
msgid "Admin Boots"
msgstr "But Pentadbir"
#: ../3d_armor/armor.lua
msgid "Wood Helmet"
msgstr "Helmet Kayu"
#: ../3d_armor/armor.lua
msgid "Wood Chestplate"
msgstr "Perisai Dada Kayu"
#: ../3d_armor/armor.lua
msgid "Wood Leggings"
msgstr "Perisai Kaki Kayu"
#: ../3d_armor/armor.lua
msgid "Wood Boots"
msgstr "But Kayu"
#: ../3d_armor/armor.lua
msgid "Cactus Helmet"
msgstr "Helmet Kaktus"
#: ../3d_armor/armor.lua
msgid "Cactus Chestplate"
msgstr "Perisai Dada Kaktus"
#: ../3d_armor/armor.lua
msgid "Cactus Leggings"
msgstr "Perisai Kaki Kaktus"
#: ../3d_armor/armor.lua
msgid "Cactus Boots"
msgstr "But Kaktus"
#: ../3d_armor/armor.lua
msgid "Steel Helmet"
msgstr "Helmet Keluli"
#: ../3d_armor/armor.lua
msgid "Steel Chestplate"
msgstr "Perisai Dada Keluli"
#: ../3d_armor/armor.lua
msgid "Steel Leggings"
msgstr "Perisai Kaki Keluli"
#: ../3d_armor/armor.lua
msgid "Steel Boots"
msgstr "But Keluli"
#: ../3d_armor/armor.lua
msgid "Bronze Helmet"
msgstr "Helmet Gangsa"
#: ../3d_armor/armor.lua
msgid "Bronze Chestplate"
msgstr "Perisai Dada Gangsa"
#: ../3d_armor/armor.lua
msgid "Bronze Leggings"
msgstr "Perisai Kaki Gangsa"
#: ../3d_armor/armor.lua
msgid "Bronze Boots"
msgstr "But Gangsa"
# 'Diamond' should be translated as 'intan' because the more common word 'berlian' is only specifically used for the gemstone diamond.
#: ../3d_armor/armor.lua
msgid "Diamond Helmet"
msgstr "Helmet Intan"
#: ../3d_armor/armor.lua
msgid "Diamond Chestplate"
msgstr "Perisai Dada Intan"
#: ../3d_armor/armor.lua
msgid "Diamond Leggings"
msgstr "Perisai Kaki Intan"
#: ../3d_armor/armor.lua
msgid "Diamond Boots"
msgstr "But Intan"
#: ../3d_armor/armor.lua
msgid "Gold Helmet"
msgstr "Helmet Emas"
#: ../3d_armor/armor.lua
msgid "Gold Chestplate"
msgstr "Perisai Dada Emas"
#: ../3d_armor/armor.lua
msgid "Gold Leggings"
msgstr "Perisai Kaki Emas"
#: ../3d_armor/armor.lua
msgid "Gold Boots"
msgstr "But Emas"
#: ../3d_armor/armor.lua
msgid "Mithril Helmet"
msgstr "Helmet Mithril"
#: ../3d_armor/armor.lua
msgid "Mithril Chestplate"
msgstr "Perisai Dada Mithril"
#: ../3d_armor/armor.lua
msgid "Mithril Leggings"
msgstr "Perisai Kaki Mithril"
#: ../3d_armor/armor.lua
msgid "Mithril Boots"
msgstr "But Mithril"
#: ../3d_armor/armor.lua
msgid "Crystal Helmet"
msgstr "Helmet Kristal"
#: ../3d_armor/armor.lua
msgid "Crystal Chestplate"
msgstr "Perisai Dada Kristal"
#: ../3d_armor/armor.lua
msgid "Crystal Leggings"
msgstr "Perisai Kaki Kristal"
#: ../3d_armor/armor.lua
msgid "Crystal Boots"
msgstr "But Kristal"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Radiation"
msgstr "Radiasi"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Level"
msgstr "Tahap"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Heal"
msgstr "Pulih"
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Fire"
msgstr "Api"
#: ../3d_armor/init.lua
msgid "Your @1 got destroyed!"
msgstr "@1 anda telah musnah!"
#: ../3d_armor/init.lua
msgid "3d_armor: Failed to initialize player"
msgstr "3d_armor: Gagal mengasalkan pemain"
#: ../3d_armor/init.lua
msgid "[3d_armor] Fire Nodes disabled"
msgstr "[3d_armor] Nod-nod Api dilumpuhkan"
#: ../3d_armor_ip/init.lua
msgid "3d_armor_ip: Mod loaded but unused."
msgstr "3d_armor_ip: Mods dimuatkan tetapi tidak digunakan."
#: ../3d_armor_ip/init.lua
msgid "Back"
msgstr "Kembali"
#: ../3d_armor_ip/init.lua ../3d_armor_sfinv/init.lua ../3d_armor_ui/init.lua
msgid "Armor"
msgstr "Perisai"
#: ../3d_armor_sfinv/init.lua
msgid "3d_armor_sfinv: Mod loaded but unused."
msgstr "3d_armor_sfinv: Mods dimuatkan tetapi tidak digunakan."
#: ../3d_armor_stand/init.lua
msgid "Armor stand top"
msgstr "Bhg atas dirian perisai"
#: ../3d_armor_stand/init.lua
msgid "Armor stand"
msgstr "Dirian perisai"
#: ../3d_armor_stand/init.lua
msgid "Armor Stand"
msgstr "Dirian Perisai"
#: ../3d_armor_stand/init.lua
msgid "Locked Armor stand"
msgstr "Dirian perisai Berkunci"
#: ../3d_armor_stand/init.lua
msgid "Armor Stand (owned by @1)"
msgstr "Dirian Perisai (milik @1)"
#: ../3d_armor_ui/init.lua
msgid "3d_armor_ui: Mod loaded but unused."
msgstr "3d_armor_ui: Mods dimuatkan tetapi tidak digunakan."
#: ../3d_armor_ui/init.lua
msgid "3d Armor"
msgstr "Perisai 3d"
#: ../3d_armor_ui/init.lua
msgid "Armor not initialized!"
msgstr "Perisai tidak diasalkan!"
#: ../hazmat_suit/init.lua
msgid "hazmat_suit: Mod loaded but unused."
msgstr "hazmat_suit: Mods dimuatkan tetapi tidak digunakan."
#: ../hazmat_suit/init.lua
msgid "Hazmat Helmet"
msgstr "Helmet Keselamatan"
#: ../hazmat_suit/init.lua
msgid "Hazmat Chestplate"
msgstr "Perisai Dada Keselamatan"
#: ../hazmat_suit/init.lua
msgid "Hazmat Sleeve"
msgstr "Perisai Tangan Keselamatan"
#: ../hazmat_suit/init.lua
msgid "Hazmat Leggins"
msgstr "Perisai Kaki Keselamatan"
#: ../hazmat_suit/init.lua
msgid "Hazmat Boots"
msgstr "But Keselamatan"
#: ../hazmat_suit/init.lua
msgid "Hazmat Suit"
msgstr "Pakaian Keselamatan"
#: ../shields/init.lua
msgid "Admin Shield"
msgstr "Perisai Pegang Pentadbir"
#: ../shields/init.lua
msgid "Wooden Shield"
msgstr "Perisai Pegang Kayu"
#: ../shields/init.lua
msgid "Enhanced Wood Shield"
msgstr "Perisai Pegang Kayu Kukuh"
#: ../shields/init.lua
msgid "Cactus Shield"
msgstr "Perisai Pegang Kaktus"
#: ../shields/init.lua
msgid "Enhanced Cactus Shield"
msgstr "Perisai Pegang Kaktus Kukuh"
#: ../shields/init.lua
msgid "Steel Shield"
msgstr "Perisai Pegang Keluli"
#: ../shields/init.lua
msgid "Bronze Shield"
msgstr "Perisai Pegang Gangsa"
#: ../shields/init.lua
msgid "Diamond Shield"
msgstr "Perisai Pegang Intan"
#: ../shields/init.lua
msgid "Gold Shield"
msgstr "Perisai Pegang Emas"
#: ../shields/init.lua
msgid "Mithril Shield"
msgstr "Perisai Pegang Mithril"
#: ../shields/init.lua
msgid "Crystal Shield"
msgstr "Perisai Pegang Kristal"
#: ../technic_armor/init.lua
msgid "technic_armor: Mod loaded but unused."
msgstr "technic_armor: Mods dimuatkan tetapi tidak digunakan."
# 'Lead' here is the chemical compound so the translation is 'plumbum', not 'pimpin' (act of leading).
#: ../technic_armor/init.lua
msgid "Lead"
msgstr "Plumbum"
#: ../technic_armor/init.lua
msgid "Brass"
msgstr "Loyang"
#: ../technic_armor/init.lua
msgid "Cast Iron"
msgstr "Besi Tuang"
#: ../technic_armor/init.lua
msgid "Carbon Steel"
msgstr "Keluli Karbon"
#: ../technic_armor/init.lua
msgid "Stainless Steel"
msgstr "Keluli Tahan Karat"
#: ../technic_armor/init.lua
msgid "Tin"
msgstr "Timah"
#: ../technic_armor/init.lua
msgid "Silver"
msgstr "Perak"
#: ../technic_armor/init.lua
msgid "Helmet"
msgstr "Helmet"
#: ../technic_armor/init.lua
msgid "Chestplate"
msgstr "Perisai Dada"
#: ../technic_armor/init.lua
msgid "Leggings"
msgstr "Perisai Kaki"
#: ../technic_armor/init.lua
msgid "Boots"
msgstr "But"
#: ../technic_armor/init.lua
msgid "Shield"
msgstr "Perisai Pegang"
#. Translators: @1 stands for material and @2 for part of the armor, so that you could use a conjunction if in your language part name comes first then material (e.g. in french 'Silver Boots' is translated in 'Bottes en argent' by using '@2 en @1' as translated string)
#: ../technic_armor/init.lua
msgid "@1 @2"
msgstr "@2 @1"

383
mods/3d_armor-version-0.4.11/3d_armor/locale/template.pot Normal file
View File

@ -0,0 +1,383 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-08-06 18:20+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=CHARSET\n"
"Content-Transfer-Encoding: 8bit\n"
#: ../3d_armor/api.lua
msgid "3d_armor: Player name is nil @1"
msgstr ""
#: ../3d_armor/api.lua
msgid "3d_armor: Player inventory is nil @1"
msgstr ""
#: ../3d_armor/api.lua
msgid "3d_armor: Detached armor inventory is nil @1"
msgstr ""
#: ../3d_armor/api.lua
msgid "3d_armor: Player reference is nil @1"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Admin Helmet"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Admin Chestplate"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Admin Leggings"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Admin Boots"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Wood Helmet"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Wood Chestplate"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Wood Leggings"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Wood Boots"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Cactus Helmet"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Cactus Chestplate"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Cactus Leggings"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Cactus Boots"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Steel Helmet"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Steel Chestplate"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Steel Leggings"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Steel Boots"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Bronze Helmet"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Bronze Chestplate"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Bronze Leggings"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Bronze Boots"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Diamond Helmet"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Diamond Chestplate"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Diamond Leggings"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Diamond Boots"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Gold Helmet"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Gold Chestplate"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Gold Leggings"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Gold Boots"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Mithril Helmet"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Mithril Chestplate"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Mithril Leggings"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Mithril Boots"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Crystal Helmet"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Crystal Chestplate"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Crystal Leggings"
msgstr ""
#: ../3d_armor/armor.lua
msgid "Crystal Boots"
msgstr ""
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Radiation"
msgstr ""
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Level"
msgstr ""
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Heal"
msgstr ""
#: ../3d_armor/init.lua ../3d_armor_ui/init.lua
msgid "Fire"
msgstr ""
#: ../3d_armor/init.lua
msgid "Your @1 got destroyed!"
msgstr ""
#: ../3d_armor/init.lua
msgid "3d_armor: Failed to initialize player"
msgstr ""
#: ../3d_armor/init.lua
msgid "[3d_armor] Fire Nodes disabled"
msgstr ""
#: ../3d_armor_ip/init.lua
msgid "3d_armor_ip: Mod loaded but unused."
msgstr ""
#: ../3d_armor_ip/init.lua
msgid "Back"
msgstr ""
#: ../3d_armor_ip/init.lua ../3d_armor_sfinv/init.lua ../3d_armor_ui/init.lua
msgid "Armor"
msgstr ""
#: ../3d_armor_sfinv/init.lua
msgid "3d_armor_sfinv: Mod loaded but unused."
msgstr ""
#: ../3d_armor_stand/init.lua
msgid "Armor stand top"
msgstr ""
#: ../3d_armor_stand/init.lua
msgid "Armor stand"
msgstr ""
#: ../3d_armor_stand/init.lua
msgid "Armor Stand"
msgstr ""
#: ../3d_armor_stand/init.lua
msgid "Locked Armor stand"
msgstr ""
#: ../3d_armor_stand/init.lua
msgid "Armor Stand (owned by @1)"
msgstr ""
#: ../3d_armor_ui/init.lua
msgid "3d_armor_ui: Mod loaded but unused."
msgstr ""
#: ../3d_armor_ui/init.lua
msgid "3d Armor"
msgstr ""
#: ../3d_armor_ui/init.lua
msgid "Armor not initialized!"
msgstr ""
#: ../hazmat_suit/init.lua
msgid "hazmat_suit: Mod loaded but unused."
msgstr ""
#: ../hazmat_suit/init.lua
msgid "Hazmat Helmet"
msgstr ""
#: ../hazmat_suit/init.lua
msgid "Hazmat Chestplate"
msgstr ""
#: ../hazmat_suit/init.lua
msgid "Hazmat Sleeve"
msgstr ""
#: ../hazmat_suit/init.lua
msgid "Hazmat Leggins"
msgstr ""
#: ../hazmat_suit/init.lua
msgid "Hazmat Boots"
msgstr ""
#: ../hazmat_suit/init.lua
msgid "Hazmat Suit"
msgstr ""
#: ../shields/init.lua
msgid "Admin Shield"
msgstr ""
#: ../shields/init.lua
msgid "Wooden Shield"
msgstr ""
#: ../shields/init.lua
msgid "Enhanced Wood Shield"
msgstr ""
#: ../shields/init.lua
msgid "Cactus Shield"
msgstr ""
#: ../shields/init.lua
msgid "Enhanced Cactus Shield"
msgstr ""
#: ../shields/init.lua
msgid "Steel Shield"
msgstr ""
#: ../shields/init.lua
msgid "Bronze Shield"
msgstr ""
#: ../shields/init.lua
msgid "Diamond Shield"
msgstr ""
#: ../shields/init.lua
msgid "Gold Shield"
msgstr ""
#: ../shields/init.lua
msgid "Mithril Shield"
msgstr ""
#: ../shields/init.lua
msgid "Crystal Shield"
msgstr ""
#: ../technic_armor/init.lua
msgid "technic_armor: Mod loaded but unused."
msgstr ""
#: ../technic_armor/init.lua
msgid "Lead"
msgstr ""
#: ../technic_armor/init.lua
msgid "Brass"
msgstr ""
#: ../technic_armor/init.lua
msgid "Cast Iron"
msgstr ""
#: ../technic_armor/init.lua
msgid "Carbon Steel"
msgstr ""
#: ../technic_armor/init.lua
msgid "Stainless Steel"
msgstr ""
#: ../technic_armor/init.lua
msgid "Tin"
msgstr ""
#: ../technic_armor/init.lua
msgid "Silver"
msgstr ""
#: ../technic_armor/init.lua
msgid "Helmet"
msgstr ""
#: ../technic_armor/init.lua
msgid "Chestplate"
msgstr ""
#: ../technic_armor/init.lua
msgid "Leggings"
msgstr ""
#: ../technic_armor/init.lua
msgid "Boots"
msgstr ""
#: ../technic_armor/init.lua
msgid "Shield"
msgstr ""
#. Translators: @1 stands for material and @2 for part of the armor, so that you could use a conjunction if in your language part name comes first then material (e.g. in french 'Silver Boots' is translated in 'Bottes en argent' by using '@2 en @1' as translated string)
#: ../technic_armor/init.lua
msgid "@1 @2"
msgstr ""

BIN
mods/3d_armor-version-0.4.11/3d_armor/models/3d_armor_character.b3d Normal file
View File

Binary file not shown.

BIN
mods/3d_armor-version-0.4.11/3d_armor/models/3d_armor_character.blend Normal file
View File

Binary file not shown.

BIN
mods/3d_armor-version-0.4.11/3d_armor/textures/3d_armor_trans.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 274 B

BIN
mods/3d_armor-version-0.4.11/3d_armor/textures/3d_armor_ui_form.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.9 KiB

BIN
mods/3d_armor-version-0.4.11/3d_armor/textures/character_preview.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 349 B

BIN
mods/3d_armor-version-0.4.11/3d_armor/textures/inventory_plus_armor.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 533 B

44
mods/3d_armor-version-0.4.11/3d_armor/textures/preview_index.txt Normal file
View File

@ -0,0 +1,44 @@
3d_armor/textures/3d_armor_helmet_wood.png:head
3d_armor/textures/3d_armor_chestplate_wood.png:torso
3d_armor/textures/3d_armor_leggings_wood.png:legs
3d_armor/textures/3d_armor_boots_wood.png:feet
3d_armor/textures/3d_armor_helmet_cactus.png:head
3d_armor/textures/3d_armor_chestplate_cactus.png:torso
3d_armor/textures/3d_armor_leggings_cactus.png:legs
3d_armor/textures/3d_armor_boots_cactus.png:feet
3d_armor/textures/3d_armor_helmet_steel.png:head
3d_armor/textures/3d_armor_chestplate_steel.png:torso
3d_armor/textures/3d_armor_leggings_steel.png:legs
3d_armor/textures/3d_armor_boots_steel.png:feet
3d_armor/textures/3d_armor_helmet_bronze.png:head
3d_armor/textures/3d_armor_chestplate_bronze.png:torso
3d_armor/textures/3d_armor_leggings_bronze.png:legs
3d_armor/textures/3d_armor_boots_bronze.png:feet
3d_armor/textures/3d_armor_helmet_gold.png:head
3d_armor/textures/3d_armor_chestplate_gold.png:torso
3d_armor/textures/3d_armor_leggings_gold.png:legs
3d_armor/textures/3d_armor_boots_gold.png:feet
3d_armor/textures/3d_armor_helmet_diamond.png:head
3d_armor/textures/3d_armor_chestplate_diamond.png:torso
3d_armor/textures/3d_armor_leggings_diamond.png:legs
3d_armor/textures/3d_armor_boots_diamond.png:feet
3d_armor/textures/3d_armor_helmet_mithril.png:head
3d_armor/textures/3d_armor_chestplate_mithril.png:torso
3d_armor/textures/3d_armor_leggings_mithril.png:legs
3d_armor/textures/3d_armor_boots_mithril.png:feet
3d_armor/textures/3d_armor_helmet_crystal.png:head
3d_armor/textures/3d_armor_chestplate_crystal.png:torso
3d_armor/textures/3d_armor_leggings_crystal.png:legs
3d_armor/textures/3d_armor_boots_crystal.png:feet
3d_armor/textures/3d_armor_helmet_admin.png:head
3d_armor/textures/3d_armor_chestplate_admin.png:torso
3d_armor/textures/3d_armor_leggings_admin.png:legs
3d_armor/textures/3d_armor_boots_admin.png:feet

25
mods/3d_armor-version-0.4.11/3d_armor/tools/updatepo.sh Normal file
View File

@ -0,0 +1,25 @@
#! /bin/bash
# To create a new translation:
# msginit --locale=ll_CC -o locale/ll_CC.po -i locale/template.pot
cd "$(dirname "${BASH_SOURCE[0]}")/..";
# Extract translatable strings.
xgettext --from-code=UTF-8 \
--language=Lua \
--sort-by-file \
--keyword=S \
--keyword=NS:1,2 \
--keyword=N_ \
--keyword=F \
--add-comments='Translators:' \
--add-location=file \
-o locale/template.pot \
$(find .. -name '*.lua')
# Update translations.
find locale -name '*.po' | while read -r file; do
echo $file
msgmerge --update $file locale/template.pot;
done

5
mods/3d_armor-version-0.4.11/3d_armor_ip/LICENSE.txt Normal file
View File

@ -0,0 +1,5 @@
[mod] 3d Armor integration to inventory plus [3d_armor_ip]
==========================================================
License Source Code: (C) 2012-2018 Stuart Jones - LGPL v2.1

2
mods/3d_armor-version-0.4.11/3d_armor_ip/depends.txt Normal file
View File

@ -0,0 +1,2 @@
3d_armor
inventory_plus?

1
mods/3d_armor-version-0.4.11/3d_armor_ip/description.txt Normal file
View File

@ -0,0 +1 @@
Adds 3d_armor page to the inventory plus

38
mods/3d_armor-version-0.4.11/3d_armor_ip/init.lua Normal file
View File

@ -0,0 +1,38 @@
-- support for i18n
local S = armor_i18n.gettext
local F = armor_i18n.fgettext
if not minetest.global_exists("inventory_plus") then
minetest.log("warning", S("3d_armor_ip: Mod loaded but unused."))
return
end
armor.formspec = "size[8,8.5]button[6,0;2,0.5;main;"..F("Back").."]"..armor.formspec
armor:register_on_update(function(player)
local name = player:get_player_name()
local formspec = armor:get_armor_formspec(name, true)
local page = player:get_inventory_formspec()
if page:find("detached:"..name.."_armor") then
inventory_plus.set_inventory_formspec(player, formspec)
end
end)
if minetest.get_modpath("crafting") then
inventory_plus.get_formspec = function(player, page)
end
end
minetest.register_on_joinplayer(function(player)
inventory_plus.register_button(player,"armor", S("Armor"))
end)
minetest.register_on_player_receive_fields(function(player, formname, fields)
if fields.armor then
local name = armor:get_valid_player(player, "[on_player_receive_fields]")
if not name then
return
end
local formspec = armor:get_armor_formspec(name, true)
inventory_plus.set_inventory_formspec(player, formspec)
end
end)

5
mods/3d_armor-version-0.4.11/3d_armor_sfinv/LICENSE.txt Normal file
View File

@ -0,0 +1,5 @@
[mod] 3d Armor sfinv integration [3d_armor_sfinv]
=================================================
License Source Code: (C) 2012-2018 Stuart Jones - LGPL v2.1

2
mods/3d_armor-version-0.4.11/3d_armor_sfinv/depends.txt Normal file
View File

@ -0,0 +1,2 @@
3d_armor
sfinv?

1
mods/3d_armor-version-0.4.11/3d_armor_sfinv/description.txt Normal file
View File

@ -0,0 +1 @@
Adds 3d_armor page to the sfinv inventory

21
mods/3d_armor-version-0.4.11/3d_armor_sfinv/init.lua Normal file
View File

@ -0,0 +1,21 @@
-- support for i18n
local S = armor_i18n.gettext
if not minetest.global_exists("sfinv") then
minetest.log("warning", S("3d_armor_sfinv: Mod loaded but unused."))
return
end
sfinv.register_page("3d_armor:armor", {
title = S("Armor"),
get = function(self, player, context)
local name = player:get_player_name()
local formspec = armor:get_armor_formspec(name, true)
return sfinv.make_formspec(player, context, formspec, false)
end
})
armor:register_on_update(function(player)
if sfinv.enabled then
sfinv.set_player_inventory_formspec(player)
end
end)

5
mods/3d_armor-version-0.4.11/3d_armor_ui/LICENSE.txt Normal file
View File

@ -0,0 +1,5 @@
[mod] 3d Armor integration to unified inventory [3d_armor_ui]
=============================================================
License Source Code: (C) 2012-2018 Stuart Jones - LGPL v2.1

2
mods/3d_armor-version-0.4.11/3d_armor_ui/depends.txt Normal file
View File

@ -0,0 +1,2 @@
3d_armor
unified_inventory?

1
mods/3d_armor-version-0.4.11/3d_armor_ui/description.txt Normal file
View File

@ -0,0 +1 @@
Adds 3d_armor page to the unified inventory

52
mods/3d_armor-version-0.4.11/3d_armor_ui/init.lua Normal file
View File

@ -0,0 +1,52 @@
-- support for i18n
local S = armor_i18n.gettext
local F = armor_i18n.fgettext
if not minetest.global_exists("unified_inventory") then
minetest.log("warning", S("3d_armor_ui: Mod loaded but unused."))
return
end
if unified_inventory.sfinv_compat_layer then
return
end
armor:register_on_update(function(player)
local name = player:get_player_name()
if unified_inventory.current_page[name] == "armor" then
unified_inventory.set_inventory_formspec(player, "armor")
end
end)
unified_inventory.register_button("armor", {
type = "image",
image = "inventory_plus_armor.png",
tooltip = S("3d Armor")
})
unified_inventory.register_page("armor", {
get_formspec = function(player, perplayer_formspec)
local fy = perplayer_formspec.formspec_y
local name = player:get_player_name()
if armor.def[name].init_time == 0 then
return {formspec="label[0,0;"..F("Armor not initialized!").."]"}
end
local formspec = "background[0.06,"..fy..";7.92,7.52;3d_armor_ui_form.png]"..
"label[0,0;"..F("Armor").."]"..
"list[detached:"..name.."_armor;armor;0,"..fy..";2,3;]"..
"image[2.5,"..(fy - 0.25)..";2,4;"..armor.textures[name].preview.."]"..
"label[5.0,"..(fy + 0.0)..";"..F("Level")..": "..armor.def[name].level.."]"..
"label[5.0,"..(fy + 0.5)..";"..F("Heal")..": "..armor.def[name].heal.."]"..
"listring[current_player;main]"..
"listring[detached:"..name.."_armor;armor]"
if armor.config.fire_protect then
formspec = formspec.."label[5.0,"..(fy + 1.0)..";"..
F("Fire")..": "..armor.def[name].fire.."]"
end
if minetest.global_exists("technic") then
formspec = formspec.."label[5.0,"..(fy + 1.5)..";"..
F("Radiation")..": "..armor.def[name].groups["radiation"].."]"
end
return {formspec=formspec}
end,
})

9
mods/3d_armor-version-0.4.11/LICENSE.md Normal file
View File

@ -0,0 +1,9 @@
3D Armor - Visible Player Armor
===============================
License Source Code: Copyright (C) 2013-2018 Stuart Jones - LGPL v2.1
Armor Textures: Copyright (C) 2017-2018 davidthecreator - CC-BY-SA 3.0
Special credit to Jordach and MirceaKitsune for providing the default 3d character model.

69
mods/3d_armor-version-0.4.11/README.md Normal file
View File

@ -0,0 +1,69 @@
Modpack - 3d Armor [0.4.11]
===========================
### Table of Contents
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
- [[mod] Visible Player Armor [3d_armor]](#mod-visible-player-armor-3d_armor)
- [[mod] Visible Wielded Items [wieldview]](#mod-visible-wielded-items-wieldview)
- [[mod] Shields [shields]](#mod-shields-shields)
- [[mod] 3d Armor Stand [3d_armor_stand]](#mod-3d-armor-stand-3d_armor_stand)
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
[mod] Visible Player Armor [3d_armor]
-------------------------------------
Minetest Version: 0.4.16
Game: minetest_game and many derivatives
Depends: default
Adds craftable armor that is visible to other players. Each armor item worn contributes to
a player's armor group level making them less vulnerable to attack.
Armor takes damage when a player is hurt, however, many armor items offer a 'stackable'
percentage chance of restoring the lost health points. Overall armor level is boosted by 10%
when wearing a full matching set (helmet, chestplate, leggings and boots of the same material)
Fire protection has been added by TenPlus1 and in use when ethereal mod is found and crystal
armor has been enabled. each piece of armor offers 1 fire protection, level 1 protects
against torches, level 2 against crystal spikes, 3 for fire and 5 protects when in lava.
Compatible with sfinv, inventory plus or unified inventory by enabling the appropriate
inventory module, [3d_armor_sfinv], [3d_armor_ip] and [3d_armor_ui] respectively.
Also compatible with [smart_inventory] without the need for additional modules.
built in support player skins [skins] by Zeg9 and Player Textures [player_textures] by PilzAdam
and [simple_skins] by TenPlus1.
Armor can be configured by adding a file called armor.conf in 3d_armor mod or world directory.
see armor.conf.example for all available options.
For mod installation instructions, please visit: http://wiki.minetest.com/wiki/Installing_Mods
[mod] Visible Wielded Items [wieldview]
---------------------------------------
Depends: 3d_armor
Makes hand wielded items visible to other players.
[mod] Shields [shields]
-----------------------
Depends: 3d_armor
Originally a part of 3d_armor, shields have been re-included as an optional extra.
If you do not want shields then simply remove the shields folder from the modpack.
[mod] 3d Armor Stand [3d_armor_stand]
-------------------------------------
Depends: 3d_armor
Adds a chest-like armor stand for armor storage and display.

1
mods/3d_armor-version-0.4.11/description.txt Normal file
View File

@ -0,0 +1 @@
Visible player armor & wielded items.

1
mods/3d_armor-version-0.4.11/modern_armor/depends.txt Normal file
View File

@ -0,0 +1 @@
3d_armor

151
mods/3d_armor-version-0.4.11/modern_armor/init.lua Normal file
View File

@ -0,0 +1,151 @@
--[[
modern_armor_loot =
{
"modern_armor_inv_helmet_biker", "modern_armor_inv_helmet_construction", "modern_armor_inv_helmet_military", "modern_armor_inv_helmet_swat",
"modern_armor_inv_vest_civilian", "modern_armor_inv_vest_military", "modern_armor_inv_vest_police", "modern_armor_inv_vest_swat"
}
--]]
local enable_craft = true
armor:register_armor("modern_armor:vest_civilian", {
description = ("Civilian Soft Armor"),
inventory_image = "modern_armor_inv_vest_civilian.png",
groups = {armor_torso=1, armor_heal=0, armor_use=800,
physics_speed=-0.04, physics_gravity=0.04},
armor_groups = {fleshy=7},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
armor:register_armor("modern_armor:vest_police", {
description = ("Police Soft Armor"),
inventory_image = "modern_armor_inv_vest_police.png",
groups = {armor_torso=1, armor_heal=0, armor_use=800,
physics_speed=-0.04, physics_gravity=0.04},
armor_groups = {fleshy=7},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
armor:register_armor("modern_armor:vest_swat", {
description = ("SWAT Plate Carrier"),
inventory_image = "modern_armor_inv_vest_swat.png",
groups = {armor_torso=1, armor_heal=0, armor_use=800,
physics_speed=-0.08, physics_gravity=0.08},
armor_groups = {fleshy=10},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
armor:register_armor("modern_armor:vest_military", {
description = ("Military Plate Carrier"),
inventory_image = "modern_armor_inv_vest_military.png",
groups = {armor_torso=1, armor_heal=0, armor_use=800,
physics_speed=-0.08, physics_gravity=0.08},
armor_groups = {fleshy=10},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
armor:register_armor("modern_armor:helmet_swat", {
description = ("SWAT Helmet"),
inventory_image = "modern_armor_inv_helmet_swat.png",
groups = {armor_head=1, armor_heal=0, armor_use=800},
armor_groups = {fleshy=5},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
armor:register_armor("modern_armor:helmet_military", {
description = ("Military Helmet"),
inventory_image = "modern_armor_inv_helmet_military.png",
groups = {armor_head=1, armor_heal=0, armor_use=800},
armor_groups = {fleshy=5},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
armor:register_armor("modern_armor:helmet_construction", {
description = ("Construction Helmet"),
inventory_image = "modern_armor_inv_helmet_construction.png",
groups = {armor_head=1, armor_heal=0, armor_use=800},
armor_groups = {fleshy=3},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
armor:register_armor("modern_armor:helmet_biker", {
description = ("Biker Helmet"),
inventory_image = "modern_armor_inv_helmet_biker.png",
groups = {armor_head=1, armor_heal=0, armor_use=800},
armor_groups = {fleshy=3},
damage_groups = {cracky=2, snappy=3, choppy=2, crumbly=1, level=2},
})
if enable_craft then
minetest.register_craftitem("modern_armor:kevlar", {
description = "Kevlar",
inventory_image = "modern_armor_kevlar.png",
})
minetest.register_craft({
output = "modern_armor:kevlar 4",
recipe = {
{"default:paper","group:wool","default:paper"},
{"group:wool","default:paper","group:wool"},
{"default:paper","group:wool","default:paper"}
}
})
minetest.register_craft({
output = "modern_armor:vest_civilian",
recipe = {
{"modern_armor:kevlar","","modern_armor:kevlar"},
{"modern_armor:kevlar","modern_armor:kevlar","modern_armor:kevlar"},
{"modern_armor:kevlar","modern_armor:kevlar","modern_armor:kevlar"}
}
})
minetest.register_craft({
output = "modern_armor:vest_police",
recipe = {
{"modern_armor:kevlar","default:gold_ingot","modern_armor:kevlar"},
{"modern_armor:kevlar","modern_armor:kevlar","modern_armor:kevlar"},
{"modern_armor:kevlar","modern_armor:kevlar","modern_armor:kevlar"}
}
})
minetest.register_craft({
output = "modern_armor:vest_swat",
recipe = {
{"modern_armor:kevlar","","modern_armor:kevlar"},
{"modern_armor:kevlar","technic:copper_plate","modern_armor:kevlar"},
{"modern_armor:kevlar","technic:copper_plate","modern_armor:kevlar"}
}
})
minetest.register_craft({
output = "modern_armor:vest_military",
recipe = {
{"modern_armor:kevlar","","modern_armor:kevlar"},
{"modern_armor:kevlar","technic:composite_plate","modern_armor:kevlar"},
{"modern_armor:kevlar","technic:composite_plate","modern_armor:kevlar"}
}
})
minetest.register_craft({
output = "modern_armor:helmet_swat",
recipe = {
{"modern_armor:kevlar","modern_armor:kevlar","modern_armor:kevlar"},
{"modern_armor:kevlar","default:glass","modern_armor:kevlar"},
{"default:steel_ingot","",""}
}
})
minetest.register_craft({
output = "modern_armor:helmet_military",
recipe = {
{"modern_armor:kevlar","modern_armor:kevlar","modern_armor:kevlar"},
{"modern_armor:kevlar","default:glass","modern_armor:kevlar"},
{"default:steel_ingot","dye:yellow",""}
}
})
minetest.register_craft({
output = "modern_armor:helmet_construction",
recipe = {
{"homedecor:plastic_sheeting","homedecor:plastic_sheeting","homedecor:plastic_sheeting"},
{"homedecor:plastic_sheeting","wool:yellow","homedecor:plastic_sheeting"}
}
})
minetest.register_craft({
output = "modern_armor:helmet_biker",
recipe = {
{"homedecor:plastic_sheeting","homedecor:plastic_sheeting","homedecor:plastic_sheeting"},
{"homedecor:plastic_sheeting","default:glass","homedecor:plastic_sheeting"},
{"homedecor:plastic_sheeting","wool:black","homedecor:plastic_sheeting"},
}
})
end

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_helmet_biker.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 319 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_helmet_biker_preview.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 204 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_helmet_construction.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 563 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_helmet_construction_preview.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 327 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_helmet_military.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.1 KiB

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_helmet_military_preview.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 349 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_helmet_swat.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.9 KiB

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_helmet_swat_preview.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 347 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_inv_helmet_biker.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 217 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_inv_helmet_construction.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 326 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_inv_helmet_military.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 391 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_inv_helmet_swat.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 380 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_inv_vest_civilian.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 292 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_inv_vest_military.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 273 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_inv_vest_police.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 308 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_inv_vest_swat.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 234 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_kevlar.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 441 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_vest_civilian.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 439 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_vest_civilian_preview.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 302 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_vest_military.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 396 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_vest_military_preview.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 287 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_vest_police.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 519 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_vest_police_preview.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 317 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_vest_swat.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 468 B

BIN
mods/3d_armor-version-0.4.11/modern_armor/textures/modern_armor_vest_swat_preview.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 243 B

0
mods/3d_armor-version-0.4.11/modpack.txt Normal file
View File

81
mods/3d_armor-version-0.4.11/preview_gen.py Normal file
View File

@ -0,0 +1,81 @@
#!/usr/bin/python
import os
import sys
import Image
try :
arg = sys.argv[1]
except IndexError :
print "Usage: preview_gen.py <index_file>"
sys.exit(1)
try :
index = open(arg, "r")
except IOError :
print "Failed to open index file%s" %s (arg)
sys.exit(1)
preview = []
for line in index.readlines() :
if ":" in line :
line = line.rstrip('\n')
preview.append(line.split(':'))
print "Generating preview images..."
for fn, place in preview :
try :
imi = Image.open(fn)
except IOError :
print "Failed to open %s" % (fn)
sys.exit(1)
w, h = imi.size
if h != w / 2:
print "Incompatible texture size %s" % (fn)
sys.exit(1)
s = w / 64
imo = Image.new("RGBA", (16 * s, 32 * s))
if place == "all" or place == "head" :
face = (40 * s, 8 * s, 48 * s, 16 * s)
side_l = (56 * s, 8 * s, 57 * s, 16 * s)
side_r = (63 * s, 8 * s, 64 * s, 16 * s)
imo.paste(imi.crop(side_l), (4 * s, 0, 5 * s, 8 * s))
imo.paste(imi.crop(side_r), (11 * s, 0, 12 * s, 8 * s))
imo.paste(imi.crop(face), (4 * s, 0, 12 * s, 8 * s))
if place == "all" or place == "torso" :
arm = (44 * s, 20 * s, 48 * s, 32 * s)
body = (20 * s, 20 * s, 28 * s, 32 * s)
imo.paste(imi.crop(arm), (0 * s, 8 * s, 4 * s, 20 * s))
imo.paste(imi.crop(arm).transpose(Image.FLIP_LEFT_RIGHT),
(12 * s, 8 * s, 16 * s, 20 * s))
imo.paste(imi.crop(body), (4 * s, 8 * s, 12 * s, 20 * s))
if place == "all" or place == "legs" :
leg = (4 * s, 20 * s, 8 * s, 32 * s)
imo.paste(imi.crop(leg), (4 * s, 20 * s, 8 * s, 32 * s))
imo.paste(imi.crop(leg).transpose(Image.FLIP_LEFT_RIGHT),
(8 * s, 20 * s, 12 * s, 32 * s))
if place == "all" or place == "feet" :
boot = (20 * s, 4 * s, 24 * s, 11 * s)
imo.paste(imi.crop(boot), (4 * s, 25 * s, 8 * s, 32 * s))
imo.paste(imi.crop(boot).transpose(Image.FLIP_LEFT_RIGHT),
(8 * s, 25 * s, 12 * s, 32 * s))
size = (32 * s, 64 * s)
imo = imo.resize(size)
if place == "shield" :
shield = (0, 0, 16 * s, 16 * s)
imo.paste(imi.crop(shield), (16 * s, 32 * s, 32 * s, 48 * s))
outfile = fn.replace(".png", "_preview.png")
imo.save(outfile)
print outfile

BIN
mods/3d_armor-version-0.4.11/screenshot.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 145 KiB

5
mods/3d_armor-version-0.4.11/wieldview/LICENSE.txt Normal file
View File

@ -0,0 +1,5 @@
[mod] visible wielded items [wieldview]
=======================================
License Source Code: Copyright (C) 2013-2018 Stuart Jones - LGPL v2.1

23
mods/3d_armor-version-0.4.11/wieldview/README.txt Normal file
View File

@ -0,0 +1,23 @@
[mod] visible wielded items [wieldview]
=======================================
Depends on: 3d_armor
Makes hand wielded items visible to other players.
default settings: [minetest.conf]
# Set number of seconds between visible wielded item updates.
wieldview_update_time = 2
# Show nodes as tiles, disabled by default
wieldview_node_tiles = false
Info for modders
################
Wield image transformation: To apply a simple transformation to the item in
hand, add the group “wieldview_transform” to the item definition. The group
rating equals one of the numbers used for the [transform texture modifier
of the Lua API.

1
mods/3d_armor-version-0.4.11/wieldview/depends.txt Normal file
View File

@ -0,0 +1 @@
3d_armor

1
mods/3d_armor-version-0.4.11/wieldview/description.txt Normal file
View File

@ -0,0 +1 @@
Makes hand wielded items visible to other players.

83
mods/3d_armor-version-0.4.11/wieldview/init.lua Normal file
View File

@ -0,0 +1,83 @@
local time = 0
local update_time = tonumber(minetest.settings:get("wieldview_update_time"))
if not update_time then
update_time = 2
minetest.settings:set("wieldview_update_time", tostring(update_time))
end
local node_tiles = minetest.settings:get_bool("wieldview_node_tiles")
if not node_tiles then
node_tiles = false
minetest.settings:set("wieldview_node_tiles", "false")
end
wieldview = {
wielded_item = {},
transform = {},
}
dofile(minetest.get_modpath(minetest.get_current_modname()).."/transform.lua")
wieldview.get_item_texture = function(self, item)
local texture = "3d_armor_trans.png"
if item ~= "" then
if minetest.registered_items[item] then
if minetest.registered_items[item].inventory_image ~= "" then
texture = minetest.registered_items[item].inventory_image
elseif node_tiles == true and minetest.registered_items[item].tiles
and type(minetest.registered_items[item].tiles[1]) == "string"
and minetest.registered_items[item].tiles[1] ~= "" then
texture = minetest.inventorycube(minetest.registered_items[item].tiles[1])
end
end
-- Get item image transformation, first from group, then from transform.lua
local transform = minetest.get_item_group(item, "wieldview_transform")
if transform == 0 then
transform = wieldview.transform[item]
end
if transform then
-- This actually works with groups ratings because transform1, transform2, etc.
-- have meaning and transform0 is used for identidy, so it can be ignored
texture = texture.."^[transform"..tostring(transform)
end
end
return texture
end
wieldview.update_wielded_item = function(self, player)
if not player then
return
end
local name = player:get_player_name()
local stack = player:get_wielded_item()
local item = stack:get_name()
if not item then
return
end
if self.wielded_item[name] then
if self.wielded_item[name] == item then
return
end
armor.textures[name].wielditem = self:get_item_texture(item)
armor:update_player_visuals(player)
end
self.wielded_item[name] = item
end
minetest.register_on_joinplayer(function(player)
local name = player:get_player_name()
wieldview.wielded_item[name] = ""
minetest.after(0, function(player)
wieldview:update_wielded_item(player)
end, player)
end)
minetest.register_globalstep(function(dtime)
time = time + dtime
if time > update_time then
for _,player in ipairs(minetest.get_connected_players()) do
wieldview:update_wielded_item(player)
end
time = 0
end
end)

24
mods/3d_armor-version-0.4.11/wieldview/transform.lua Normal file
View File

@ -0,0 +1,24 @@
-- Wielded Item Transformations - http://dev.minetest.net/texture
wieldview.transform = {
["default:torch"]="R270",
["default:sapling"]="R270",
["flowers:dandelion_white"]="R270",
["flowers:dandelion_yellow"]="R270",
["flowers:geranium"]="R270",
["flowers:rose"]="R270",
["flowers:tulip"]="R270",
["flowers:viola"]="R270",
["bucket:bucket_empty"]="R270",
["bucket:bucket_water"]="R270",
["bucket:bucket_lava"]="R270",
["screwdriver:screwdriver"]="R270",
["screwdriver:screwdriver1"]="R270",
["screwdriver:screwdriver2"]="R270",
["screwdriver:screwdriver3"]="R270",
["screwdriver:screwdriver4"]="R270",
["vessels:glass_bottle"]="R270",
["vessels:drinking_glass"]="R270",
["vessels:steel_bottle"]="R270",
}

2
mods/WorldEdit-1.2/.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
*~

465
mods/WorldEdit-1.2/ChatCommands.md Normal file
View File

@ -0,0 +1,465 @@
Chat Commands
-------------
For more information, see the [README](README.md).
Many commands also have shorter names that can be typed faster. For example, if we wanted to use `//move ? 5`, we could instead type `//m ? 5`. All shortened names are listed below:
| Short Name | Original Name |
|:-----------|:-------------------|
| `//i` | `//inspect` |
| `//rst` | `//reset` |
| `//mk` | `//mark` |
| `//umk` | `//unmark` |
| `//1` | `//pos1` |
| `//2` | `//pos2` |
| `//fp` | `//fixedpos` |
| `//v` | `//volume` |
| `//s` | `//set` |
| `//r` | `//replace` |
| `//ri` | `//replaceinverse` |
| `//hcube` | `//hollowcube` |
| `//hspr` | `//hollowsphere` |
| `//spr` | `//sphere` |
| `//hdo` | `//hollowdome` |
| `//do` | `//dome` |
| `//hcyl` | `//hollowcylinder` |
| `//cyl` | `//cylinder` |
| `//hpyr` | `//hollowpyramid` |
| `//pyr` | `//pyramid` |
### `//about`
Get information about the mod.
//about
### `//inspect on/off/1/0/true/false/yes/no/enable/disable/<blank>`
Enable or disable node inspection.
//inspect on
//inspect off
//inspect 1
//inspect 0
//inspect true
//inspect false
//inspect yes
//inspect no
//inspect enable
//inspect disable
//inspect
### `//reset`
Reset the region so that it is empty.
//reset
### `//mark`
Show markers at the region positions.
//mark
### `//unmark`
Hide markers if currently shown.
//unmark
### `//pos1`
Set WorldEdit region position 1 to the player's location.
//pos1
### `//pos2`
Set WorldEdit region position 2 to the player's location.
//pos2
### `//p set/set1/set2/get`
Set WorldEdit region, WorldEdit position 1, or WorldEdit position 2 by punching nodes, or display the current WorldEdit region.
//p set
//p set1
//p set2
//p get
### `//fixedpos set1 x y z`
Set a WorldEdit region position to the position at (`<x>`, `<y>`, `<z>`).
//fixedpos set1 0 0 0
//fixedpos set1 -30 5 28
//fixedpos set2 1004 -200 432
### `//volume`
Display the volume of the current WorldEdit region.
//volume
### `//deleteblocks`
Delete the MapBlocks (16x16x16 units) that contain the selected region. This means that mapgen will be invoked for that area. As only whole MapBlocks get removed, the deleted area is usually larger than the selected one. Also, mapgen can trigger mechanisms like mud reflow or cavegen, which affects nodes (up to 112 nodes away) outside the MapBlock, so dont use this near buildings. Note that active entities are not part of a MapBlock and do not get deleted.
//deleteblocks
### `//set <node>`
Set the current WorldEdit region to `<node>`.
//set air
//set cactus
//set Blue Lightstone
//set dirt with grass
### `//param2 <param2>`
Set the param2 value of all nodes in the current WorldEdit region to `<param2>`.
### `//mix <node1> ...`
Fill the current WorldEdit region with a random mix of `<node1>`, `...`.
//mix air
//mix cactus stone glass sandstone
//mix Bronze
//mix default:cobble air
### `//replace <search node> <replace node>`
Replace all instances of `<search node>` with `<replace node>` in the current WorldEdit region.
//replace Cobblestone air
//replace lightstone_blue glass
//replace dirt Bronze Block
//replace mesecons:wire_00000000_off flowers:flower_tulip
### `//replaceinverse <search node> <replace node>`
Replace all nodes other than `<search node>` with `<replace node>` in the current WorldEdit region.
//replaceinverse Cobblestone air
//replaceinverse flowers:flower_waterlily glass
//replaceinverse dirt Bronze Block
//replaceinverse mesecons:wire_00000000_off flowers:flower_tulip
### `//hollowcube <width> <height> <length> <node>`
Adds a hollow cube with its ground level centered at WorldEdit position 1 with dimensions `<width>` x `<height>` x `<length>`, composed of `<node>`.
//hollowcube 6 5 6 Diamond Block
### `//cube <width> <height> <length> <node>`
Adds a cube with its ground level centered at WorldEdit position 1 with dimensions `<width>` x `<height>` x `<length>`, composed of `<node>`.
//cube 6 5 6 Diamond Block
//cube 7 2 1 default:cobble
### `//hollowsphere <radius> <node>`
Add hollow sphere centered at WorldEdit position 1 with radius `<radius>`, composed of `<node>`.
//hollowsphere 5 Diamond Block
//hollowsphere 12 glass
//hollowsphere 17 mesecons:wire_00000000_off
### `//sphere <radius> <node>`
Add sphere centered at WorldEdit position 1 with radius `<radius>`, composed of `<node>`.
//sphere 5 Diamond Block
//sphere 12 glass
//sphere 17 mesecons:wire_00000000_off
### `//hollowdome <radius> <node>`
Add hollow dome centered at WorldEdit position 1 with radius `<radius>`, composed of `<node>`.
//hollowdome 5 Diamond Block
//hollowdome -12 glass
//hollowdome 17 mesecons:wire_00000000_off
### `//dome <radius> <node>`
Add dome centered at WorldEdit position 1 with radius `<radius>`, composed of `<node>`.
//dome 5 Diamond Block
//dome -12 glass
//dome 17 mesecons:wire_00000000_off
### `//hollowcylinder x/y/z/? <length> <radius1> [radius2] <node>`
Add hollow cylinder at WorldEdit position 1 along the x/y/z/? axis with length `<length>`, base radius `<radius1>` (and top radius `[radius2]`), composed of `<node>`.
Despite its name this command allows you to create cones (`radius2` = 0) as well as any shapes inbetween (0 < `radius2` < `radius1`).
Swapping `radius1` and `radius2` will create the same object but upside-down.
//hollowcylinder x +5 8 Bronze Block
//hollowcylinder y 28 10 glass
//hollowcylinder z -12 3 mesecons:wire_00000000_off
//hollowcylinder ? 2 4 default:stone
//hollowcylinder y 10 10 0 walls:cobble
//hollowcylinder x 6 0 5 Dirt
//hollowcylinder z 20 10 20 default:desert_stone
### `//cylinder x/y/z/? <length> <radius1> [radius2] <node>`
Add cylinder at WorldEdit position 1 along the x/y/z/? axis with length `<length>`, base radius `<radius1>` (and top radius `[radius2]`), composed of `<node>`.
Can also create shapes other than cylinders, e.g. cones (see documentation above).
//cylinder x +5 8 Bronze Block
//cylinder y 28 10 glass
//cylinder z -12 3 mesecons:wire_00000000_off
//cylinder ? 2 4 default:stone
//cylinder y 10 10 0 walls:cobble
//cylinder x 6 0 5 Dirt
//cylinder z 20 10 20 default:desert_stone
### `//hollowpyramid x/y/z? <height> <node>`
Add hollow pyramid centered at WorldEdit position 1 along the x/y/z/? axis with height `<height>`, composed of `<node>`.
//hollowpyramid x 8 Diamond Block
//hollowpyramid y -5 glass
//hollowpyramid z 2 mesecons:wire_00000000_off
//hollowpyramid ? 12 mesecons:wire_00000000_off
### `//pyramid x/y/z? <height> <node>`
Add pyramid centered at WorldEdit position 1 along the x/y/z/? axis with height `<height>`, composed of `<node>`.
//pyramid x 8 Diamond Block
//pyramid y -5 glass
//pyramid z 2 mesecons:wire_00000000_off
//pyramid ? 12 mesecons:wire_00000000_off
### `//spiral <length> <height> <spacer> <node>`
Add spiral centered at WorldEdit position 1 with side length `<length>`, height `<height>`, space between walls `<spacer>`, composed of `<node>`.
//spiral 20 5 3 Diamond Block
//spiral 5 2 1 glass
//spiral 7 1 5 mesecons:wire_00000000_off
### `//copy x/y/z/? <amount>`
Copy the current WorldEdit region along the x/y/z/? axis by `<amount>` nodes.
//copy x 15
//copy y -7
//copy z +4
//copy ? 8
### `//move x/y/z/? <amount>`
Move the current WorldEdit positions and region along the x/y/z/? axis by `<amount>` nodes.
//move x 15
//move y -7
//move z +4
//move ? -1
### `//stack x/y/z/? <count>`
Stack the current WorldEdit region along the x/y/z/? axis `<count>` times.
//stack x 3
//stack y -1
//stack z +5
//stack ? 12
### `//stack2 <count> <x> <y> <z>`
Stack the current WorldEdit region `<count>` times by offset `<x>`, `<y>`, `<z>`.
//stack2 5 3 8 2
//stack2 1 -1 -1 -1
### `//scale <factor>`
Scale the current WorldEdit positions and region by a factor of positive integer `<factor>` with position 1 as the origin.
//scale 2
//scale 1
//scale 10
### `//transpose x/y/z/? x/y/z/?`
Transpose the current WorldEdit positions and region along the x/y/z/? and x/y/z/? axes.
//transpose x y
//transpose x z
//transpose y z
//transpose ? y
### `//flip x/y/z/?`
Flip the current WorldEdit region along the x/y/z/? axis.
//flip x
//flip y
//flip z
//flip ?
### `//rotate x/y/z/? <angle>`
Rotate the current WorldEdit positions and region along the x/y/z/? axis by angle `<angle>` (90 degree increment).
//rotate x 90
//rotate y 180
//rotate z 270
//rotate ? -90
### `//orient <angle>`
Rotate oriented nodes in the current WorldEdit region around the Y axis by angle `<angle>` (90 degree increment)
//orient 90
//orient 180
//orient 270
//orient -90
### `//fixlight`
Fixes the lighting in the current WorldEdit region.
//fixlight
### `//drain`
Removes any fluid node within the current WorldEdit region.
//drain
### `//hide`
Hide all nodes in the current WorldEdit region non-destructively.
//hide
### `//suppress <node>`
Suppress all <node> in the current WorldEdit region non-destructively.
//suppress Diamond Block
//suppress glass
//suppress mesecons:wire_00000000_off
### `//highlight <node>`
Highlight <node> in the current WorldEdit region by hiding everything else non-destructively.
//highlight Diamond Block
//highlight glass
//highlight mesecons:wire_00000000_off
### `//restore`
Restores nodes hidden with WorldEdit in the current WorldEdit region.
//restore
### `//save <file>`
Save the current WorldEdit region to "(world folder)/schems/`<file>`.we".
//save some random filename
//save huge_base
### `//allocate <file>`
Set the region defined by nodes from "(world folder)/schems/`<file>`.we" as the current WorldEdit region.
//allocate some random filename
//allocate huge_base
### `//load <file>`
Load nodes from "(world folder)/schems/`<file>`.we" with position 1 of the current WorldEdit region as the origin.
//load some random filename
//load huge_base
### `//lua <code>`
Executes `<code>` as a Lua chunk in the global namespace.
//lua worldedit.pos1["singleplayer"] = {x=0, y=0, z=0}
//lua worldedit.rotate(worldedit.pos1["singleplayer"], worldedit.pos2["singleplayer"], "y", 90)
### `//luatransform <code>`
Executes `<code>` as a Lua chunk in the global namespace with the variable pos available, for each node in the current WorldEdit region.
//luatransform minetest.add_node(pos, {name="default:stone"})
//luatransform if minetest.get_node(pos).name == "air" then minetest.add_node(pos, {name="default:water_source"})
### `//mtschemcreate <file>`
Save the current WorldEdit region using the Minetest Schematic format to "(world folder)/schems/`<file>`.mts".
//mtschemcreate some random filename
//mtschemcreate huge_base
### `//mtschemplace <file>`
Load nodes from "(world folder)/schems/`<file>`.mts" with position 1 of the current WorldEdit region as the origin.
//mtschemplace some random filename
//mtschemplace huge_base
### `//mtschemprob start/finish/get`
After using `//mtschemprob start` all nodes punched will bring up a text field where a probablity can be entered.
This mode can be left with `//mtschemprob finish`. `//mtschemprob get` will display the probabilities saved for the nodes.
//mtschemprob get
### `//clearobjects`
Clears all objects within the WorldEdit region.
//clearobjects
### `//shift x/y/z/?/up/down/left/right/front/back [+|-]<amount>`
Shifts the selection area by `[+|-]<amount>` without touching its contents. The shifting axis can be absolute (`x/y/z`) or
relative (`up/down/left/right/front/back`).
//shift left 5
### `//expand [+|-]x/y/z/?/up/down/left/right/front/back <amount> [reverse-amount]`
Expands the selection by `<amount>` in the selected absolute or relative axis. If specified, the selection can be expanded in the
opposite direction over the same axis by `[reverse-amount]`.
//expand right 7 5
### `//contract [+|-]x/y/z/?/up/down/left/right/front/back <amount> [reverse-amount]`
Contracts the selection by `<amount>` in the selected absolute or relative axis. If specified, the selection can be contracted in the
opposite direction over the same axis by `[reverse-amount]`.
//expand right 7 5
### `//outset [hv] <amount>`
Expands the selection in all directions by `<amount>`. If specified, the selection can be expanded horizontally in the x and z axes `[h]`
or vertically in the y axis `[v]`.
//outset v 5
### `//inset [hv] <amount>`
Contracts the selection in all directions by `<amount>`. If specified, the selection can be contracted horizontally in the x and z axes `[h]`
or vertically in the y axis `[v]`.
//outset v 5

661
mods/WorldEdit-1.2/LICENSE.txt Normal file
View File

@ -0,0 +1,661 @@
GNU AFFERO GENERAL PUBLIC LICENSE
Version 3, 19 November 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU Affero General Public License is a free, copyleft license for
software and other kinds of works, specifically designed to ensure
cooperation with the community in the case of network server software.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
our General Public Licenses are intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
Developers that use our General Public Licenses protect your rights
with two steps: (1) assert copyright on the software, and (2) offer
you this License which gives you legal permission to copy, distribute
and/or modify the software.
A secondary benefit of defending all users' freedom is that
improvements made in alternate versions of the program, if they
receive widespread use, become available for other developers to
incorporate. Many developers of free software are heartened and
encouraged by the resulting cooperation. However, in the case of
software used on network servers, this result may fail to come about.
The GNU General Public License permits making a modified version and
letting the public access it on a server without ever releasing its
source code to the public.
The GNU Affero General Public License is designed specifically to
ensure that, in such cases, the modified source code becomes available
to the community. It requires the operator of a network server to
provide the source code of the modified version running there to the
users of that server. Therefore, public use of a modified version, on
a publicly accessible server, gives the public access to the source
code of the modified version.
An older license, called the Affero General Public License and
published by Affero, was designed to accomplish similar goals. This is
a different license, not a version of the Affero GPL, but Affero has
released a new version of the Affero GPL which permits relicensing under
this license.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU Affero General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Remote Network Interaction; Use with the GNU General Public License.
Notwithstanding any other provision of this License, if you modify the
Program, your modified version must prominently offer all users
interacting with it remotely through a computer network (if your version
supports such interaction) an opportunity to receive the Corresponding
Source of your version by providing access to the Corresponding Source
from a network server at no charge, through some standard or customary
means of facilitating copying of software. This Corresponding Source
shall include the Corresponding Source for any work covered by version 3
of the GNU General Public License that is incorporated pursuant to the
following paragraph.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the work with which it is combined will remain governed by version
3 of the GNU General Public License.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU Affero General Public License from time to time. Such new versions
will be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU Affero General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU Affero General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU Affero General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If your software can interact with users remotely through a computer
network, you should also make sure that it provides a way for users to
get its source. For example, if your program is a web application, its
interface could display a "Source" link that leads users to an archive
of the code. There are many ways you could offer source, and different
solutions will be better for different programs; see section 13 for the
specific requirements.
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU AGPL, see
<http://www.gnu.org/licenses/>.

161
mods/WorldEdit-1.2/README.md Normal file
View File

@ -0,0 +1,161 @@
WorldEdit v1.2
==============
The ultimate in-game world editing tool for [Minetest](http://minetest.net/)! Tons of functionality to help with building, fixing, and more.
For more information, see the [forum topic](https://forum.minetest.net/viewtopic.php?id=572) at the Minetest forums.
# New users should see the [tutorial](Tutorial.md).
![Screenshot](http://i.imgur.com/lwhodrv.png)
Installing
----------
If you are using Windows, consider installing this mod using [MODSTER](https://forum.minetest.net/viewtopic.php?id=6497), a super simple mod installer that will take care of everything for you. If you are using MODSTER, skip directly to step 6 in the instructions below.
There is a nice installation guide over at the [Minetest Wiki](http://wiki.minetest.com/wiki/Installing_mods). Here is a short summary:
1. Download the mod from the [official releases page](https://github.com/Uberi/Minetest-WorldEdit/releases). The download links are labelled "Source Code". If you are using Windows, you will probably want to download the ZIP version.
2. You should have a file named `SOMETHING.zip` or `SOMETHING.tar.gz`.
3. Extract this file using your archiver of choice. If you are using Windows, open the ZIP file and move the folder inside to a safe place outside of the ZIP file.
4. Make sure that you now have a folder with a file named README.md inside it. If you just have another folder inside this folder, use this nested folder instead.
5. Move this folder into the `MINETEST_FOLDER/mods` folder, where `MINETEST_FOLDER` is the folder Minetest is located in.
6. Open Minetest to a world selection screen.
7. Select a world you want to use WorldEdit in by left clicking on it once, and press the **Configure** button.
8. You should have a mod selection screen. Select the one named something like `Minetest-WorldEdit` by left clicking once and press the **Enable MP** button.
9. Press the **Save** button. You can now use WorldEdit in that world. Repeat steps 7 to 9 to enable WorldEdit for other worlds too.
If you are having trouble, try asking for help in the [IRC channel](http://webchat.freenode.net/?channels=#minetest) (faster but may not always have helpers online) or ask on the [forum topic](https://forum.minetest.net/viewtopic.php?id=572) (slower but more likely to get help).
Usage
-----
WorldEdit works primarily through the WorldEdit GUI and chat commands. Depending on your key bindings, you can invoke chat entry with the "t" key, and open the chat console with the "F10" key.
WorldEdit has a huge potential for abuse by untrusted players. Therefore, users will not be able to use WorldEdit unless they have the `worldedit` privelege. This is available by default in single player, but in multiplayer the permission must be explicitly given by someone with the right credentials, using the follwoing chat command: `/grant <player name> worldedit`. This privelege can later be removed using the following chat command: `/revoke <player name> worldedit`.
Certain functions/commands such as WorldEdit `//lua` and `//luatransform` chat commands additionally require the `server` privilege. This is because it is extremely dangerous to give access to these commands to untrusted players, since they essentially are able to control the computer the server is running on. Give this privilege only to people you trust with your computer.
For in-game information about these commands, type `/help <command name>` in the chat. For example, to learn more about the `//copy` command, simply type `/help /copy` to display information relevant to copying a region.
Interface
---------
WorldEdit is accessed in-game in two main ways.
The GUI adds a screen to each player's inventory that gives access to various WorldEdit functions. The [tutorial](Tutorial.md) and the [Chat Commands Reference](ChatCommands.md) may be helpful in learning to use it.
The chat interface adds many chat commands that perform various WorldEdit powered tasks. It is documented in the [Chat Commands Reference](ChatCommands.md).
Compatibility
-------------
This mod supports Minetest versions 0.4.8 and newer. Older versions of WorldEdit may work with older versions of Minetest, but are not recommended or supported.
WorldEdit works quite well with other mods, and does not have any known mod conflicts.
WorldEdit GUI requires one of [sfinv](https://github.com/minetest/minetest_game/tree/master/mods/sfinv) (included in minetest_game since 0.4.15), [Unified Inventory](https://forum.minetest.net/viewtopic.php?id=3933) or [Inventory++](https://forum.minetest.net/viewtopic.php?id=6204).
If you use any other inventory manager mods, note that they may conflict with the WorldEdit GUI. If this is the case, it may be necessary to disable them.
WorldEdit API
-------------
WorldEdit exposes all significant functionality in a simple Lua interface.
Adding WorldEdit to the file "depends.txt" in your mod gives you access to all of the `worldedit` functions. The API is useful for tasks such as high-performance node manipulation, alternative interfaces, and map creation.
AGPLv3 compatible mods may further include WorldEdit files in their own mods. This may be useful if a modder wishes to completely avoid any dependencies on WorldEdit. Note that it is required to give credit to the authors.
This API is documented in the [WorldEdit API Reference](WorldEdit%20API.md).
Axes
----
The coordinate system is the same as that used by Minetest; positive Y is upwards, positive X is rightwards, and positive Z is forwards, if a player is facing North (positive Z axis).
When an axis is specified in a WorldEdit chat command, it is specified as one of the following values: `x`, `y`, `z`, or `?`.
In the GUI, there is a dropdown menu for this purpose. The "Look direction" option has the same effect as `?` does in chat commands.
The value `?` represents the axis the player is currently facing. If the player is facing more than one axis, the axis the player face direction is closest to will be used.
Nodes
-----
Node names are required for many types of commands that identify or modify specific types of nodes. They can be specified in a number of ways.
First, by description - the tooltip that appears when hovering over the item in an inventory. This is case insensitive and includes values such as "Cobblestone" and "bronze block". Note that certain commands (namely, `//replace` and `//replaceinverse`) do not support descriptions that contain spaces in the `<searchnode>` field.
Second, by name - the node name that is defined by code, but without the mod name prefix. This is case sensitive and includes values such as "piston_normal_off" and "cactus". Nodes defined in the `default` mod always take precedence over other nodes when searching for the correct one, and if there are multiple possible nodes (such as "a:celery" and "b:celery"), one is chosen in no particular order.
Finally, by full name - the unambiguous identifier of the node, prefixes and all. This is case sensitive and includes values such as "default:stone" and "mesecons:wire_00000000_off".
The node name "air" can be used anywhere a normal node name can, and acts as a blank node. This is useful for clearing or removing nodes. For example, `//set air` would remove all the nodes in the current WorldEdit region. Similarly, `//sphere 10 air`, when WorldEdit position 1 underground, would dig a large sphere out of the ground.
Regions
-------
Most WorldEdit commands operate on regions. Regions are a set of two positions that define a 3D cuboid. They are local to each player and chat commands affect only the region for the player giving the commands.
Each positions together define two opposing corners of the cube. With two opposing corners it is possible to determine both the location and dimensions of the region.
Regions are not saved between server restarts. They start off as empty regions, and cannot be used with most WorldEdit commands until they are set to valid values.
Markers
-------
Entities are used to mark the location of the WorldEdit regions. They appear as boxes containing the number 1 or 2, and represent position 1 and 2 of the WorldEdit region, respectively.
To remove the entities, simply punch them. This does not reset the positions themselves.
Schematics
----------
WorldEdit supports two different types of schematics.
The first is the WorldEdit Schematic format, with the file extension ".we", and in some older versions, ".wem". There have been several previous versions of the WorldEdit Schematic format, but WorldEdit is capable of loading any past versions, and will always support them - there is no need to worry about schematics becoming obselete.
As of version 5, WorldEdit schematics include a header. The header is seperated from the content by a colon (`:`). It contains fields seperated by commas (`,`). Currently only one field is used, which contains the version in ASCII decimal.
The current version of the WorldEdit Schematic format is essentially an array of node data tables in Lua 5.1 table syntax preceded by a header.
Specifically it looks like this:
5:return {
{
y = <y-axis coordinate>,
x = <x-axis coordinate>,
z = <z-axis coordinate>,
name = <node name>,
param1 = <param1 value>,
param2 = <param2 value>,
meta = <metadata table>,
},
<...>
}
The ordering of the values and minor aspects of the syntax, such as trailing commas or newlines, are not guaranteed to stay the same in future versions.
The WorldEdit Schematic format is accessed via the WorldEdit API, or WorldEdit serialization chat commands such as `//serialize` and `//deserialize`.
The second is the Minetest Schematic format (MTS). The details of this format may be found in the Minetest documentation and are out of the scope of this document. Access to this format is done via specialized MTS commands such as `//mtschemcreate` and `//mtschemplace`.
Authors
-------
WorldEdit would not be possible without the contributions of many developers and designers. Below, they are listed alphabetically:
cheapie
cornernote
cyisfor
danierukun
electricface
est31
kaeza
khonkhortisan
pickardjoe
Sebastien Ponce
sfan5
ShadowNinja
spillz
Uberi/Temperest
License
-------
Copyright 2013 sfan5, Anthony Zhang (Uberi/Temperest), and Brett O'Donnell (cornernote).
This mod is licensed under the [GNU Affero General Public License](http://www.gnu.org/licenses/agpl-3.0.html).
Basically, this means everyone is free to use, modify, and distribute the files, as long as these modifications are also licensed the same way.
Most importantly, the Affero variant of the GPL requires you to publish your modifications in source form, even if the mod is run only on the server, and not distributed.

120
mods/WorldEdit-1.2/Tutorial.md Normal file
View File

@ -0,0 +1,120 @@
WorldEdit Tutorial
==================
This is a step-by-step tutorial outlining the basic usage of WorldEdit. For more information, see the [README](README.md).
Let's start with a few assumptions:
* You have a compatible version of Minetest working.
* See the [README](README.md) for compatibility information.
* You have WorldEdit installed as a mod.
* If using Windows, [MODSTER](https://forum.minetest.net/viewtopic.php?pid=101463) makes installing mods totally painless.
* Simply download the file, extract the archive, and move it to the correct mod folder for Minetest.
* See the installation instructions in [README](README.md) if you need more details.
* You are familiar with the basics of the game.
* How to walk, jump, and climb.
* How to dig, place, and punch blocks.
* One of the following:
* How to type into the chat and read text from it.
* How to open the inventory screen and press buttons on it.
Overview
--------
WorldEdit has a "region", which is simply a cuboid area defined by two markers, both of which the player can move around. Every player can have their own region with their own two markers.
WorldEdit GUI buttons and chat commands generally work inside the region selected, or around the first marker.
If you are using the chat commands, follow the steps under **Chat Commands**. If you are using the WorldEdit GUI, follow the steps under **WorldEdit GUI**.
Step 1: Selecting a region
--------------------------
### Chat Commands
In the chat prompt, enter `//p set`. In the chat, you are prompted to punch two nodes to set the positions of the two markers.
Punch a nearby node. Be careful of breakable ones such as torches. A black cube reading "1" will appear around the node. This is the marker for WorldEdit position 1.
Walk away from the node you just punched. Now, punch another node. A black cube reading "2" will appear around the node. This is the marker for WorldEdit position 2.
### WorldEdit GUI
Open the main WorldEdit GUI from your inventory screen. The icon looks like a globe with a red dot in the center.
Press the "Get/Set Positions" button. On the new screen, press the "Set Position 1" button. The inventory screen should close.
Punch a nearby node. Be careful of breakable ones such as torches. A black cube reading "1" will appear around the node. This is the marker for WorldEdit position 1.
Walk away from the node you just punched. Open your inventory again. It should be on the same page as it was before.
Press the "Set Position 2" button. The inventory screen should close.
Now, punch another node. A black cube reading "2" will appear around the node. This is the marker for WorldEdit position 2.
Step 2: Region commands
-----------------------
### Chat Commands
In the chat prompt, enter `//set mese`. In the chat, you will see a message showing the number of nodes set after a small delay.
Look at the place between the two markers: it is now filled with MESE blocks!
The `//set <node>` command fills the region with whatever node you want. It is a region-oriented command, which means it works inside the WorldEdit region only.
Now, try a few different variations, such as `//set torch`, `//set cobble`, and `//set water`.
### WorldEdit GUI
Open the main WorldEdit GUI from your inventory screen.
Press the "Set Nodes" button. You should see a new screen with various options for setting nodes.
Enter "mese" in the "Name" field. Press Search if you would like to see what the node you just entered looks like.
Press the "Set Nodes" button on this screen. In the chat, you will see a message showing the number of nodes set after a small delay.
Look at the place between the two markers: it is now filled with MESE blocks!
The "Set Nodes" function fills the region with whatever node you want. It is a region-oriented command, which means it works inside the WorldEdit region only.
Now, try a few different variations on the node name, such as "torch", "cobble", and "water".
Step 3: Position commands
-------------------------
### Chat Commands
In the chat prompt, enter `//hollowdome 30 glass`. In the chat, you will see a message showing the number of nodes set after a small delay.
Look around marker 1: it is now surrounded by a hollow glass dome!
The `//hollowdome <radius> <node>` command creates a hollow dome centered around marker 1, made of any node you want. It is a position-oriented command, which means it works around marker 1 and can go outside the WorldEdit region.
### WorldEdit GUI
Open the main WorldEdit GUI from your inventory screen.
Press the "Sphere/Dome" button. You should see a new screen with various options for making spheres or domes.
Enter "glass" in the "Name" field. Press Search if you would like to see what the node you just entered looks like.
Enter "30" in the "Radius" field.
Press the "Hollow Dome" button on this screen. In the chat, you will see a message showing the number of nodes added after a small delay.
Look around marker 1: it is now surrounded by a hollow glass dome!
The "Hollow Dome" function creates a hollow dome centered around marker 1, made of any node you want. It is a position-oriented command, which means it works around marker 1 and can go outside the WorldEdit region.
Step 4: Other commands
----------------------
### Chat Commands
There are many more commands than what is shown here. See the [Chat Commands Reference](ChatCommands.md) for a detailed list of them, along with descriptions and examples for every single one.
If you're in-game and forgot how a command works, just use the `/help <command name>` command, without the first forward slash. For example, to see some information about the `//set <node>` command mentioned earlier, simply use `/help /set`.
A very useful command to check out is the `//save <schematic>` command, which can save everything inside the WorldEdit region to a file, stored on the computer hosting the server (the player's computer, in single player mode). You can then later use `//load <schematic>` to load the data in a file into a world, even another world on another computer.
### WorldEdit GUI
This only scratches the surface of what WorldEdit is capable of. Most of the functions in the WorldEdit GUI correspond to chat commands, and so the [Chat Commands Reference](ChatCommands.md) may be useful if you get stuck.
It is helpful to explore the various buttons in the interface and check out what they do. Learning the chat command interface is also useful if you use WorldEdit intensively - an experienced chat command user can usually work faster than an experienced WorldEdit GUI user.

237
mods/WorldEdit-1.2/WorldEdit API.md Normal file
View File

@ -0,0 +1,237 @@
WorldEdit API
=============
The WorldEdit API is composed of multiple modules, each of which is independent and can be used without the other. Each module is contained within a single file.
If needed, individual modules such as visualization.lua can be removed without affecting the rest of the program. The only file that cannot be removed is init.lua, which is necessary for the mod to run.
For more information, see the [README](README.md).
General
-------
### value = worldedit.version
Contains the current version of WorldEdit in a table of the form `{major=MAJOR_INTEGER, minor=MINOR_INTEGER}`, where `MAJOR_INTEGER` is the major version (the number before the period) as an integer, and `MINOR_INTEGER` is the minor version (the number after the period) as an integer. This is intended for version checking purposes.
### value = worldedit.version_string
Contains the current version of WorldEdit in the form of a string `"MAJOR_INTEGER.MINOR_INTEGER"`, where `MAJOR_INTEGER` is the major version (the number before the period) as an integer, and `MINOR_INTEGER` is the minor version (the number after the period) as an integer. This is intended for display purposes.
Manipulations
-------------
Contained in manipulations.lua, this module allows several node operations to be applied over a region.
### count = worldedit.set(pos1, pos2, node_name)
Sets a region defined by positions `pos1` and `pos2` to `node_name`. To clear a region, use "air" as the value of `node_name`.
Returns the number of nodes set.
### `count = worldedit.set_param2(pos1, pos2, param2)`
Sets the param2 values of all nodes in a region defined by positions `pos1` and `pos2` to `param2`.
Returns the number of nodes set.
### count = worldedit.replace(pos1, pos2, searchnode, replacenode)
Replaces all instances of `searchnode` with `replacenode` in a region defined by positions `pos1` and `pos2`.
Returns the number of nodes replaced.
### count = worldedit.replaceinverse(pos1, pos2, searchnode, replacenode)
Replaces all nodes other than `searchnode` with `replacenode` in a region defined by positions `pos1` and `pos2`.
Returns the number of nodes replaced.
### count = worldedit.copy(pos1, pos2, axis, amount)
Copies the region defined by positions `pos1` and `pos2` along the `axis` axis ("x" or "y" or "z") by `amount` nodes.
Returns the number of nodes copied.
### count = worldedit.copy2(pos1, pos2, off)
Copies the region defined by positions `pos1` and `pos2` by the offset vector `off`.
Returns the number of nodes copied.
### count = worldedit.move(pos1, pos2, axis, amount)
Moves the region defined by positions `pos1` and `pos2` along the `axis` axis ("x" or "y" or "z") by `amount` nodes.
Returns the number of nodes moved.
### count = worldedit.stack(pos1, pos2, axis, count)
Duplicates the region defined by positions `pos1` and `pos2` along the `axis` axis ("x" or "y" or "z") `count` times.
Returns the number of nodes stacked.
### count = worldedit.stack2(pos1, pos2, direction, amount)
Duplicates the region defined by positions `pos1` and `pos2` `amount` times with offset vector `direction`.
Returns the number of nodes stacked.
### count, newpos1, newpos2 = worldedit.stretch(pos1, pos2, stretchx, stretchy, stretchz)
Stretches the region defined by positions `pos1` and `pos2` by an factor of positive integers `stretchx`, `stretchy`. and `stretchz` along the X, Y, and Z axes, respectively, with `pos1` as the origin.
Returns the number of nodes stretched, the new scaled position 1, and the new scaled position 2.
### count, newpos1, newpos2 = worldedit.transpose(pos1, pos2, axis1, axis2)
Transposes a region defined by the positions `pos1` and `pos2` between the `axis1` and `axis2` axes ("x" or "y" or "z").
Returns the number of nodes transposed, the new transposed position 1, and the new transposed position 2.
### count = worldedit.flip(pos1, pos2, axis)
Flips a region defined by the positions `pos1` and `pos2` along the `axis` axis ("x" or "y" or "z").
Returns the number of nodes flipped.
### count, newpos2, newpos2 = worldedit.rotate(pos1, pos2, angle)
Rotates a region defined by the positions `pos1` and `pos2` by `angle` degrees clockwise around the y axis (supporting 90 degree increments only).
Returns the number of nodes rotated, the new position 1, and the new position 2.
### count = worldedit.orient(pos1, pos2, angle)
Rotates all oriented nodes in a region defined by the positions `pos1` and `pos2` by `angle` degrees clockwise (90 degree increment) around the Y axis.
Returns the number of nodes oriented.
### count = worldedit.fixlight(pos1, pos2)
Fixes the lighting in a region defined by positions `pos1` and `pos2`.
Returns the number of nodes updated.
### count = worldedit.clearobjects(pos1, pos2)
Clears all objects in a region defined by the positions `pos1` and `pos2`.
Returns the number of objects cleared.
Primitives
----------
Contained in primitives.lua, this module allows the creation of several geometric primitives.
### count = worldedit.cube(pos, width, height, length, node_name, hollow)
Adds a cube with its ground level centered at `pos`, the dimensions `width` x `height` x `length`, composed of `node_name`.
Returns the number of nodes added.
### count = worldedit.sphere(pos, radius, node_name, hollow)
Adds a sphere centered at `pos` with radius `radius`, composed of `node_name`.
Returns the number of nodes added.
### count = worldedit.dome(pos, radius, node_name, hollow)
Adds a dome centered at `pos` with radius `radius`, composed of `node_name`.
Returns the number of nodes added.
### count = worldedit.cylinder(pos, axis, length, radius1, radius2, node_name, hollow)
Adds a cylinder-like at `pos` along the `axis` axis ("x" or "y" or "z") with length `length`, base radius `radius1` and top radius `radius2`, composed of `node_name`.
Returns the number of nodes added.
### count = worldedit.pyramid(pos, axis, height, node_name, hollow)
Adds a pyramid centered at `pos` along the `axis` axis ("x" or "y" or "z") with height `height`, composed of `node_name`.
Returns the number of nodes added.
### count = worldedit.spiral(pos, length, height, spacer, node_name)
Adds a spiral centered at `pos` with side length `length`, height `height`, space between walls `spacer`, composed of `node_name`.
Returns the number of nodes added.
Visualization
-------------
Contained in visualization.lua, this module allows nodes to be visualized in different ways.
### volume = worldedit.volume(pos1, pos2)
Determines the volume of the region defined by positions `pos1` and `pos2`.
Returns the volume.
### count = worldedit.hide(pos1, pos2)
Hides all nodes in a region defined by positions `pos1` and `pos2` by non-destructively replacing them with invisible nodes.
Returns the number of nodes hidden.
### count = worldedit.suppress(pos1, pos2, node_name)
Suppresses all instances of `node_name` in a region defined by positions `pos1` and `pos2` by non-destructively replacing them with invisible nodes.
Returns the number of nodes suppressed.
### count = worldedit.highlight(pos1, pos2, node_name)
Highlights all instances of `node_name` in a region defined by positions `pos1` and `pos2` by non-destructively hiding all other nodes.
Returns the number of nodes found.
### count = worldedit.restore(pos1, pos2)
Restores all nodes hidden with WorldEdit functions in a region defined by positions `pos1` and `pos2`.
Returns the number of nodes restored.
Serialization
-------------
Contained in serialization.lua, this module allows regions of nodes to be serialized and deserialized to formats suitable for use outside MineTest.
### version, extra_fields, content = worldedit.read_header(value)
Reads the header from serialized data `value`.
Returns the version as a positive integer (nil for unknown versions),
extra header fields (nil if not supported), and the content after the header.
### data, count = worldedit.serialize(pos1, pos2)
Converts the region defined by positions `pos1` and `pos2` into a single string.
Returns the serialized data and the number of nodes serialized, or nil.
### pos1, pos2, count = worldedit.allocate(origin_pos, value)
Determines the volume the nodes represented by string `value` would occupy if deserialized at `origin_pos`.
Returns the two corner positions and the number of nodes, or nil.
### count = worldedit.deserialize(origin_pos, value)
Loads the nodes represented by string `value` at position `origin_pos`.
Returns the number of nodes deserialized or nil.
Code
----
Contained in code.lua, this module allows arbitrary Lua code to be used with WorldEdit.
### error = worldedit.lua(code)
Executes `code` as a Lua chunk in the global namespace.
Returns an error if the code fails or nil otherwise.
### error = worldedit.luatransform(pos1, pos2, code)
Executes `code` as a Lua chunk in the global namespace with the variable `pos` available, for each node in a region defined by positions `pos1` and `pos2`.
Returns an error if the code fails or nil otherwise.

12
mods/WorldEdit-1.2/config.ld Normal file
View File

@ -0,0 +1,12 @@
project = "WorldEdit"
title = "WorldEdit API Documentation"
description = "Minetest mod to mass-modify nodes"
format = "markdown"
file = {"worldedit"}
topics = {
"README.md",
"Tutorial.md",
"ChatCommands.md",
"LICENSE.txt"
}

0
mods/WorldEdit-1.2/modpack.txt Normal file
View File

52
mods/WorldEdit-1.2/worldedit/code.lua Normal file
View File

@ -0,0 +1,52 @@
--- Lua code execution functions.
-- @module worldedit.code
--- Executes `code` as a Lua chunk in the global namespace.
-- @return An error message if the code fails, or nil on success.
function worldedit.lua(code)
local func, err = loadstring(code)
if not func then -- Syntax error
return err
end
local good, err = pcall(func)
if not good then -- Runtime error
return err
end
return nil
end
--- Executes `code` as a Lua chunk in the global namespace with the variable
-- pos available, for each node in a region defined by positions `pos1` and
-- `pos2`.
-- @return An error message if the code fails, or nil on success.
function worldedit.luatransform(pos1, pos2, code)
pos1, pos2 = worldedit.sort_pos(pos1, pos2)
local factory, err = loadstring("return function(pos) " .. code .. " end")
if not factory then -- Syntax error
return err
end
local func = factory()
worldedit.keep_loaded(pos1, pos2)
local pos = {x=pos1.x, y=0, z=0}
while pos.x <= pos2.x do
pos.y = pos1.y
while pos.y <= pos2.y do
pos.z = pos1.z
while pos.z <= pos2.z do
local good, err = pcall(func, pos)
if not good then -- Runtime error
return err
end
pos.z = pos.z + 1
end
pos.y = pos.y + 1
end
pos.x = pos.x + 1
end
return nil
end

114
mods/WorldEdit-1.2/worldedit/common.lua Normal file
View File

@ -0,0 +1,114 @@
--- Common functions [INTERNAL]. All of these functions are internal!
-- @module worldedit.common
--- Copies and modifies positions `pos1` and `pos2` so that each component of
-- `pos1` is less than or equal to the corresponding component of `pos2`.
-- Returns the new positions.
function worldedit.sort_pos(pos1, pos2)
pos1 = {x=pos1.x, y=pos1.y, z=pos1.z}
pos2 = {x=pos2.x, y=pos2.y, z=pos2.z}
if pos1.x > pos2.x then
pos2.x, pos1.x = pos1.x, pos2.x
end
if pos1.y > pos2.y then
pos2.y, pos1.y = pos1.y, pos2.y
end
if pos1.z > pos2.z then
pos2.z, pos1.z = pos1.z, pos2.z
end
return pos1, pos2
end
--- Determines the volume of the region defined by positions `pos1` and `pos2`.
-- @return The volume.
function worldedit.volume(pos1, pos2)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
return (pos2.x - pos1.x + 1) *
(pos2.y - pos1.y + 1) *
(pos2.z - pos1.z + 1)
end
--- Gets other axes given an axis.
-- @raise Axis must be x, y, or z!
function worldedit.get_axis_others(axis)
if axis == "x" then
return "y", "z"
elseif axis == "y" then
return "x", "z"
elseif axis == "z" then
return "x", "y"
else
error("Axis must be x, y, or z!")
end
end
function worldedit.keep_loaded(pos1, pos2)
local manip = minetest.get_voxel_manip()
manip:read_from_map(pos1, pos2)
end
local mh = {}
worldedit.manip_helpers = mh
--- Generates an empty VoxelManip data table for an area.
-- @return The empty data table.
function mh.get_empty_data(area)
-- Fill emerged area with ignore so that blocks in the area that are
-- only partially modified aren't overwriten.
local data = {}
local c_ignore = minetest.get_content_id("ignore")
for i = 1, worldedit.volume(area.MinEdge, area.MaxEdge) do
data[i] = c_ignore
end
return data
end
function mh.init(pos1, pos2)
local manip = minetest.get_voxel_manip()
local emerged_pos1, emerged_pos2 = manip:read_from_map(pos1, pos2)
local area = VoxelArea:new({MinEdge=emerged_pos1, MaxEdge=emerged_pos2})
return manip, area
end
function mh.init_radius(pos, radius)
local pos1 = vector.subtract(pos, radius)
local pos2 = vector.add(pos, radius)
return mh.init(pos1, pos2)
end
function mh.init_axis_radius(base_pos, axis, radius)
return mh.init_axis_radius_length(base_pos, axis, radius, radius)
end
function mh.init_axis_radius_length(base_pos, axis, radius, length)
local other1, other2 = worldedit.get_axis_others(axis)
local pos1 = {
[axis] = base_pos[axis],
[other1] = base_pos[other1] - radius,
[other2] = base_pos[other2] - radius
}
local pos2 = {
[axis] = base_pos[axis] + length,
[other1] = base_pos[other1] + radius,
[other2] = base_pos[other2] + radius
}
return mh.init(pos1, pos2)
end
function mh.finish(manip, data)
-- Update map
manip:set_data(data)
manip:write_to_map()
manip:update_map()
end

74
mods/WorldEdit-1.2/worldedit/compatibility.lua Normal file
View File

@ -0,0 +1,74 @@
--- Compatibility functions.
-- @module worldedit.compatibility
local function deprecated(new_func)
local info = debug.getinfo(1, "n")
local msg = "worldedit." .. info.name .. "() is deprecated."
if new_func then
msg = msg .. " Use worldedit." .. new_func .. "() instead."
end
minetest.log("deprecated", msg)
end
worldedit.allocate_old = worldedit.allocate
worldedit.deserialize_old = worldedit.deserialize
function worldedit.metasave(pos1, pos2, filename)
deprecated("save")
local file, err = io.open(filename, "wb")
if err then return 0 end
local data, count = worldedit.serialize(pos1, pos2)
file:write(data)
file:close()
return count
end
function worldedit.metaload(originpos, filename)
deprecated("load")
filename = minetest.get_worldpath() .. "/schems/" .. file .. ".wem"
local file, err = io.open(filename, "wb")
if err then return 0 end
local data = file:read("*a")
return worldedit.deserialize(originpos, data)
end
function worldedit.scale(pos1, pos2, factor)
deprecated("stretch")
return worldedit.stretch(pos1, pos2, factor, factor, factor)
end
function worldedit.valueversion(value)
deprecated("read_header")
local version = worldedit.read_header(value)
if not version or version > worldedit.LATEST_SERIALIZATION_VERSION then
return 0
end
return version
end
function worldedit.replaceinverse(pos1, pos2, search_node, replace_node)
deprecated("replace")
return worldedit.replace(pos1, pos2, search_node, replace_node, true)
end
function worldedit.clearobjects(...)
deprecated("clear_objects")
return worldedit.clear_objects(...)
end
function worldedit.hollow_sphere(pos, radius, node_name)
deprecated("sphere")
return worldedit.sphere(pos, radius, node_name, true)
end
function worldedit.hollow_dome(pos, radius, node_name)
deprecated("dome")
return worldedit.dome(pos, radius, node_name, true)
end
function worldedit.hollow_cylinder(pos, axis, length, radius, node_name)
deprecated("cylinder")
return worldedit.cylinder(pos, axis, length, radius, node_name, true)
end

258
mods/WorldEdit-1.2/worldedit/cuboid.lua Normal file
View File

@ -0,0 +1,258 @@
-- Expands or contracts the cuboid in all axes by amount (positive or negative)
worldedit.cuboid_volumetric_expand = function(name, amount)
local pos1 = worldedit.pos1[name]
local pos2 = worldedit.pos2[name]
if pos1 == nil or pos2 == nil then
return false, "Undefined cuboid"
end
local delta1 = vector.new()
local delta2 = vector.new()
local delta_dir1
local delta_dir2
delta1 = vector.add(delta1, amount)
delta2 = vector.add(delta2, amount)
delta_dir1, delta_dir2 = worldedit.get_expansion_directions(pos1, pos2)
delta1 = vector.multiply(delta1, delta_dir1)
delta2 = vector.multiply(delta2, delta_dir2)
worldedit.pos1[name] = vector.add(pos1, delta1)
worldedit.pos2[name] = vector.add(pos2, delta2)
return true
end
-- Expands or contracts the cuboid in a single axis by amount (positive or negative)
worldedit.cuboid_linear_expand = function(name, axis, direction, amount)
local pos1 = worldedit.pos1[name]
local pos2 = worldedit.pos2[name]
if pos1 == nil or pos2 == nil then
return false, "undefined cuboid"
end
if direction ~= 1 and direction ~= -1 then
return false, "invalid marker"
end
local marker = worldedit.marker_get_closest_to_axis(name, axis, direction)
local deltavect = vector.new()
if axis == 'x' then
deltavect.x = amount * direction
elseif axis == 'y' then
deltavect.y = amount * direction
elseif axis == 'z' then
deltavect.z = amount * direction
else
return false, "invalid axis"
end
worldedit.marker_move(name, marker, deltavect)
return true
end
-- Shifts the cuboid by '+-amount' in axis 'axis'
worldedit.cuboid_shift = function(name, axis, amount)
local pos1 = worldedit.pos1[name]
local pos2 = worldedit.pos2[name]
if pos1 == nil or pos2 == nil then
return false, "undefined cuboid"
end
if axis == 'x' then
worldedit.pos1[name].x = pos1.x + amount
worldedit.pos2[name].x = pos2.x + amount
elseif axis == 'y' then
worldedit.pos1[name].y = pos1.y + amount
worldedit.pos2[name].y = pos2.y + amount
elseif axis == 'z' then
worldedit.pos1[name].z = pos1.z + amount
worldedit.pos2[name].z = pos2.z + amount
else
return false, "invalid axis"
end
return true
end
-- Moves the location of a single marker by adding deltavector
worldedit.marker_move = function(name, marker, deltavector)
if marker ~= 1 and marker ~= 2 then
return false
end
if marker == 1 then
local pos = worldedit.pos1[name]
worldedit.pos1[name] = vector.add(deltavector, pos)
else
local pos = worldedit.pos2[name]
worldedit.pos2[name] = vector.add(deltavector, pos)
end
return true
end
-- Updates the location ingame of the markers
worldedit.marker_update = function(name, marker)
if marker == nil then
worldedit.mark_pos1(name)
worldedit.mark_pos2(name)
elseif marker == 1 then
worldedit.mark_pos1(name)
elseif marker == 2 then
worldedit.mark_pos2(name)
else
minetest.debug(
"worldedit: Invalid execution of function update_markers")
end
end
-- Returns two vectors with the directions for volumetric expansion
worldedit.get_expansion_directions = function(mark1, mark2)
if mark1 == nil or mark2 == nil then
return
end
local dir1 = vector.new()
local dir2 = vector.new()
if mark1.x < mark2.x then
dir1.x = -1
dir2.x = 1
else
dir1.x = 1
dir2.x = -1
end
if mark1.y < mark2.y then
dir1.y = -1
dir2.y = 1
else
dir1.y = 1
dir2.y = -1
end
if mark1.z < mark2.z then
dir1.z = -1
dir2.z = 1
else
dir1.z = 1
dir2.z = -1
end
return dir1, dir2
end
-- Return the marker that is closest to the player
worldedit.marker_get_closest_to_player = function(name)
local playerpos = minetest.get_player_by_name(name):getpos()
local dist1 = vector.distance(playerpos, worldedit.pos1[name])
local dist2 = vector.distance(playerpos, worldedit.pos2[name])
if dist1 < dist2 then
return 1
else
return 2
end
end
-- Returns the closest marker to the specified axis and direction
worldedit.marker_get_closest_to_axis = function(name, axis, direction)
local pos1 = vector.new()
local pos2 = vector.new()
if direction ~= 1 and direction ~= -1 then
return nil
end
if axis == 'x' then
pos1.x = worldedit.pos1[name].x * direction
pos2.x = worldedit.pos2[name].x * direction
if pos1.x > pos2.x then
return 1
else
return 2
end
elseif axis == 'y' then
pos1.y = worldedit.pos1[name].y * direction
pos2.y = worldedit.pos2[name].y * direction
if pos1.y > pos2.y then
return 1
else
return 2
end
elseif axis == 'z' then
pos1.z = worldedit.pos1[name].z * direction
pos2.z = worldedit.pos2[name].z * direction
if pos1.z > pos2.z then
return 1
else
return 2
end
else
return nil
end
end
-- Translates up, down, left, right, front, back to their corresponding axes and
-- directions according to faced direction
worldedit.translate_direction = function(name, direction)
local axis, dir = worldedit.player_axis(name)
local resaxis, resdir
if direction == "up" then
return 'y', 1
end
if direction == "down" then
return 'y', -1
end
if direction == "front" then
if axis == "y" then
resaxis = nil
resdir = nil
else
resaxis = axis
resdir = dir
end
end
if direction == "back" then
if axis == "y" then
resaxis = nil
resdir = nil
else
resaxis = axis
resdir = -dir
end
end
if direction == "left" then
if axis == 'x' then
resaxis = 'z'
resdir = dir
elseif axis == 'z' then
resaxis = 'x'
resdir = -dir
end
end
if direction == "right" then
if axis == 'x' then
resaxis = 'z'
resdir = -dir
elseif axis == 'z' then
resaxis = 'x'
resdir = dir
end
end
return resaxis, resdir
end

48
mods/WorldEdit-1.2/worldedit/init.lua Normal file
View File

@ -0,0 +1,48 @@
--- Worldedit.
-- @module worldedit
-- @release 1.2
-- @copyright 2013 sfan5, Anthony Zhang (Uberi/Temperest), and Brett O'Donnell (cornernote).
-- @license GNU Affero General Public License version 3 (AGPLv3)
-- @author sfan5
-- @author Anthony Zang (Uberi/Temperest)
-- @author Bret O'Donnel (cornernote)
-- @author ShadowNinja
worldedit = {}
local ver = {major=1, minor=2}
worldedit.version = ver
worldedit.version_string = string.format("%d.%d", ver.major, ver.minor)
if not minetest.get_voxel_manip then
local err_msg = "This version of WorldEdit requires Minetest 0.4.8 or later! You have an old version."
minetest.log("error", string.rep("#", 128))
minetest.log("error", err_msg)
minetest.log("error", string.rep("#", 128))
error(err_msg)
end
local path = minetest.get_modpath(minetest.get_current_modname())
local function load_module(path)
local file = io.open(path, "r")
if not file then return end
file:close()
return dofile(path)
end
dofile(path .. "/common.lua")
load_module(path .. "/manipulations.lua")
load_module(path .. "/primitives.lua")
load_module(path .. "/visualization.lua")
load_module(path .. "/serialization.lua")
load_module(path .. "/code.lua")
load_module(path .. "/compatibility.lua")
load_module(path .. "/cuboid.lua")
if minetest.setting_getbool("log_mods") then
print("[WorldEdit] Loaded!")
end

649
mods/WorldEdit-1.2/worldedit/manipulations.lua Normal file
View File

@ -0,0 +1,649 @@
--- Generic node manipulations.
-- @module worldedit.manipulations
local mh = worldedit.manip_helpers
--- Sets a region to `node_names`.
-- @param pos1
-- @param pos2
-- @param node_names Node name or list of node names.
-- @return The number of nodes set.
function worldedit.set(pos1, pos2, node_names)
pos1, pos2 = worldedit.sort_pos(pos1, pos2)
local manip, area = mh.init(pos1, pos2)
local data = mh.get_empty_data(area)
if type(node_names) == "string" then -- Only one type of node
local id = minetest.get_content_id(node_names)
-- Fill area with node
for i in area:iterp(pos1, pos2) do
data[i] = id
end
else -- Several types of nodes specified
local node_ids = {}
for i, v in ipairs(node_names) do
node_ids[i] = minetest.get_content_id(v)
end
-- Fill area randomly with nodes
local id_count, rand = #node_ids, math.random
for i in area:iterp(pos1, pos2) do
data[i] = node_ids[rand(id_count)]
end
end
mh.finish(manip, data)
return worldedit.volume(pos1, pos2)
end
--- Sets param2 of a region.
-- @param pos1
-- @param pos2
-- @param param2 Value of param2 to set
-- @return The number of nodes set.
function worldedit.set_param2(pos1, pos2, param2)
pos1, pos2 = worldedit.sort_pos(pos1, pos2)
local manip, area = mh.init(pos1, pos2)
local param2_data = manip:get_param2_data()
-- Set param2 for every node
for i in area:iterp(pos1, pos2) do
param2_data[i] = param2
end
-- Update map
manip:set_param2_data(param2_data)
manip:write_to_map()
manip:update_map()
return worldedit.volume(pos1, pos2)
end
--- Replaces all instances of `search_node` with `replace_node` in a region.
-- When `inverse` is `true`, replaces all instances that are NOT `search_node`.
-- @return The number of nodes replaced.
function worldedit.replace(pos1, pos2, search_node, replace_node, inverse)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
local manip, area = mh.init(pos1, pos2)
local data = manip:get_data()
local search_id = minetest.get_content_id(search_node)
local replace_id = minetest.get_content_id(replace_node)
local count = 0
--- TODO: This could be shortened by checking `inverse` in the loop,
-- but that would have a speed penalty. Is the penalty big enough
-- to matter?
if not inverse then
for i in area:iterp(pos1, pos2) do
if data[i] == search_id then
data[i] = replace_id
count = count + 1
end
end
else
for i in area:iterp(pos1, pos2) do
if data[i] ~= search_id then
data[i] = replace_id
count = count + 1
end
end
end
mh.finish(manip, data)
return count
end
--- Duplicates a region `amount` times with offset vector `direction`.
-- Stacking is spread across server steps, one copy per step.
-- @return The number of nodes stacked.
function worldedit.stack2(pos1, pos2, direction, amount, finished)
local i = 0
local translated = {x=0, y=0, z=0}
local function next_one()
if i < amount then
i = i + 1
translated.x = translated.x + direction.x
translated.y = translated.y + direction.y
translated.z = translated.z + direction.z
worldedit.copy2(pos1, pos2, translated)
minetest.after(0, next_one)
else
if finished then
finished()
end
end
end
next_one()
return worldedit.volume(pos1, pos2) * amount
end
--- Copies a region along `axis` by `amount` nodes.
-- @param pos1
-- @param pos2
-- @param axis Axis ("x", "y", or "z")
-- @param amount
-- @return The number of nodes copied.
function worldedit.copy(pos1, pos2, axis, amount)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
worldedit.keep_loaded(pos1, pos2)
local get_node, get_meta, set_node = minetest.get_node,
minetest.get_meta, minetest.set_node
-- Copy things backwards when negative to avoid corruption.
-- FIXME: Lots of code duplication here.
if amount < 0 then
local pos = {}
pos.x = pos1.x
while pos.x <= pos2.x do
pos.y = pos1.y
while pos.y <= pos2.y do
pos.z = pos1.z
while pos.z <= pos2.z do
local node = get_node(pos) -- Obtain current node
local meta = get_meta(pos):to_table() -- Get meta of current node
local value = pos[axis] -- Store current position
pos[axis] = value + amount -- Move along axis
set_node(pos, node) -- Copy node to new position
get_meta(pos):from_table(meta) -- Set metadata of new node
pos[axis] = value -- Restore old position
pos.z = pos.z + 1
end
pos.y = pos.y + 1
end
pos.x = pos.x + 1
end
else
local pos = {}
pos.x = pos2.x
while pos.x >= pos1.x do
pos.y = pos2.y
while pos.y >= pos1.y do
pos.z = pos2.z
while pos.z >= pos1.z do
local node = get_node(pos) -- Obtain current node
local meta = get_meta(pos):to_table() -- Get meta of current node
local value = pos[axis] -- Store current position
pos[axis] = value + amount -- Move along axis
set_node(pos, node) -- Copy node to new position
get_meta(pos):from_table(meta) -- Set metadata of new node
pos[axis] = value -- Restore old position
pos.z = pos.z - 1
end
pos.y = pos.y - 1
end
pos.x = pos.x - 1
end
end
return worldedit.volume(pos1, pos2)
end
--- Copies a region by offset vector `off`.
-- @param pos1
-- @param pos2
-- @param off
-- @return The number of nodes copied.
function worldedit.copy2(pos1, pos2, off)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
worldedit.keep_loaded(pos1, pos2)
local get_node, get_meta, set_node = minetest.get_node,
minetest.get_meta, minetest.set_node
local pos = {}
pos.x = pos2.x
while pos.x >= pos1.x do
pos.y = pos2.y
while pos.y >= pos1.y do
pos.z = pos2.z
while pos.z >= pos1.z do
local node = get_node(pos) -- Obtain current node
local meta = get_meta(pos):to_table() -- Get meta of current node
local newpos = vector.add(pos, off) -- Calculate new position
set_node(newpos, node) -- Copy node to new position
get_meta(newpos):from_table(meta) -- Set metadata of new node
pos.z = pos.z - 1
end
pos.y = pos.y - 1
end
pos.x = pos.x - 1
end
return worldedit.volume(pos1, pos2)
end
--- Moves a region along `axis` by `amount` nodes.
-- @return The number of nodes moved.
function worldedit.move(pos1, pos2, axis, amount)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
worldedit.keep_loaded(pos1, pos2)
--- TODO: Move slice by slice using schematic method in the move axis
-- and transfer metadata in separate loop (and if the amount is
-- greater than the length in the axis, copy whole thing at a time and
-- erase original after, using schematic method).
local get_node, get_meta, set_node, remove_node = minetest.get_node,
minetest.get_meta, minetest.set_node, minetest.remove_node
-- Copy things backwards when negative to avoid corruption.
--- FIXME: Lots of code duplication here.
if amount < 0 then
local pos = {}
pos.x = pos1.x
while pos.x <= pos2.x do
pos.y = pos1.y
while pos.y <= pos2.y do
pos.z = pos1.z
while pos.z <= pos2.z do
local node = get_node(pos) -- Obtain current node
local meta = get_meta(pos):to_table() -- Get metadata of current node
remove_node(pos) -- Remove current node
local value = pos[axis] -- Store current position
pos[axis] = value + amount -- Move along axis
set_node(pos, node) -- Move node to new position
get_meta(pos):from_table(meta) -- Set metadata of new node
pos[axis] = value -- Restore old position
pos.z = pos.z + 1
end
pos.y = pos.y + 1
end
pos.x = pos.x + 1
end
else
local pos = {}
pos.x = pos2.x
while pos.x >= pos1.x do
pos.y = pos2.y
while pos.y >= pos1.y do
pos.z = pos2.z
while pos.z >= pos1.z do
local node = get_node(pos) -- Obtain current node
local meta = get_meta(pos):to_table() -- Get metadata of current node
remove_node(pos) -- Remove current node
local value = pos[axis] -- Store current position
pos[axis] = value + amount -- Move along axis
set_node(pos, node) -- Move node to new position
get_meta(pos):from_table(meta) -- Set metadata of new node
pos[axis] = value -- Restore old position
pos.z = pos.z - 1
end
pos.y = pos.y - 1
end
pos.x = pos.x - 1
end
end
return worldedit.volume(pos1, pos2)
end
--- Duplicates a region along `axis` `amount` times.
-- Stacking is spread across server steps, one copy per step.
-- @param pos1
-- @param pos2
-- @param axis Axis direction, "x", "y", or "z".
-- @param count
-- @return The number of nodes stacked.
function worldedit.stack(pos1, pos2, axis, count)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
local length = pos2[axis] - pos1[axis] + 1
if count < 0 then
count = -count
length = -length
end
local amount = 0
local copy = worldedit.copy
local i = 1
function next_one()
if i <= count then
i = i + 1
amount = amount + length
copy(pos1, pos2, axis, amount)
minetest.after(0, next_one)
end
end
next_one()
return worldedit.volume(pos1, pos2) * count
end
--- Stretches a region by a factor of positive integers along the X, Y, and Z
-- axes, respectively, with `pos1` as the origin.
-- @param pos1
-- @param pos2
-- @param stretch_x Amount to stretch along X axis.
-- @param stretch_y Amount to stretch along Y axis.
-- @param stretch_z Amount to stretch along Z axis.
-- @return The number of nodes scaled.
-- @return The new scaled position 1.
-- @return The new scaled position 2.
function worldedit.stretch(pos1, pos2, stretch_x, stretch_y, stretch_z)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
-- Prepare schematic of large node
local get_node, get_meta, place_schematic = minetest.get_node,
minetest.get_meta, minetest.place_schematic
local placeholder_node = {name="", param1=255, param2=0}
local nodes = {}
for i = 1, stretch_x * stretch_y * stretch_z do
nodes[i] = placeholder_node
end
local schematic = {size={x=stretch_x, y=stretch_y, z=stretch_z}, data=nodes}
local size_x, size_y, size_z = stretch_x - 1, stretch_y - 1, stretch_z - 1
local new_pos2 = {
x = pos1.x + (pos2.x - pos1.x) * stretch_x + size_x,
y = pos1.y + (pos2.y - pos1.y) * stretch_y + size_y,
z = pos1.z + (pos2.z - pos1.z) * stretch_z + size_z,
}
worldedit.keep_loaded(pos1, new_pos2)
local pos = {x=pos2.x, y=0, z=0}
local big_pos = {x=0, y=0, z=0}
while pos.x >= pos1.x do
pos.y = pos2.y
while pos.y >= pos1.y do
pos.z = pos2.z
while pos.z >= pos1.z do
local node = get_node(pos) -- Get current node
local meta = get_meta(pos):to_table() -- Get meta of current node
-- Calculate far corner of the big node
local pos_x = pos1.x + (pos.x - pos1.x) * stretch_x
local pos_y = pos1.y + (pos.y - pos1.y) * stretch_y
local pos_z = pos1.z + (pos.z - pos1.z) * stretch_z
-- Create large node
placeholder_node.name = node.name
placeholder_node.param2 = node.param2
big_pos.x, big_pos.y, big_pos.z = pos_x, pos_y, pos_z
place_schematic(big_pos, schematic)
-- Fill in large node meta
if next(meta.fields) ~= nil or next(meta.inventory) ~= nil then
-- Node has meta fields
for x = 0, size_x do
for y = 0, size_y do
for z = 0, size_z do
big_pos.x = pos_x + x
big_pos.y = pos_y + y
big_pos.z = pos_z + z
-- Set metadata of new node
get_meta(big_pos):from_table(meta)
end
end
end
end
pos.z = pos.z - 1
end
pos.y = pos.y - 1
end
pos.x = pos.x - 1
end
return worldedit.volume(pos1, pos2) * stretch_x * stretch_y * stretch_z, pos1, new_pos2
end
--- Transposes a region between two axes.
-- @return The number of nodes transposed.
-- @return The new transposed position 1.
-- @return The new transposed position 2.
function worldedit.transpose(pos1, pos2, axis1, axis2)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
local compare
local extent1, extent2 = pos2[axis1] - pos1[axis1], pos2[axis2] - pos1[axis2]
if extent1 > extent2 then
compare = function(extent1, extent2)
return extent1 > extent2
end
else
compare = function(extent1, extent2)
return extent1 < extent2
end
end
-- Calculate the new position 2 after transposition
local new_pos2 = {x=pos2.x, y=pos2.y, z=pos2.z}
new_pos2[axis1] = pos1[axis1] + extent2
new_pos2[axis2] = pos1[axis2] + extent1
local upper_bound = {x=pos2.x, y=pos2.y, z=pos2.z}
if upper_bound[axis1] < new_pos2[axis1] then upper_bound[axis1] = new_pos2[axis1] end
if upper_bound[axis2] < new_pos2[axis2] then upper_bound[axis2] = new_pos2[axis2] end
worldedit.keep_loaded(pos1, upper_bound)
local pos = {x=pos1.x, y=0, z=0}
local get_node, get_meta, set_node = minetest.get_node,
minetest.get_meta, minetest.set_node
while pos.x <= pos2.x do
pos.y = pos1.y
while pos.y <= pos2.y do
pos.z = pos1.z
while pos.z <= pos2.z do
local extent1, extent2 = pos[axis1] - pos1[axis1], pos[axis2] - pos1[axis2]
if compare(extent1, extent2) then -- Transpose only if below the diagonal
local node1 = get_node(pos)
local meta1 = get_meta(pos):to_table()
local value1, value2 = pos[axis1], pos[axis2] -- Save position values
pos[axis1], pos[axis2] = pos1[axis1] + extent2, pos1[axis2] + extent1 -- Swap axis extents
local node2 = get_node(pos)
local meta2 = get_meta(pos):to_table()
set_node(pos, node1)
get_meta(pos):from_table(meta1)
pos[axis1], pos[axis2] = value1, value2 -- Restore position values
set_node(pos, node2)
get_meta(pos):from_table(meta2)
end
pos.z = pos.z + 1
end
pos.y = pos.y + 1
end
pos.x = pos.x + 1
end
return worldedit.volume(pos1, pos2), pos1, new_pos2
end
--- Flips a region along `axis`.
-- @return The number of nodes flipped.
function worldedit.flip(pos1, pos2, axis)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
worldedit.keep_loaded(pos1, pos2)
--- TODO: Flip the region slice by slice along the flip axis using schematic method.
local pos = {x=pos1.x, y=0, z=0}
local start = pos1[axis] + pos2[axis]
pos2[axis] = pos1[axis] + math.floor((pos2[axis] - pos1[axis]) / 2)
local get_node, get_meta, set_node = minetest.get_node,
minetest.get_meta, minetest.set_node
while pos.x <= pos2.x do
pos.y = pos1.y
while pos.y <= pos2.y do
pos.z = pos1.z
while pos.z <= pos2.z do
local node1 = get_node(pos)
local meta1 = get_meta(pos):to_table()
local value = pos[axis] -- Save position
pos[axis] = start - value -- Shift position
local node2 = get_node(pos)
local meta2 = get_meta(pos):to_table()
set_node(pos, node1)
get_meta(pos):from_table(meta1)
pos[axis] = value -- Restore position
set_node(pos, node2)
get_meta(pos):from_table(meta2)
pos.z = pos.z + 1
end
pos.y = pos.y + 1
end
pos.x = pos.x + 1
end
return worldedit.volume(pos1, pos2)
end
--- Rotates a region clockwise around an axis.
-- @param pos1
-- @param pos2
-- @param axis Axis ("x", "y", or "z").
-- @param angle Angle in degrees (90 degree increments only).
-- @return The number of nodes rotated.
-- @return The new first position.
-- @return The new second position.
function worldedit.rotate(pos1, pos2, axis, angle)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
local other1, other2 = worldedit.get_axis_others(axis)
angle = angle % 360
local count
if angle == 90 then
worldedit.flip(pos1, pos2, other1)
count, pos1, pos2 = worldedit.transpose(pos1, pos2, other1, other2)
elseif angle == 180 then
worldedit.flip(pos1, pos2, other1)
count = worldedit.flip(pos1, pos2, other2)
elseif angle == 270 then
worldedit.flip(pos1, pos2, other2)
count, pos1, pos2 = worldedit.transpose(pos1, pos2, other1, other2)
else
error("Only 90 degree increments are supported!")
end
return count, pos1, pos2
end
--- Rotates all oriented nodes in a region clockwise around the Y axis.
-- @param pos1
-- @param pos2
-- @param angle Angle in degrees (90 degree increments only).
-- @return The number of nodes oriented.
-- TODO: Support 6D facedir rotation along arbitrary axis.
function worldedit.orient(pos1, pos2, angle)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
local registered_nodes = minetest.registered_nodes
local wallmounted = {
[90] = {[0]=0, 1, 5, 4, 2, 3},
[180] = {[0]=0, 1, 3, 2, 5, 4},
[270] = {[0]=0, 1, 4, 5, 3, 2}
}
local facedir = {
[90] = {[0]=1, 2, 3, 0},
[180] = {[0]=2, 3, 0, 1},
[270] = {[0]=3, 0, 1, 2}
}
angle = angle % 360
if angle == 0 then
return 0
end
if angle % 90 ~= 0 then
error("Only 90 degree increments are supported!")
end
local wallmounted_substitution = wallmounted[angle]
local facedir_substitution = facedir[angle]
worldedit.keep_loaded(pos1, pos2)
local count = 0
local set_node, get_node, get_meta, swap_node = minetest.set_node,
minetest.get_node, minetest.get_meta, minetest.swap_node
local pos = {x=pos1.x, y=0, z=0}
while pos.x <= pos2.x do
pos.y = pos1.y
while pos.y <= pos2.y do
pos.z = pos1.z
while pos.z <= pos2.z do
local node = get_node(pos)
local def = registered_nodes[node.name]
if def then
if def.paramtype2 == "wallmounted" then
node.param2 = wallmounted_substitution[node.param2]
local meta = get_meta(pos):to_table()
set_node(pos, node)
get_meta(pos):from_table(meta)
count = count + 1
elseif def.paramtype2 == "facedir" then
node.param2 = facedir_substitution[node.param2]
local meta = get_meta(pos):to_table()
set_node(pos, node)
get_meta(pos):from_table(meta)
count = count + 1
end
end
pos.z = pos.z + 1
end
pos.y = pos.y + 1
end
pos.x = pos.x + 1
end
return count
end
--- Attempts to fix the lighting in a region.
-- @return The number of nodes updated.
function worldedit.fixlight(pos1, pos2)
local pos1, pos2 = worldedit.sort_pos(pos1, pos2)
local vmanip = minetest.get_voxel_manip(pos1, pos2)
vmanip:write_to_map()
vmanip:update_map() -- this updates the lighting
return worldedit.volume(pos1, pos2)
end
--- Clears all objects in a region.
-- @return The number of objects cleared.
function worldedit.clear_objects(pos1, pos2)
pos1, pos2 = worldedit.sort_pos(pos1, pos2)
worldedit.keep_loaded(pos1, pos2)
-- Offset positions to include full nodes (positions are in the center of nodes)
local pos1x, pos1y, pos1z = pos1.x - 0.5, pos1.y - 0.5, pos1.z - 0.5
local pos2x, pos2y, pos2z = pos2.x + 0.5, pos2.y + 0.5, pos2.z + 0.5
-- Center of region
local center = {
x = pos1x + ((pos2x - pos1x) / 2),
y = pos1y + ((pos2y - pos1y) / 2),
z = pos1z + ((pos2z - pos1z) / 2)
}
-- Bounding sphere radius
local radius = math.sqrt(
(center.x - pos1x) ^ 2 +
(center.y - pos1y) ^ 2 +
(center.z - pos1z) ^ 2)
local count = 0
for _, obj in pairs(minetest.get_objects_inside_radius(center, radius)) do
local entity = obj:get_luaentity()
-- Avoid players and WorldEdit entities
if not obj:is_player() and (not entity or
not entity.name:find("^worldedit:")) then
local pos = obj:getpos()
if pos.x >= pos1x and pos.x <= pos2x and
pos.y >= pos1y and pos.y <= pos2y and
pos.z >= pos1z and pos.z <= pos2z then
-- Inside region
obj:remove()
count = count + 1
end
end
end
return count
end

328
mods/WorldEdit-1.2/worldedit/primitives.lua Normal file
View File

@ -0,0 +1,328 @@
--- Functions for creating primitive shapes.
-- @module worldedit.primitives
local mh = worldedit.manip_helpers
--- Adds a cube
-- @param pos Position of ground level center of cube
-- @param width Cube width. (x)
-- @param height Cube height. (y)
-- @param length Cube length. (z)
-- @param node_name Name of node to make cube of.
-- @param hollow Whether the cube should be hollow.
-- @return The number of nodes added.
function worldedit.cube(pos, width, height, length, node_name, hollow)
-- Set up voxel manipulator
local basepos = vector.subtract(pos, {x=math.floor(width/2), y=0, z=math.floor(length/2)})
local manip, area = mh.init(basepos, vector.add(basepos, {x=width, y=height, z=length}))
local data = mh.get_empty_data(area)
-- Add cube
local node_id = minetest.get_content_id(node_name)
local stride = {x=1, y=area.ystride, z=area.zstride}
local offset = vector.subtract(basepos, area.MinEdge)
local count = 0
for z = 0, length-1 do
local index_z = (offset.z + z) * stride.z + 1 -- +1 for 1-based indexing
for y = 0, height-1 do
local index_y = index_z + (offset.y + y) * stride.y
for x = 0, width-1 do
local is_wall = z == 0 or z == length-1
or y == 0 or y == height-1
or x == 0 or x == width-1
if not hollow or is_wall then
local i = index_y + (offset.x + x)
data[i] = node_id
count = count + 1
end
end
end
end
mh.finish(manip, data)
return count
end
--- Adds a sphere of `node_name` centered at `pos`.
-- @param pos Position to center sphere at.
-- @param radius Sphere radius.
-- @param node_name Name of node to make shere of.
-- @param hollow Whether the sphere should be hollow.
-- @return The number of nodes added.
function worldedit.sphere(pos, radius, node_name, hollow)
local manip, area = mh.init_radius(pos, radius)
local data = mh.get_empty_data(area)
-- Fill selected area with node
local node_id = minetest.get_content_id(node_name)
local min_radius, max_radius = radius * (radius - 1), radius * (radius + 1)
local offset_x, offset_y, offset_z = pos.x - area.MinEdge.x, pos.y - area.MinEdge.y, pos.z - area.MinEdge.z
local stride_z, stride_y = area.zstride, area.ystride
local count = 0
for z = -radius, radius do
-- Offset contributed by z plus 1 to make it 1-indexed
local new_z = (z + offset_z) * stride_z + 1
for y = -radius, radius do
local new_y = new_z + (y + offset_y) * stride_y
for x = -radius, radius do
local squared = x * x + y * y + z * z
if squared <= max_radius and (not hollow or squared >= min_radius) then
-- Position is on surface of sphere
local i = new_y + (x + offset_x)
data[i] = node_id
count = count + 1
end
end
end
end
mh.finish(manip, data)
return count
end
--- Adds a dome.
-- @param pos Position to center dome at.
-- @param radius Dome radius. Negative for concave domes.
-- @param node_name Name of node to make dome of.
-- @param hollow Whether the dome should be hollow.
-- @return The number of nodes added.
-- TODO: Add axis option.
function worldedit.dome(pos, radius, node_name, hollow)
local min_y, max_y = 0, radius
if radius < 0 then
radius = -radius
min_y, max_y = -radius, 0
end
local manip, area = mh.init_axis_radius(pos, "y", radius)
local data = mh.get_empty_data(area)
-- Add dome
local node_id = minetest.get_content_id(node_name)
local min_radius, max_radius = radius * (radius - 1), radius * (radius + 1)
local offset_x, offset_y, offset_z = pos.x - area.MinEdge.x, pos.y - area.MinEdge.y, pos.z - area.MinEdge.z
local stride_z, stride_y = area.zstride, area.ystride
local count = 0
for z = -radius, radius do
local new_z = (z + offset_z) * stride_z + 1 --offset contributed by z plus 1 to make it 1-indexed
for y = min_y, max_y do
local new_y = new_z + (y + offset_y) * stride_y
for x = -radius, radius do
local squared = x * x + y * y + z * z
if squared <= max_radius and (not hollow or squared >= min_radius) then
-- Position is in dome
local i = new_y + (x + offset_x)
data[i] = node_id
count = count + 1
end
end
end
end
mh.finish(manip, data)
return count
end
--- Adds a cylinder.
-- @param pos Position to center base of cylinder at.
-- @param axis Axis ("x", "y", or "z")
-- @param length Cylinder length.
-- @param radius1 Cylinder base radius.
-- @param radius2 Cylinder top radius.
-- @param node_name Name of node to make cylinder of.
-- @param hollow Whether the cylinder should be hollow.
-- @return The number of nodes added.
function worldedit.cylinder(pos, axis, length, radius1, radius2, node_name, hollow)
local other1, other2 = worldedit.get_axis_others(axis)
-- Backwards compatibility
if type(radius2) == "string" then
hollow = node_name
node_name = radius2
radius2 = radius1 -- straight cylinder
end
-- Handle negative lengths
local current_pos = {x=pos.x, y=pos.y, z=pos.z}
if length < 0 then
length = -length
current_pos[axis] = current_pos[axis] - length
radius1, radius2 = radius2, radius1
end
-- Set up voxel manipulator
local manip, area = mh.init_axis_radius_length(current_pos, axis, math.max(radius1, radius2), length)
local data = mh.get_empty_data(area)
-- Add desired shape (anything inbetween cylinder & cone)
local node_id = minetest.get_content_id(node_name)
local stride = {x=1, y=area.ystride, z=area.zstride}
local offset = {
x = current_pos.x - area.MinEdge.x,
y = current_pos.y - area.MinEdge.y,
z = current_pos.z - area.MinEdge.z,
}
local count = 0
for i = 0, length - 1 do
-- Calulate radius for this "height" in the cylinder
local radius = radius1 + (radius2 - radius1) * (i + 1) / length
radius = math.floor(radius + 0.5) -- round
local min_radius, max_radius = radius * (radius - 1), radius * (radius + 1)
for index2 = -radius, radius do
-- Offset contributed by other axis 1 plus 1 to make it 1-indexed
local new_index2 = (index2 + offset[other1]) * stride[other1] + 1
for index3 = -radius, radius do
local new_index3 = new_index2 + (index3 + offset[other2]) * stride[other2]
local squared = index2 * index2 + index3 * index3
if squared <= max_radius and (not hollow or squared >= min_radius) then
-- Position is in cylinder, add node here
local vi = new_index3 + (offset[axis] + i) * stride[axis]
data[vi] = node_id
count = count + 1
end
end
end
end
mh.finish(manip, data)
return count
end
--- Adds a pyramid.
-- @param pos Position to center base of pyramid at.
-- @param axis Axis ("x", "y", or "z")
-- @param height Pyramid height.
-- @param node_name Name of node to make pyramid of.
-- @param hollow Whether the pyramid should be hollow.
-- @return The number of nodes added.
function worldedit.pyramid(pos, axis, height, node_name, hollow)
local other1, other2 = worldedit.get_axis_others(axis)
-- Set up voxel manipulator
local manip, area = mh.init_axis_radius(pos, axis,
height >= 0 and height or -height)
local data = mh.get_empty_data(area)
-- Handle inverted pyramids
local start_axis, end_axis, step
if height > 0 then
height = height - 1
step = 1
else
height = height + 1
step = -1
end
-- Add pyramid
local node_id = minetest.get_content_id(node_name)
local stride = {x=1, y=area.ystride, z=area.zstride}
local offset = {
x = pos.x - area.MinEdge.x,
y = pos.y - area.MinEdge.y,
z = pos.z - area.MinEdge.z,
}
local size = math.abs(height * step)
local count = 0
-- For each level of the pyramid
for index1 = 0, height, step do
-- Offset contributed by axis plus 1 to make it 1-indexed
local new_index1 = (index1 + offset[axis]) * stride[axis] + 1
for index2 = -size, size do
local new_index2 = new_index1 + (index2 + offset[other1]) * stride[other1]
for index3 = -size, size do
local i = new_index2 + (index3 + offset[other2]) * stride[other2]
if (not hollow or size - math.abs(index2) < 2 or size - math.abs(index3) < 2) then
data[i] = node_id
count = count + 1
end
end
end
size = size - 1
end
mh.finish(manip, data)
return count
end
--- Adds a spiral.
-- @param pos Position to center spiral at.
-- @param length Spral length.
-- @param height Spiral height.
-- @param spacer Space between walls.
-- @param node_name Name of node to make spiral of.
-- @return Number of nodes added.
-- TODO: Add axis option.
function worldedit.spiral(pos, length, height, spacer, node_name)
local extent = math.ceil(length / 2)
local manip, area = mh.init_axis_radius_length(pos, "y", extent, height)
local data = mh.get_empty_data(area)
-- Set up variables
local node_id = minetest.get_content_id(node_name)
local stride = {x=1, y=area.ystride, z=area.zstride}
local offset_x, offset_y, offset_z = pos.x - area.MinEdge.x, pos.y - area.MinEdge.y, pos.z - area.MinEdge.z
local i = offset_z * stride.z + offset_y * stride.y + offset_x + 1
-- Add first column
local count = height
local column = i
for y = 1, height do
data[column] = node_id
column = column + stride.y
end
-- Add spiral segments
local stride_axis, stride_other = stride.x, stride.z
local sign = -1
local segment_length = 0
spacer = spacer + 1
-- Go through each segment except the last
for segment = 1, math.floor(length / spacer) * 2 do
-- Change sign and length every other turn starting with the first
if segment % 2 == 1 then
sign = -sign
segment_length = segment_length + spacer
end
-- Fill segment
for index = 1, segment_length do
-- Move along the direction of the segment
i = i + stride_axis * sign
local column = i
-- Add column
for y = 1, height do
data[column] = node_id
column = column + stride.y
end
end
count = count + segment_length * height
stride_axis, stride_other = stride_other, stride_axis -- Swap axes
end
-- Add shorter final segment
sign = -sign
for index = 1, segment_length do
i = i + stride_axis * sign
local column = i
-- Add column
for y = 1, height do
data[column] = node_id
column = column + stride.y
end
end
count = count + segment_length * height
mh.finish(manip, data)
return count
end

239
mods/WorldEdit-1.2/worldedit/serialization.lua Normal file
View File

@ -0,0 +1,239 @@
--- Schematic serialization and deserialiation.
-- @module worldedit.serialization
worldedit.LATEST_SERIALIZATION_VERSION = 5
local LATEST_SERIALIZATION_HEADER = worldedit.LATEST_SERIALIZATION_VERSION .. ":"
--[[
Serialization version history:
1: Original format. Serialized Lua table with a weird linked format...
2: Position and node seperated into sub-tables in fields `1` and `2`.
3: List of nodes, one per line, with fields seperated by spaces.
Format: <X> <Y> <Z> <Name> <Param1> <Param2>
4: Serialized Lua table containing a list of nodes with `x`, `y`, `z`,
`name`, `param1`, `param2`, and `meta` fields.
5: Added header and made `param1`, `param2`, and `meta` fields optional.
Header format: <Version>,<ExtraHeaderField1>,...:<Content>
--]]
--- Reads the header of serialized data.
-- @param value Serialized WorldEdit data.
-- @return The version as a positive natural number, or 0 for unknown versions.
-- @return Extra header fields as a list of strings, or nil if not supported.
-- @return Content (data after header).
function worldedit.read_header(value)
if value:find("^[0-9]+[%-:]") then
local header_end = value:find(":", 1, true)
local header = value:sub(1, header_end - 1):split(",")
local version = tonumber(header[1])
table.remove(header, 1)
local content = value:sub(header_end + 1)
return version, header, content
end
-- Old versions that didn't include a header with a version number
if value:find("([+-]?%d+)%s+([+-]?%d+)%s+([+-]?%d+)") and not value:find("%{") then -- List format
return 3, nil, value
elseif value:find("^[^\"']+%{%d+%}") then
if value:find("%[\"meta\"%]") then -- Meta flat table format
return 2, nil, value
end
return 1, nil, value -- Flat table format
elseif value:find("%{") then -- Raw nested table format
return 4, nil, value
end
return nil
end
--- Converts the region defined by positions `pos1` and `pos2`
-- into a single string.
-- @return The serialized data.
-- @return The number of nodes serialized.
function worldedit.serialize(pos1, pos2)
pos1, pos2 = worldedit.sort_pos(pos1, pos2)
worldedit.keep_loaded(pos1, pos2)
local pos = {x=pos1.x, y=0, z=0}
local count = 0
local result = {}
local get_node, get_meta = minetest.get_node, minetest.get_meta
while pos.x <= pos2.x do
pos.y = pos1.y
while pos.y <= pos2.y do
pos.z = pos1.z
while pos.z <= pos2.z do
local node = get_node(pos)
if node.name ~= "air" and node.name ~= "ignore" then
count = count + 1
local meta = get_meta(pos):to_table()
local meta_empty = true
-- Convert metadata item stacks to item strings
for name, inventory in pairs(meta.inventory) do
for index, stack in ipairs(inventory) do
meta_empty = false
inventory[index] = stack.to_string and stack:to_string() or stack
end
end
for k in pairs(meta) do
if k ~= "inventory" then
meta_empty = false
break
end
end
result[count] = {
x = pos.x - pos1.x,
y = pos.y - pos1.y,
z = pos.z - pos1.z,
name = node.name,
param1 = node.param1 ~= 0 and node.param1 or nil,
param2 = node.param2 ~= 0 and node.param2 or nil,
meta = not meta_empty and meta or nil,
}
end
pos.z = pos.z + 1
end
pos.y = pos.y + 1
end
pos.x = pos.x + 1
end
-- Serialize entries
result = minetest.serialize(result)
return LATEST_SERIALIZATION_HEADER .. result, count
end
--- Loads the schematic in `value` into a node list in the latest format.
-- Contains code based on [table.save/table.load](http://lua-users.org/wiki/SaveTableToFile)
-- by ChillCode, available under the MIT license.
-- @return A node list in the latest format, or nil on failure.
local function load_schematic(value)
local version, header, content = worldedit.read_header(value)
local nodes = {}
if version == 1 or version == 2 then -- Original flat table format
local tables = minetest.deserialize(content)
if not tables then return nil end
-- Transform the node table into an array of nodes
for i = 1, #tables do
for j, v in pairs(tables[i]) do
if type(v) == "table" then
tables[i][j] = tables[v[1]]
end
end
end
nodes = tables[1]
if version == 1 then --original flat table format
for i, entry in ipairs(nodes) do
local pos = entry[1]
entry.x, entry.y, entry.z = pos.x, pos.y, pos.z
entry[1] = nil
local node = entry[2]
entry.name, entry.param1, entry.param2 = node.name, node.param1, node.param2
entry[2] = nil
end
end
elseif version == 3 then -- List format
for x, y, z, name, param1, param2 in content:gmatch(
"([+-]?%d+)%s+([+-]?%d+)%s+([+-]?%d+)%s+" ..
"([^%s]+)%s+(%d+)%s+(%d+)[^\r\n]*[\r\n]*") do
param1, param2 = tonumber(param1), tonumber(param2)
table.insert(nodes, {
x = tonumber(x),
y = tonumber(y),
z = tonumber(z),
name = name,
param1 = param1 ~= 0 and param1 or nil,
param2 = param2 ~= 0 and param2 or nil,
})
end
elseif version == 4 or version == 5 then -- Nested table format
if not jit then
-- This is broken for larger tables in the current version of LuaJIT
nodes = minetest.deserialize(content)
else
-- XXX: This is a filthy hack that works surprisingly well - in LuaJIT, `minetest.deserialize` will fail due to the register limit
nodes = {}
content = content:gsub("return%s*{", "", 1):gsub("}%s*$", "", 1) -- remove the starting and ending values to leave only the node data
local escaped = content:gsub("\\\\", "@@"):gsub("\\\"", "@@"):gsub("(\"[^\"]*\")", function(s) return string.rep("@", #s) end)
local startpos, startpos1, endpos = 1, 1
while true do -- go through each individual node entry (except the last)
startpos, endpos = escaped:find("},%s*{", startpos)
if not startpos then
break
end
local current = content:sub(startpos1, startpos)
local entry = minetest.deserialize("return " .. current)
table.insert(nodes, entry)
startpos, startpos1 = endpos, endpos
end
local entry = minetest.deserialize("return " .. content:sub(startpos1)) -- process the last entry
table.insert(nodes, entry)
end
else
return nil
end
return nodes
end
--- Determines the volume the nodes represented by string `value` would occupy
-- if deserialized at `origin_pos`.
-- @return Low corner position.
-- @return High corner position.
-- @return The number of nodes.
function worldedit.allocate(origin_pos, value)
local nodes = load_schematic(value)
if not nodes then return nil end
return worldedit.allocate_with_nodes(origin_pos, nodes)
end
-- Internal
function worldedit.allocate_with_nodes(origin_pos, nodes)
local huge = math.huge
local pos1x, pos1y, pos1z = huge, huge, huge
local pos2x, pos2y, pos2z = -huge, -huge, -huge
local origin_x, origin_y, origin_z = origin_pos.x, origin_pos.y, origin_pos.z
for i, entry in ipairs(nodes) do
local x, y, z = origin_x + entry.x, origin_y + entry.y, origin_z + entry.z
if x < pos1x then pos1x = x end
if y < pos1y then pos1y = y end
if z < pos1z then pos1z = z end
if x > pos2x then pos2x = x end
if y > pos2y then pos2y = y end
if z > pos2z then pos2z = z end
end
local pos1 = {x=pos1x, y=pos1y, z=pos1z}
local pos2 = {x=pos2x, y=pos2y, z=pos2z}
return pos1, pos2, #nodes
end
--- Loads the nodes represented by string `value` at position `origin_pos`.
-- @return The number of nodes deserialized.
function worldedit.deserialize(origin_pos, value)
local nodes = load_schematic(value)
if not nodes then return nil end
local pos1, pos2 = worldedit.allocate_with_nodes(origin_pos, nodes)
worldedit.keep_loaded(pos1, pos2)
local origin_x, origin_y, origin_z = origin_pos.x, origin_pos.y, origin_pos.z
local count = 0
local add_node, get_meta = minetest.add_node, minetest.get_meta
for i, entry in ipairs(nodes) do
entry.x, entry.y, entry.z = origin_x + entry.x, origin_y + entry.y, origin_z + entry.z
-- Entry acts as both position and node
add_node(entry, entry)
if entry.meta then
get_meta(entry):from_table(entry.meta)
end
end
return #nodes
end

Some files were not shown because too many files have changed in this diff Show More