Add debug hologram projector (#79)

StructureLib built the missing block name on the server, where only
en_US is loaded, so players on dedicated servers saw English names in
chat. Send the item's lang key and let the client translate it. Stacks
whose name is not a plain key, GT meta items among them, keep the old
server side name.

Players also saw two shapes of the same message: a bracketed name with
rarity color and an item tooltip from two of the survivalPlaceBlocks
branches, a bare yellow name from the stack list branch. All three now
build the name the same way.

.github/workflows/optimize-images.yml

@@ -0,0 +1,17 @@
+name: Optimize images
+
+on:
+  pull_request:
+    branches: [ master, main, release/** ]
+    paths:
+      - "**/*.png"
+
+  push:
+    branches: [ master, main, release/** ]
+    paths:
+      - "**/*.png"
+
+jobs:
+  optimize-images:
+    uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/optimize-images.yml@master
+    secrets: inherit

.github/workflows/publish-javadoc.yaml

@@ -5,6 +5,7 @@ on:
     branches:
       - master
       - feature/doc
+      - '**/*-javadoc'
     tags:
       - '*'
   delete:
@@ -26,7 +27,7 @@ jobs:
         with:
           fetch-depth: 0
           ref: gh-pages
-    
+
       - name: Deploy 🚀
         id: deploy
         shell: bash
@@ -34,17 +35,17 @@ jobs:
           if git rm -r $TARGET_FOLDER ; then
             echo Nothing to clean up
           fi
-          
+
           find . -name javadoc -type d -print | sed 's#^\./\(.*\)/javadoc$#\1#' | sort --version-sort --reverse > index.txt
           git add index.txt
           git config user.name "${GITHUB_ACTOR}"
           git config user.email "${GITHUB_ACTOR_ID}-${GITHUB_ACTOR}@users.noreply.github.com"
           git commit -m "Clean up javadoc after ref $TARGET_FOLDER is deleted"
           git push
-          echo "hash=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT            
+          echo "hash=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
         env:
           TARGET_FOLDER: ${{ github.ref_name }}
-          
+
   javadoc:
     if: github.event_name == 'push'
     concurrency: javadoc-publish

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is 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.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  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.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  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 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. Use with the GNU Affero General Public License.
+
+  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 Affero 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 special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU 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 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 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 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 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  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 GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

addon.gradle

@@ -1,7 +1,7 @@
 javadoc {
     javadocTool = javaToolchains.javadocToolFor {
         // Last version with frames, but it also has search
-        languageVersion = JavaLanguageVersion.of(11)
+        languageVersion = JavaLanguageVersion.of(25)
         vendor = JvmVendorSpec.ADOPTIUM
     }
 
@@ -18,9 +18,8 @@ javadoc {
 
     options {
         overview "src/main/javadoc/overview.html"
-        links 'https://docs.oracle.com/javase/8/docs/api/'
+        links 'https://docs.oracle.com/en/java/javase/25/docs/api/'
         links 'https://skmedix.github.io/ForgeJavaDocs/javadoc/forge/1.7.10-10.13.4.1614/'
-        addBooleanOption("-frames", true)
     }
 }
 

dependencies.gradle

@@ -1,9 +1,9 @@
 // Add your dependencies here
 
 dependencies {
-    api("com.github.GTNewHorizons:GTNHLib:0.6.39:dev")
-    implementation("com.github.GTNewHorizons:NotEnoughItems:2.7.84-GTNH:dev")
-
+    api("com.github.GTNewHorizons:GTNHLib:0.11.21:dev")
+    implementation("com.github.GTNewHorizons:NotEnoughItems:2.8.110-GTNH:dev")
     testImplementation(platform('org.junit:junit-bom:5.9.2'))
     testImplementation('org.junit.jupiter:junit-jupiter')
+	testRuntimeOnly ('org.junit.platform:junit-platform-launcher')
 }

gradle.properties

@@ -39,9 +39,33 @@ remoteMappings = https\://raw.githubusercontent.com/MinecraftForge/FML/1.7.10/co
 # `./gradlew runClient --username=AnotherPlayer`, or configuring this command in your IDE.
 developmentEnvironmentUserName = Developer
 
-# Enables using modern Java syntax (up to version 17) via Jabel, while still targeting JVM 8.
-# See https://github.com/bsideup/jabel for details on how this works.
-enableModernJavaSyntax = true
+# Enables modern Java syntax support. Valid values:
+# - false: No modern syntax, Java 8 only
+# - jabel: Jabel syntax-only support, compiles to J8 bytecode
+# - jvmDowngrader: Full modern Java via JVM Downgrader (syntax + stdlib APIs)
+# - modern: Native modern Java bytecode, no downgrading
+enableModernJavaSyntax = jabel
+
+# If set, ignores the above setting and compiles with the given toolchain. This may cause unexpected issues,
+# and should *not* be used in most situations. -1 disables this.
+# forceToolchainVersion = -1
+
+# Target JVM version for JVM Downgrader bytecode downgrading.
+# Only used when enableModernJavaSyntax = jvmDowngrader
+# downgradeTargetVersion = 8
+
+# Comma-separated list of Java versions for multi-release jar support (JVM Downgrader only).
+# Classes will be available in META-INF/versions/N/ for each version N in this list.
+# Default: "21,25" (J25+ gets native classes, J21-24 gets partial downgrade, J8-20 gets full downgrade).
+# jvmDowngraderMultiReleaseVersions = 21,25
+
+# Specifies how JVM Downgrader API stubs are provided. Options:
+# - shade: Shade minimized stubs into the jar
+# - gtnhlib: GTNHLib provides stubs at runtime (adds version constraint)
+# - external: Another dependency provides stubs (no constraint, no warning)
+# - (empty): Warning reminding you to configure stubs
+# Note: 'shade' option requires you to verify license compliance, see: https://github.com/unimined/JvmDowngrader/blob/main/LICENSE.md
+# jvmDowngraderStubsProvider =
 
 # Enables injecting missing generics into the decompiled source code for a better coding experience.
 # Turns most publicly visible List, Map, etc. into proper List<E>, Map<K, V> types.
@@ -96,7 +120,9 @@ usesMixinDebug = false
 # Specify the location of your implementation of IMixinConfigPlugin. Leave it empty otherwise.
 mixinPlugin =
 
-# Specify the package that contains all of your Mixins. You may only place Mixins in this package or the build will fail!
+# Specify the package that contains all of your Mixins. The package must exist or
+# the build will fail. If you have a package property defined in your mixins.<modid>.json,
+# it must match with this or the build will fail.
 mixinsPackage = mixins
 
 # Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin!
@@ -172,6 +198,12 @@ curseForgeRelations =
 # projects. New projects should not use this parameter.
 # customArchiveBaseName =
 
+# Optional parameter to customize the default working directory used by the runClient* tasks. Relative to the project directory.
+# runClientWorkingDirectory = run/client
+
+# Optional parameter to customize the default working directory used by the runServer* tasks. Relative to the project directory.
+# runServerWorkingDirectory = run/server
+
 # Optional parameter to have the build automatically fail if an illegal version is used.
 # This can be useful if you e.g. only want to allow versions in the form of '1.1.xxx'.
 # The check is ONLY performed if the version is a git tag.
@@ -201,3 +233,6 @@ curseForgeRelations =
 # This is meant to be set in $HOME/.gradle/gradle.properties.
 # ideaCheckSpotlessOnBuild = true
 
+# Non-GTNH properties
+org.gradle.configuration-cache = true
+org.gradle.parallel = true

gradle/gradle-daemon-jvm.properties

@@ -0,0 +1,12 @@
+#This file is generated by updateDaemonJvm
+toolchainUrl.FREE_BSD.AARCH64=https\://api.foojay.io/disco/v3.0/ids/cf726b4a1c84b50457225f9bba6d7650/redirect
+toolchainUrl.FREE_BSD.X86_64=https\://api.foojay.io/disco/v3.0/ids/fa1e318c287360478e3c83a9a3ef1007/redirect
+toolchainUrl.LINUX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/cf726b4a1c84b50457225f9bba6d7650/redirect
+toolchainUrl.LINUX.X86_64=https\://api.foojay.io/disco/v3.0/ids/fa1e318c287360478e3c83a9a3ef1007/redirect
+toolchainUrl.MAC_OS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/c2dd35c9d0aaf0ba6ad0791320f99dfc/redirect
+toolchainUrl.MAC_OS.X86_64=https\://api.foojay.io/disco/v3.0/ids/e5810bd7fd1f8a586644409d395a7e55/redirect
+toolchainUrl.UNIX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/cf726b4a1c84b50457225f9bba6d7650/redirect
+toolchainUrl.UNIX.X86_64=https\://api.foojay.io/disco/v3.0/ids/fa1e318c287360478e3c83a9a3ef1007/redirect
+toolchainUrl.WINDOWS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/7b3c4877c0749019e6805bb61e421497/redirect
+toolchainUrl.WINDOWS.X86_64=https\://api.foojay.io/disco/v3.0/ids/d76df094a9cbbabd3b08251f9e61444a/redirect
+toolchainVersion=25

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.0-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -57,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/b631911858264c0b6e4d6603d677ff5218766cee/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -114,7 +114,6 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 
 # Determine the Java command to use to start the JVM.
@@ -172,7 +171,6 @@ fi
 # For Cygwin or MSYS, switch paths to Windows format before running java
 if "$cygwin" || "$msys" ; then
     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
     JAVACMD=$( cygpath --unix "$JAVACMD" )
 
@@ -212,8 +210,7 @@ DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
         "$@"
 
 # Stop when "xargs" is not available.

gradlew.bat

@@ -70,11 +70,10 @@ goto fail
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
 
 :end
 @rem End local scope for the variables with windows NT shell

settings.gradle

@@ -17,7 +17,7 @@ pluginManagement {
 }
 
 plugins {
-    id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.42'
+    id 'com.gtnewhorizons.gtnhsettingsconvention' version '2.0.26'
 }
 
 

src/main/java/com/gtnewhorizon/structurelib/ChannelPickHandler.java

@@ -0,0 +1,88 @@
+package com.gtnewhorizon.structurelib;
+
+import java.util.Collection;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ChatComponentTranslation;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+
+import com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor;
+import com.gtnewhorizon.structurelib.net.SetChannelDataMessage;
+
+/**
+ * Handler for middle-click channel picking. When the player holds a hologram projector on the cursor and middle-clicks
+ * a registered indicator item, the corresponding channel is set on the projector. The same applies in world when the
+ * projector is held in hand and a registered indicator block is middle-clicked. Shift+middle-click wipes all channels.
+ * Was made side neutral to support server-side validation at some point if necessary.
+ */
+public final class ChannelPickHandler {
+
+    private ChannelPickHandler() {}
+
+    /**
+     * Handle a middle-click event while holding a hologram projector on the cursor.
+     */
+    public static boolean handleMiddleClick(EntityPlayer player, ItemStack holoStack, @Nullable ItemStack targetStack,
+            final boolean isSneaking) {
+        return handlePick(player, holoStack, targetStack, isSneaking, true);
+    }
+
+    public static boolean handleWorldPick(World world, EntityPlayer player, ItemStack holoStack,
+            @Nullable MovingObjectPosition hit, final boolean isSneaking) {
+        ItemStack targetStack = null;
+
+        if (hit != null) {
+            Block block = world.getBlock(hit.blockX, hit.blockY, hit.blockZ);
+            if (!block.isAir(world, hit.blockX, hit.blockY, hit.blockZ)) {
+                targetStack = block.getPickBlock(hit, world, hit.blockX, hit.blockY, hit.blockZ, player);
+            }
+        }
+
+        // A null target still goes through so that shift+middle-click wipes even when aiming at nothing
+        return handlePick(player, holoStack, targetStack, isSneaking, false);
+    }
+
+    private static boolean handlePick(EntityPlayer player, ItemStack holoStack, @Nullable ItemStack targetStack,
+            final boolean isSneaking, final boolean onCursor) {
+        // Clear channels on shift+middle-click. The "press again to confirm" gesture is gated client-side
+        // (see ChannelWipeConfirmation) before this method is ever called.
+        if (isSneaking) {
+            ChannelDataAccessor.wipeChannelData(holoStack);
+            sendChannelData(player, holoStack, onCursor);
+            player.addChatMessage(new ChatComponentTranslation("structurelib.pickchannel.cleared"));
+            return true;
+        }
+
+        if (targetStack == null) return false; // nothing hovered, cancel silently
+
+        Collection<Map.Entry<String, Integer>> channels = ChannelDescription.iterate(targetStack);
+        if (channels.isEmpty()) {
+            player.addChatMessage(new ChatComponentTranslation("structurelib.pickchannel.nomapping"));
+            return false;
+        }
+
+        // Assuming there's only 1 channel per item for now (same behavior as drag and drop)
+        Map.Entry<String, Integer> first = channels.iterator().next();
+        ChannelDataAccessor.setChannelData(holoStack, first.getKey(), first.getValue());
+        sendChannelData(player, holoStack, onCursor);
+        player.addChatMessage(
+                new ChatComponentTranslation("structurelib.pickchannel.success", first.getKey(), first.getValue()));
+        return true;
+    }
+
+    /**
+     * Player is the one triggering this update, so should already be in-sync.
+     */
+    private static void sendChannelData(EntityPlayer player, ItemStack holoStack, boolean onCursor) {
+        if (!(player instanceof EntityPlayerMP)) {
+            StructureLib.net.sendToServer(new SetChannelDataMessage(holoStack, onCursor));
+        }
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/ChannelWipeConfirmation.java

@@ -0,0 +1,33 @@
+package com.gtnewhorizon.structurelib;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.ChatComponentTranslation;
+
+/**
+ * Client-side-only confirmation gate for "wipe all channels" shift+middle-click gesture.
+ */
+public final class ChannelWipeConfirmation {
+
+    private static final long CONFIRM_WINDOW_MS = 5000;
+    private static long armedAtMs = -1;
+
+    private ChannelWipeConfirmation() {}
+
+    /**
+     * Call this before invoking {@link ChannelPickHandler} whenever the wipe gesture (shift+middle-click) is detected.
+     *
+     * @return true if this is a confirming second press within the window and the wipe should proceed now; false if
+     *         this press only armed the confirmation.
+     */
+    public static boolean confirm(EntityPlayer player) {
+        long now = Minecraft.getSystemTime();
+        if (now - armedAtMs > CONFIRM_WINDOW_MS) {
+            armedAtMs = now;
+            player.addChatMessage(new ChatComponentTranslation("structurelib.pickchannel.confirmwipe"));
+            return false;
+        }
+        armedAtMs = -1;
+        return true;
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/ClientProxy.java

@@ -30,6 +30,7 @@ import net.minecraft.util.IChatComponent;
 import net.minecraft.util.IIcon;
 import net.minecraft.util.Vec3;
 import net.minecraft.world.World;
+import net.minecraftforge.client.event.MouseEvent;
 import net.minecraftforge.client.event.RenderWorldLastEvent;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.common.config.ConfigElement;
@@ -40,6 +41,7 @@ import org.apache.commons.lang3.tuple.Pair;
 import org.lwjgl.opengl.GL11;
 
 import com.gtnewhorizon.structurelib.entity.fx.WeightlessParticleFX;
+import com.gtnewhorizon.structurelib.item.ItemConstructableTrigger;
 import com.gtnewhorizon.structurelib.net.RegistryOrderSyncMessage;
 import com.gtnewhorizon.structurelib.net.SetChannelDataMessage;
 
@@ -53,6 +55,8 @@ import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import cpw.mods.fml.common.gameevent.TickEvent.ClientTickEvent;
 import cpw.mods.fml.common.gameevent.TickEvent.Phase;
 import cpw.mods.fml.common.network.FMLNetworkEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
 
 public class ClientProxy extends CommonProxy {
 
@@ -346,9 +350,7 @@ public class ClientProxy extends CommonProxy {
         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
-            if (!(o instanceof HintParticleInfo)) return false;
-
-            HintParticleInfo that = (HintParticleInfo) o;
+            if (!(o instanceof HintParticleInfo that)) return false;
 
             return x == that.x && y == that.y && z == that.z;
         }
@@ -397,8 +399,6 @@ public class ClientProxy extends CommonProxy {
             double worldY = y + 0.25;
             double worldZ = z + 0.25;
 
-            // this rendering code is independently written by glee8e on July 10th, 2023
-            // and is released as part of StructureLib under LGPL terms, just like everything else in this project
             // cube is a very special model. its facings can be rendered correctly by viewer distance without using
             // surface normals and view vector
             // here we do a 2 pass render.
@@ -564,6 +564,35 @@ public class ClientProxy extends CommonProxy {
 
     public static class ForgeEventHandler {
 
+        @SubscribeEvent
+        @SideOnly(Side.CLIENT)
+        public void onMouseEvent(MouseEvent event) {
+            final EntityPlayer player = Minecraft.getMinecraft().thePlayer;
+
+            if (player == null || player.isDead) {
+                return;
+            }
+
+            final ItemStack heldItem = player.getHeldItem();
+
+            if (heldItem == null || !(heldItem.getItem() instanceof ItemConstructableTrigger)) return;
+
+            if (event.button != 2 || !event.buttonstate) return;
+
+            // Sink the middle click as soon as a projector is held, so vanilla pick block does not run
+            event.setCanceled(true);
+
+            final boolean isSneaking = player.isSneaking();
+            if (isSneaking && !ChannelWipeConfirmation.confirm(player)) return;
+
+            ChannelPickHandler.handleWorldPick(
+                    player.worldObj,
+                    player,
+                    heldItem,
+                    Minecraft.getMinecraft().objectMouseOver,
+                    isSneaking);
+        }
+
         @SubscribeEvent
         public void onEntityJoinWorld(EntityJoinWorldEvent e) {
             if (e.world.isRemote && e.entity instanceof EntityClientPlayerMP) {

src/main/java/com/gtnewhorizon/structurelib/CommonProxy.java

@@ -17,6 +17,7 @@ import net.minecraftforge.common.MinecraftForge;
 import com.gtnewhorizon.structurelib.net.ErrorHintParticleMessage;
 import com.gtnewhorizon.structurelib.net.UpdateHintParticleMessage;
 
+import cpw.mods.fml.common.event.FMLInitializationEvent;
 import cpw.mods.fml.common.event.FMLLoadCompleteEvent;
 import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
@@ -64,6 +65,8 @@ public class CommonProxy {
 
     public void preInit(FMLPreInitializationEvent e) {}
 
+    public void init(FMLInitializationEvent e) {}
+
     public long getOverworldTime() {
         return MinecraftServer.getServer().getEntityWorld().getTotalWorldTime();
     }

src/main/java/com/gtnewhorizon/structurelib/GuiEditRegistryConfig.java

@@ -112,7 +112,6 @@ public class GuiEditRegistryConfig extends GuiScreen {
     /**
      * Adds the buttons (and other controls) to the screen in question.
      */
-    @SuppressWarnings("unchecked")
     @Override
     public void initGui() {
         Keyboard.enableRepeatEvents(true);
@@ -185,8 +184,7 @@ public class GuiEditRegistryConfig extends GuiScreen {
      */
     @Override
     public void onGuiClosed() {
-        if (this.configID != null && this.parentScreen instanceof GuiConfig) {
-            GuiConfig parentGuiConfig = (GuiConfig) this.parentScreen;
+        if (this.configID != null && this.parentScreen instanceof GuiConfig parentGuiConfig) {
             parentGuiConfig.needsRefresh = true;
             parentGuiConfig.initGui();
         }
@@ -319,21 +317,16 @@ public class GuiEditRegistryConfig extends GuiScreen {
         for (EntriesList list : lists) {
             list.drawScreenPost(mouseX, mouseY, partialTicks);
         }
-        if (this.undoHoverChecker.checkHover(mouseX, mouseY)) this.drawToolTip(
+        if (this.undoHoverChecker.checkHover(mouseX, mouseY)) this.func_146283_a(
                 this.mc.fontRenderer.listFormattedStringToWidth(I18n.format("fml.configgui.tooltip.undoAll"), 300),
                 mouseX,
                 mouseY);
-        if (this.resetHoverChecker.checkHover(mouseX, mouseY)) this.drawToolTip(
+        if (this.resetHoverChecker.checkHover(mouseX, mouseY)) this.func_146283_a(
                 this.mc.fontRenderer.listFormattedStringToWidth(I18n.format("fml.configgui.tooltip.resetAll"), 300),
                 mouseX,
                 mouseY);
     }
 
-    @SuppressWarnings("rawtypes")
-    public void drawToolTip(List stringList, int x, int y) {
-        this.func_146283_a(stringList, x, y);
-    }
-
     private class EntriesList extends GuiListExtended {
 
         final String heading;
@@ -571,13 +564,13 @@ public class GuiEditRegistryConfig extends GuiScreen {
         void drawToolTip(int mouseX, int mouseY) {
             // ensure checkHover() is always called, or the hover threshold might fail under certain corner cases
             if (hoverCheckerText.checkHover(mouseX, mouseY)) {
-                GuiEditRegistryConfig.this.drawToolTip(
+                GuiEditRegistryConfig.this.func_146283_a(
                         mc.fontRenderer.listFormattedStringToWidth(tooltip, entriesList.getListWidth()),
                         mouseX,
                         mouseY);
             }
             if (hoverCheckerBtnDrag.checkHover(mouseX, mouseY) && !isDragging) {
-                GuiEditRegistryConfig.this.drawToolTip(
+                GuiEditRegistryConfig.this.func_146283_a(
                         mc.fontRenderer.listFormattedStringToWidth(
                                 I18n.format("structurelib.configgui.drag.tooltip"),
                                 entriesList.getListWidth()),

src/main/java/com/gtnewhorizon/structurelib/SortedRegistry.java

@@ -75,7 +75,6 @@ public class SortedRegistry<V> implements Iterable<V> {
     }
 
     static void cleanup(MinecraftServer server) {
-        @SuppressWarnings("unchecked")
         List<EntityPlayerMP> players = server.getConfigurationManager().playerEntityList;
         Set<UUID> onlinePlayerIDs = players.stream().map(EntityPlayerMP::getUniqueID).collect(Collectors.toSet());
         int removed = 0;

src/main/java/com/gtnewhorizon/structurelib/StructureLib.java

@@ -22,6 +22,7 @@ import com.gtnewhorizon.structurelib.command.CommandConfigureChannels;
 import com.gtnewhorizon.structurelib.command.CommandRegistryDebug;
 import com.gtnewhorizon.structurelib.item.ItemBlockHint;
 import com.gtnewhorizon.structurelib.item.ItemConstructableTrigger;
+import com.gtnewhorizon.structurelib.item.ItemDebugConstructableTrigger;
 import com.gtnewhorizon.structurelib.item.ItemFrontRotationTool;
 import com.gtnewhorizon.structurelib.net.AlignmentMessage;
 import com.gtnewhorizon.structurelib.net.ErrorHintParticleMessage;
@@ -33,6 +34,7 @@ import com.gtnewhorizon.structurelib.util.XSTR;
 
 import cpw.mods.fml.common.Mod;
 import cpw.mods.fml.common.SidedProxy;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
 import cpw.mods.fml.common.event.FMLInterModComms;
 import cpw.mods.fml.common.event.FMLLoadCompleteEvent;
 import cpw.mods.fml.common.event.FMLPreInitializationEvent;
@@ -98,6 +100,7 @@ public class StructureLib {
     static Item itemBlockHint;
     static Item itemFrontRotationTool;
     static Item itemConstructableTrigger;
+    static Item itemDebugConstructableTrigger;
     public static final CreativeTabs creativeTab = new CreativeTabs("structurelib") {
 
         @Override
@@ -118,6 +121,9 @@ public class StructureLib {
         GameRegistry.registerItem(
                 itemConstructableTrigger = new ItemConstructableTrigger(),
                 itemConstructableTrigger.getUnlocalizedName());
+        GameRegistry.registerItem(
+                itemDebugConstructableTrigger = new ItemDebugConstructableTrigger(),
+                itemDebugConstructableTrigger.getUnlocalizedName());
         proxy.preInit(e);
         NetworkRegistry.INSTANCE.registerGuiHandler(instance(), new GuiHandler());
 
@@ -128,6 +134,11 @@ public class StructureLib {
         DevelopHelper.onPreInit();
     }
 
+    @Mod.EventHandler
+    public void init(FMLInitializationEvent e) {
+        proxy.init(e);
+    }
+
     @Mod.EventHandler
     public void loadComplete(FMLLoadCompleteEvent e) {
         proxy.loadComplete(e);

src/main/java/com/gtnewhorizon/structurelib/alignment/constructable/ChannelDataAccessor.java

@@ -38,7 +38,9 @@ public class ChannelDataAccessor {
      * If given subchannel does not exist, masterStack may or may not be returned to save performance. Code within
      * StructureLib can depend on this behavior, you cannot.
      *
-     * @param masterStack trigger item. can be the return value of another {@link #withChannel(ItemStack, String)} call
+     * @param masterStack trigger item. can be the return value of another
+     *                    {@link com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor#withChannel(net.minecraft.item.ItemStack, String)}
+     *                    call
      * @param channel     subchannel to use. will use current master channel data instead if this channel does not exist
      *                    Note: all channel identifiers are supposed to be lower case and not empty.
      * @return a trigger item with new master channel
@@ -107,13 +109,13 @@ public class ChannelDataAccessor {
      * 
      * @param masterStack trigger stack to check
      * @param channel     channel identifier. Note: all channel identifiers are supposed to be lower case and not empty.
-     * @param data        subchannel data. should always be a positive value
+     * @param data        positive subchannel data
      */
     public static void setChannelData(ItemStack masterStack, String channel, int data) {
         if (StringUtils.isEmpty(channel) || masterStack == null) throw new IllegalArgumentException();
+        if (data < 1) throw new IllegalArgumentException("Channel data must be positive");
         if (StructureLibAPI.isDebugEnabled() && !channel.toLowerCase(Locale.ROOT).equals(channel))
             throw new IllegalArgumentException("Channel name can be lower case ONLY");
-        if (data <= 0) throw new IllegalArgumentException();
         if (masterStack.stackTagCompound == null) masterStack.stackTagCompound = new NBTTagCompound();
         NBTTagCompound main = masterStack.stackTagCompound;
         if (!main.hasKey(SECONDARY_HINT_TAG, TAG_COMPOUND)) main.setTag(SECONDARY_HINT_TAG, new NBTTagCompound());
@@ -146,7 +148,12 @@ public class ChannelDataAccessor {
      */
     public static void wipeChannelData(ItemStack masterStack) {
         if (masterStack == null) throw new IllegalArgumentException();
-        if (masterStack.stackTagCompound != null) masterStack.stackTagCompound.removeTag(SECONDARY_HINT_TAG);
+        if (masterStack.stackTagCompound != null) {
+            masterStack.stackTagCompound.removeTag(SECONDARY_HINT_TAG);
+            if (masterStack.stackTagCompound.hasNoTags()) {
+                masterStack.stackTagCompound = null;
+            }
+        }
     }
 
     /**

src/main/java/com/gtnewhorizon/structurelib/alignment/constructable/ConstructableUtility.java

@@ -16,6 +16,7 @@ import com.gtnewhorizon.structurelib.StructureLib;
 import com.gtnewhorizon.structurelib.StructureLibAPI;
 import com.gtnewhorizon.structurelib.alignment.IAlignment;
 import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing;
+import com.gtnewhorizon.structurelib.item.ItemDebugConstructableTrigger;
 import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
 
@@ -70,11 +71,10 @@ public class ConstructableUtility {
 
         if (constructable == null) return false;
 
-        if (aPlayer instanceof EntityPlayerMP) {
-            EntityPlayerMP playerMP = (EntityPlayerMP) aPlayer;
+        if (aPlayer instanceof EntityPlayerMP playerMP) {
             // server side and sneaking (already checked above)
             // do construct
-            if (aPlayer.capabilities.isCreativeMode) {
+            if (aPlayer.capabilities.isCreativeMode || aStack.getItem() instanceof ItemDebugConstructableTrigger) {
                 constructable.construct(aStack, false);
             } else if (constructable instanceof ISurvivalConstructable) {
                 int built = ((ISurvivalConstructable) constructable).survivalConstruct(

src/main/java/com/gtnewhorizon/structurelib/block/BlockHint.java

@@ -50,6 +50,10 @@ public class BlockHint extends Block {
 
     @Override
     public IIcon getIcon(int aSide, int aMeta) {
+        // For numbered hints, top and bottom are blank
+        if (aSide <= 1 && aMeta <= 11) {
+            return hint[13];
+        }
         return hint[aMeta];
     }
 
@@ -61,10 +65,9 @@ public class BlockHint extends Block {
     }
 
     @Override
-    @SuppressWarnings("unchecked")
-    public void getSubBlocks(Item aItem, CreativeTabs par2CreativeTabs, List aList) {
+    public void getSubBlocks(Item item, CreativeTabs tab, List<ItemStack> list) {
         for (int i = 0; i <= 15; i++) {
-            aList.add(new ItemStack(aItem, 1, i));
+            list.add(new ItemStack(item, 1, i));
         }
     }
 }

src/main/java/com/gtnewhorizon/structurelib/command/CommandConfigureChannels.java

@@ -26,7 +26,7 @@ public class CommandConfigureChannels extends CommandBase {
     public String getCommandUsage(ICommandSender p_71518_1_) {
         return "/sl_channel <wipe/getall>\n" + "/sl_channel <get/unset> <channel name>\n"
                 + "/sl_channel <set> <channel name> <value>\n"
-                + "<channel name> can have space in it. <value> must be positive integer";
+                + "<channel name> can have space in it. Values below 1 clear the channel";
     }
 
     @Override
@@ -45,9 +45,7 @@ public class CommandConfigureChannels extends CommandBase {
     public void processCommand(ICommandSender sender, String[] args) {
         if (args.length == 0) throw new WrongUsageException(getCommandUsage(sender));
 
-        if (!(sender instanceof EntityPlayerMP)) throw new WrongUsageException("must be a player");
-
-        EntityPlayerMP player = (EntityPlayerMP) sender;
+        if (!(sender instanceof EntityPlayerMP player)) throw new WrongUsageException("must be a player");
 
         ItemStack heldItem = player.getHeldItem();
         if (heldItem == null || !(heldItem.getItem() instanceof ItemConstructableTrigger)) {
@@ -110,11 +108,14 @@ public class CommandConfigureChannels extends CommandBase {
                     throw new WrongUsageException("%s not a valid value", args[args.length - 1]);
                 }
 
-                if (value <= 0) throw new WrongUsageException("%s not a valid value", args[args.length - 1]);
-
-                ChannelDataAccessor.setChannelData(heldItem, channel, value);
+                if (value < 1) {
+                    ChannelDataAccessor.unsetChannelData(heldItem, channel);
+                } else {
+                    ChannelDataAccessor.setChannelData(heldItem, channel, value);
+                }
                 player.inventoryContainer.detectAndSendChanges();
-                sender.addChatMessage(new ChatComponentText(channel + " value: " + value));
+                sender.addChatMessage(
+                        new ChatComponentText(value < 1 ? channel + " no value" : channel + " value: " + value));
                 break;
         }
     }

src/main/java/com/gtnewhorizon/structurelib/command/CommandRegistryDebug.java

@@ -39,9 +39,7 @@ public class CommandRegistryDebug extends CommandBase {
     public void processCommand(ICommandSender sender, String[] args) {
         if (args.length != 1) throw new WrongUsageException(getCommandUsage(sender));
 
-        if (!(sender instanceof EntityPlayerMP)) throw new WrongUsageException("must be a player");
-
-        EntityPlayerMP player = (EntityPlayerMP) sender;
+        if (!(sender instanceof EntityPlayerMP player)) throw new WrongUsageException("must be a player");
 
         SortedRegistry<?> registry = SortedRegistry.getRegistry(args[0]);
         if (registry == null) throw new WrongUsageException("registry not found");

src/main/java/com/gtnewhorizon/structurelib/core/StructureLibCore.java

@@ -1,5 +1,6 @@
 package com.gtnewhorizon.structurelib.core;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
@@ -7,7 +8,9 @@ import java.util.Set;
 
 import com.gtnewhorizon.gtnhmixins.IEarlyMixinLoader;
 
+import cpw.mods.fml.relauncher.FMLLaunchHandler;
 import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
+import cpw.mods.fml.relauncher.Side;
 
 @IFMLLoadingPlugin.MCVersion("1.7.10")
 public class StructureLibCore implements IFMLLoadingPlugin, IEarlyMixinLoader {
@@ -44,6 +47,11 @@ public class StructureLibCore implements IFMLLoadingPlugin, IEarlyMixinLoader {
 
     @Override
     public List<String> getMixins(Set<String> loadedCoreMods) {
-        return Arrays.asList("blockChangeNotifier.MixinForgeHooks", "blockChangeNotifier.MixinWorld");
+        List<String> mixins = new ArrayList<>(
+                Arrays.asList("blockChangeNotifier.MixinForgeHooks", "blockChangeNotifier.MixinWorld"));
+        if (FMLLaunchHandler.side() == Side.CLIENT) {
+            mixins.add("MixinGuiContainer_PickChannel");
+        }
+        return mixins;
     }
 }

src/main/java/com/gtnewhorizon/structurelib/gui/GuiScreenConfigureChannels.java

@@ -64,6 +64,9 @@ public class GuiScreenConfigureChannels extends GuiContainer implements IGuiScre
     private GuiTextField key, value;
     protected int guiTop, guiLeft;
     private List<String> info;
+    private boolean wipePending = false;
+    private long wipePendingTime = 0;
+    private static final long WIPE_CONFIRM_TIMEOUT_MS = 3000;
 
     public GuiScreenConfigureChannels(Container container, ItemStack trigger) {
         super(container);
@@ -164,40 +167,17 @@ public class GuiScreenConfigureChannels extends GuiContainer implements IGuiScre
         list.onGuiInit(this);
         autoCompleteList.onGuiInit(this);
 
-        addButton(
-                new GuiButton(
-                        ADD_BTN,
-                        guiLeft + 12,
-                        guiTop + 157,
-                        47,
-                        20,
-                        I18n.format("item.structurelib.constructableTrigger.gui.add")));
-        addButton(
-                new GuiButton(
-                        UNSET_BTN,
-                        guiLeft + 65,
-                        guiTop + 157,
-                        47,
-                        20,
-                        I18n.format("item.structurelib.constructableTrigger.gui.unset")));
-        addButton(
-                new GuiButton(
-                        WIPE_BTN,
-                        guiLeft + 118,
-                        guiTop + 157,
-                        47,
-                        20,
-                        I18n.format("item.structurelib.constructableTrigger.gui.wipe")));
+        addButton(new GuiButton(ADD_BTN, guiLeft + 12, guiTop + 157, 47, 20, I18n.format(I18N_PREFIX + "add")));
+        addButton(new GuiButton(UNSET_BTN, guiLeft + 65, guiTop + 157, 47, 20, I18n.format(I18N_PREFIX + "unset")));
+        addButton(new GuiButton(WIPE_BTN, guiLeft + 118, guiTop + 157, 47, 20, I18n.format(I18N_PREFIX + "wipe")));
 
         updateButtons();
         tooltipSplitCache.clear();
         info = StreamSupport
                 .stream(
-                        Splitter.on("\\n").split(
-                                StatCollector.translateToLocal("item.structurelib.constructableTrigger.gui.info"))
-                                .spliterator(),
+                        Splitter.on("\\n").split(StatCollector.translateToLocal(I18N_PREFIX + "info")).spliterator(),
                         false)
-                .flatMap(line -> fontRendererObj.listFormattedStringToWidth(line, width * 3 / 5).stream())
+                .flatMap(line -> fontRendererObj.listFormattedStringToWidth(line, width * 1 / 3).stream())
                 .collect(Collectors.toList());
     }
 
@@ -241,8 +221,7 @@ public class GuiScreenConfigureChannels extends GuiContainer implements IGuiScre
         actionPerformed(but);
     }
 
-    @SuppressWarnings("unchecked")
-    private List<GuiButton> getButtonList() {
+    public List<GuiButton> getButtonList() {
         return buttonList;
     }
 
@@ -285,6 +264,11 @@ public class GuiScreenConfigureChannels extends GuiContainer implements IGuiScre
         switch (aKey) {
             case Keyboard.KEY_TAB:
                 if (key.isFocused()) {
+                    if (autoCompleteList.getSelectedElement() != null) {
+                        key.setText(autoCompleteList.getSelectedElement());
+                        return;
+                    }
+
                     key.setFocused(false);
                     value.setFocused(true);
                 } else {
@@ -322,11 +306,10 @@ public class GuiScreenConfigureChannels extends GuiContainer implements IGuiScre
                 }
                 break;
         }
-        if (key.textboxKeyTyped(aChar, aKey)) {
+        if (key.textboxKeyTyped(aChar, aKey) || value.textboxKeyTyped(aChar, aKey)) {
             updateButtons();
             return;
         }
-        if (value.textboxKeyTyped(aChar, aKey)) return;
         super.keyTyped(aChar, aKey);
     }
 
@@ -337,7 +320,8 @@ public class GuiScreenConfigureChannels extends GuiContainer implements IGuiScre
         boolean existing = !StringUtils.isEmpty(keyText) && ChannelDataAccessor.hasSubChannel(trigger, keyText);
         getButtonList().get(ADD_BTN).displayString = existing ? I18n.format(I18N_PREFIX + "set")
                 : I18n.format(I18N_PREFIX + "add");
-        getButtonList().get(ADD_BTN).enabled = !StringUtils.isBlank(value.getText())
+        getButtonList().get(ADD_BTN).enabled = !StringUtils.isBlank(key.getText())
+                && !StringUtils.isBlank(value.getText())
                 && Integer.parseInt(value.getText()) > 0;
         getButtonList().get(UNSET_BTN).enabled = existing && !StringUtils.isBlank(value.getText());
 
@@ -365,9 +349,17 @@ public class GuiScreenConfigureChannels extends GuiContainer implements IGuiScre
                 ChannelDataAccessor.unsetChannelData(trigger, key.getText());
                 break;
             case WIPE_BTN:
-                ChannelDataAccessor.wipeChannelData(trigger);
-                key.setText("");
-                this.value.setText("");
+                if (!wipePending) {
+                    wipePending = true;
+                    wipePendingTime = System.currentTimeMillis();
+                    btn.displayString = I18n.format(I18N_PREFIX + "wipe.confirm");
+                } else {
+                    wipePending = false;
+                    btn.displayString = I18n.format(I18N_PREFIX + "wipe");
+                    ChannelDataAccessor.wipeChannelData(trigger);
+                    key.setText("");
+                    this.value.setText("");
+                }
                 break;
         }
 
@@ -388,6 +380,10 @@ public class GuiScreenConfigureChannels extends GuiContainer implements IGuiScre
         super.updateScreen();
         key.updateCursorCounter();
         value.updateCursorCounter();
+        if (wipePending && System.currentTimeMillis() - wipePendingTime > WIPE_CONFIRM_TIMEOUT_MS) {
+            wipePending = false;
+            getButtonList().get(WIPE_BTN).displayString = I18n.format(I18N_PREFIX + "wipe");
+        }
     }
 
     @Override
@@ -397,22 +393,10 @@ public class GuiScreenConfigureChannels extends GuiContainer implements IGuiScre
         int topLeftY = (this.height - this.getYSize()) / 2;
         drawTexturedModalRect(topLeftX, topLeftY, 0, 0, getXSize(), getYSize());
         list.drawScreen(mX, mY, partialTick);
-        fontRendererObj.drawString(
-                I18n.format("item.structurelib.constructableTrigger.gui.title"),
-                guiLeft + 12,
-                guiTop + 9,
-                0);
-        fontRendererObj.drawString(
-                I18n.format("item.structurelib.constructableTrigger.gui.key"),
-                guiLeft + 12,
-                guiTop + 122,
-                0);
+        fontRendererObj.drawString(I18n.format(I18N_PREFIX + "title"), guiLeft + 12, guiTop + 9, 0);
+        fontRendererObj.drawString(I18n.format(I18N_PREFIX + "key"), guiLeft + 12, guiTop + 122, 0);
         key.drawTextBox();
-        fontRendererObj.drawString(
-                I18n.format("item.structurelib.constructableTrigger.gui.value"),
-                guiLeft + 12,
-                guiTop + 142,
-                0);
+        fontRendererObj.drawString(I18n.format(I18N_PREFIX + "value"), guiLeft + 12, guiTop + 142, 0);
         value.drawTextBox();
     }
 
@@ -455,7 +439,7 @@ public class GuiScreenConfigureChannels extends GuiContainer implements IGuiScre
             tooltip.addAll(
                     fontRendererObj.listFormattedStringToWidth(
                             StatCollector.translateToLocalFormatted(
-                                    "item.structurelib.constructableTrigger.gui.channels.from",
+                                    I18N_PREFIX + "channels.from",
                                     Loader.instance().getIndexedModList().get(e.getKey()).getName()),
                             maxLine));
             tooltip.addAll(

src/main/java/com/gtnewhorizon/structurelib/item/ItemBlockHint.java

@@ -21,10 +21,9 @@ public class ItemBlockHint extends ItemBlock {
     }
 
     @Override
-    @SuppressWarnings("unchecked")
-    public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List aList, boolean aF3_H) {
-        aList.add(translateToLocal("structurelib.blockhint.desc.0")); // Helps while building
-        switch (aStack.getItemDamage()) {
+    public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean adv) {
+        tooltip.add(translateToLocal("structurelib.blockhint.desc.0")); // Helps while building
+        switch (stack.getItemDamage()) {
             case 0:
             case 1:
             case 2:
@@ -37,35 +36,36 @@ public class ItemBlockHint extends ItemBlock {
             case 9:
             case 10:
             case 11:
-                aList.add(
+                // Placeholder for a certain group.
+                tooltip.add(
                         EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD
-                                + translateToLocal("structurelib.blockhint.desc.1")); // Placeholder for a certain
-                                                                                      // group.
+                                + translateToLocal("structurelib.blockhint.desc.1"));
                 break;
             case 12:
-                aList.add(
+                // General placeholder.
+                tooltip.add(
                         EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD
-                                + translateToLocal("structurelib.blockhint.desc.2")); // General placeholder.
+                                + translateToLocal("structurelib.blockhint.desc.2"));
                 break;
             case 13:
-                aList.add(
+                // Make sure it contains Air material.
+                tooltip.add(
                         EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD
-                                + translateToLocal("structurelib.blockhint.desc.3")); // Make sure it contains Air
-                                                                                      // material.
+                                + translateToLocal("structurelib.blockhint.desc.3"));
                 break;
             case 14:
-                aList.add(
+                // Make sure it does not contain Air material.
+                tooltip.add(
                         EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD
-                                + translateToLocal("structurelib.blockhint.desc.4")); // Make sure it does not contain
-                                                                                      // Air material.
+                                + translateToLocal("structurelib.blockhint.desc.4"));
                 break;
             case 15:
-                aList.add(EnumChatFormatting.BLUE + translateToLocal("structurelib.blockhint.desc.5")); // ERROR, what
-                                                                                                        // did u expect?
+                // ERROR, what did u expect?
+                tooltip.add(EnumChatFormatting.BLUE + translateToLocal("structurelib.blockhint.desc.5"));
                 break;
             default: // WTF?
-                aList.add("Damn son where did you get that!?");
-                aList.add(EnumChatFormatting.BLUE + "From outer space... I guess...");
+                tooltip.add("Damn son where did you get that!?");
+                tooltip.add(EnumChatFormatting.BLUE + "From outer space... I guess...");
         }
     }
 

src/main/java/com/gtnewhorizon/structurelib/item/ItemConstructableTrigger.java

@@ -45,31 +45,30 @@ public class ItemConstructableTrigger extends Item {
         return ConstructableUtility.handle(stack, player, world, x, y, z, side);
     }
 
-    @SuppressWarnings("unchecked")
     @Override
-    public void addInformation(ItemStack aStack, EntityPlayer ep, List aList, boolean boo) {
+    public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean adv) {
         if (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
-            aList.add(
+            tooltip.add(
                     translateToLocalFormatted(
                             "item.structurelib.constructableTrigger.desc.lshift.0",
-                            ChannelDataAccessor.countChannelData(aStack)));
-            ChannelDataAccessor.iterateChannelData(aStack).map(e -> e.getKey() + ": " + e.getValue())
-                    .forEach(aList::add);
+                            ChannelDataAccessor.countChannelData(stack)));
+            ChannelDataAccessor.iterateChannelData(stack).map(e -> e.getKey() + ": " + e.getValue())
+                    .forEach(tooltip::add);
         } else {
-            aList.add(translateToLocal("item.structurelib.constructableTrigger.desc.0")); // Triggers Constructable
-                                                                                          // Interface
-            aList.add(BLUE + translateToLocal("item.structurelib.constructableTrigger.desc.1")); // Shows multiblock
-                                                                                                 // construction
-                                                                                                 // details,
-            aList.add(BLUE + translateToLocal("item.structurelib.constructableTrigger.desc.2")); // just Use on a
-                                                                                                 // multiblock
-                                                                                                 // controller.
-            aList.add(BLUE + translateToLocal("item.structurelib.constructableTrigger.desc.3")); // (Sneak Use in
-                                                                                                 // creative to build)
-            aList.add(BLUE + translateToLocal("item.structurelib.constructableTrigger.desc.4")); // Quantity affects
-                                                                                                 // tier/mode/type
-            if (ChannelDataAccessor.hasSubChannel(aStack))
-                aList.add(translateToLocal("item.structurelib.constructableTrigger.desc.5"));
+            // Tooltip text:
+            // Triggers Constructable Interface
+            // Shows multiblock construction details,
+            // just Use on a multiblock controller.
+            // (Sneak Use in creative to build)
+            // Quantity affects tier/mode/type
+
+            tooltip.add(translateToLocal("item.structurelib.constructableTrigger.desc.0"));
+            tooltip.add(BLUE + translateToLocal("item.structurelib.constructableTrigger.desc.1"));
+            tooltip.add(BLUE + translateToLocal("item.structurelib.constructableTrigger.desc.2"));
+            tooltip.add(BLUE + translateToLocal("item.structurelib.constructableTrigger.desc.3"));
+            tooltip.add(BLUE + translateToLocal("item.structurelib.constructableTrigger.desc.4"));
+            if (ChannelDataAccessor.hasSubChannel(stack))
+                tooltip.add(translateToLocal("item.structurelib.constructableTrigger.desc.5"));
         }
     }
 }

src/main/java/com/gtnewhorizon/structurelib/item/ItemDebugConstructableTrigger.java

@@ -0,0 +1,14 @@
+package com.gtnewhorizon.structurelib.item;
+
+import static com.gtnewhorizon.structurelib.StructureLibAPI.MOD_ID;
+
+/**
+ * Hologram projector that always performs a creative build, whatever the player's game mode.
+ */
+public class ItemDebugConstructableTrigger extends ItemConstructableTrigger {
+
+    public ItemDebugConstructableTrigger() {
+        setUnlocalizedName("structurelib.debugConstructableTrigger");
+        setTextureName(MOD_ID + ":itemDebugConstructableTrigger");
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/item/ItemFrontRotationTool.java

@@ -34,15 +34,14 @@ public class ItemFrontRotationTool extends Item {
 
     @Override
     @SideOnly(Side.CLIENT)
-    public void addInformation(ItemStack p_77624_1_, EntityPlayer p_77624_2_, List<String> aList, boolean p_77624_4_) {
-        aList.add(translateToLocal("item.structurelib.frontRotationTool.desc.0")); // Triggers Front Rotation Interface
-        aList.add(EnumChatFormatting.BLUE + translateToLocal("item.structurelib.frontRotationTool.desc.1")); // Rotates
-                                                                                                             // only the
-                                                                                                             // front
-                                                                                                             // panel,
-        aList.add(EnumChatFormatting.BLUE + translateToLocal("item.structurelib.frontRotationTool.desc.2")); // which
-                                                                                                             // allows
-                                                                                                             // structure
-                                                                                                             // rotation.
+    public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean adv) {
+        // Tooltip Text:
+        // Triggers Front Rotation Interface
+        // Rotates only the front panel,
+        // which allows structure rotation.
+
+        tooltip.add(translateToLocal("item.structurelib.frontRotationTool.desc.0"));
+        tooltip.add(EnumChatFormatting.BLUE + translateToLocal("item.structurelib.frontRotationTool.desc.1"));
+        tooltip.add(EnumChatFormatting.BLUE + translateToLocal("item.structurelib.frontRotationTool.desc.2"));
     }
 }

src/main/java/com/gtnewhorizon/structurelib/mixins/early/MixinGuiContainer_PickChannel.java

@@ -0,0 +1,64 @@
+package com.gtnewhorizon.structurelib.mixins.early;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import com.gtnewhorizon.structurelib.ChannelPickHandler;
+import com.gtnewhorizon.structurelib.ChannelWipeConfirmation;
+import com.gtnewhorizon.structurelib.StructureLib;
+import com.gtnewhorizon.structurelib.item.ItemConstructableTrigger;
+
+import codechicken.nei.NEIClientConfig;
+import codechicken.nei.guihook.GuiContainerManager;
+import cpw.mods.fml.common.Loader;
+
+@Mixin(value = GuiContainer.class, priority = 100)
+public abstract class MixinGuiContainer_PickChannel {
+
+    @Inject(method = "mouseClicked(III)V", at = @At("HEAD"), cancellable = true)
+    private void slib$onMouseClicked(int mouseX, int mouseY, int mouseButton, CallbackInfo ci) {
+        if (mouseButton != 2) return;
+
+        EntityPlayer player = Minecraft.getMinecraft().thePlayer;
+        if (player == null) return;
+
+        ItemStack cursorStack = player.inventory.getItemStack();
+        if (cursorStack == null || !(cursorStack.getItem() instanceof ItemConstructableTrigger)) return;
+
+        // Sink middle click as soon as projector is picked up
+        ci.cancel();
+
+        ItemStack hoveredStack = null;
+        try {
+            Slot slot = slib$invokeGetSlotAtPosition(mouseX, mouseY);
+            if (slot != null) {
+                hoveredStack = slot.getStack();
+            }
+
+            // try NEI
+            if (hoveredStack == null && Loader.isModLoaded("NotEnoughItems") && !NEIClientConfig.isHidden()) {
+                hoveredStack = GuiContainerManager.getStackMouseOver((GuiContainer) (Object) this);
+            }
+        } catch (Exception e) {
+            StructureLib.LOGGER.error("Error while resolving hovered slot for channel pick", e);
+        }
+
+        boolean isSneaking = GuiScreen.isShiftKeyDown();
+        if (isSneaking && !ChannelWipeConfirmation.confirm(player)) return;
+
+        ChannelPickHandler.handleMiddleClick(player, cursorStack, hoveredStack, isSneaking);
+    }
+
+    @Invoker("getSlotAtPosition")
+    protected abstract Slot slib$invokeGetSlotAtPosition(int x, int y);
+}

src/main/java/com/gtnewhorizon/structurelib/net/SetChannelDataMessage.java

@@ -23,15 +23,22 @@ import io.netty.buffer.ByteBuf;
 public class SetChannelDataMessage implements IMessage {
 
     private final List<Map.Entry<String, Integer>> data = new ArrayList<>();
+    private boolean onCursor;
 
     public SetChannelDataMessage() {}
 
     public SetChannelDataMessage(ItemStack trigger) {
+        this(trigger, false);
+    }
+
+    public SetChannelDataMessage(ItemStack trigger, final boolean onCursor) {
+        this.onCursor = onCursor;
         ChannelDataAccessor.iterateChannelData(trigger).forEach(data::add);
     }
 
     @Override
     public void fromBytes(ByteBuf buf) {
+        onCursor = buf.readBoolean();
         data.clear();
         int size = ByteBufUtils.readVarShort(buf);
         for (int i = 0; i < size; i++) {
@@ -41,6 +48,7 @@ public class SetChannelDataMessage implements IMessage {
 
     @Override
     public void toBytes(ByteBuf buf) {
+        buf.writeBoolean(onCursor);
         ByteBufUtils.writeVarShort(buf, data.size());
         for (Entry<String, Integer> e : data) {
             ByteBufUtils.writeUTF8String(buf, e.getKey());
@@ -53,11 +61,11 @@ public class SetChannelDataMessage implements IMessage {
         @Override
         public IMessage onMessage(SetChannelDataMessage message, MessageContext ctx) {
             EntityPlayerMP player = ctx.getServerHandler().playerEntity;
-            ItemStack heldItem = player.getHeldItem();
-            if (heldItem != null && heldItem.getItem() instanceof ItemConstructableTrigger) {
-                ChannelDataAccessor.wipeChannelData(heldItem);
+            ItemStack target = message.onCursor ? player.inventory.getItemStack() : player.getHeldItem();
+            if (target != null && target.getItem() instanceof ItemConstructableTrigger) {
+                ChannelDataAccessor.wipeChannelData(target);
                 for (Entry<String, Integer> e : message.data) {
-                    ChannelDataAccessor.setChannelData(heldItem, e.getKey(), e.getValue());
+                    ChannelDataAccessor.setChannelData(target, e.getKey(), e.getValue());
                 }
                 // since this is a set all channel request from the client, we would assume client already know
                 // what this would look like on the client, so no sync
@@ -65,7 +73,7 @@ public class SetChannelDataMessage implements IMessage {
                 StructureLib.LOGGER.warn(
                         "{} trying to set channel data on {}, which is not a hologram projector!",
                         player.getUniqueID(),
-                        heldItem);
+                        target);
             }
             return null;
         }

src/main/java/com/gtnewhorizon/structurelib/structure/ChatThrottleKey.java

@@ -14,9 +14,7 @@ class ChatThrottleKey {
         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
-            if (!(o instanceof NoExplicitChannel)) return false;
-
-            NoExplicitChannel that = (NoExplicitChannel) o;
+            if (!(o instanceof NoExplicitChannel that)) return false;
 
             return subchannel.equals(that.subchannel);
         }

src/main/java/com/gtnewhorizon/structurelib/structure/IChannelDefinition.java

@@ -0,0 +1,98 @@
+package com.gtnewhorizon.structurelib.structure;
+
+/**
+ * Describes a channel used by one structure definition.
+ *
+ * <p>
+ * Channel values are integers stored on the constructable trigger item. Implementations may override the default
+ * validation and normalization policy when a simple bounded range is not sufficient.
+ * </p>
+ */
+public interface IChannelDefinition {
+
+    /**
+     * Creates a channel with a bounded inclusive range and clamping normalization.
+     *
+     * @param channel      channel identifier
+     * @param minimumValue inclusive minimum value
+     * @param maximumValue inclusive maximum value
+     * @return bounded channel definition
+     */
+    static IChannelDefinition bounded(String channel, int minimumValue, int maximumValue) {
+        if (minimumValue < 1 || maximumValue < minimumValue) {
+            throw new IllegalArgumentException("Invalid channel bounds");
+        }
+        return new IChannelDefinition() {
+
+            @Override
+            public String getChannel() {
+                return channel;
+            }
+
+            @Override
+            public int getMinimumValue() {
+                return minimumValue;
+            }
+
+            @Override
+            public int getMaximumValue() {
+                return maximumValue;
+            }
+        };
+    }
+
+    /**
+     * Creates a channel accepting every positive integer.
+     *
+     * @param channel channel identifier
+     * @return unbounded channel definition
+     */
+    static IChannelDefinition unbounded(String channel) {
+        return () -> channel;
+    }
+
+    /**
+     * Returns the lower-case channel identifier.
+     *
+     * @return channel identifier
+     */
+    String getChannel();
+
+    /**
+     * Returns the smallest value advertised by this definition. The default is {@code 1}.
+     *
+     * @return minimum value
+     */
+    default int getMinimumValue() {
+        return 1;
+    }
+
+    /**
+     * Returns the largest value advertised by this definition. The default is {@link java.lang.Integer#MAX_VALUE}.
+     *
+     * @return maximum value
+     */
+    default int getMaximumValue() {
+        return Integer.MAX_VALUE;
+    }
+
+    /**
+     * Checks whether a value is already valid without normalization.
+     *
+     * @param value value to check
+     * @return true when the value is valid
+     */
+    default boolean isValueValid(int value) {
+        return value >= getMinimumValue() && value <= getMaximumValue();
+    }
+
+    /**
+     * Converts a stored value to the value used by the structure definition.
+     *
+     * @param value stored value
+     * @return normalized value
+     */
+    default int normalizeValue(int value) {
+        return Math.max(getMinimumValue(), Math.min(getMaximumValue(), value));
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/structure/IStructureDefinition.java

@@ -3,6 +3,8 @@ package com.gtnewhorizon.structurelib.structure;
 import static com.gtnewhorizon.structurelib.structure.IStructureWalker.ignoreBlockUnloaded;
 import static com.gtnewhorizon.structurelib.structure.IStructureWalker.skipBlockUnloaded;
 
+import java.util.Collection;
+import java.util.Collections;
 import java.util.function.Function;
 
 import net.minecraft.entity.player.EntityPlayer;
@@ -56,6 +58,48 @@ import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing;
  */
 public interface IStructureDefinition<T> {
 
+    /**
+     * Returns channel definitions declared by this structure.
+     *
+     * @return an immutable or otherwise read-only channel collection
+     */
+    default Collection<IChannelDefinition> getChannelDefinitions() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * Returns channel definitions explicitly added by the structure builder.
+     *
+     * @return explicitly declared channel definitions
+     */
+    default Collection<IChannelDefinition> getExplicitChannelDefinitions() {
+        return getChannelDefinitions();
+    }
+
+    /**
+     * Finds a channel definition by identifier.
+     *
+     * @param channel channel identifier
+     * @return channel definition, or {@code null} when it is not declared
+     */
+    default IChannelDefinition getChannelDefinition(String channel) {
+        for (IChannelDefinition definition : getChannelDefinitions()) {
+            if (definition.getChannel().equals(channel)) return definition;
+        }
+        return null;
+    }
+
+    /**
+     * Reads one channel using the standard trigger-item channel semantics.
+     *
+     * @param trigger trigger item containing channel data
+     * @param channel channel identifier
+     * @return stored channel data, or the trigger stack size when absent
+     */
+    default int getChannelData(ItemStack trigger, String channel) {
+        return ChannelDataAccessor.getChannelData(trigger, channel);
+    }
+
     /**
      * Used internally
      * <p>
@@ -319,6 +363,22 @@ public interface IStructureDefinition<T> {
         return walker.getBuilt();
     }
 
+    default void iterate(String piece, World world, ExtendedFacing extendedFacing, int basePositionX, int basePositionY,
+            int basePositionZ, int basePositionA, int basePositionB, int basePositionC, IStructureWalker<T> predicate) {
+        StructureUtility.iterateV2(
+                getStructureFor(piece),
+                world,
+                extendedFacing,
+                basePositionX,
+                basePositionY,
+                basePositionZ,
+                basePositionA,
+                basePositionB,
+                basePositionC,
+                predicate,
+                "customIterate");
+    }
+
     /**
      * Low level utility.
      *

src/main/java/com/gtnewhorizon/structurelib/structure/IStructureElement.java

@@ -4,7 +4,9 @@ import static com.gtnewhorizon.structurelib.StructureLib.LOGGER;
 import static com.gtnewhorizon.structurelib.StructureLib.PANIC_MODE;
 
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
@@ -32,6 +34,15 @@ public interface IStructureElement<T> {
 
     boolean check(T t, World world, int x, int y, int z);
 
+    /**
+     * Returns the channels used by this element.
+     *
+     * @return lower-case channel identifiers
+     */
+    default Collection<String> getChannels() {
+        return Collections.emptySet();
+    }
+
     /**
      * Pure (stateless and side effect free) function to test if current block could be valid. Used to give user hints
      * about incorrectly placed blocks given a controller and trigger item. If couldBeValid(...) == false for a set of
@@ -42,6 +53,30 @@ public interface IStructureElement<T> {
         return true;
     }
 
+    /**
+     * Returns a human-readable description of what block(s) this element accepts. Used for diagnostic messages when
+     * structure checks fail (e.g. "expected Input Bus at (1, 2, 3)").
+     * <p>
+     * Unlike {@link #getBlocksToPlace}, which returns the full set of concrete block variants for autoplacing (e.g.
+     * every tier of Input Bus), this method returns <b>category-level</b> descriptions suitable for display to the
+     * player (e.g. just "Input Bus"). It also requires no parameters, no world, trigger item, or environment, making it
+     * usable in contexts where those are unavailable.
+     * <p>
+     * Implementations should return <b>lang keys</b> (e.g. {@code "tile.blockGlass.name"}) rather than pre-translated
+     * display names. The caller is responsible for translating these keys on the client side via
+     * {@code StatCollector.translateToLocal()}. If a key has no matching translation, {@code translateToLocal} returns
+     * the input string unchanged, so pre-translated fallback strings also work.
+     *
+     * @param context the context object (e.g. the multiblock controller), used to determine state-dependent
+     *                descriptions
+     * @return a list of accepted block descriptions as lang keys (or display names as fallback), or null if no
+     *         description is available
+     */
+    @Nullable
+    default List<String> getDescription(T context) {
+        return null;
+    }
+
     boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger);
 
     boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger);
@@ -71,7 +106,7 @@ public interface IStructureElement<T> {
                 "Default implementation of survivalPlaceBlock hit! Things aren't going to work well! IStructureElement class: {}",
                 getClass().getName());
         if (!StructureLibAPI.isBlockTriviallyReplaceable(world, x, y, z, actor)) return PlaceResult.REJECT;
-        return PlaceResult.SKIP;
+        return PlaceResult.REJECT_CONTINUE;
     }
 
     /**
@@ -181,7 +216,7 @@ public interface IStructureElement<T> {
         if (StructureLibAPI.isDebugEnabled()) LOGGER.info(
                 "Fallback shim code of survivalPlaceBlock hit! Things aren't going to work well! IStructureElement class: {}",
                 getClass().getName());
-        return PlaceResult.SKIP;
+        return PlaceResult.REJECT_CONTINUE;
     }
 
     /**
@@ -204,6 +239,12 @@ public interface IStructureElement<T> {
             public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
                 return IStructureElement.this.spawnHint(t, world, x, y, z, trigger);
             }
+
+            @Nullable
+            @Override
+            public List<String> getDescription(T context) {
+                return IStructureElement.this.getDescription(context);
+            }
         };
     }
 
@@ -237,16 +278,21 @@ public interface IStructureElement<T> {
 
     enum PlaceResult {
         /**
-         * This element either exists already, or does not yet have an implementation for survivalPlaceBlock, or some
-         * other unforeseen situations. TODO this definition doesn't seem right. Should we separate SKIP from EXISTS, or
-         * SKIP from ERROR?
+         * The element's check passed, the position is already valid. No placement is needed. In the walker: continue
+         * iteration (no error, not counted as placed). In ofChain: short-circuits, remaining alternatives are skipped.
          */
         SKIP,
         /**
-         * This element's space is occupied by other stuff and require player attention, or player missing required
-         * resource, or the block cannot be placed due to obscure mechanisms, or some other unforeseen situations.
+         * The element cannot handle this position (occupied, missing resources, etc.). In the walker: stop iteration
+         * with error particles. In ofChain: try next alternative.
          */
         REJECT,
+        /**
+         * This element has no survivalPlaceBlock implementation (default fallback), or otherwise cannot place but is
+         * not an error condition. In the walker: continue iteration silently (like SKIP). In ofChain: try next
+         * alternative (like REJECT), so a better-suited element can handle it.
+         */
+        REJECT_CONTINUE,
         /**
          * Autoplace cannot proceed within this tick. To proceed further would require stopping the placement and wait
          * for next round.

src/main/java/com/gtnewhorizon/structurelib/structure/IStructureElementChain.java

@@ -1,7 +1,9 @@
 package com.gtnewhorizon.structurelib.structure;
 
 import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
@@ -61,6 +63,19 @@ public interface IStructureElementChain<T> extends IStructureElement<T> {
         return false;
     }
 
+    @Nullable
+    @Override
+    default List<String> getDescription(T context) {
+        Set<String> descriptions = new LinkedHashSet<>();
+        for (IStructureElement<T> fallback : fallbacks()) {
+            List<String> desc = fallback.getDescription(context);
+            if (desc != null) {
+                descriptions.addAll(desc);
+            }
+        }
+        return descriptions.isEmpty() ? null : new ArrayList<>(descriptions);
+    }
+
     @Nullable
     @Override
     default BlocksToPlace getBlocksToPlace(T t, World world, int x, int y, int z, ItemStack trigger,
@@ -82,47 +97,51 @@ public interface IStructureElementChain<T> extends IStructureElement<T> {
     @Override
     default PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger, IItemSource s,
             EntityPlayerMP actor, Consumer<IChatComponent> chatter) {
-        boolean haveSkip = false;
+        boolean allContinue = true;
         List<IChatComponent> bufferedNoise = new ArrayList<>();
         for (IStructureElement<T> fallback : fallbacks()) {
             PlaceResult result = fallback.survivalPlaceBlock(t, world, x, y, z, trigger, s, actor, bufferedNoise::add);
             switch (result) {
+                case REJECT_CONTINUE:
+                    break;
                 case REJECT:
+                    allContinue = false;
                     break;
                 case SKIP:
-                    haveSkip = true;
-                    break;
+                    bufferedNoise.forEach(chatter);
+                    return PlaceResult.SKIP;
                 default:
                     return result;
             }
         }
         // dump all that noise back into upstream
         bufferedNoise.forEach(chatter);
-        // TODO need reconsider to ensure this is the right course of action
-        return haveSkip ? PlaceResult.SKIP : PlaceResult.REJECT;
+        return allContinue ? PlaceResult.REJECT_CONTINUE : PlaceResult.REJECT;
     }
 
     @Override
     default PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger,
             AutoPlaceEnvironment env) {
-        boolean haveSkip = false;
+        boolean allContinue = true;
         List<IChatComponent> bufferedNoise = new ArrayList<>();
         for (IStructureElement<T> fallback : fallbacks()) {
             PlaceResult result = fallback
                     .survivalPlaceBlock(t, world, x, y, z, trigger, env.withChatter(bufferedNoise::add));
             switch (result) {
+                case REJECT_CONTINUE:
+                    break;
                 case REJECT:
+                    allContinue = false;
                     break;
                 case SKIP:
-                    haveSkip = true;
-                    break;
+                    bufferedNoise.forEach(env.getChatter());
+                    return PlaceResult.SKIP;
                 default:
                     return result;
             }
         }
         // dump all that noise back into upstream
         bufferedNoise.forEach(env.getChatter());
-        // TODO need reconsider to ensure this is the right course of action
-        return haveSkip ? PlaceResult.SKIP : PlaceResult.REJECT;
+        return allContinue ? PlaceResult.REJECT_CONTINUE : PlaceResult.REJECT;
     }
 }

src/main/java/com/gtnewhorizon/structurelib/structure/IStructureElementCheckOnly.java

@@ -27,12 +27,12 @@ public interface IStructureElementCheckOnly<T> extends IStructureElement<T> {
     @Override
     default PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger, IItemSource s,
             EntityPlayerMP actor, Consumer<IChatComponent> chatter) {
-        return PlaceResult.SKIP;
+        return PlaceResult.REJECT_CONTINUE;
     }
 
     @Override
     default PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger,
             AutoPlaceEnvironment env) {
-        return PlaceResult.SKIP;
+        return PlaceResult.REJECT_CONTINUE;
     }
 }

src/main/java/com/gtnewhorizon/structurelib/structure/IStructureWalker.java

@@ -2,8 +2,25 @@ package com.gtnewhorizon.structurelib.structure;
 
 import net.minecraft.world.World;
 
-interface IStructureWalker<T> {
+/**
+ * A functional interface that is used to iterate over an arbitrary structure.
+ */
+@FunctionalInterface
+public interface IStructureWalker<T> {
 
+    /**
+     * Called once per structure element.
+     *
+     * @param element The current element
+     * @param world   The current world
+     * @param x       The absolute X position of the element in world coordinates
+     * @param y       The absolute Y position of the element in world coordinates
+     * @param z       The absolute Z position of the element in world coordinates
+     * @param a       The relative A position of the element in structure-local coordinates (pre transform)
+     * @param b       The relative B position of the element in structure-local coordinates (pre transform)
+     * @param c       The relative C position of the element in structure-local coordinates (pre transform)
+     * @return False to stop iterating, true to continue.
+     */
     boolean visit(IStructureElement<T> element, World world, int x, int y, int z, int a, int b, int c);
 
     default boolean blockNotLoaded(IStructureElement<T> element, World world, int x, int y, int z, int a, int b,

src/main/java/com/gtnewhorizon/structurelib/structure/LazyStructureElement.java

@@ -1,5 +1,6 @@
 package com.gtnewhorizon.structurelib.structure;
 
+import java.util.List;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
@@ -65,4 +66,10 @@ class LazyStructureElement<T> implements IStructureElementDeferred<T> {
             AutoPlaceEnvironment env) {
         return get(t).survivalPlaceBlock(t, world, x, y, z, trigger, env);
     }
+
+    @Nullable
+    @Override
+    public List<String> getDescription(T context) {
+        return elem != null ? elem.getDescription(context) : null;
+    }
 }

src/main/java/com/gtnewhorizon/structurelib/structure/StructureDefinition.java

@@ -5,8 +5,12 @@ import static com.gtnewhorizon.structurelib.structure.StructureUtility.notAir;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.step;
 
 import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Locale;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Set;
@@ -19,18 +23,28 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
     private final Map<Character, IStructureElement<T>> elements;
     private final Map<String, String> shapes;
     private final Map<String, IStructureElement<T>[]> structures;
-    private final Map<String, Set<Vec3Impl>> occupiedSpaces;
+    private final Map<String, OccupiedSpace> occupiedSpaces;
+    private final Map<String, IChannelDefinition> channelDefinitions;
+    private final Set<String> explicitChannels;
+    private final Collection<IChannelDefinition> channelDefinitionValues;
+    private final Collection<IChannelDefinition> explicitChannelDefinitions;
 
     public static <B> Builder<B> builder() {
         return new Builder<>();
     }
 
     private StructureDefinition(Map<Character, IStructureElement<T>> elements, Map<String, String> shapes,
-            Map<String, IStructureElement<T>[]> structures, Map<String, Set<Vec3Impl>> occupiedSpaces) {
+            Map<String, IStructureElement<T>[]> structures, Map<String, OccupiedSpace> occupiedSpaces,
+            Map<String, IChannelDefinition> channelDefinitions, Set<String> explicitChannels) {
         this.elements = elements;
         this.shapes = shapes;
         this.structures = structures;
         this.occupiedSpaces = occupiedSpaces;
+        this.channelDefinitions = Collections.unmodifiableMap(new HashMap<>(channelDefinitions));
+        this.explicitChannels = Collections.unmodifiableSet(new HashSet<>(explicitChannels));
+        this.channelDefinitionValues = Collections.unmodifiableCollection(this.channelDefinitions.values());
+        this.explicitChannelDefinitions = Collections.unmodifiableList(
+                this.explicitChannels.stream().map(this.channelDefinitions::get).collect(Collectors.toList()));
     }
 
     public static class Builder<T> {
@@ -42,13 +56,17 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
         private final Map<Vec3Impl, Character> navigates;
         private final Map<Character, IStructureElement<T>> elements;
         private final Map<String, String> shapes;
-        private final Map<String, Set<Vec3Impl>> occupiedSpaces;
+        private final Map<String, OccupiedSpace> occupiedSpaces;
+        private final Map<String, IChannelDefinition> channels;
+        private final Set<String> explicitChannels;
 
         private Builder() {
             navigates = new HashMap<>();
             elements = new HashMap<>();
             shapes = new HashMap<>();
             occupiedSpaces = new HashMap<>();
+            channels = new HashMap<>();
+            explicitChannels = new HashSet<>();
         }
 
         public Map<Character, IStructureElement<T>> getElements() {
@@ -95,7 +113,19 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
                 }
                 builder.setLength(builder.length() - 1);
             }
-            Set<Vec3Impl> occupiedSpace = new HashSet<>();
+            int sizeA = 0;
+            int sizeB = 0;
+            long occupiedCount = 0;
+            for (String[] strings : structurePiece) {
+                sizeB = Math.max(sizeB, strings.length);
+                for (String string : strings) {
+                    sizeA = Math.max(sizeA, string.length());
+                    for (int i = 0; i < string.length(); i++) {
+                        if (string.charAt(i) != ' ') occupiedCount++;
+                    }
+                }
+            }
+            OccupiedSpace occupiedSpace = new OccupiedSpace(sizeA, sizeB, structurePiece.length, occupiedCount);
             // these track the global current location
             int aa = 0, bb = 0, cc = 0;
             // these track the vec3 towards next meaningful element
@@ -109,7 +139,7 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
                 } else if (ch == '~') {
                     builder.setCharAt(i, A);
                     ch = A;
-                    occupiedSpace.add(Vec3Impl.getFromPool(aa, bb, cc));
+                    occupiedSpace.add(aa, bb, cc);
                 }
                 if (ch == A) {
                     aa++;
@@ -135,28 +165,45 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
                         addElement(navigate, step(vec3));
                     }
                     builder.setCharAt(i - 1, navigate);
-                    occupiedSpace.add(Vec3Impl.getFromPool(aa, bb, cc));
+                    occupiedSpace.add(aa, bb, cc);
                     aa++;
                     a = 0;
                     b = 0;
                     c = 0;
                 } else {
-                    occupiedSpace.add(Vec3Impl.getFromPool(aa, bb, cc));
+                    occupiedSpace.add(aa, bb, cc);
                     aa++;
                 }
             }
 
             occupiedSpaces.put(name, occupiedSpace);
 
-            String built = builder.toString().replaceAll("[\\uA000\\uB000\\uC000]", "");
+            boolean hasPlus = false;
+            boolean hasMinus = false;
 
-            if (built.contains("+")) {
+            int write = 0;
+            for (int read = 0; read < builder.length(); read++) {
+                char ch = builder.charAt(read);
+                if (ch == A || ch == B || ch == C) {
+                    continue;
+                }
+                if (ch == '+') {
+                    hasPlus = true;
+                } else if (ch == '-') {
+                    hasMinus = true;
+                }
+                if (read != write) builder.setCharAt(write, ch);
+                write++;
+            }
+            builder.setLength(write);
+
+            if (hasPlus) {
                 addElement('+', notAir());
             }
-            if (built.contains("-")) {
+            if (hasMinus) {
                 addElement('-', isAir());
             }
-            shapes.put(name, built);
+            shapes.put(name, builder.toString());
             return this;
         }
 
@@ -165,22 +212,61 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
          */
         @Deprecated
         public Builder<T> addElement(Character name, IStructureElement<T> structurePiece) {
-            elements.putIfAbsent(name, structurePiece);
+            if (elements.putIfAbsent(name, structurePiece) == null) registerElementChannel(structurePiece);
             return this;
         }
 
         public Builder<T> addElement(char name, IStructureElement<T> structurePiece) {
-            elements.putIfAbsent(name, structurePiece);
+            if (elements.putIfAbsent(name, structurePiece) == null) registerElementChannel(structurePiece);
             return this;
         }
 
+        public Builder<T> addChannel(IChannelDefinition definition) {
+            validateChannelDefinition(definition);
+            channels.put(definition.getChannel(), definition);
+            explicitChannels.add(definition.getChannel());
+            return this;
+        }
+
+        public Builder<T> addChannel(String channel, int minimumValue, int maximumValue) {
+            return addChannel(IChannelDefinition.bounded(channel, minimumValue, maximumValue));
+        }
+
+        private void registerElementChannel(IStructureElement<T> structurePiece) {
+            for (String channel : structurePiece.getChannels()) {
+                validateChannelName(channel);
+                if (!explicitChannels.contains(channel)) {
+                    channels.putIfAbsent(channel, IChannelDefinition.unbounded(channel));
+                }
+            }
+        }
+
+        private void validateChannelDefinition(IChannelDefinition definition) {
+            if (definition == null) throw new IllegalArgumentException("Channel definition cannot be null");
+            validateChannelName(definition.getChannel());
+            if (definition.getMinimumValue() < 1 || definition.getMaximumValue() < definition.getMinimumValue()) {
+                throw new IllegalArgumentException("Invalid channel definition values");
+            }
+        }
+
+        private void validateChannelName(String channel) {
+            if (channel == null || channel.isEmpty() || !channel.toLowerCase(Locale.ROOT).equals(channel)) {
+                throw new IllegalArgumentException("Channel name must be non-empty and lower case");
+            }
+        }
+
         public IStructureDefinition<T> build() {
+            for (IStructureElement<T> element : elements.values()) {
+                registerElementChannel(element);
+            }
             Map<String, IStructureElement<T>[]> structures = compileStructureMap();
             return new StructureDefinition<>(
                     new HashMap<>(elements),
                     new HashMap<>(shapes),
                     structures,
-                    occupiedSpaces);
+                    occupiedSpaces,
+                    channels,
+                    explicitChannels);
         }
 
         @SuppressWarnings("unchecked")
@@ -233,6 +319,21 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
         return structures;
     }
 
+    @Override
+    public Collection<IChannelDefinition> getChannelDefinitions() {
+        return channelDefinitionValues;
+    }
+
+    @Override
+    public Collection<IChannelDefinition> getExplicitChannelDefinitions() {
+        return explicitChannelDefinitions;
+    }
+
+    @Override
+    public IChannelDefinition getChannelDefinition(String channel) {
+        return channelDefinitions.get(channel);
+    }
+
     @Override
     public IStructureElement<T>[] getStructureFor(String name) {
         IStructureElement<T>[] elements = structures.get(name);
@@ -242,8 +343,49 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
 
     @Override
     public boolean isContainedInStructure(String name, int offsetA, int offsetB, int offsetC) {
-        Set<Vec3Impl> occupiedSpace = occupiedSpaces.get(name);
+        OccupiedSpace occupiedSpace = occupiedSpaces.get(name);
         if (occupiedSpace == null) throw new NoSuchElementException(name);
-        return occupiedSpace.contains(new Vec3Impl(offsetA, offsetB, offsetC));
+        return occupiedSpace.contains(offsetA, offsetB, offsetC);
+    }
+
+    private static class OccupiedSpace {
+
+        private final int sizeA;
+        private final int sizeB;
+        private final int sizeC;
+        private final BitSet occupied;
+        private final Set<Vec3Impl> sparseOccupied;
+
+        private OccupiedSpace(int sizeA, int sizeB, int sizeC, long occupiedCount) {
+            this.sizeA = sizeA;
+            this.sizeB = sizeB;
+            this.sizeC = sizeC;
+            long volume = (long) sizeA * sizeB * sizeC;
+            if (volume <= Integer.MAX_VALUE && volume <= Math.max(1024L, occupiedCount * 256L)) {
+                occupied = new BitSet((int) volume);
+                sparseOccupied = null;
+            } else {
+                occupied = null;
+                sparseOccupied = new HashSet<>();
+            }
+        }
+
+        private void add(int a, int b, int c) {
+            if (occupied != null) {
+                occupied.set(index(a, b, c));
+            } else {
+                sparseOccupied.add(new Vec3Impl(a, b, c));
+            }
+        }
+
+        private boolean contains(int a, int b, int c) {
+            if (a < 0 || b < 0 || c < 0 || a >= sizeA || b >= sizeB || c >= sizeC) return false;
+            if (occupied != null) return occupied.get(index(a, b, c));
+            return sparseOccupied.contains(new Vec3Impl(a, b, c));
+        }
+
+        private int index(int a, int b, int c) {
+            return (c * sizeB + b) * sizeA + a;
+        }
     }
 }

src/main/java/com/gtnewhorizon/structurelib/structure/StructureUtility.java

@@ -4,12 +4,14 @@ import static com.gtnewhorizon.structurelib.StructureLib.LOGGER;
 import static com.gtnewhorizon.structurelib.StructureLib.PANIC_MODE;
 import static java.lang.Integer.MIN_VALUE;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -30,15 +32,18 @@ import javax.annotation.Nullable;
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.event.HoverEvent;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChatComponentText;
 import net.minecraft.util.ChatComponentTranslation;
 import net.minecraft.util.IChatComponent;
 import net.minecraft.util.IIcon;
+import net.minecraft.util.StatCollector;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
@@ -314,6 +319,25 @@ public class StructureUtility {
         return survivalPlaceBlock(block, meta, world, x, y, z, s, (EntityPlayer) actor, chatter);
     }
 
+    /**
+     * Build a chat component naming the given stack, so that the receiving client localizes it.
+     * <p>
+     * Falls back to the server side display name for stacks whose name is not a plain translation key, e.g. items that
+     * assemble their name in {@link Item#getItemStackDisplayName(ItemStack)}.
+     */
+    private static IChatComponent getStackChatName(ItemStack stack) {
+        String key = stack.getUnlocalizedName() + ".name";
+        if (!StatCollector.canTranslate(key)) return stack.func_151000_E();
+        IChatComponent name = new ChatComponentText("[").appendSibling(new ChatComponentTranslation(key))
+                .appendText("]");
+        NBTTagCompound tag = new NBTTagCompound();
+        stack.writeToNBT(tag);
+        name.getChatStyle()
+                .setChatHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_ITEM, new ChatComponentText(tag.toString())))
+                .setColor(stack.getRarity().rarityColor);
+        return name;
+    }
+
     /**
      * This is a helper method for implementing
      * {@link IStructureElement#survivalPlaceBlock(Object, World, int, int, int, ItemStack, IItemSource, EntityPlayerMP, Consumer)}
@@ -338,13 +362,10 @@ public class StructureUtility {
         ItemStack stack = new ItemStack(itemBlock, 1, itemMeta);
         if (!s.takeOne(stack, true)) {
             if (chatter != null) chatter.accept(
-                    new ChatComponentTranslation(
-                            "structurelib.autoplace.error.no_simple_block",
-                            stack.func_151000_E()));
+                    new ChatComponentTranslation("structurelib.autoplace.missing_block", getStackChatName(stack)));
             return PlaceResult.REJECT;
         }
-        if (block instanceof ICustomBlockSetting) {
-            ICustomBlockSetting blockCustom = (ICustomBlockSetting) block;
+        if (block instanceof ICustomBlockSetting blockCustom) {
             blockCustom.setBlock(world, x, y, z, meta);
         } else if (!stack.copy()
                 .tryPlaceItemIntoWorld(actor, world, x, y, z, ForgeDirection.UP.ordinal(), 0.5f, 0.5f, 0.5f)) {
@@ -447,7 +468,7 @@ public class StructureUtility {
         if (!StructureLibAPI.isBlockTriviallyReplaceable(world, x, y, z, actor)) return PlaceResult.REJECT;
         if (!assumeStackPresent && !s.takeOne(stack, true)) {
             if (chatter != null) chatter.accept(
-                    new ChatComponentTranslation("structurelib.autoplace.error.no_item_stack", stack.func_151000_E()));
+                    new ChatComponentTranslation("structurelib.autoplace.missing_block", getStackChatName(stack)));
             return PlaceResult.REJECT;
         }
         if (!stack.copy().tryPlaceItemIntoWorld(actor, world, x, y, z, ForgeDirection.UP.ordinal(), 0.5f, 0.5f, 0.5f))
@@ -637,7 +658,7 @@ public class StructureUtility {
      * given tier, then player will be allowed to use multiple kinds of blocks, but their tier is guaranteed to be the
      * same.
      * <p>
-     * <h3>WARNING</h3> <b>You SHOULD NOT return notSet from your tierExtractor.</b> If you do so, we will have this
+     * <h4>WARNING</h4> <b>You SHOULD NOT return notSet from your tierExtractor.</b> If you do so, we will have this
      * chain of events:
      * <ul>
      * <li>at check start, tier is reset to notSet
@@ -650,7 +671,7 @@ public class StructureUtility {
      * doing its business
      * <li>Player enjoy a (probably) hilariously shaped multi and (probably) reduced build cost.
      * </ul>
-     * <h3>Example Implementation</h3>
+     * <h4>Example Implementation</h4>
      * <p>
      * Assume you have 16 tier, each map to one particular block's 16 different meta. You will usually want something
      * like this
@@ -706,6 +727,29 @@ public class StructureUtility {
     public static <T, TIER> IStructureElement<T> ofBlocksTiered(ITierConverter<TIER> tierExtractor,
             @Nullable List<Pair<Block, Integer>> allKnownTiers, @Nullable TIER notSet, BiConsumer<T, TIER> setter,
             Function<T, TIER> getter) {
+        List<String> descriptions = null;
+        if (allKnownTiers != null) {
+            descriptions = new ArrayList<>();
+            for (Pair<Block, Integer> tier : allKnownTiers) {
+                Item item = Item.getItemFromBlock(tier.getLeft());
+                if (item != null) {
+                    descriptions.add(new ItemStack(item, 1, tier.getRight()).getUnlocalizedName() + ".name");
+                }
+            }
+        }
+        return ofBlocksTiered(tierExtractor, allKnownTiers, notSet, setter, getter, descriptions);
+    }
+
+    /**
+     * Like {@link #ofBlocksTiered(ITierConverter, List, Object, BiConsumer, Function)}, but with an explicit
+     * description that will be returned by {@link IStructureElement#getDescription(Object)}.
+     *
+     * @param description the description lang keys to attach to this element, or null for no description
+     * @see #ofBlocksTiered(ITierConverter, List, Object, BiConsumer, Function)
+     */
+    public static <T, TIER> IStructureElement<T> ofBlocksTiered(ITierConverter<TIER> tierExtractor,
+            @Nullable List<Pair<Block, Integer>> allKnownTiers, @Nullable TIER notSet, BiConsumer<T, TIER> setter,
+            Function<T, TIER> getter, @Nullable List<String> description) {
         List<Pair<Block, Integer>> hints = allKnownTiers == null ? Collections.emptyList() : allKnownTiers;
         if (hints.stream().anyMatch(Objects::isNull)) throw new IllegalArgumentException();
         IStructureElementCheckOnly<T> check = ofBlocksTiered(tierExtractor, notSet, setter, getter);
@@ -746,8 +790,7 @@ public class StructureUtility {
             public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
                 Pair<Block, Integer> hint = getHint(trigger);
                 if (hint == null) return false;
-                if (hint.getKey() instanceof ICustomBlockSetting) {
-                    ICustomBlockSetting block = (ICustomBlockSetting) hint.getKey();
+                if (hint.getKey() instanceof ICustomBlockSetting block) {
                     block.setBlock(world, x, y, z, hint.getValue());
                 } else {
                     world.setBlock(x, y, z, hint.getKey(), hint.getValue(), 2);
@@ -767,7 +810,7 @@ public class StructureUtility {
             public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger,
                     AutoPlaceEnvironment env) {
                 Pair<Block, Integer> hint = getHint(trigger);
-                if (hint == null) return PlaceResult.REJECT; // TODO or SKIP?
+                if (hint == null) return PlaceResult.REJECT;
                 Block block = world.getBlock(x, y, z);
                 int meta = world.getBlockMetadata(x, y, z);
                 TIER tier = tierExtractor.convert(block, meta);
@@ -784,6 +827,24 @@ public class StructureUtility {
                         env.getActor(),
                         env.getChatter());
             }
+
+            @Nullable
+            @Override
+            public List<String> getDescription(T context) {
+                TIER currentTier = getter.apply(context);
+                if (Objects.equals(currentTier, notSet)) return description;
+
+                for (Pair<Block, Integer> pair : hints) {
+                    TIER pairTier = tierExtractor.convert(pair.getKey(), pair.getValue());
+                    if (!Objects.equals(pairTier, currentTier)) continue;
+                    Item item = Item.getItemFromBlock(pair.getKey());
+                    if (item == null) continue;
+                    return Collections
+                            .singletonList(new ItemStack(item, 1, pair.getValue()).getUnlocalizedName() + ".name");
+                }
+                return description;
+            }
+
         };
     }
 
@@ -1407,10 +1468,65 @@ public class StructureUtility {
                         AutoPlaceEnvironment env) {
                     return BlocksToPlace.create(block, meta);
                 }
+
+                @Nullable
+                @Override
+                public List<String> getDescription(T context) {
+                    Item item = Item.getItemFromBlock(block);
+                    if (item == null) return null;
+                    return Collections.singletonList(new ItemStack(item, 1, meta).getUnlocalizedName() + ".name");
+                }
             };
         } else {
             return new IStructureElement<T>() {
 
+                @Override
+                public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger,
+                        AutoPlaceEnvironment env) {
+                    BlocksToPlace e = getBlocksToPlace(t, world, x, y, z, trigger, env);
+                    IItemSource source = env.getSource();
+                    EntityPlayer actor = env.getActor();
+                    Consumer<IChatComponent> chatter = env.getChatter();
+                    if (check(t, world, x, y, z)) return PlaceResult.SKIP;
+                    if (e.getStacks() == null) {
+                        ItemStack taken = source.takeOne(e.getPredicate(), true);
+                        return StructureUtility.survivalPlaceBlock(
+                                taken,
+                                NBTMode.EXACT,
+                                taken.stackTagCompound,
+                                false,
+                                world,
+                                x,
+                                y,
+                                z,
+                                source,
+                                actor,
+                                chatter);
+                    }
+                    for (ItemStack stack : e.getStacks()) {
+                        if (!source.takeOne(stack, true)) {
+                            env.getChatter().accept(
+                                    new ChatComponentTranslation(
+                                            "structurelib.autoplace.missing_block",
+                                            getStackChatName(stack)));
+                            continue;
+                        }
+                        return StructureUtility.survivalPlaceBlock(
+                                stack,
+                                NBTMode.EXACT,
+                                stack.stackTagCompound,
+                                false,
+                                world,
+                                x,
+                                y,
+                                z,
+                                source,
+                                actor,
+                                chatter);
+                    }
+                    return PlaceResult.REJECT;
+                }
+
                 @Override
                 public boolean check(T t, World world, int x, int y, int z) {
                     Block worldBlock = world.getBlock(x, y, z);
@@ -1439,6 +1555,14 @@ public class StructureUtility {
                         AutoPlaceEnvironment env) {
                     return BlocksToPlace.create(block, meta);
                 }
+
+                @Nullable
+                @Override
+                public List<String> getDescription(T context) {
+                    Item item = Item.getItemFromBlock(block);
+                    if (item == null) return null;
+                    return Collections.singletonList(new ItemStack(item, 1, meta).getUnlocalizedName() + ".name");
+                }
             };
         }
     }
@@ -1481,6 +1605,14 @@ public class StructureUtility {
                     // there is getSubItems on ItemBlock, but it's client only
                     return BlocksToPlace.create(defaultBlock, defaultMeta);
                 }
+
+                @Nullable
+                @Override
+                public List<String> getDescription(T context) {
+                    Item item = Item.getItemFromBlock(block);
+                    if (item == null) return null;
+                    return Collections.singletonList(new ItemStack(item, 1, 0).getUnlocalizedName() + ".name");
+                }
             };
         } else {
             return new IStructureElement<T>() {
@@ -1513,6 +1645,14 @@ public class StructureUtility {
                     // there is getSubItems on ItemBlock, but it's client only
                     return BlocksToPlace.create(defaultBlock, defaultMeta);
                 }
+
+                @Nullable
+                @Override
+                public List<String> getDescription(T context) {
+                    Item item = Item.getItemFromBlock(block);
+                    if (item == null) return null;
+                    return Collections.singletonList(new ItemStack(item, 1, 0).getUnlocalizedName() + ".name");
+                }
             };
         }
     }
@@ -1776,6 +1916,71 @@ public class StructureUtility {
                     AutoPlaceEnvironment env) {
                 return element.survivalPlaceBlock(t, world, x, y, z, trigger, env);
             }
+
+            @Nullable
+            @Override
+            public List<String> getDescription(T context) {
+                return element.getDescription(context);
+            }
+        };
+    }
+
+    /**
+     * Wraps an element and overrides its description. Useful for providing human-readable names to elements whose
+     * underlying implementation doesn't provide a description (e.g. tiered block elements).
+     *
+     * @param description the description to use, or null to clear any existing description
+     * @param element     the element to wrap
+     */
+    public static <B extends IStructureElement<T>, T> IStructureElement<T> withDescription(
+            @Nullable List<String> description, B element) {
+        return new IStructureElement<T>() {
+
+            @Override
+            public boolean check(T t, World world, int x, int y, int z) {
+                return element.check(t, world, x, y, z);
+            }
+
+            @Override
+            public boolean couldBeValid(T t, World world, int x, int y, int z, ItemStack trigger) {
+                return element.couldBeValid(t, world, x, y, z, trigger);
+            }
+
+            @Override
+            public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
+                return element.placeBlock(t, world, x, y, z, trigger);
+            }
+
+            @Override
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                return element.spawnHint(t, world, x, y, z, trigger);
+            }
+
+            @Nullable
+            @Override
+            public BlocksToPlace getBlocksToPlace(T t, World world, int x, int y, int z, ItemStack trigger,
+                    AutoPlaceEnvironment env) {
+                return element.getBlocksToPlace(t, world, x, y, z, trigger, env);
+            }
+
+            @Override
+            @Deprecated
+            public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger,
+                    IItemSource s, EntityPlayerMP actor, Consumer<IChatComponent> chatter) {
+                return element.survivalPlaceBlock(t, world, x, y, z, trigger, s, actor, chatter);
+            }
+
+            @Override
+            public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger,
+                    AutoPlaceEnvironment env) {
+                return element.survivalPlaceBlock(t, world, x, y, z, trigger, env);
+            }
+
+            @Nullable
+            @Override
+            public List<String> getDescription(T context) {
+                return description;
+            }
         };
     }
 
@@ -1832,6 +2037,12 @@ public class StructureUtility {
                     AutoPlaceEnvironment env) {
                 return element.survivalPlaceBlock(t, world, x, y, z, trigger, env);
             }
+
+            @Nullable
+            @Override
+            public List<String> getDescription(T context) {
+                return element.getDescription(context);
+            }
         };
     }
 
@@ -1840,11 +2051,11 @@ public class StructureUtility {
     /**
      * Enable this structure element only if given predicate returns true.
      * <p>
-     * Return SKIP when survival auto place if given predicate returns false.
+     * Return REJECT_CONTINUE when survival auto place if given predicate returns false.
      */
     public static <T> IStructureElement<T> onlyIf(Predicate<? super T> predicate,
             IStructureElement<? super T> downstream) {
-        return onlyIf(predicate, downstream, PlaceResult.SKIP);
+        return onlyIf(predicate, downstream, PlaceResult.REJECT_CONTINUE);
     }
 
     /**
@@ -1901,6 +2112,12 @@ public class StructureUtility {
                 if (predicate.test(t)) return downstream.survivalPlaceBlock(t, world, x, y, z, trigger, env);
                 return placeResultWhenDisabled;
             }
+
+            @Nullable
+            @Override
+            public List<String> getDescription(T context) {
+                return downstream.getDescription(context);
+            }
         };
     }
 
@@ -1913,10 +2130,10 @@ public class StructureUtility {
      * using {@link #isAir()}. It will not attempt to capture any errors though, so next one will not be tried if
      * previous one would crash.
      * <p>
-     * (*): For survival auto place, it will * REJECT, if all structure element REJECT * SKIP, if 1 or more structure
-     * element SKIP and the rest structure element (0 or more) REJECT * any other result, **immediately** upon any
-     * structure element returns these other results. This behavior is not 100% fixed and might change later on, but we
-     * will send the notice on a best effort basis.
+     * (*): For survival auto place, it will: REJECT, if any structure element returns REJECT (and none returned ACCEPT,
+     * STOP, ACCEPT_STOP, or SKIP); REJECT_CONTINUE, if all structure elements return REJECT_CONTINUE (none returned
+     * REJECT); SKIP, as soon as any structure element returns SKIP; any other result, immediately upon any structure
+     * element returning those.
      * <p>
      * Take care while chaining, as it will try to call every structure element until it returns true. If none does it
      * will finally return false.
@@ -1998,6 +2215,12 @@ public class StructureUtility {
                     AutoPlaceEnvironment env) {
                 return elem.survivalPlaceBlock(t.getCurrentContext(), world, x, y, z, trigger, env);
             }
+
+            @Nullable
+            @Override
+            public List<String> getDescription(T context) {
+                return elem.getDescription(context.getCurrentContext());
+            }
         };
     }
     // endregion
@@ -2607,7 +2830,7 @@ public class StructureUtility {
         if (keyExtractor == null || map == null) {
             throw new IllegalArgumentException();
         }
-        return defer(keyExtractorCheck.andThen(map::get), keyExtractor.<IStructureElement<T>>andThen(map::get));
+        return defer(keyExtractorCheck.andThen(map::get), keyExtractor.andThen(map::get));
     }
 
     /**
@@ -2771,7 +2994,14 @@ public class StructureUtility {
      * See channels.md in docs folder
      */
     public static <T> IStructureElement<T> withChannel(String channel, IStructureElement<T> backing) {
-        return new IStructureElement<T>() {
+        return new IStructureElement<>() {
+
+            private final Collection<String> channels = channelsFor(backing, channel);
+
+            @Override
+            public Collection<String> getChannels() {
+                return channels;
+            }
 
             public boolean check(T t, World world, int x, int y, int z) {
                 return backing.check(t, world, x, y, z);
@@ -2811,7 +3041,8 @@ public class StructureUtility {
             @Override
             public BlocksToPlace getBlocksToPlace(T t, World world, int x, int y, int z, ItemStack trigger,
                     AutoPlaceEnvironment env) {
-                return backing.getBlocksToPlace(t, world, x, y, z, trigger, env);
+                return backing
+                        .getBlocksToPlace(t, world, x, y, z, ChannelDataAccessor.withChannel(trigger, channel), env);
             }
 
             @Deprecated
@@ -2835,8 +3066,21 @@ public class StructureUtility {
                     warnNoExplicitSubChannel(env.getActor());
                 return backing.survivalPlaceBlock(t, world, x, y, z, newTrigger, env);
             }
+
+            @Nullable
+            @Override
+            public List<String> getDescription(T context) {
+                return backing.getDescription(context);
+            }
         };
     }
+
+    private static <T> Collection<String> channelsFor(IStructureElement<T> backing, String channel) {
+        Set<String> channels = new LinkedHashSet<>();
+        channels.add(channel);
+        channels.addAll(backing.getChannels());
+        return Collections.unmodifiableSet(channels);
+    }
     // endregion
 
     /**

src/main/java/com/gtnewhorizon/structurelib/structure/SurvivalBuildStructureWalker.java

@@ -43,9 +43,10 @@ class SurvivalBuildStructureWalker<T> implements IStructureWalker<T> {
         env.offsetABC[2] = c;
         env.setSource(params.getSource());
         PlaceResult placeResult = element.survivalPlaceBlock(object, world, x, y, z, trigger, env);
-        if (placeResult != PlaceResult.SKIP && built == -1) built = 0;
+        if (placeResult != PlaceResult.SKIP && placeResult != PlaceResult.REJECT_CONTINUE && built == -1) built = 0;
         switch (placeResult) {
             case SKIP:
+            case REJECT_CONTINUE:
                 return true;
             case ACCEPT:
                 if (check) element.check(object, world, x, y, z);

src/main/java/com/gtnewhorizon/structurelib/util/InventoryUtility.java

@@ -1,17 +1,3 @@
-/**
- * Copyright (c) 2022, glee8e This file is part of StructureLib.
- * <p>
- * StructureLib 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 of the License, or (at your option) any
- * later version.
- * <p>
- * StructureLib 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.
- * <p>
- * You should have received a copy of the GNU Lesser General Public License along with Foobar; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
 package com.gtnewhorizon.structurelib.util;
 
 import java.util.Arrays;

src/main/java/com/gtnewhorizon/structurelib/util/ItemStackArrayIterable.java

@@ -1,41 +0,0 @@
-package com.gtnewhorizon.structurelib.util;
-
-import java.util.Iterator;
-
-import net.minecraft.item.ItemStack;
-
-public class ItemStackArrayIterable implements Iterable<ItemStack> {
-
-    private final ItemStack[] stacks;
-
-    public ItemStackArrayIterable(ItemStack[] stacks) {
-        this.stacks = stacks;
-    }
-
-    public ItemStack[] getStacks() {
-        return stacks;
-    }
-
-    @Override
-    public Iterator<ItemStack> iterator() {
-        return new Iterator<ItemStack>() {
-
-            private int ptr = 0;
-
-            @Override
-            public boolean hasNext() {
-                return ptr < stacks.length;
-            }
-
-            @Override
-            public ItemStack next() {
-                return stacks[ptr++];
-            }
-
-            @Override
-            public void remove() {
-                stacks[ptr - 1] = null;
-            }
-        };
-    }
-}

src/main/java/com/gtnewhorizon/structurelib/util/MiscUtils.java

@@ -11,7 +11,6 @@ public class MiscUtils {
 
     private MiscUtils() {}
 
-    @SuppressWarnings("unchecked")
     public static Set<String> getTagKeys(NBTTagCompound tag) {
         return tag.func_150296_c();
     }

src/main/java/com/gtnewhorizon/structurelib/util/Vec3Impl.java

@@ -141,8 +141,7 @@ public class Vec3Impl implements Comparable<Vec3Impl> {
     public boolean equals(Object o) {
         if (this == o) {
             return true;
-        } else if (o instanceof Vec3Impl) {
-            Vec3Impl vec3i = (Vec3Impl) o;
+        } else if (o instanceof Vec3Impl vec3i) {
             return val0 == vec3i.val0 && val1 == vec3i.val1 && val2 == vec3i.val2;
         }
         return false;

src/main/javadoc/overview.html

@@ -174,6 +174,37 @@ StructureLib API documentation.
     master channel.
 </p>
 
+<h3>Metadata-only channels</h3>
+
+<p>
+    A channel does not need to represent a block or an element in a structure shape. Structure definitions can declare
+    metadata-only channels for values such as a widget selection or a variable structure height. These declarations are
+    independent of <code>addElement</code> and do not require a fake block or a shape character.
+</p>
+
+<pre>
+IStructureDefinition.&lt;Controller&gt;builder()
+        .addChannel("height", 3, 100)
+        .addChannel("length", 4, 50)
+        .addChannel(IChannelDefinition.unbounded("widget"))
+        .addElement('A', ...)
+        .build();
+</pre>
+
+<p>
+    Channel values are still stored as integers in the trigger item's <code>channels</code> NBT compound. The
+    generic channel GUI has no active structure definition, so it edits integers and does not impose one
+    structure's range on every other structure using the same channel name. Structure-aware code reads values through
+    <code>IStructureDefinition#getChannelData</code>, which uses the definition's default when the subchannel is absent
+    and then applies that definition's local normalization policy.
+</p>
+
+<p>
+    Existing elements wrapped with <code>StructureUtility.withChannel</code> are discovered automatically. An explicit
+    channel declaration supplies its local range and normalization policy for that structure. The same channel name may
+    therefore use different ranges in different structure definitions.
+</p>
+
 <h3>why is this called channel?</h3>
 
 Just give me a better name and I'd do the renaming.

src/main/resources/assets/structurelib/lang/en_US.lang

@@ -34,16 +34,23 @@ item.structurelib.constructableTrigger.gui.title=Sub Channels
 item.structurelib.constructableTrigger.gui.key=Key:
 item.structurelib.constructableTrigger.gui.value=Value:
 item.structurelib.constructableTrigger.gui.add=Add
-item.structurelib.constructableTrigger.gui.set=Set
-item.structurelib.constructableTrigger.gui.unset=Unset
-item.structurelib.constructableTrigger.gui.wipe=§4Wipe
+item.structurelib.constructableTrigger.gui.set=Update
+item.structurelib.constructableTrigger.gui.unset=Remove
+item.structurelib.constructableTrigger.gui.wipe=§4Clear
+item.structurelib.constructableTrigger.gui.wipe.confirm=§4Sure?
 item.structurelib.constructableTrigger.gui.channels.from=§rMod: §9§o%s
-item.structurelib.constructableTrigger.gui.info=Many multiblocks support some degree of variation in its structure and use sub channels to indicate which variant to use.\n Sub channels are has a sequence of lower case characters as key and a positive integer as value. Most known sub channels should be available as typeahead completions.\nYou can also drag and drop items from NEI to set the corresponding sub channel value. These items all have a tooltip of §oIndicates value X for sub channel Y§r.
+item.structurelib.constructableTrigger.gui.info=Many multiblocks support some degree of variation in their structure and a sub channel allows indication of which variant to use.\n All sub channels have a sequence of lowercase characters as key and a positive integer as value. Most known sub channels should be available as typeahead completions.\n You can also drag and drop items from NEI to set the corresponding sub channel value. These items all have a tooltip of "§oIndicates§r §ovalue§r §oX§r §ofor§r §osub§r §ochannel§r §oY§r".
+
+item.structurelib.debugConstructableTrigger.name=Debug Multiblock Structure Hologram Projector
 
 channels.structurelib.show_errors=When set, will highlight parts of the multiblock that is definitely wrong
 
-structurelib.tooltip.channelvalue=§7Indicates value §6%d§r§7 for sub channel §6%s
-structurelib.tooltip.indicator_dnd=Drop into GUI to select this value for this channel
+structurelib.tooltip.channelvalue=§7Value §b%d§r§7 for subchannel §b%s
+structurelib.tooltip.indicator_dnd=Drop into GUI or middle-click to select this value for this channel
+structurelib.pickchannel.success=§aSet §b%s§r§a to §b%d§r
+structurelib.pickchannel.cleared=§aAll channels cleared§r
+structurelib.pickchannel.confirmwipe=§6Sneak+Middle-click again to clear all channels
+structurelib.pickchannel.nomapping=§cNo channel mapping found for this item
 
 structurelib.autoplace.built_stat=Built %s blocks
 structurelib.autoplace.complete=§aThis multiblock has completed!
@@ -51,6 +58,7 @@ structurelib.autoplace.error.not_enabled=§cThis multiblock does not support aut
 structurelib.autoplace.error.no_simple_block=§cSuggested to place §r%s§c but none was found
 structurelib.autoplace.error.no_item_stack=§cSuggested to place block by using §r%s§c but none was found
 structurelib.autoplace.warning.no_explicit_channel=§6This structure depends on nonexistent sub channel §r%s§6. Using master channel instead.
+structurelib.autoplace.missing_block=§cMissing block: %s
 
 structurelib.blockhint.desc.0=Helps while building
 structurelib.blockhint.0.name=Hint 1 dot

src/main/resources/assets/structurelib/lang/ru_RU.lang

@@ -0,0 +1,200 @@
+tile.structurelib.blockhint.name=Подсказка
+tile.structurelib.blockhint.0.name=Подсказка 1 точка
+tile.structurelib.blockhint.1.name=Подсказка 2 точки
+tile.structurelib.blockhint.2.name=Подсказка 3 точки
+tile.structurelib.blockhint.3.name=Подсказка 4 точки
+tile.structurelib.blockhint.4.name=Подсказка 5 точек
+tile.structurelib.blockhint.5.name=Подсказка 6 точек
+tile.structurelib.blockhint.6.name=Подсказка 7 точек
+tile.structurelib.blockhint.7.name=Подсказка 8 точек
+tile.structurelib.blockhint.8.name=Подсказка 9 точек
+tile.structurelib.blockhint.9.name=Подсказка 10 точек
+tile.structurelib.blockhint.10.name=Подсказка 11 точек
+tile.structurelib.blockhint.11.name=Подсказка 12 точек
+tile.structurelib.blockhint.12.name=Общая подсказка
+tile.structurelib.blockhint.13.name=Подсказка воздух
+tile.structurelib.blockhint.14.name=Подсказка нет воздуха
+tile.structurelib.blockhint.15.name=Подсказка ошибка
+
+item.structurelib.frontRotationTool.name=Инструмент для поворота (Автономный)
+item.structurelib.frontRotationTool.desc.0=Открывает интерфейс поворота лицевой стороны
+item.structurelib.frontRotationTool.desc.1=Поворачивает только лицевую сторону,
+item.structurelib.frontRotationTool.desc.2=что позволяет повернуть всю структуру.
+
+item.structurelib.constructableTrigger.name=Голограммный проектор мультиблоковой структуры
+item.structurelib.constructableTrigger.desc.0=Используется по интерфейсу контроллера
+item.structurelib.constructableTrigger.desc.1=Показывает схему постройки мультиблочной структуры,
+item.structurelib.constructableTrigger.desc.2=используется при нажатии по контроллеру
+item.structurelib.constructableTrigger.desc.3=(Shift+ПКМ для автоматической постройки)
+item.structurelib.constructableTrigger.desc.4=Количество проекторов в одном слоте влияет на тир/режим/тип постройки, если он не задан в GUI проектора
+item.structurelib.constructableTrigger.desc.5=Удерживайте §l[LSHIFT]§r для отображения данных канала
+item.structurelib.constructableTrigger.desc.lshift.0=Содержит %d подканал
+item.structurelib.constructableTrigger.too_fast=Подождите %d миллисекунд перед очередным автозаполнением...
+item.structurelib.constructableTrigger.gui.title=Подканалы
+item.structurelib.constructableTrigger.gui.key=Ключ:
+item.structurelib.constructableTrigger.gui.value=Значение:
+item.structurelib.constructableTrigger.gui.add=Добавить
+item.structurelib.constructableTrigger.gui.set=Обновить
+item.structurelib.constructableTrigger.gui.unset=Удалить
+item.structurelib.constructableTrigger.gui.wipe=§4Очистить
+item.structurelib.constructableTrigger.gui.wipe.confirm=§4Уверен?
+item.structurelib.constructableTrigger.gui.channels.from=§rМод: §9§o%s
+item.structurelib.constructableTrigger.gui.info=Многие мультиблоки поддерживают различные вариации структуры. Субканал позволяет указать, какой именно вариант использовать.\nВсе субканалы в качестве ключа используют строку из строчных букв, а в качестве значения - положительное целое число. Для большинства известных субканалов доступно автодополнение при вводе.\nВы также можете перетаскивать предметы из NEI, чтобы задать значение соответствующего субканала. Все эти предметы имеют подсказку: "§oЗадаёт§r §oзначение§r §oX§r §oдля§r §oсубканала§r §oY§r"
+
+channels.structurelib.show_errors=Если включено, подсвечивает элементы мультиблока с явными ошибками
+
+structurelib.tooltip.channelvalue=§7Указывает значение §b%d§r§7 для подканала §b%s
+structurelib.tooltip.indicator_dnd=Перейдите в GUI, чтобы выбрать это значение для этого канала.
+
+structurelib.autoplace.built_stat=Построено %s блоков
+structurelib.autoplace.complete=§aЭтот мультиблок собран!
+structurelib.autoplace.error.not_enabled=§cЭтот мультиблок не поддерживает автозаполнение в выживании!
+structurelib.autoplace.error.no_simple_block=§cПредлагалось разместить §r%s§c но ничего не нашлось
+structurelib.autoplace.error.no_item_stack=§cПредлагалось разместить блок используя §r%s§c но ничего не нашлось
+structurelib.autoplace.warning.no_explicit_channel=§6Эта структура зависит от несуществующего подканала §r%s§6. Вместо этого используйте главный канал.
+
+structurelib.blockhint.desc.0=Помогает при постройке
+structurelib.blockhint.0.name=Подсказка 1 точка
+structurelib.blockhint.1.name=Подсказка 2 точки
+structurelib.blockhint.2.name=Подсказка 3 точки
+structurelib.blockhint.3.name=Подсказка 4 точки
+structurelib.blockhint.4.name=Подсказка 5 точек
+structurelib.blockhint.5.name=Подсказка 6 точек
+structurelib.blockhint.6.name=Подсказка 7 точек
+structurelib.blockhint.7.name=Подсказка 8 точек
+structurelib.blockhint.8.name=Подсказка 9 точек
+structurelib.blockhint.9.name=Подсказка 10 точек
+structurelib.blockhint.10.name=Подсказка 11 точек
+structurelib.blockhint.11.name=Подсказка 12 точек
+structurelib.blockhint.desc.1=Заполнитель конкретной группы.
+structurelib.blockhint.12.name=Общая подсказка
+structurelib.blockhint.desc.2=Общий заполнитель.
+structurelib.blockhint.13.name=Подсказка воздух
+structurelib.blockhint.desc.3=Убедитесь, что это содержит воздух.
+structurelib.blockhint.14.name=Подсказка нет воздуха
+structurelib.blockhint.desc.4=Убедитесь, что это не содержит воздух.
+structurelib.blockhint.15.name=Подсказка ошибка
+structurelib.blockhint.desc.5=ОШИБКА (а что вы ожидали?)
+itemGroup.structurelib=StructureLib
+
+structurelib.facing.0=вниз нормальный нет
+structurelib.facing.1=вниз нормальный по горизонтали
+structurelib.facing.2=вниз нормальный по вертикали
+structurelib.facing.3=вниз нормальный оба
+structurelib.facing.4=вниз по часовой стрелке нет
+structurelib.facing.5=вниз по часовой стрелке по горизонтали
+structurelib.facing.6=вниз по часовой стрелке по вертикали
+structurelib.facing.7=вниз по часовой стрелке оба
+structurelib.facing.8=вниз перевернутый
+structurelib.facing.9=вниз перевернутый
+structurelib.facing.10=вниз перевернутый
+structurelib.facing.11=вниз перевернутый
+structurelib.facing.12=вниз против часовой стрелки
+structurelib.facing.13=вниз против часовой стрелки
+structurelib.facing.14=вниз против часовой стрелки
+structurelib.facing.15=вниз против часовой стрелки
+structurelib.facing.16=вверх нормальный нет
+structurelib.facing.17=вверх нормальный по горизонтали
+structurelib.facing.18=вверх нормальный по вертикали
+structurelib.facing.19=вверх нормальный оба
+structurelib.facing.20=вверх по часовой стрелке нет
+structurelib.facing.21=вверх по часовой стрелке по горизонтали
+structurelib.facing.22=вверх по часовой стрелке по вертикали
+structurelib.facing.23=вверх по часовой стрелке оба
+structurelib.facing.24=вверх перевернутый
+structurelib.facing.25=вверх перевернутый
+structurelib.facing.26=вверх перевернутый
+structurelib.facing.27=вверх перевернутый
+structurelib.facing.28=вверх против часовой стрелки
+structurelib.facing.29=вверх против часовой стрелки
+structurelib.facing.30=вверх против часовой стрелки
+structurelib.facing.31=вверх против часовой стрелки
+structurelib.facing.32=север нормальный нет
+structurelib.facing.33=север нормальный по горизонтали
+structurelib.facing.34=север нормальный по вертикали
+structurelib.facing.35=север нормальный оба
+structurelib.facing.36=север по часовой стрелке нет
+structurelib.facing.37=север по часовой стрелке по горизонтали
+structurelib.facing.38=север по часовой стрелке по вертикали
+structurelib.facing.39=север по часовой стрелке оба
+structurelib.facing.40=север перевернутый
+structurelib.facing.41=север перевернутый
+structurelib.facing.42=север перевернутый
+structurelib.facing.43=север перевернутый
+structurelib.facing.44=север против часовой стрелки
+structurelib.facing.45=север против часовой стрелки
+structurelib.facing.46=север против часовой стрелки
+structurelib.facing.47=север против часовой стрелки
+structurelib.facing.48=юг нормальный нет
+structurelib.facing.49=юг нормальный по горизонтали
+structurelib.facing.50=юг нормальный по вертикали
+structurelib.facing.51=юг нормальный оба
+structurelib.facing.52=юг по часовой стрелке нет
+structurelib.facing.53=юг по часовой стрелке по горизонтали
+structurelib.facing.54=юг по часовой стрелке по вертикали
+structurelib.facing.55=юг по часовой стрелке оба
+structurelib.facing.56=юг перевернутый
+structurelib.facing.57=юг перевернутый
+structurelib.facing.58=юг перевернутый
+structurelib.facing.59=юг перевернутый
+structurelib.facing.60=юг против часовой стрелки
+structurelib.facing.61=юг против часовой стрелки
+structurelib.facing.62=юг против часовой стрелки
+structurelib.facing.63=юг против часовой стрелки
+structurelib.facing.64=запад нормальный нет
+structurelib.facing.65=запад нормальный по горизонтали
+structurelib.facing.66=запад нормальный по вертикали
+structurelib.facing.67=запад нормальный оба
+structurelib.facing.68=запад по часовой стрелке нет
+structurelib.facing.69=запад по часовой стрелке по горизонтали
+structurelib.facing.70=запад по часовой стрелке по вертикали
+structurelib.facing.71=запад по часовой стрелке оба
+structurelib.facing.72=запад перевернутый
+structurelib.facing.73=запад перевернутый
+structurelib.facing.74=запад перевернутый
+structurelib.facing.75=запад перевернутый
+structurelib.facing.76=запад против часовой стрелки
+structurelib.facing.77=запад против часовой стрелки
+structurelib.facing.78=запад против часовой стрелки
+structurelib.facing.79=запад против часовой стрелки
+structurelib.facing.80=восток нормальный нет
+structurelib.facing.81=восток нормальный по горизонтали
+structurelib.facing.82=восток нормальный по вертикали
+structurelib.facing.83=восток нормальный оба
+structurelib.facing.84=восток по часовой стрелке нет
+structurelib.facing.85=восток по часовой стрелке по горизонтали
+structurelib.facing.86=восток по часовой стрелке по вертикали
+structurelib.facing.87=восток по часовой стрелке оба
+structurelib.facing.88=восток перевернутый
+structurelib.facing.89=восток перевернутый
+structurelib.facing.90=восток перевернутый
+structurelib.facing.91=восток перевернутый
+structurelib.facing.92=восток против часовой стрелки
+structurelib.facing.93=восток против часовой стрелки
+structurelib.facing.94=восток против часовой стрелки
+structurelib.facing.95=восток против часовой стрелки
+
+structurelib.config.client=Настройки клиента
+structurelib.config.client.tooltip=Настройки, которые изменяют только внешний вид игры, но не то, как она функционирует.
+structurelib.config.client.hologram=Голограммные настройки
+structurelib.config.client.hologram.tooltip=Настройки, которые по умолчанию меняют способ проецирования голограммы в мир.
+structurelib.config.client.hologram.maxCoexisting=Макс. сосуществующих голограмм
+structurelib.config.client.hologram.maxCoexisting.tooltip=Количество голограмм, которые могут сосуществовать. Обычно все подсказки, сгенерированные одним щелчком ПКМ, принадлежат одной голограмме. Будет предпринята попытка удаления старой голограммы, когда будет проецироваться новая голограмма и этот лимит будет превышен.
+structurelib.config.client.hologram.removeColliding=Удалить сталкивающиеся голограммы
+structurelib.config.client.hologram.removeColliding.tooltip=Whether an attempt will be made to remove any existing hologram that collides with a new hologram.
+
+structurelib.config.registries=Sorted Registries
+structurelib.config.registries.tooltip=Sorted Registry is how StructureLib internally keep track of certain features. Each individual elements may be reordered, disabled and enabled at user's command. Changes will be synced to server if needed.\nThis gui can also be accessed in game by shift right clicking air with Multiblock Structure Hologram Projector.
+structurelib.config.registries.stackextractors=Stack Extractors
+structurelib.config.registries.stackextractors.tooltip=Controls which inventory-from-stack functions are enabled during survival autoplace
+structurelib.config.registries.inventoryproviders=Источники инвентарей
+structurelib.config.registries.inventoryproviders.tooltip=Controls which inventories functions are enabled during survival autoplace
+
+structurelib.configgui.enabled=Включённый элемент
+structurelib.configgui.disabled=Отключённый элемент
+structurelib.configgui.drag.tooltip=Перетащите эту кнопку, чтобы изменить порядок этого элемента.
+
+structurelib.sortedregistry.inventoryproviders.5000-main-inventory=Основной инвентарь игрока
+structurelib.sortedregistry.inventoryproviders.5000-main-inventory.tooltip=36 ячеек для предметов в вашем основном инвентаре. Слоты для брони исключены.
+structurelib.sortedregistry.inventoryproviders.7000-ender-inventory=Инвентарь сундука Эндера
+structurelib.sortedregistry.inventoryproviders.7000-ender-inventory.tooltip=Соединяет на ваш инвентарь из ванильного сундука Эндера. Требуется не менее один "похожий на рюкзак Эндера" предмет в основном инвентаре для работы.

src/main/resources/assets/structurelib/lang/zh_CN.lang

@@ -42,7 +42,7 @@ item.structurelib.constructableTrigger.gui.info=许多多方块的结构都是
 
 channels.structurelib.show_errors=添加后，在投影时会高亮标出必然错误的部分
 
-structurelib.tooltip.channelvalue=§7表示子信道 §6%2$s§r§7 为 §6%d§r
+structurelib.tooltip.channelvalue=§7表示子信道 §b%2$s§r§7 为 §b%d§r
 structurelib.tooltip.indicator_dnd=拖入GUI中来选择该值
 
 structurelib.autoplace.built_stat=已放置 %s 个方块