Compare commits

..
15 Commits
Author SHA1 Message Date
ДмитрийandClaude Sonnet 5.5 4eda03ab63 v0.1.3: interface scales with the window, realmlist line per Friends mode, robust close handler
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 19:42:05 +05:00
ДмитрийandClaude Sonnet 5.5 0e1016e93c v0.1.2: background self-update (install on close), module configs, quiet logging, fixes from the first clean install
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 15:53:05 +05:00
ДмитрийandClaude Sonnet 5.5 a6ae4e78a3 Self-update in the background (install on close), module configs created from .dist, quiet-logging + table fixups in clean-base, backlog notes
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 15:36:07 +05:00
ДмитрийandClaude Sonnet 5.5 2d0bfd0a38 clean-base: never ship Trace-level logging templates from a maintainer repack
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 15:26:07 +05:00
ДмитрийandClaude Sonnet 5.5 ca8b7739e1 Add AGPL-3.0 licence (LICENSE, Cargo/npm metadata, README licence notes)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 14:02:22 +05:00
ДмитрийandClaude Sonnet 5.5 ba2515145f Example: install from a package URL (used to verify the published base release)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 13:18:10 +05:00
ДмитрийandClaude Sonnet 5.5 f620f87432 v0.1.1: language picker on welcome screen, friendly errors for unpublished package / unreachable server, backlog notes
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 12:27:21 +05:00
ДмитрийandClaude Sonnet 5.5 68050882b8 UI: translate settings editor; add tools/check-i18n.mjs; mock accepts event listeners
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 11:58:43 +05:00
ДмитрийandClaude Sonnet 5.5 fc7277e250 UI: translate server update card
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 11:56:23 +05:00
ДмитрийandClaude Sonnet 5.5 6ae1fccba8 UI: translate Console page
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 11:55:33 +05:00
ДмитрийandClaude Sonnet 5.5 3039906411 UI: translate Play with Friends page
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 11:55:08 +05:00
ДмитрийandClaude Sonnet 5.5 b5bfeb20e7 UI: translate Backups page
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 11:54:18 +05:00
ДмитрийandClaude Sonnet 5.5 0b975a7c42 UI: translate Diagnostics and About cards
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 11:53:28 +05:00
ДмитрийandClaude Sonnet 5.5 488a1a45c6 UI: translate Players, Companions, Client cards
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 11:52:50 +05:00
ДмитрийandClaude Sonnet 5.5 9dee0ce8b1 UI: translate Import and Install screens
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-09-30 11:51:51 +05:00
44 changed files with 3199 additions and 389 deletions

No files matched your search

Generated
+3 -3
View File
@@ -347,7 +347,7 @@ dependencies = [
[[package]]
name = "coa-core"
version = "0.1.0"
version = "0.1.3"
dependencies = [
"base64 0.22.1",
"chrono",
@@ -375,7 +375,7 @@ dependencies = [
[[package]]
name = "coa-release"
version = "0.1.0"
version = "0.1.3"
dependencies = [
"chrono",
"coa-core",
@@ -384,7 +384,7 @@ dependencies = [
[[package]]
name = "coa-server-manager"
version = "0.1.0"
version = "0.1.3"
dependencies = [
"coa-core",
"serde",
+2 -1
View File
@@ -3,8 +3,9 @@ resolver = "2"
members = ["crates/coa-core", "crates/coa-release", "src-tauri"]
[workspace.package]
version = "0.1.0"
version = "0.1.3"
edition = "2021"
license = "AGPL-3.0-only"
[profile.release]
lto = "thin"
+662
View File
@@ -0,0 +1,662 @@
GNU AFFERO GENERAL PUBLIC LICENSE
Version 3, 19 November 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 Affero General Public License is a free, copyleft license for
software and other kinds of works, specifically designed to ensure
cooperation with the community in the case of network server software.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
our General Public Licenses are intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
Developers that use our General Public Licenses protect your rights
with two steps: (1) assert copyright on the software, and (2) offer
you this License which gives you legal permission to copy, distribute
and/or modify the software.
A secondary benefit of defending all users' freedom is that
improvements made in alternate versions of the program, if they
receive widespread use, become available for other developers to
incorporate. Many developers of free software are heartened and
encouraged by the resulting cooperation. However, in the case of
software used on network servers, this result may fail to come about.
The GNU General Public License permits making a modified version and
letting the public access it on a server without ever releasing its
source code to the public.
The GNU Affero General Public License is designed specifically to
ensure that, in such cases, the modified source code becomes available
to the community. It requires the operator of a network server to
provide the source code of the modified version running there to the
users of that server. Therefore, public use of a modified version, on
a publicly accessible server, gives the public access to the source
code of the modified version.
An older license, called the Affero General Public License and
published by Affero, was designed to accomplish similar goals. This is
a different license, not a version of the Affero GPL, but Affero has
released a new version of the Affero GPL which permits relicensing under
this license.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU Affero General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Remote Network Interaction; Use with the GNU General Public License.
Notwithstanding any other provision of this License, if you modify the
Program, your modified version must prominently offer all users
interacting with it remotely through a computer network (if your version
supports such interaction) an opportunity to receive the Corresponding
Source of your version by providing access to the Corresponding Source
from a network server at no charge, through some standard or customary
means of facilitating copying of software. This Corresponding Source
shall include the Corresponding Source for any work covered by version 3
of the GNU General Public License that is incorporated pursuant to the
following paragraph.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the work with which it is combined will remain governed by version
3 of the GNU General Public License.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU Affero General Public License from time to time. Such new versions
will be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU Affero General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU Affero General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU Affero General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If your software can interact with users remotely through a computer
network, you should also make sure that it provides a way for users to
get its source. For example, if your program is a web application, its
interface could display a "Source" link that leads users to an archive
of the code. There are many ways you could offer source, and different
solutions will be better for different programs; see section 13 for the
specific requirements.
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU AGPL, see
<https://www.gnu.org/licenses/>.
+12
View File
@@ -32,3 +32,15 @@ Start/stop testing must use a disposable copy: `tools/make-fixture.ps1` builds `
on offset ports from the pristine packaged database. Never run start/stop against a server in use.
`tests/e2e/cdp.mjs` drives the real window through WebView2 remote debugging
(`WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS=--remote-debugging-port=9222`).
## License
CoA Server Manager is free software under the [GNU Affero General Public License v3.0](LICENSE) (`AGPL-3.0-only`).
* The server it installs is built from a public fork of AzerothCore
([`Corfirean/azerothcore-wotlk-coa`](https://github.com/Corfirean/azerothcore-wotlk-coa)), which keeps its own licences
(GPL-2.0-or-later for the MaNGOS-derived parts, AGPL-3.0 for AzerothCore-original files), and the
[`mod-coa-playerbots`](https://github.com/Corfirean/mod-coa-playerbots) module (AGPL-3.0). The exact commits behind every
package are written into its manifest, so the matching source is always available.
* The bundled MySQL keeps its own GPL-2.0 licence (its text ships in the package's `Licenses` folder).
* The game data in the `Data` folder (`dbc`, `maps`, `vmaps`, `mmaps`) was extracted from the client of the discontinued
Ascension "Conquest of Azeroth" realm and is **not** covered by this licence.
+1
View File
@@ -2,6 +2,7 @@
name = "coa-core"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
serde = { version = "1", features = ["derive"] }
+13
View File
@@ -0,0 +1,13 @@
//! Install from a package URL into a NEW folder (production trust key). usage: install_pkg <package url> <destination>
use coa_core::download::Cancel;
use coa_core::install::{install_base, Params, Source};
use coa_core::registry::Registry;
fn main() {
let a: Vec<String> = std::env::args().skip(1).collect();
let reg = Registry::at(std::env::temp_dir().join("coa-install-url").join("installs.json"));
let _ = std::fs::remove_dir_all(std::env::temp_dir().join("coa-install-url"));
let t = std::time::Instant::now();
let r = install_base(&Params { source: Source::Url(a[0].clone()), dest: a[1].clone().into(), trusted_key: coa_core::signing::EMBEDDED_PUBLIC_KEY, registry: &reg, cancel: Cancel::default() }, &|s| eprintln!(" {:>3}% {}", s.percent, s.step)).unwrap_or_else(|e| panic!("install failed: {e:?}"));
println!("installed {} at {} in {:?}", r.version, r.path, t.elapsed());
}
+33
View File
@@ -75,6 +75,20 @@ pub fn scaffolding(rel: &str) -> bool {
l.starts_with("runtime/") || l.starts_with("scripts/") || l.starts_with("settings/") || l.starts_with("licenses/") || l == "readme.txt" || (l.starts_with("core/") && l.ends_with(".dll") && !l[5..].contains('/'))
}
/// A maintainer's repack may have "detailed logging" switched on: the launcher then rewrites the config templates to Trace
/// level and keeps the untouched copies as `*.template.original`. A shipped package must start quiet (an active Trace
/// log writes gigabytes and stalls the world server), so put the originals back and drop the backups.
pub fn restore_quiet_logging(settings: &Path) -> Result<()> {
for name in ["worldserver.conf.template", "authserver.conf.template"] {
let original = settings.join(format!("{name}.original"));
if original.is_file() {
fs::copy(&original, settings.join(name))?;
fs::remove_file(&original)?;
}
}
Ok(())
}
pub fn build(p: &Params, say: &dyn Fn(&str)) -> Result<()> {
if p.out.exists() {
return Err(Error::Invalid(format!("{} already exists; choose a new folder.", p.out.display())));
@@ -102,6 +116,7 @@ pub fn build(p: &Params, say: &dyn Fn(&str)) -> Result<()> {
fs::create_dir_all(&dst)?;
copy_dir(&p.repack.join(&d), &dst, &|rel| !scaffolding(rel), p.repack)?;
}
restore_quiet_logging(&p.out.join("Settings"))?;
fs::create_dir_all(p.out.join("Core"))?;
for e in fs::read_dir(p.repack.join("Core"))? {
let e = e?;
@@ -179,6 +194,12 @@ pub fn build(p: &Params, say: &dyn Fn(&str)) -> Result<()> {
if let Some((id, why)) = report.failed {
return Err(Error::Invalid(format!("Database update {id} failed: {why}")));
}
// 3b. A module script older than a table rename re-creates the old table next to the renamed one (the core then
// logs an error at every start). Fold its rows into the new table and drop it.
let both = db.query("SELECT COUNT(*) FROM information_schema.TABLES WHERE TABLE_SCHEMA='acore_world' AND TABLE_NAME IN ('item_template_ascension_compat','item_template_coa');")?;
if both.trim() == "2" {
db.query("INSERT IGNORE INTO acore_world.item_template_coa SELECT * FROM acore_world.item_template_ascension_compat; DROP TABLE acore_world.item_template_ascension_compat;")?;
}
// 4. prove it is clean
let accounts = db.query("SELECT COUNT(*) FROM acore_auth.account;")?;
let chars = db.query("SELECT COUNT(*) FROM acore_characters.characters;")?;
@@ -227,6 +248,18 @@ mod tests {
}
}
#[test]
fn detailed_logging_templates_are_replaced_by_their_originals() {
let d = tempfile::tempdir().unwrap();
fs::write(d.path().join("worldserver.conf.template"), "Logger.root=6,Console Server").unwrap();
fs::write(d.path().join("worldserver.conf.template.original"), "Logger.root=2,Console Server").unwrap();
fs::write(d.path().join("authserver.conf.template"), "unchanged").unwrap();
restore_quiet_logging(d.path()).unwrap();
assert_eq!(fs::read_to_string(d.path().join("worldserver.conf.template")).unwrap(), "Logger.root=2,Console Server");
assert!(!d.path().join("worldserver.conf.template.original").exists());
assert_eq!(fs::read_to_string(d.path().join("authserver.conf.template")).unwrap(), "unchanged");
}
#[test]
fn refuses_to_overwrite_an_existing_output_folder() {
let d = tempfile::tempdir().unwrap();
+46
View File
@@ -119,6 +119,30 @@ pub struct SettingsView {
}
/// Keys whose value in the generated conf differs from the template (i.e. hand edits the launcher will reset).
/// Modules read `Core/configs/modules/<name>.conf`, but packages ship only the documented `<name>.conf.dist` (the active
/// files are the server owner's). Create every missing active file from its `.dist`, so a fresh server runs with the
/// documented defaults (for example `CoA.Enable = 1`, without which the Ascension client is dropped after login).
/// Existing files are never touched. Files the launcher writes itself are skipped. Returns the created file names.
pub fn materialize_module_configs(root: &Path) -> Result<Vec<String>> {
let dir = root.join("Core").join("configs").join("modules");
let mut created = Vec::new();
let Ok(entries) = fs::read_dir(&dir) else { return Ok(created) };
for e in entries.flatten() {
let name = e.file_name().to_string_lossy().into_owned();
let Some(stem) = name.strip_suffix(".conf.dist") else { continue };
if stem == "coa_bugreport" || stem == "mod_ascension_compat" {
continue; // written by the launcher at every start
}
let active = dir.join(format!("{stem}.conf"));
if !active.exists() {
fs::copy(e.path(), &active)?;
created.push(format!("{stem}.conf"));
}
}
created.sort();
Ok(created)
}
pub fn drift(root: &Path) -> Result<Vec<String>> {
let t = targets(root, Scope::Server)?;
let Some(generated) = &t.generated else { return Ok(Vec::new()) };
@@ -463,6 +487,28 @@ mod tests {
pairs.iter().map(|(k, v)| (k.to_string(), v.clone())).collect()
}
#[test]
fn missing_module_configs_are_created_from_their_dist_and_existing_ones_are_kept() {
let (_d, root, _m) = fixture();
let m = root.join("Core/configs/modules");
fs::create_dir_all(&m).unwrap();
fs::write(m.join("coa.conf.dist"), "CoA.Enable = 1
").unwrap();
fs::write(m.join("spellbook.conf.dist"), "Spellbook.Enable = 1
").unwrap();
fs::write(m.join("spellbook.conf"), "Spellbook.Enable = 0
").unwrap();
fs::write(m.join("coa_bugreport.conf.dist"), "x = 1
").unwrap();
assert_eq!(materialize_module_configs(&root).unwrap(), vec!["coa.conf".to_string()]);
assert_eq!(fs::read_to_string(m.join("coa.conf")).unwrap(), "CoA.Enable = 1
");
assert_eq!(fs::read_to_string(m.join("spellbook.conf")).unwrap(), "Spellbook.Enable = 0
");
assert!(!m.join("coa_bugreport.conf").exists());
assert!(materialize_module_configs(&root).unwrap().is_empty());
}
#[test]
fn schemas_and_presets_are_self_consistent() {
for scope in [Scope::Bots, Scope::Server] {
+18
View File
@@ -20,6 +20,10 @@ pub enum Error {
UnknownInstallation(String),
#[error("{0}")]
Invalid(String),
#[error("package not published: {0}")]
PackageNotPublished(String),
#[error("download server unreachable: {0}")]
NetworkUnreachable(String),
#[error("invalid values: {}", .0.iter().map(|f| format!("{}: {}", f.key, f.message)).collect::<Vec<_>>().join("; "))]
Validation(Vec<FieldError>),
}
@@ -46,6 +50,8 @@ pub enum ErrorCode {
StartupFailed,
HashMismatch,
PathRejected,
PackageNotPublished,
NetworkUnreachable,
Unknown,
}
@@ -126,6 +132,16 @@ impl ErrorCode {
"The requested file location is outside the server folder.",
&[ShowDetails],
),
ErrorCode::PackageNotPublished => (
"This server package is not available yet",
"Nothing has been published at the download location. Try again later, or install from a local package folder (Advanced).",
&[Retry, ShowDetails],
),
ErrorCode::NetworkUnreachable => (
"Could not reach the download server",
"Check your internet connection and try again.",
&[Retry, ShowDetails],
),
ErrorCode::Unknown => ("Something went wrong", "See the technical details.", &[ShowDetails]),
};
Human { code: self, title, message, actions }
@@ -139,6 +155,8 @@ impl Error {
Error::HashMismatch { .. } => ErrorCode::HashMismatch,
Error::PathRejected(_) => ErrorCode::PathRejected,
Error::Validation(_) => ErrorCode::InvalidConfigValue,
Error::PackageNotPublished(_) => ErrorCode::PackageNotPublished,
Error::NetworkUnreachable(_) => ErrorCode::NetworkUnreachable,
_ => ErrorCode::Unknown,
}
}
+1
View File
@@ -269,6 +269,7 @@ pub fn install_base(p: &Params, report: &dyn Fn(Step)) -> Result<Installed> {
fs::remove_dir(&dest)?; // only succeeds for an empty folder (preflight verified)
}
fs::rename(&staging_root, &dest)?;
crate::config::materialize_module_configs(&dest)?;
let mut meta = InstallMeta::new(InstallKind::New, &dest);
meta.core.commit = m.core.commit.clone();
+4 -1
View File
@@ -28,7 +28,10 @@ pub fn fetch_small(source: &Source, name: &str) -> Result<Vec<u8>> {
let url = format!("{}/{name}", base.trim_end_matches('/'));
download::check_url(&url)?;
let t = download::HttpTransport::new()?;
let reply = download::Transport::get(&t, &url, 0).map_err(|e| Error::Invalid(format!("Could not reach the download server: {e}")))?;
let reply = download::Transport::get(&t, &url, 0).map_err(|e| Error::NetworkUnreachable(format!("{e}")))?;
if reply.status == 404 || reply.status == 410 {
return Err(Error::PackageNotPublished(format!("the download server answered {} for {name} ({url})", reply.status)));
}
if reply.status != 200 {
return Err(Error::Invalid(format!("The download server answered {} for {name}.", reply.status)));
}
+1
View File
@@ -2,6 +2,7 @@
name = "coa-release"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
coa-core = { path = "../coa-core" }
+32
View File
@@ -483,3 +483,35 @@ The reference install classifies as **Healthy (customised)**: repack shape, bina
`Intl`; settings-schema titles/descriptions (`schemas/*.json`) get per-locale overlays (`schemas/i18n/<locale>.json`);
translations are reviewed by native speakers before release, with an English fallback for missing keys and a CI check
that every locale has every key. Do this before the first public release so strings are not retro-fitted.
**Status (2026-09-30):** catalogue + picker + all screens translated (en/ru/de/fr/es drafts, `tools/check-i18n.mjs` checks
keys/placeholders). Still English: settings-schema titles/descriptions/presets, companion size names, diagnostics check
texts and update step names coming from the backend (need `schemas/i18n/<locale>.json` overlays and code-keyed backend strings).
* **Language choice on the very first screen** (requested 2026-09-30): the welcome screen must offer the language picker
right away (before any other text is read), preselected from the OS language; the choice is persisted and shared with
Settings. **Done 2026-09-30:** shared `LanguagePicker` (top-right of the welcome screen and in Settings).
* **Clean-install gap found by the owner (2026-09-30):** installing from the default URL fails with 404 because the `base`
release does not exist yet (only `edge` is published). The message is now human ("package not available yet"). Also open:
the base package has no `Data\` (maps/dbc/vmaps, ~3.8 GB); the installer needs a "use my existing Data folder / download"
step, and the owner must decide hosting/legal for game data before `base` is published.
* **Modules tab** (requested 2026-09-30): install/manage optional server modules (bots, AH bot, Solocraft, ...).
Design decision: AzerothCore modules are compiled into `worldserver.exe`, so "install" cannot mean "drop files in".
Plan: CI builds one binary containing a curated set of modules, every one disabled by default; the Manager only
enables/disables and configures them (`Core/configs/modules/<name>.conf`, schema-driven settings editor as for bots).
A `modules.json` catalogue travels with update packages (id, title, description, category, source repo + commit,
licence, conf file, enable key, settings schema, needed DB migrations, conflicts, status tested/experimental).
Adding a module = add it to the CI build list + catalogue entry, released as an ordinary update. Only modules tested
against the CoA fork and licence-compatible (AGPL/GPL, because the binary is distributed) are listed. The fork's own
CoA features (dynamic XP, ethereal bazaar, ...) appear in the same tab as "built in" toggles.
* **Known launcher leftovers:** the repack's `Scripts/manage.py` still renders `mod_ascension_compat.conf` at every start;
the core now ignores it ("is no longer read ... move its settings into coa.conf") - harmless warning, clean up together
with a launcher refresh. Migration-runner root cause for the re-created `item_template_ascension_compat` table (a module
script older than the rename is seen as pending) is worked around in `clean-base`, not fixed in the runner.
* **Bug found by the owner on the first clean install (2026-09-30):** login worked at the auth step but the game dropped
the connection. Causes: (1) the package shipped the maintainer's Trace-level logging templates (gigabytes of log per
hour, world thread stalled); (2) no active `coa.conf` (`CoA.Enable = 1`) because packages contain only `*.conf.dist`.
Fixed: `clean-base` restores quiet templates, `assemble-tree` ships `coa.conf.dist`, and the Manager creates missing
module `.conf` files from their `.dist` on install and before each start of a Manager-installed server.
+2 -1
View File
@@ -1,7 +1,8 @@
{
"name": "coa-server-manager",
"private": true,
"version": "0.1.0",
"version": "0.1.3",
"license": "AGPL-3.0-only",
"type": "module",
"scripts": {
"dev": "vite",
+1
View File
@@ -2,6 +2,7 @@
name = "coa-server-manager"
version.workspace = true
edition.workspace = true
license.workspace = true
[lib]
name = "coa_server_manager_lib"
+2 -1
View File
@@ -9,6 +9,7 @@
"core:default",
"dialog:allow-open",
"updater:default",
"process:allow-restart"
"process:allow-restart",
"core:window:allow-destroy"
]
}
+12
View File
@@ -187,6 +187,18 @@ async fn run_verb(state: &AppState, id: String, verb: Verb) -> std::result::Resu
#[tauri::command]
async fn start_server(state: State<'_, AppState>, id: String) -> std::result::Result<DriverOutcome, UiError> {
// Servers installed before module configs were created automatically get them now (missing files only). Imported
// servers are never written to by the Manager outside the launcher's own start-up.
if let Ok(root) = path_of(&state, &id) {
let _ = tauri::async_runtime::spawn_blocking(move || {
let (_, meta) = install_meta(&root)?;
if meta.kind == coa_core::registry::InstallKind::New {
coa_core::config::materialize_module_configs(&root)?;
}
Ok::<(), Error>(())
})
.await;
}
let out = run_verb(&state, id.clone(), Verb::StartAll).await?;
if out.ok {
if let Ok(root) = path_of(&state, &id) {
+1 -1
View File
@@ -1,7 +1,7 @@
{
"$schema": "https://schema.tauri.app/config/2",
"productName": "CoA Server Manager",
"version": "0.1.0",
"version": "0.1.3",
"identifier": "com.coa.servermanager",
"build": {
"beforeDevCommand": "npm run dev",
+24 -1
View File
@@ -4,10 +4,12 @@ import { Welcome } from "@/screens/Welcome";
import { ImportServer } from "@/screens/ImportServer";
import { Shell } from "@/screens/Shell";
import { InstallServer } from "@/screens/InstallServer";
import { UpdateBanner } from "@/components/UpdateBanner";
import { autoUpdateEnabled, installOnClose, lookForUpdate } from "@/lib/selfUpdate";
type View = "welcome" | "add" | "import" | "install";
export default function App() {
function Main() {
const [servers, setServers] = useState<ServerSummary[] | null>(null);
const [view, setView] = useState<View>("welcome");
const [activeId, setActiveId] = useState<string | null>(null);
@@ -75,3 +77,24 @@ export default function App() {
/>
);
}
export default function App() {
// Quietly fetch a new Manager version a few seconds after start and install it when the window is closed.
useEffect(() => {
const stop = installOnClose();
const timer = setTimeout(() => {
if (autoUpdateEnabled()) void lookForUpdate({ download: true });
}, 5000);
return () => {
clearTimeout(timer);
stop();
};
}, []);
return (
<>
<Main />
<UpdateBanner />
</>
);
}
+24
View File
@@ -0,0 +1,24 @@
import { Globe } from "lucide-react";
import { LOCALES, useI18n, type Locale } from "@/i18n";
/** Language switch shared by the welcome screen and Settings. Names are shown in their own language. */
export function LanguagePicker({ className }: { className?: string }) {
const { t, locale, setLocale } = useI18n();
return (
<label className={`inline-flex items-center gap-2 text-sm text-muted ${className ?? ""}`}>
<Globe className="h-4 w-4" aria-hidden />
<span className="sr-only">{t("settings.language")}</span>
<select
value={locale}
onChange={(e) => setLocale(e.target.value as Locale)}
className="cursor-pointer rounded-md border border-line bg-bg px-3 py-2 text-sm text-ink outline-none focus:border-gold"
>
{LOCALES.map((l) => (
<option key={l.id} value={l.id}>
{l.name}
</option>
))}
</select>
</label>
);
}
+25
View File
@@ -0,0 +1,25 @@
import { Download } from "lucide-react";
import { Button } from "@/components/ui/button";
import { useT } from "@/i18n";
import { installNow, useSelfUpdate } from "@/lib/selfUpdate";
/** Small notice shown once a new Manager version is downloaded and waiting to be installed. */
export function UpdateBanner() {
const t = useT();
const s = useSelfUpdate();
if (s.phase !== "ready" && s.phase !== "installing") return null;
return (
<div className="fixed bottom-5 right-5 z-50 flex max-w-sm items-start gap-3 rounded-card border border-gold/50 bg-card p-4 shadow-[0_8px_30px_rgb(0_0_0/0.5)]" role="status">
<Download className="mt-0.5 h-5 w-5 shrink-0 text-gold" aria-hidden />
<div className="text-sm">
<p className="font-medium">{t("selfupd.ready", { v: s.version ?? "" })}</p>
<p className="mt-0.5 text-muted">{s.phase === "installing" ? t("selfupd.installing") : t("selfupd.onClose")}</p>
{s.phase === "ready" && (
<Button className="mt-2" size="sm" variant="secondary" onClick={() => void installNow()}>
{t("selfupd.now")}
</Button>
)}
</div>
</div>
);
}
+2
View File
@@ -22,6 +22,8 @@ export {};
if(cmd==="start_server"){await new Promise((r: any)=>setTimeout(r,1500));running=true;return {ok:true,exit_code:0,code:null,human:null,output:""};}
if(cmd==="stop_server"){await new Promise((r: any)=>setTimeout(r,1500));running=false;return {ok:true,exit_code:0,code:null,human:null,output:""};}
if(cmd.startsWith("plugin:dialog")) return "C:\games\CoA-Repack";
if(cmd==="plugin:event|listen") return 1;
if(cmd==="plugin:event|unlisten") return null;
throw new Error("unmocked "+cmd);
}
};
+3 -3
View File
@@ -42,10 +42,10 @@ export function lookup(locale: Locale, key: Key, vars?: Vars): string {
}
/** Plural form: tries `key_<category>` (one/few/many/other) for the locale, then `key_other`, then `key`. */
export function lookupPlural(locale: Locale, key: Key, n: number, vars?: Vars): string {
export function lookupPlural(locale: Locale, key: string, n: number, vars?: Vars): string {
const cat = new Intl.PluralRules(locale).select(n);
const d = DICTS[locale];
const text = d[`${key}_${cat}` as Key] ?? d[`${key}_other` as Key] ?? en[`${key}_${cat}` as Key] ?? en[`${key}_other` as Key] ?? en[key] ?? key;
const text = d[`${key}_${cat}` as Key] ?? d[`${key}_other` as Key] ?? en[`${key}_${cat}` as Key] ?? en[`${key}_other` as Key] ?? en[key as Key] ?? key;
return interpolate(text, { n, ...vars });
}
@@ -53,7 +53,7 @@ interface Ctx {
locale: Locale;
setLocale: (l: Locale) => void;
t: (key: Key, vars?: Vars) => string;
tn: (key: Key, n: number, vars?: Vars) => string;
tn: (key: string, n: number, vars?: Vars) => string;
}
const I18n = createContext<Ctx>({
+335
View File
@@ -98,6 +98,341 @@ const de: Partial<Record<keyof typeof en, string>> = {
"err.path_rejected.message": "Der angeforderte Dateipfad liegt außerhalb des Serverordners.",
"err.unknown.title": "Etwas ist schiefgelaufen",
"err.unknown.message": "Siehe die technischen Details.",
// Import server
"import.title": "Vorhandenen Server hinzufügen",
"import.subtitle": "Wähle den Ordner, aus dem dein Server läuft. Er wird nur gelesen.",
"import.dialogTitle": "Serverordner auswählen",
"import.choose": "Ordner wählen …",
"import.chooseAnother": "Anderen Ordner wählen",
"import.looking": "Server wird untersucht …",
"import.healthy.title": "Vorhandener Server erkannt",
"import.healthy.text": "Alles, was zum Betrieb dieses Servers nötig ist, wurde gefunden.",
"import.partial.title": "Server teilweise gefunden",
"import.partial.text": "Einige Teile fehlen. Du kannst ihn trotzdem hinzufügen; es wird nichts automatisch repariert.",
"import.custom.title": "Angepasster Server erkannt",
"import.custom.text": "Dieser Build wird nicht erkannt. Einige Update- und Installationsfunktionen sind deaktiviert.",
"import.incompatible.title": "Das ist kein Serverordner",
"import.incompatible.text": "Wähle den Ordner, der Core, Data und mysql (oder deine worldserver.exe) enthält.",
"import.techDetails": "Technische Details anzeigen",
"import.detected": "Erkannt",
"import.notInstalled": "Nicht installiert",
"import.notFound": "Nicht gefunden",
"import.noChanges": "Beim Import werden keine Dateien verändert.",
"import.add": "Server hinzufügen",
// Install server
"install.title": "Neuen Server installieren",
"install.subtitle": "Wähle einen Ordner oder behalte den vorgeschlagenen. Alles andere wird für dich eingerichtet.",
"install.installTo": "Installieren nach",
"install.browse": "Durchsuchen …",
"install.dialogTitle": "Wähle den Installationsort für deinen Server",
"install.pkgDialogTitle": "Wähle einen Serverpaket-Ordner",
"install.ready": "Dieser Ordner ist bereit. {gb} GB frei.",
"install.failedTitle": "Die Installation konnte nicht abgeschlossen werden",
"install.nothingInstalled": "Es wurde nichts installiert. Du kannst es erneut versuchen; heruntergeladene Dateien bleiben erhalten.",
"install.showTech": "Technische Details anzeigen",
"install.hideTech": "Technische Details ausblenden",
"install.advanced": "Erweitert",
"install.localPkg": "Aus einem lokalen Paketordner installieren statt herunterzuladen",
"install.localPkgHint": "(leer lassen zum Herunterladen)",
"install.button": "Installieren",
"install.progressTitle": "Server wird vorbereitet",
"install.progressText": "Das kann einige Minuten dauern. Du kannst dieses Fenster geöffnet lassen.",
"install.step.checking": "Computer wird geprüft",
"install.step.downloading": "Server wird heruntergeladen",
"install.step.unpacking": "Entpacken",
"install.step.database": "Datenbank wird vorbereitet",
"install.step.finishing": "Abschluss",
"install.doneTitle": "Dein Server ist bereit",
"install.doneText": "Alles ist installiert. Starte ihn auf dem nächsten Bildschirm.",
"install.open": "MEINEN SERVER ÖFFNEN",
// Players
"players.title": "Spieler",
"players.createTitle": "Erstelle dein Konto",
"players.createText": "Das sind der Name und das Passwort, mit denen du dich im Spiel anmeldest.",
"players.startFirst": "Starte zuerst den Server – Konten werden erstellt, solange er läuft.",
"players.username": "Benutzername",
"players.password": "Passwort",
"players.admin": "Dieses Konto zum Administrator machen",
"players.adminHint": "Administratoren können im Spiel Gamemaster-Befehle nutzen. Tu dies nur für Konten, denen du vertraust.",
"players.create": "Konto erstellen",
"players.created": "Konto „{name}“ erstellt. Du kannst dich jetzt damit im Spiel anmelden.",
// Companions
"comp.title": "KI-Begleiter",
"comp.population": "{online} jetzt online · insgesamt {total} erstellt",
"comp.reading": "Aktuelle Anzahl wird gelesen …",
"comp.startToSee": "Starte den Server, um zu sehen, wie viele Begleiter online sind.",
"comp.wantMore": "Möchtest du mehr Begleiter?",
"comp.custom": "Benutzerdefiniert",
"comp.numberLabel": "Anzahl der Begleiter",
"comp.largeWarning": "Große Mengen können mehr CPU und Speicher benötigen. Erhöhe schrittweise.",
"comp.hardware": "Dieser Computer: {cores} Kerne, {ram} GB Arbeitsspeicher.",
"comp.add": "{n} Begleiter hinzufügen",
"comp.addPlain": "Begleiter hinzufügen",
"comp.stoppedHint": "Der Server ist gestoppt: Sie werden beim nächsten Start erstellt.",
"comp.spawned": "{n} Begleiter werden erstellt. Sie erscheinen nach und nach in den nächsten Minuten.",
"comp.saved": "Gespeichert. {n} Begleiter melden sich beim Serverstart an.",
// Client
"client.title": "Spielclient",
"client.looking": "Suche …",
"client.intro": "Sag dem Manager, wo dein Spiel installiert ist, um einen SPIELEN-Button zu erhalten. Deine Spieldateien werden nie geändert, außer der Serveradresse und dem Begleiter-Addon.",
"client.chooseFolder": "Spielordner wählen …",
"client.dialogTitle": "Wähle den Ordner deines Spielclients",
"client.connectsTo": "Verbindet mit",
"client.thisComputer": "✓ dieser Computer",
"client.notThisServer": "nicht dieser Server",
"client.addon": "Begleiter-Addon",
"client.installedVersion": "Installiert (Version {v})",
"client.installed": "Installiert",
"client.addonNotInstalled": "Nicht installiert",
"client.updateAvailable": "ein Update ist verfügbar",
"client.otherAddons": "Andere Addons",
"client.leftAsIs": "{n} – bleiben unverändert",
"client.pointLocal": "Spiel auf diesen Server ausrichten",
"client.pointedNote": "Das Spiel verbindet sich jetzt mit diesem Computer. Die vorherige Adresse wurde gespeichert.",
"client.installAddon": "Begleiter-Addon installieren",
"client.updateAddon": "Begleiter-Addon aktualisieren",
"client.addonNote": "Begleiter-Addon installiert. Andere Addons wurden nicht angetastet.",
"client.changeFolder": "Ordner ändern …",
// Diagnostics
"diag.title": "Diagnose",
"diag.text": "Sucht nach häufigen Problemen. Es wird nichts verändert.",
"diag.run": "Diagnose starten",
"diag.verify": "Serverdateien prüfen",
"diag.export": "Diagnosepaket exportieren",
"diag.saved": "Für Fehlerberichte gespeichert: {path}",
"diag.allGood": "Alles sieht gut aus.",
"diag.problems_one": "{n} Punkt zum Prüfen",
"diag.problems_few": "{n} Punkte zum Prüfen",
"diag.problems_many": "{n} Punkte zum Prüfen",
"diag.problems_other": "{n} Punkte zum Prüfen",
"diag.word.ok": "OK",
"diag.word.warn": "Achtung",
"diag.word.fail": "Problem",
"diag.filesOk": "Alle Programmdateien sind unversehrt.",
"diag.filesDiffer": "{n} Programmdatei(en) weichen vom Installierten ab. Deine eigenen Dateien werden hier nie aufgeführt. „Nach Updates suchen“ stellt fehlende wieder her.",
"diag.fileMissing": "fehlt",
"diag.fileChanged": "geändert",
// About Manager
"about.version": "Version {v}. Programmupdates verändern deinen Server nie.",
"about.check": "Nach neuer Version suchen",
"about.install": "{v} installieren und neu starten",
"about.upToDate": "CoA Server Manager ist auf dem neuesten Stand.",
"about.checkFailed": "Die Suche nach einer neuen Version ist fehlgeschlagen. Prüfe deine Internetverbindung und versuche es erneut.",
"about.installFailed": "Das Update konnte nicht installiert werden. Dein Server wurde nicht angetastet.",
// Backups
"bk.title": "Sicherungen",
"bk.trigger.manual": "Manuelle Sicherung",
"bk.trigger.automatic": "Automatische Sicherung",
"bk.trigger.before-update": "Vor dem Update",
"bk.trigger.before-restore": "Sicherheitskopie vor einer Wiederherstellung",
"bk.trigger.before-migration": "Vor dem Datenbank-Update",
"bk.trigger.before-bots": "Vor der Installation der Begleiter",
"bk.trigger.before-repair": "Vor der Reparatur",
"bk.trigger.before-dangerous-change": "Vor einer riskanten Änderung",
"bk.kind.quick": "Charaktere, Konten und Einstellungen",
"bk.kind.full": "Alles, einschließlich der Weltdatenbank",
"bk.kind.config": "Nur Einstellungen",
"bk.kind.database": "Charaktere und Konten",
"bk.db.characters": "Charaktere",
"bk.db.auth": "Konten",
"bk.db.world": "Weltdaten",
"bk.today": "Heute {time}",
"bk.yesterday": "Gestern {time}",
"bk.created": "Sicherung erstellt.",
"bk.last": "Letzte Sicherung: {when}",
"bk.none": "Noch keine Sicherungen",
"bk.keptNext": "Sicherungen liegen neben deinem Server und überschreiben nie deine Live-Daten.",
"bk.backUpNow": "Jetzt sichern",
"bk.full": "Vollsicherung",
"bk.fullHint": "Sichert auch die große Weltdatenbank",
"bk.settingsOnly": "Nur Einstellungen",
"bk.working": "Wird ausgeführt …",
"bk.failed": "Das hat nicht funktioniert",
"bk.restoreFrom": "Wiederherstellen aus „{what}“, {when}",
"bk.restoreNote": "Es wird nichts gelöscht. Deine aktuellen Daten werden zuerst gesichert, und eine ersetzte Datenbank bleibt unter neuem Namen erhalten.",
"bk.stopFirst": "Stoppe zuerst den Server – Datenbanken können nur bei gestopptem Server wiederhergestellt werden.",
"bk.settingsRestored": "Einstellungen wiederhergestellt. Eine Sicherheitskopie der vorherigen Einstellungen wurde gespeichert.",
"bk.restoreSettings": "Einstellungen wiederherstellen",
"bk.confirmDb": "Datenbank „{db}“ aus dieser Sicherung wiederherstellen? Fortschritt seit {when} wird beiseitegelegt (nicht gelöscht).",
"bk.dbRestored": "{n} Tabellen wiederhergestellt. Die vorherigen Daten bleiben als {schema} erhalten.",
"bk.restoreDb": "{db} wiederherstellen",
"bk.loading": "Wird geladen …",
"bk.empty": "Deine Sicherungen erscheinen hier.",
"bk.restore": "Wiederherstellen",
"bk.verify": "Prüfen",
"bk.intact": "Diese Sicherung ist unversehrt.",
"bk.problem": "Problem gefunden: {details}",
"bk.delete": "Löschen",
"bk.confirmDelete": "Diese Sicherung löschen? Nur diese Sicherung wird entfernt; dein Server bleibt unberührt.",
// Friends
"fr.title": "Mit Freunden spielen",
"fr.looking": "Verbindung wird geprüft …",
"fr.ok": "OK",
"fr.notYet": "noch nicht",
"fr.mode.lan.title": "Lokales Netzwerk",
"fr.mode.lan.text": "Freunde im selben Heimnetzwerk oder WLAN.",
"fr.mode.direct.title": "Über das Internet",
"fr.mode.direct.text": "Freunde von überall, über deine Internetverbindung. Dein Router muss das erlauben.",
"fr.mode.private.title": "Privates Netzwerk",
"fr.mode.private.text": "Freunde von überall, ohne Router-Einrichtung. Nutzt die kostenlose Tailscale-App.",
"fr.restartToApply": "Starte den Server neu, um dies anzuwenden.",
"fr.ready": "Bereit für Freunde.",
"fr.exposedTitle": "Etwas Privates ist aus deinem Netzwerk erreichbar",
"fr.exposedText": "{what} akzeptieren Verbindungen von anderen Computern. Starte den Server über dieses Programm neu, um sie zu schließen.",
"fr.what.database": "Datenbank",
"fr.what.console": "Serverkonsole",
"fr.and": " und ",
"fr.status": "Status",
"fr.st.running": "Server läuft",
"fr.st.open": "Anmelde- und Spielserver sind für andere Computer offen",
"fr.st.firewall": "Die Windows-Firewall lässt die Spielports zu",
"fr.st.private": "Datenbank und Serverkonsole sind nur auf diesem Computer erreichbar",
"fr.inUse": "In Gebrauch",
"fr.yourLan": "Deine Adresse in diesem Netzwerk:",
"fr.unknown": "unbekannt",
"fr.checkConn": "Meine Verbindung prüfen",
"fr.cgnat": "Dein Internetanbieter erlaubt kein direktes Hosting. Nutze stattdessen das private Netzwerk.",
"fr.publicAddr": "Deine öffentliche Adresse:",
"fr.noRouter": " · dein Router kann nicht automatisch eingerichtet werden; leite die beiden Spielports manuell weiter",
"fr.noInternet": "Das Internet war nicht erreichbar, um deine Adresse zu ermitteln.",
"fr.tsMissing": "Tailscale ist nicht installiert. Installiere die kostenlose App von tailscale.com/download, melde dich an und komm zurück.",
"fr.tsOff": "Tailscale ist installiert, aber nicht verbunden. Melde dich zuerst an.",
"fr.privateAddr": "Deine private Adresse:",
"fr.checkFirst": "Prüfe zuerst deine Verbindung",
"fr.reapply": "Erneut anwenden",
"fr.enable": "Aktivieren",
"fr.onlyLocal": "Jetzt kann sich nur dieser Computer verbinden.",
"fr.stopSharing": "Freigabe beenden (nur dieser Computer)",
"fr.giveTitle": "Gib das deinem Freund",
"fr.giveText": "Er trägt diese Zeile in die Datei realmlist.wtf seines Spiels ein. Passwörter und Einstellungen werden nie weitergegeben.",
"fr.copied": "Kopiert",
"fr.copy": "Verbindungsdaten kopieren",
"fr.pkg": "Freundepaket erstellen (zip)",
"fr.pkgSaved": "Gespeichert: {path}",
// Console
"con.title": "Konsole",
"con.tab.world": "Welt",
"con.tab.auth": "Anmeldung",
"con.tab.database": "Datenbank",
"con.tab.manager": "Manager",
"con.searchLabel": "Protokoll durchsuchen",
"con.search": "Suchen …",
"con.follow": "Mitverfolgen",
"con.copied": "Kopiert",
"con.copyErrors": "Fehler kopieren",
"con.empty": "Nichts anzuzeigen.",
"con.commandsNote": "Befehle gehen direkt an den laufenden Weltserver. Riskante (Herunterfahren, Löschen, Sperren) verlangen eine Bestätigung.",
"con.commandLabel": "Befehl",
"con.send": "Senden",
"con.confirmRisky": "„{cmd}“ kann Dinge herunterfahren oder viele Datensätze ändern. Trotzdem senden?",
// Server updates
"upd.act.create": "Neue Datei",
"upd.act.replace": "Aktualisiert",
"upd.act.merge-config": "Neue Einstellungen hinzugefügt",
"upd.act.skip": "Unverändert",
"upd.act.conflict": "Braucht deine Entscheidung",
"upd.updatedTo": "Auf Version {v} aktualisiert.",
"upd.confirmBack": "Zur vorherigen Version zurückkehren? Deine Charaktere und Konten werden nicht verändert.",
"upd.wentBack": "Zur vorherigen Version zurückgekehrt. Deine Daten wurden nicht angetastet.",
"upd.dialogTitle": "Wähle einen Update-Paketordner",
"upd.pendingBad": "Der aktualisierte Server ist nicht korrekt gestartet",
"upd.pendingUnfinished": "Ein früheres Update wurde nicht abgeschlossen",
"upd.safeBack": "Du kannst sicher zur vorherigen Version zurückkehren.",
"upd.backNote": "Das Zurückkehren stellt Programmdateien und Einstellungen wieder her. Charaktere und Konten werden nie automatisch zurückgesetzt.",
"upd.goBackTo": "Zu Version {v} zurückkehren",
"upd.goBackBefore": "Zur Version vor dem Update zurückkehren",
"upd.title": "Server-Updates",
"upd.text": "Updates werden auf Echtheit geprüft, vorher gesichert und können rückgängig gemacht werden.",
"upd.check": "Nach Updates suchen",
"upd.folderLabel": "Update-Paketordner",
"upd.folderHint": "Update-Paketordner (leer lassen für die offizielle Quelle)",
"upd.available": "Version {to} ist verfügbar",
"upd.availableFrom": "Version {to} ist verfügbar (du hast {from})",
"upd.summary": "Download {size} · {files} Datei(en) ändern sich",
"upd.summaryDb": "Download {size} · {files} Datei(en) ändern sich · {db} Datenbank-Update(s)",
"upd.conflict": "Diese Datei wurde außerhalb des CoA Server Managers geändert.",
"upd.keep": "Meine Datei behalten",
"upd.replace": "Durch Update ersetzen",
"upd.now": "Jetzt aktualisieren",
"upd.stopNote": "Der Server wird während des Updates gestoppt und danach zur Prüfung erneut gestartet.",
// Settings editor
"set.restart.runtime": "Wird sofort angewendet",
"set.restart.world": "Erfordert Neustart des Weltservers",
"set.restart.full": "Erfordert einen vollständigen Serverneustart",
"set.on": "An",
"set.off": "Aus",
"set.enterNumber": "Gib eine Zahl ein",
"set.enterInt": "Gib eine ganze Zahl ein",
"set.atLeast": "Muss mindestens {n} sein",
"set.atMost": "Darf höchstens {n} sein",
"set.careful": "Vorsicht",
"set.changed": "Geändert",
"set.default": "Standard: {v}",
"set.range": "Bereich {min}–{max}",
"set.badValue": "Die Datei enthält einen unbrauchbaren Wert ({problem}); der Standardwert wird angezeigt.",
"set.drift": "In der generierten Datei von Hand geändert – der Launcher setzt es beim nächsten Start zurück, sofern du es nicht hier speicherst.",
"set.reset": "Auf Standard zurücksetzen",
"set.resetItem": "„{name}“ auf Standard zurücksetzen",
"set.nothingYet": "Noch nichts zu konfigurieren",
"set.loading": "Einstellungen werden geladen …",
"set.confirmCareful": "Du änderst {n} als „Vorsicht“ markierte Einstellung(en). Zuvor wird ein Snapshot der aktuellen Konfiguration gespeichert, sodass sich das rückgängig machen lässt. Fortfahren?",
"set.driftTitle": "{n} Einstellung(en) wurden von Hand geändert",
"set.driftText": "Der Server-Launcher erstellt worldserver.conf bei jedem Start aus seiner Vorlage neu, daher gehen diese manuellen Änderungen verloren:",
"set.presets": "Voreinstellungen:",
"set.restoreDefaults": "Empfohlene Standardwerte wiederherstellen",
"set.matches": "Nichts zu ändern – deine Einstellungen stimmen bereits überein.",
"set.willChange_one": "Dadurch wird {n} Einstellung geändert:",
"set.willChange_few": "Dadurch werden {n} Einstellungen geändert:",
"set.willChange_many": "Dadurch werden {n} Einstellungen geändert:",
"set.willChange_other": "Dadurch werden {n} Einstellungen geändert:",
"set.apply": "Anwenden",
"set.nothingChanged": "Nichts geändert.",
"set.saved": "Gespeichert.",
"set.restartRequired_one": "Für {n} Einstellung ist ein Neustart nötig.",
"set.restartRequired_few": "Für {n} Einstellungen ist ein Neustart nötig.",
"set.restartRequired_many": "Für {n} Einstellungen ist ein Neustart nötig.",
"set.restartRequired_other": "Für {n} Einstellungen ist ein Neustart nötig.",
"set.appliesNextStart": "Die Änderungen werden beim nächsten Serverstart angewendet.",
"set.restartNow": "Jetzt neu starten",
"set.later": "Später",
"set.notSaved": "Es wurde nichts gespeichert. Korrigiere die markierten Einstellungen und versuche es erneut.",
"set.advanced": "Erweiterte Einstellungen ({n})",
"set.unknownKept": "{n} weitere Einstellung(en) in der Konfigurationsdatei bleiben genau so erhalten.",
"set.unsaved_one": "{n} nicht gespeicherte Änderung",
"set.unsaved_few": "{n} nicht gespeicherte Änderungen",
"set.unsaved_many": "{n} nicht gespeicherte Änderungen",
"set.unsaved_other": "{n} nicht gespeicherte Änderungen",
"set.discard": "Verwerfen",
"set.save": "Änderungen speichern",
// Download errors
"err.package_not_published.title": "Dieses Serverpaket ist noch nicht verfügbar",
"err.package_not_published.message": "Am Download-Ort wurde noch nichts veröffentlicht. Versuche es später erneut oder installiere aus einem lokalen Paketordner (Erweitert).",
"err.network_unreachable.title": "Der Download-Server war nicht erreichbar",
"err.network_unreachable.message": "Prüfe deine Internetverbindung und versuche es erneut.",
// Manager self-update
"selfupd.ready": "Manager {v} ist installationsbereit",
"selfupd.onClose": "Es wird installiert, wenn du den Manager schließt. Deine Server laufen weiter.",
"selfupd.installing": "Installation läuft … der Manager wird geschlossen.",
"selfupd.now": "Jetzt installieren",
"about.auto": "Updates im Hintergrund laden und beim Schließen des Managers installieren",
"about.autoHint": "Ein Manager-Update stoppt oder verändert deine Server nie.",
// Friends line
"fr.copyLine": "Zeile kopieren",
};
export default de;
+335
View File
@@ -98,6 +98,341 @@ const en = {
"err.path_rejected.message": "The requested file location is outside the server folder.",
"err.unknown.title": "Something went wrong",
"err.unknown.message": "See the technical details.",
// Import server
"import.title": "Add an existing server",
"import.subtitle": "Pick the folder your server runs from. It will only be read.",
"import.dialogTitle": "Choose your server folder",
"import.choose": "Choose folder…",
"import.chooseAnother": "Choose another folder",
"import.looking": "Looking at your server…",
"import.healthy.title": "Existing server detected",
"import.healthy.text": "Everything needed to run this server was found.",
"import.partial.title": "Server partly found",
"import.partial.text": "Some parts are missing. You can still add it; nothing will be fixed automatically.",
"import.custom.title": "Custom server detected",
"import.custom.text": "This build is not recognised. Some update and install features will be disabled.",
"import.incompatible.title": "This is not a server folder",
"import.incompatible.text": "Choose the folder that contains Core, Data and mysql (or your worldserver.exe).",
"import.techDetails": "Show technical details",
"import.detected": "Detected",
"import.notInstalled": "Not installed",
"import.notFound": "Not found",
"import.noChanges": "No files will be changed during import.",
"import.add": "Add server",
// Install server
"install.title": "Install a new server",
"install.subtitle": "Choose a folder, or keep the suggested one. Everything else is set up for you.",
"install.installTo": "Install to",
"install.browse": "Browse…",
"install.dialogTitle": "Choose where to install your server",
"install.pkgDialogTitle": "Choose a server package folder",
"install.ready": "This folder is ready. {gb} GB free.",
"install.failedTitle": "The installation could not finish",
"install.nothingInstalled": "Nothing was installed. You can try again; downloaded files are kept.",
"install.showTech": "Show technical details",
"install.hideTech": "Hide technical details",
"install.advanced": "Advanced",
"install.localPkg": "Install from a local package folder instead of downloading",
"install.localPkgHint": "(leave empty to download)",
"install.button": "Install",
"install.progressTitle": "Preparing your server",
"install.progressText": "This can take a few minutes. You can leave this window open.",
"install.step.checking": "Checking your computer",
"install.step.downloading": "Downloading server",
"install.step.unpacking": "Unpacking",
"install.step.database": "Preparing database",
"install.step.finishing": "Finishing",
"install.doneTitle": "Your server is ready",
"install.doneText": "Everything is installed. Start it from the next screen.",
"install.open": "OPEN MY SERVER",
// Players
"players.title": "Players",
"players.createTitle": "Create your account",
"players.createText": "This is the name and password you use to log in to the game.",
"players.startFirst": "Start the server first — accounts are created while it is running.",
"players.username": "Username",
"players.password": "Password",
"players.admin": "Make this account an administrator",
"players.adminHint": "Administrators can use game-master commands in the game. Only do this for accounts you trust.",
"players.create": "Create account",
"players.created": "Account “{name}” created. You can log in to the game with it now.",
// Companions
"comp.title": "AI companions",
"comp.population": "{online} online now · {total} created in total",
"comp.reading": "Reading the current population…",
"comp.startToSee": "Start the server to see how many companions are online.",
"comp.wantMore": "Would you like more companions?",
"comp.custom": "Custom",
"comp.numberLabel": "Number of companions",
"comp.largeWarning": "Large populations may need more CPU and memory. Increase gradually.",
"comp.hardware": "This computer: {cores} cores, {ram} GB memory.",
"comp.add": "Add {n} companions",
"comp.addPlain": "Add companions",
"comp.stoppedHint": "The server is stopped: they will be created the next time it runs.",
"comp.spawned": "Creating {n} companions. They appear gradually over the next minutes.",
"comp.saved": "Saved. {n} companions will log in when the server starts.",
// Client
"client.title": "Game client",
"client.looking": "Looking…",
"client.intro": "Tell Manager where your game is installed to get a PLAY button. Your game files are never changed except the server address and the companion addon.",
"client.chooseFolder": "Choose game folder…",
"client.dialogTitle": "Choose your game client folder",
"client.connectsTo": "Connects to",
"client.thisComputer": "✓ this computer",
"client.notThisServer": "not this server",
"client.addon": "Companion addon",
"client.installedVersion": "Installed (version {v})",
"client.installed": "Installed",
"client.addonNotInstalled": "Not installed",
"client.updateAvailable": "an update is available",
"client.otherAddons": "Other addons",
"client.leftAsIs": "{n} — left exactly as they are",
"client.pointLocal": "Point the game at this server",
"client.pointedNote": "The game now connects to this computer. The previous address was saved.",
"client.installAddon": "Install companion addon",
"client.updateAddon": "Update companion addon",
"client.addonNote": "Companion addon installed. Other addons were not touched.",
"client.changeFolder": "Change folder…",
// Diagnostics
"diag.title": "Diagnostics",
"diag.text": "Looks for common problems. Nothing is changed.",
"diag.run": "Run diagnostics",
"diag.verify": "Check server files",
"diag.export": "Export diagnostic package",
"diag.saved": "Saved for bug reports: {path}",
"diag.allGood": "Everything looks good.",
"diag.problems_one": "{n} thing to look at",
"diag.problems_few": "{n} things to look at",
"diag.problems_many": "{n} things to look at",
"diag.problems_other": "{n} things to look at",
"diag.word.ok": "OK",
"diag.word.warn": "Attention",
"diag.word.fail": "Problem",
"diag.filesOk": "All program files are intact.",
"diag.filesDiffer": "{n} program file(s) differ from what was installed. Your own files are never listed here. \"Check for updates\" restores missing ones.",
"diag.fileMissing": "missing",
"diag.fileChanged": "changed",
// About Manager
"about.version": "Version {v}. Updates to the program never change your server.",
"about.check": "Check for a new version",
"about.install": "Install {v} and restart",
"about.upToDate": "CoA Server Manager is up to date.",
"about.checkFailed": "Could not check for a new version. Check your internet connection and try again.",
"about.installFailed": "The update could not be installed. Your server was not touched.",
// Backups
"bk.title": "Backups",
"bk.trigger.manual": "Manual backup",
"bk.trigger.automatic": "Automatic backup",
"bk.trigger.before-update": "Before update",
"bk.trigger.before-restore": "Safety copy before a restore",
"bk.trigger.before-migration": "Before database update",
"bk.trigger.before-bots": "Before installing companions",
"bk.trigger.before-repair": "Before repair",
"bk.trigger.before-dangerous-change": "Before a risky change",
"bk.kind.quick": "Characters, accounts and settings",
"bk.kind.full": "Everything, including the world database",
"bk.kind.config": "Settings only",
"bk.kind.database": "Characters and accounts",
"bk.db.characters": "Characters",
"bk.db.auth": "Accounts",
"bk.db.world": "World data",
"bk.today": "Today {time}",
"bk.yesterday": "Yesterday {time}",
"bk.created": "Backup created.",
"bk.last": "Last backup: {when}",
"bk.none": "No backups yet",
"bk.keptNext": "Backups are kept next to your server and never overwrite your live data.",
"bk.backUpNow": "Back up now",
"bk.full": "Full backup",
"bk.fullHint": "Also saves the large world database",
"bk.settingsOnly": "Settings only",
"bk.working": "Working…",
"bk.failed": "That did not work",
"bk.restoreFrom": "Restore from {what}, {when}",
"bk.restoreNote": "Nothing is deleted. Your current data is saved first, and a replaced database is kept alongside under a new name.",
"bk.stopFirst": "Stop the server first — databases can only be restored while it is stopped.",
"bk.settingsRestored": "Settings restored. A safety copy of the previous settings was saved.",
"bk.restoreSettings": "Restore settings",
"bk.confirmDb": "Restore the {db} database from this backup? Progress made since {when} will be set aside (not deleted).",
"bk.dbRestored": "Restored {n} tables. The previous data is kept as {schema}.",
"bk.restoreDb": "Restore {db}",
"bk.loading": "Loading…",
"bk.empty": "Your backups will appear here.",
"bk.restore": "Restore",
"bk.verify": "Verify",
"bk.intact": "This backup is intact.",
"bk.problem": "Problem found: {details}",
"bk.delete": "Delete",
"bk.confirmDelete": "Delete this backup? Only this backup is removed; your server is not affected.",
// Friends
"fr.title": "Play with Friends",
"fr.looking": "Looking at your connection…",
"fr.ok": "OK",
"fr.notYet": "not yet",
"fr.mode.lan.title": "Local network",
"fr.mode.lan.text": "Friends on the same home network or Wi-Fi.",
"fr.mode.direct.title": "Over the internet",
"fr.mode.direct.text": "Friends anywhere, through your internet connection. Needs your router to allow it.",
"fr.mode.private.title": "Private network",
"fr.mode.private.text": "Friends anywhere, no router setup. Uses the free Tailscale app.",
"fr.restartToApply": "Restart the server to apply this.",
"fr.ready": "Ready for friends.",
"fr.exposedTitle": "Something private is reachable from your network",
"fr.exposedText": "{what} accept connections from other computers. Restart the server from this program to close them.",
"fr.what.database": "database",
"fr.what.console": "server console",
"fr.and": " and ",
"fr.status": "Status",
"fr.st.running": "Server is running",
"fr.st.open": "Login and game servers are open to other computers",
"fr.st.firewall": "Windows Firewall allows the game ports",
"fr.st.private": "Database and server console are private to this computer",
"fr.inUse": "In use",
"fr.yourLan": "Your address on this network:",
"fr.unknown": "unknown",
"fr.checkConn": "Check my connection",
"fr.cgnat": "Your internet provider does not allow direct hosting. Use the private network instead.",
"fr.publicAddr": "Your public address:",
"fr.noRouter": " · your router cannot be set up automatically; forward the two game ports by hand",
"fr.noInternet": "Could not reach the internet to find your address.",
"fr.tsMissing": "Tailscale is not installed. Install the free app from tailscale.com/download, sign in, then come back.",
"fr.tsOff": "Tailscale is installed but not connected. Sign in to it first.",
"fr.privateAddr": "Your private address:",
"fr.checkFirst": "Check your connection first",
"fr.reapply": "Re-apply",
"fr.enable": "Enable",
"fr.onlyLocal": "Only this computer can connect now.",
"fr.stopSharing": "Stop sharing (this computer only)",
"fr.giveTitle": "Give this to your friend",
"fr.giveText": "They put this line in their game's realmlist.wtf file. Passwords and settings are never shared.",
"fr.copied": "Copied",
"fr.copy": "Copy connection info",
"fr.pkg": "Create friend package (zip)",
"fr.pkgSaved": "Saved: {path}",
// Console
"con.title": "Console",
"con.tab.world": "World",
"con.tab.auth": "Auth",
"con.tab.database": "Database",
"con.tab.manager": "Manager",
"con.searchLabel": "Search the log",
"con.search": "Search…",
"con.follow": "Follow",
"con.copied": "Copied",
"con.copyErrors": "Copy errors",
"con.empty": "Nothing to show.",
"con.commandsNote": "Commands go straight to the running world server. Risky ones (shutdown, deleting or banning) ask for confirmation.",
"con.commandLabel": "Command",
"con.send": "Send",
"con.confirmRisky": "“{cmd}” can shut things down or change many records. Send it anyway?",
// Server updates
"upd.act.create": "New file",
"upd.act.replace": "Updated",
"upd.act.merge-config": "New settings added",
"upd.act.skip": "Unchanged",
"upd.act.conflict": "Needs your decision",
"upd.updatedTo": "Updated to version {v}.",
"upd.confirmBack": "Go back to the previous version? Your characters and accounts are not changed.",
"upd.wentBack": "Went back to the previous version. Your data was not touched.",
"upd.dialogTitle": "Choose an update package folder",
"upd.pendingBad": "The updated server did not start correctly",
"upd.pendingUnfinished": "An earlier update did not finish",
"upd.safeBack": "You can safely go back to the previous version.",
"upd.backNote": "Going back restores program files and settings. Characters and accounts are never rolled back automatically.",
"upd.goBackTo": "Go back to version {v}",
"upd.goBackBefore": "Go back to the version before the update",
"upd.title": "Server updates",
"upd.text": "Updates are checked for authenticity, backed up first, and can be undone.",
"upd.check": "Check for updates",
"upd.folderLabel": "Update package folder",
"upd.folderHint": "Update package folder (leave empty to use the official source)",
"upd.available": "Version {to} is available",
"upd.availableFrom": "Version {to} is available (you have {from})",
"upd.summary": "Download {size} · {files} file(s) change",
"upd.summaryDb": "Download {size} · {files} file(s) change · {db} database update(s)",
"upd.conflict": "This file was modified outside CoA Server Manager.",
"upd.keep": "Keep my file",
"upd.replace": "Replace with update",
"upd.now": "Update now",
"upd.stopNote": "The server is stopped during the update and started again to check that it works.",
// Settings editor
"set.restart.runtime": "Applies immediately",
"set.restart.world": "Needs a world server restart",
"set.restart.full": "Needs a full server restart",
"set.on": "On",
"set.off": "Off",
"set.enterNumber": "Enter a number",
"set.enterInt": "Enter a whole number",
"set.atLeast": "Must be at least {n}",
"set.atMost": "Must be at most {n}",
"set.careful": "Careful",
"set.changed": "Changed",
"set.default": "Default: {v}",
"set.range": "Range {min}–{max}",
"set.badValue": "The file has an unusable value ({problem}); showing the default.",
"set.drift": "Edited by hand in the generated file — the launcher will reset it at next start unless you save it here.",
"set.reset": "Reset to default",
"set.resetItem": "Reset {name} to default",
"set.nothingYet": "Nothing to configure yet",
"set.loading": "Loading settings…",
"set.confirmCareful": "You are changing {n} setting(s) marked Careful. A snapshot of the current configuration is saved first, so this can be undone. Continue?",
"set.driftTitle": "{n} setting(s) were edited by hand",
"set.driftText": "The server launcher rebuilds worldserver.conf from its template every time it starts, so these manual edits will be lost:",
"set.presets": "Presets:",
"set.restoreDefaults": "Restore recommended defaults",
"set.matches": "Nothing to change — your settings already match.",
"set.willChange_one": "This will change {n} setting:",
"set.willChange_few": "This will change {n} settings:",
"set.willChange_many": "This will change {n} settings:",
"set.willChange_other": "This will change {n} settings:",
"set.apply": "Apply",
"set.nothingChanged": "Nothing changed.",
"set.saved": "Saved.",
"set.restartRequired_one": "Restart required to apply {n} setting.",
"set.restartRequired_few": "Restart required to apply {n} settings.",
"set.restartRequired_many": "Restart required to apply {n} settings.",
"set.restartRequired_other": "Restart required to apply {n} settings.",
"set.appliesNextStart": "The changes will apply the next time the server starts.",
"set.restartNow": "Restart now",
"set.later": "Later",
"set.notSaved": "Nothing was saved. Fix the highlighted settings and try again.",
"set.advanced": "Advanced settings ({n})",
"set.unknownKept": "{n} other setting(s) in the configuration file are kept exactly as they are.",
"set.unsaved_one": "{n} unsaved change",
"set.unsaved_few": "{n} unsaved changes",
"set.unsaved_many": "{n} unsaved changes",
"set.unsaved_other": "{n} unsaved changes",
"set.discard": "Discard",
"set.save": "Save changes",
// Download errors
"err.package_not_published.title": "This server package is not available yet",
"err.package_not_published.message": "Nothing has been published at the download location. Try again later, or install from a local package folder (Advanced).",
"err.network_unreachable.title": "Could not reach the download server",
"err.network_unreachable.message": "Check your internet connection and try again.",
// Manager self-update
"selfupd.ready": "Manager {v} is ready to install",
"selfupd.onClose": "It will be installed when you close the Manager. Your servers keep running.",
"selfupd.installing": "Installing… the Manager will close.",
"selfupd.now": "Install now",
"about.auto": "Download updates in the background and install them when I close the Manager",
"about.autoHint": "Your servers are never stopped or changed by a Manager update.",
// Friends line
"fr.copyLine": "Copy line",
} as const;
export default en;
+335
View File
@@ -98,6 +98,341 @@ const es: Partial<Record<keyof typeof en, string>> = {
"err.path_rejected.message": "La ubicación solicitada está fuera de la carpeta del servidor.",
"err.unknown.title": "Algo salió mal",
"err.unknown.message": "Consulta los detalles técnicos.",
// Import server
"import.title": "Añadir un servidor existente",
"import.subtitle": "Elige la carpeta desde la que se ejecuta tu servidor. Solo se leerá.",
"import.dialogTitle": "Elige la carpeta del servidor",
"import.choose": "Elegir carpeta…",
"import.chooseAnother": "Elegir otra carpeta",
"import.looking": "Examinando tu servidor…",
"import.healthy.title": "Servidor existente detectado",
"import.healthy.text": "Se encontró todo lo necesario para ejecutar este servidor.",
"import.partial.title": "Servidor encontrado parcialmente",
"import.partial.text": "Faltan algunas partes. Aun así puedes añadirlo; no se corregirá nada automáticamente.",
"import.custom.title": "Servidor personalizado detectado",
"import.custom.text": "Esta versión no se reconoce. Algunas funciones de actualización e instalación estarán desactivadas.",
"import.incompatible.title": "Esta no es una carpeta de servidor",
"import.incompatible.text": "Elige la carpeta que contiene Core, Data y mysql (o tu worldserver.exe).",
"import.techDetails": "Mostrar detalles técnicos",
"import.detected": "Detectado",
"import.notInstalled": "No instalado",
"import.notFound": "No encontrado",
"import.noChanges": "No se modificará ningún archivo durante la importación.",
"import.add": "Añadir servidor",
// Install server
"install.title": "Instalar un servidor nuevo",
"install.subtitle": "Elige una carpeta o mantén la sugerida. Todo lo demás se configura por ti.",
"install.installTo": "Instalar en",
"install.browse": "Examinar…",
"install.dialogTitle": "Elige dónde instalar tu servidor",
"install.pkgDialogTitle": "Elige una carpeta de paquete del servidor",
"install.ready": "Esta carpeta está lista. {gb} GB libres.",
"install.failedTitle": "La instalación no pudo terminar",
"install.nothingInstalled": "No se instaló nada. Puedes intentarlo de nuevo; los archivos descargados se conservan.",
"install.showTech": "Mostrar detalles técnicos",
"install.hideTech": "Ocultar detalles técnicos",
"install.advanced": "Avanzado",
"install.localPkg": "Instalar desde una carpeta de paquete local en lugar de descargar",
"install.localPkgHint": "(déjalo vacío para descargar)",
"install.button": "Instalar",
"install.progressTitle": "Preparando tu servidor",
"install.progressText": "Esto puede tardar unos minutos. Puedes dejar esta ventana abierta.",
"install.step.checking": "Comprobando tu equipo",
"install.step.downloading": "Descargando el servidor",
"install.step.unpacking": "Descomprimiendo",
"install.step.database": "Preparando la base de datos",
"install.step.finishing": "Finalizando",
"install.doneTitle": "Tu servidor está listo",
"install.doneText": "Todo está instalado. Inícialo desde la siguiente pantalla.",
"install.open": "ABRIR MI SERVIDOR",
// Players
"players.title": "Jugadores",
"players.createTitle": "Crea tu cuenta",
"players.createText": "Este es el nombre y la contraseña con los que inicias sesión en el juego.",
"players.startFirst": "Inicia primero el servidor: las cuentas se crean mientras está en marcha.",
"players.username": "Nombre de usuario",
"players.password": "Contraseña",
"players.admin": "Convertir esta cuenta en administrador",
"players.adminHint": "Los administradores pueden usar comandos de game master en el juego. Hazlo solo con cuentas de confianza.",
"players.create": "Crear cuenta",
"players.created": "Cuenta «{name}» creada. Ya puedes iniciar sesión en el juego con ella.",
// Companions
"comp.title": "Compañeros de IA",
"comp.population": "{online} en línea ahora · {total} creados en total",
"comp.reading": "Leyendo la población actual…",
"comp.startToSee": "Inicia el servidor para ver cuántos compañeros hay en línea.",
"comp.wantMore": "¿Quieres más compañeros?",
"comp.custom": "Personalizado",
"comp.numberLabel": "Número de compañeros",
"comp.largeWarning": "Las poblaciones grandes pueden requerir más CPU y memoria. Aumenta poco a poco.",
"comp.hardware": "Este equipo: {cores} núcleos, {ram} GB de memoria.",
"comp.add": "Añadir {n} compañeros",
"comp.addPlain": "Añadir compañeros",
"comp.stoppedHint": "El servidor está detenido: se crearán la próxima vez que se inicie.",
"comp.spawned": "Creando {n} compañeros. Aparecerán gradualmente durante los próximos minutos.",
"comp.saved": "Guardado. {n} compañeros iniciarán sesión cuando se inicie el servidor.",
// Client
"client.title": "Cliente del juego",
"client.looking": "Buscando…",
"client.intro": "Indica al Manager dónde está instalado el juego para obtener un botón JUGAR. Tus archivos del juego nunca se modifican, salvo la dirección del servidor y el addon de compañeros.",
"client.chooseFolder": "Elegir carpeta del juego…",
"client.dialogTitle": "Elige la carpeta de tu cliente del juego",
"client.connectsTo": "Se conecta a",
"client.thisComputer": "✓ este equipo",
"client.notThisServer": "no este servidor",
"client.addon": "Addon de compañeros",
"client.installedVersion": "Instalado (versión {v})",
"client.installed": "Instalado",
"client.addonNotInstalled": "No instalado",
"client.updateAvailable": "hay una actualización disponible",
"client.otherAddons": "Otros addons",
"client.leftAsIs": "{n}: se dejan exactamente como están",
"client.pointLocal": "Apuntar el juego a este servidor",
"client.pointedNote": "El juego ahora se conecta a este equipo. La dirección anterior se guardó.",
"client.installAddon": "Instalar addon de compañeros",
"client.updateAddon": "Actualizar addon de compañeros",
"client.addonNote": "Addon de compañeros instalado. Los demás addons no se tocaron.",
"client.changeFolder": "Cambiar carpeta…",
// Diagnostics
"diag.title": "Diagnóstico",
"diag.text": "Busca problemas comunes. No se cambia nada.",
"diag.run": "Ejecutar diagnóstico",
"diag.verify": "Comprobar archivos del servidor",
"diag.export": "Exportar paquete de diagnóstico",
"diag.saved": "Guardado para informes de errores: {path}",
"diag.allGood": "Todo parece correcto.",
"diag.problems_one": "{n} cosa que revisar",
"diag.problems_few": "{n} cosas que revisar",
"diag.problems_many": "{n} cosas que revisar",
"diag.problems_other": "{n} cosas que revisar",
"diag.word.ok": "Correcto",
"diag.word.warn": "Atención",
"diag.word.fail": "Problema",
"diag.filesOk": "Todos los archivos del programa están intactos.",
"diag.filesDiffer": "{n} archivo(s) del programa difieren de lo instalado. Tus propios archivos nunca aparecen aquí. «Buscar actualizaciones» restaura los que faltan.",
"diag.fileMissing": "falta",
"diag.fileChanged": "modificado",
// About Manager
"about.version": "Versión {v}. Las actualizaciones del programa nunca cambian tu servidor.",
"about.check": "Buscar una versión nueva",
"about.install": "Instalar {v} y reiniciar",
"about.upToDate": "CoA Server Manager está actualizado.",
"about.checkFailed": "No se pudo buscar una versión nueva. Comprueba tu conexión a internet e inténtalo de nuevo.",
"about.installFailed": "No se pudo instalar la actualización. Tu servidor no se ha tocado.",
// Backups
"bk.title": "Copias de seguridad",
"bk.trigger.manual": "Copia manual",
"bk.trigger.automatic": "Copia automática",
"bk.trigger.before-update": "Antes de actualizar",
"bk.trigger.before-restore": "Copia de seguridad antes de restaurar",
"bk.trigger.before-migration": "Antes de actualizar la base de datos",
"bk.trigger.before-bots": "Antes de instalar compañeros",
"bk.trigger.before-repair": "Antes de reparar",
"bk.trigger.before-dangerous-change": "Antes de un cambio arriesgado",
"bk.kind.quick": "Personajes, cuentas y ajustes",
"bk.kind.full": "Todo, incluida la base de datos del mundo",
"bk.kind.config": "Solo ajustes",
"bk.kind.database": "Personajes y cuentas",
"bk.db.characters": "Personajes",
"bk.db.auth": "Cuentas",
"bk.db.world": "Datos del mundo",
"bk.today": "Hoy {time}",
"bk.yesterday": "Ayer {time}",
"bk.created": "Copia creada.",
"bk.last": "Última copia: {when}",
"bk.none": "Aún no hay copias",
"bk.keptNext": "Las copias se guardan junto a tu servidor y nunca sobrescriben tus datos activos.",
"bk.backUpNow": "Copiar ahora",
"bk.full": "Copia completa",
"bk.fullHint": "También guarda la gran base de datos del mundo",
"bk.settingsOnly": "Solo ajustes",
"bk.working": "Trabajando…",
"bk.failed": "Eso no funcionó",
"bk.restoreFrom": "Restaurar desde «{what}», {when}",
"bk.restoreNote": "No se borra nada. Primero se guardan tus datos actuales y la base de datos reemplazada se conserva con otro nombre.",
"bk.stopFirst": "Detén primero el servidor: las bases de datos solo se pueden restaurar con el servidor detenido.",
"bk.settingsRestored": "Ajustes restaurados. Se guardó una copia de seguridad de los ajustes anteriores.",
"bk.restoreSettings": "Restaurar ajustes",
"bk.confirmDb": "¿Restaurar la base de datos «{db}» desde esta copia? El progreso desde {when} se apartará (no se borra).",
"bk.dbRestored": "Se restauraron {n} tablas. Los datos anteriores se conservan como {schema}.",
"bk.restoreDb": "Restaurar: {db}",
"bk.loading": "Cargando…",
"bk.empty": "Tus copias aparecerán aquí.",
"bk.restore": "Restaurar",
"bk.verify": "Verificar",
"bk.intact": "Esta copia está intacta.",
"bk.problem": "Problema detectado: {details}",
"bk.delete": "Eliminar",
"bk.confirmDelete": "¿Eliminar esta copia? Solo se elimina esta copia; tu servidor no se ve afectado.",
// Friends
"fr.title": "Jugar con amigos",
"fr.looking": "Examinando tu conexión…",
"fr.ok": "Correcto",
"fr.notYet": "aún no",
"fr.mode.lan.title": "Red local",
"fr.mode.lan.text": "Amigos en la misma red doméstica o Wi-Fi.",
"fr.mode.direct.title": "A través de internet",
"fr.mode.direct.text": "Amigos desde cualquier lugar, a través de tu conexión a internet. Tu router debe permitirlo.",
"fr.mode.private.title": "Red privada",
"fr.mode.private.text": "Amigos desde cualquier lugar, sin configurar el router. Usa la aplicación gratuita Tailscale.",
"fr.restartToApply": "Reinicia el servidor para aplicar esto.",
"fr.ready": "Listo para tus amigos.",
"fr.exposedTitle": "Algo privado es accesible desde tu red",
"fr.exposedText": "{what} aceptan conexiones desde otros equipos. Reinicia el servidor desde este programa para cerrarlos.",
"fr.what.database": "base de datos",
"fr.what.console": "consola del servidor",
"fr.and": " y ",
"fr.status": "Estado",
"fr.st.running": "El servidor está en marcha",
"fr.st.open": "Los servidores de acceso y de juego están abiertos a otros equipos",
"fr.st.firewall": "El Firewall de Windows permite los puertos del juego",
"fr.st.private": "La base de datos y la consola del servidor son privadas de este equipo",
"fr.inUse": "En uso",
"fr.yourLan": "Tu dirección en esta red:",
"fr.unknown": "desconocida",
"fr.checkConn": "Comprobar mi conexión",
"fr.cgnat": "Tu proveedor de internet no permite el alojamiento directo. Usa la red privada.",
"fr.publicAddr": "Tu dirección pública:",
"fr.noRouter": " · tu router no se puede configurar automáticamente; redirige los dos puertos del juego a mano",
"fr.noInternet": "No se pudo acceder a internet para averiguar tu dirección.",
"fr.tsMissing": "Tailscale no está instalado. Instala la aplicación gratuita desde tailscale.com/download, inicia sesión y vuelve.",
"fr.tsOff": "Tailscale está instalado pero no conectado. Inicia sesión primero.",
"fr.privateAddr": "Tu dirección privada:",
"fr.checkFirst": "Comprueba primero tu conexión",
"fr.reapply": "Volver a aplicar",
"fr.enable": "Activar",
"fr.onlyLocal": "Ahora solo este equipo puede conectarse.",
"fr.stopSharing": "Dejar de compartir (solo este equipo)",
"fr.giveTitle": "Dale esto a tu amigo",
"fr.giveText": "Debe poner esta línea en el archivo realmlist.wtf de su juego. Las contraseñas y ajustes nunca se comparten.",
"fr.copied": "Copiado",
"fr.copy": "Copiar datos de conexión",
"fr.pkg": "Crear paquete para amigo (zip)",
"fr.pkgSaved": "Guardado: {path}",
// Console
"con.title": "Consola",
"con.tab.world": "Mundo",
"con.tab.auth": "Acceso",
"con.tab.database": "Base de datos",
"con.tab.manager": "Manager",
"con.searchLabel": "Buscar en el registro",
"con.search": "Buscar…",
"con.follow": "Seguir",
"con.copied": "Copiado",
"con.copyErrors": "Copiar errores",
"con.empty": "Nada que mostrar.",
"con.commandsNote": "Los comandos van directamente al servidor del mundo en ejecución. Los arriesgados (apagar, borrar o vetar) piden confirmación.",
"con.commandLabel": "Comando",
"con.send": "Enviar",
"con.confirmRisky": "«{cmd}» puede apagar cosas o cambiar muchos registros. ¿Enviarlo de todos modos?",
// Server updates
"upd.act.create": "Archivo nuevo",
"upd.act.replace": "Actualizado",
"upd.act.merge-config": "Ajustes nuevos añadidos",
"upd.act.skip": "Sin cambios",
"upd.act.conflict": "Requiere tu decisión",
"upd.updatedTo": "Actualizado a la versión {v}.",
"upd.confirmBack": "¿Volver a la versión anterior? Tus personajes y cuentas no se modifican.",
"upd.wentBack": "Se volvió a la versión anterior. Tus datos no se tocaron.",
"upd.dialogTitle": "Elige una carpeta de paquete de actualización",
"upd.pendingBad": "El servidor actualizado no se inició correctamente",
"upd.pendingUnfinished": "Una actualización anterior no terminó",
"upd.safeBack": "Puedes volver con seguridad a la versión anterior.",
"upd.backNote": "Volver restaura los archivos del programa y los ajustes. Los personajes y cuentas nunca se revierten automáticamente.",
"upd.goBackTo": "Volver a la versión {v}",
"upd.goBackBefore": "Volver a la versión anterior a la actualización",
"upd.title": "Actualizaciones del servidor",
"upd.text": "Las actualizaciones se comprueban, se respaldan antes y se pueden deshacer.",
"upd.check": "Buscar actualizaciones",
"upd.folderLabel": "Carpeta del paquete de actualización",
"upd.folderHint": "Carpeta del paquete de actualización (déjala vacía para usar la fuente oficial)",
"upd.available": "La versión {to} está disponible",
"upd.availableFrom": "La versión {to} está disponible (tienes {from})",
"upd.summary": "Descarga {size} · cambian {files} archivo(s)",
"upd.summaryDb": "Descarga {size} · cambian {files} archivo(s) · {db} actualización(es) de base de datos",
"upd.conflict": "Este archivo se modificó fuera de CoA Server Manager.",
"upd.keep": "Conservar mi archivo",
"upd.replace": "Reemplazar con la actualización",
"upd.now": "Actualizar ahora",
"upd.stopNote": "El servidor se detiene durante la actualización y se inicia de nuevo para comprobar que funciona.",
// Settings editor
"set.restart.runtime": "Se aplica de inmediato",
"set.restart.world": "Requiere reiniciar el servidor del mundo",
"set.restart.full": "Requiere un reinicio completo del servidor",
"set.on": "Activado",
"set.off": "Desactivado",
"set.enterNumber": "Introduce un número",
"set.enterInt": "Introduce un número entero",
"set.atLeast": "Debe ser al menos {n}",
"set.atMost": "Debe ser como máximo {n}",
"set.careful": "Cuidado",
"set.changed": "Cambiado",
"set.default": "Predeterminado: {v}",
"set.range": "Rango {min}–{max}",
"set.badValue": "El archivo tiene un valor inutilizable ({problem}); se muestra el predeterminado.",
"set.drift": "Editado a mano en el archivo generado: el lanzador lo restablecerá en el próximo inicio a menos que lo guardes aquí.",
"set.reset": "Restablecer al valor predeterminado",
"set.resetItem": "Restablecer «{name}» al valor predeterminado",
"set.nothingYet": "Aún no hay nada que configurar",
"set.loading": "Cargando ajustes…",
"set.confirmCareful": "Vas a cambiar {n} ajuste(s) marcados como «Cuidado». Antes se guarda una instantánea de la configuración actual, así que se puede deshacer. ¿Continuar?",
"set.driftTitle": "{n} ajuste(s) editados a mano",
"set.driftText": "El lanzador del servidor reconstruye worldserver.conf desde su plantilla en cada inicio, por lo que estas ediciones manuales se perderán:",
"set.presets": "Preajustes:",
"set.restoreDefaults": "Restaurar valores recomendados",
"set.matches": "Nada que cambiar: tus ajustes ya coinciden.",
"set.willChange_one": "Esto cambiará {n} ajuste:",
"set.willChange_few": "Esto cambiará {n} ajustes:",
"set.willChange_many": "Esto cambiará {n} ajustes:",
"set.willChange_other": "Esto cambiará {n} ajustes:",
"set.apply": "Aplicar",
"set.nothingChanged": "No cambió nada.",
"set.saved": "Guardado.",
"set.restartRequired_one": "Se necesita reiniciar para aplicar {n} ajuste.",
"set.restartRequired_few": "Se necesita reiniciar para aplicar {n} ajustes.",
"set.restartRequired_many": "Se necesita reiniciar para aplicar {n} ajustes.",
"set.restartRequired_other": "Se necesita reiniciar para aplicar {n} ajustes.",
"set.appliesNextStart": "Los cambios se aplicarán la próxima vez que se inicie el servidor.",
"set.restartNow": "Reiniciar ahora",
"set.later": "Más tarde",
"set.notSaved": "No se guardó nada. Corrige los ajustes resaltados e inténtalo de nuevo.",
"set.advanced": "Ajustes avanzados ({n})",
"set.unknownKept": "{n} ajuste(s) más del archivo de configuración se conservan exactamente como están.",
"set.unsaved_one": "{n} cambio sin guardar",
"set.unsaved_few": "{n} cambios sin guardar",
"set.unsaved_many": "{n} cambios sin guardar",
"set.unsaved_other": "{n} cambios sin guardar",
"set.discard": "Descartar",
"set.save": "Guardar cambios",
// Download errors
"err.package_not_published.title": "Este paquete del servidor aún no está disponible",
"err.package_not_published.message": "Aún no se ha publicado nada en la ubicación de descarga. Inténtalo más tarde o instala desde una carpeta de paquete local (Avanzado).",
"err.network_unreachable.title": "No se pudo contactar con el servidor de descargas",
"err.network_unreachable.message": "Comprueba tu conexión a internet e inténtalo de nuevo.",
// Manager self-update
"selfupd.ready": "Manager {v} está listo para instalarse",
"selfupd.onClose": "Se instalará cuando cierres el Manager. Tus servidores siguen funcionando.",
"selfupd.installing": "Instalando… el Manager se cerrará.",
"selfupd.now": "Instalar ahora",
"about.auto": "Descargar las actualizaciones en segundo plano e instalarlas al cerrar el Manager",
"about.autoHint": "Una actualización del Manager nunca detiene ni cambia tus servidores.",
// Friends line
"fr.copyLine": "Copiar línea",
};
export default es;
+335
View File
@@ -98,6 +98,341 @@ const fr: Partial<Record<keyof typeof en, string>> = {
"err.path_rejected.message": "L’emplacement demandé est en dehors du dossier du serveur.",
"err.unknown.title": "Une erreur s’est produite",
"err.unknown.message": "Consultez les détails techniques.",
// Import server
"import.title": "Ajouter un serveur existant",
"import.subtitle": "Choisissez le dossier depuis lequel votre serveur fonctionne. Il sera seulement lu.",
"import.dialogTitle": "Choisissez le dossier du serveur",
"import.choose": "Choisir le dossier…",
"import.chooseAnother": "Choisir un autre dossier",
"import.looking": "Analyse de votre serveur…",
"import.healthy.title": "Serveur existant détecté",
"import.healthy.text": "Tout ce qui est nécessaire pour faire fonctionner ce serveur a été trouvé.",
"import.partial.title": "Serveur partiellement trouvé",
"import.partial.text": "Certaines parties manquent. Vous pouvez quand même l’ajouter ; rien ne sera réparé automatiquement.",
"import.custom.title": "Serveur personnalisé détecté",
"import.custom.text": "Cette version n’est pas reconnue. Certaines fonctions de mise à jour et d’installation seront désactivées.",
"import.incompatible.title": "Ce n’est pas un dossier de serveur",
"import.incompatible.text": "Choisissez le dossier qui contient Core, Data et mysql (ou votre worldserver.exe).",
"import.techDetails": "Afficher les détails techniques",
"import.detected": "Détecté",
"import.notInstalled": "Non installé",
"import.notFound": "Introuvable",
"import.noChanges": "Aucun fichier ne sera modifié pendant l’importation.",
"import.add": "Ajouter le serveur",
// Install server
"install.title": "Installer un nouveau serveur",
"install.subtitle": "Choisissez un dossier ou gardez celui proposé. Le reste est configuré pour vous.",
"install.installTo": "Installer dans",
"install.browse": "Parcourir…",
"install.dialogTitle": "Choisissez où installer votre serveur",
"install.pkgDialogTitle": "Choisissez un dossier de paquet serveur",
"install.ready": "Ce dossier est prêt. {gb} Go libres.",
"install.failedTitle": "L’installation n’a pas pu se terminer",
"install.nothingInstalled": "Rien n’a été installé. Vous pouvez réessayer ; les fichiers téléchargés sont conservés.",
"install.showTech": "Afficher les détails techniques",
"install.hideTech": "Masquer les détails techniques",
"install.advanced": "Avancé",
"install.localPkg": "Installer depuis un dossier de paquet local au lieu de télécharger",
"install.localPkgHint": "(laisser vide pour télécharger)",
"install.button": "Installer",
"install.progressTitle": "Préparation de votre serveur",
"install.progressText": "Cela peut prendre quelques minutes. Vous pouvez laisser cette fenêtre ouverte.",
"install.step.checking": "Vérification de votre ordinateur",
"install.step.downloading": "Téléchargement du serveur",
"install.step.unpacking": "Décompression",
"install.step.database": "Préparation de la base de données",
"install.step.finishing": "Finalisation",
"install.doneTitle": "Votre serveur est prêt",
"install.doneText": "Tout est installé. Démarrez-le depuis l’écran suivant.",
"install.open": "OUVRIR MON SERVEUR",
// Players
"players.title": "Joueurs",
"players.createTitle": "Créez votre compte",
"players.createText": "C’est le nom et le mot de passe que vous utilisez pour vous connecter au jeu.",
"players.startFirst": "Démarrez d’abord le serveur : les comptes sont créés pendant qu’il fonctionne.",
"players.username": "Nom d’utilisateur",
"players.password": "Mot de passe",
"players.admin": "Faire de ce compte un administrateur",
"players.adminHint": "Les administrateurs peuvent utiliser les commandes de maître de jeu. Ne le faites que pour des comptes de confiance.",
"players.create": "Créer le compte",
"players.created": "Compte « {name} » créé. Vous pouvez maintenant vous connecter au jeu avec.",
// Companions
"comp.title": "Compagnons IA",
"comp.population": "{online} en ligne maintenant · {total} créés au total",
"comp.reading": "Lecture de la population actuelle…",
"comp.startToSee": "Démarrez le serveur pour voir combien de compagnons sont en ligne.",
"comp.wantMore": "Souhaitez-vous plus de compagnons ?",
"comp.custom": "Personnalisé",
"comp.numberLabel": "Nombre de compagnons",
"comp.largeWarning": "De grandes populations peuvent nécessiter plus de processeur et de mémoire. Augmentez progressivement.",
"comp.hardware": "Cet ordinateur : {cores} cœurs, {ram} Go de mémoire.",
"comp.add": "Ajouter {n} compagnons",
"comp.addPlain": "Ajouter des compagnons",
"comp.stoppedHint": "Le serveur est arrêté : ils seront créés au prochain démarrage.",
"comp.spawned": "Création de {n} compagnons. Ils apparaissent progressivement dans les prochaines minutes.",
"comp.saved": "Enregistré. {n} compagnons se connecteront au démarrage du serveur.",
// Client
"client.title": "Client du jeu",
"client.looking": "Recherche…",
"client.intro": "Indiquez au Manager où le jeu est installé pour obtenir un bouton JOUER. Vos fichiers de jeu ne sont jamais modifiés, sauf l’adresse du serveur et l’addon des compagnons.",
"client.chooseFolder": "Choisir le dossier du jeu…",
"client.dialogTitle": "Choisissez le dossier de votre client de jeu",
"client.connectsTo": "Se connecte à",
"client.thisComputer": "✓ cet ordinateur",
"client.notThisServer": "pas ce serveur",
"client.addon": "Addon des compagnons",
"client.installedVersion": "Installé (version {v})",
"client.installed": "Installé",
"client.addonNotInstalled": "Non installé",
"client.updateAvailable": "une mise à jour est disponible",
"client.otherAddons": "Autres addons",
"client.leftAsIs": "{n} — laissés tels quels",
"client.pointLocal": "Diriger le jeu vers ce serveur",
"client.pointedNote": "Le jeu se connecte maintenant à cet ordinateur. L’ancienne adresse a été enregistrée.",
"client.installAddon": "Installer l’addon des compagnons",
"client.updateAddon": "Mettre à jour l’addon des compagnons",
"client.addonNote": "Addon des compagnons installé. Les autres addons n’ont pas été touchés.",
"client.changeFolder": "Changer de dossier…",
// Diagnostics
"diag.title": "Diagnostic",
"diag.text": "Recherche les problèmes courants. Rien n’est modifié.",
"diag.run": "Lancer le diagnostic",
"diag.verify": "Vérifier les fichiers du serveur",
"diag.export": "Exporter le paquet de diagnostic",
"diag.saved": "Enregistré pour les rapports de bogue : {path}",
"diag.allGood": "Tout semble en ordre.",
"diag.problems_one": "{n} point à examiner",
"diag.problems_few": "{n} points à examiner",
"diag.problems_many": "{n} points à examiner",
"diag.problems_other": "{n} points à examiner",
"diag.word.ok": "OK",
"diag.word.warn": "Attention",
"diag.word.fail": "Problème",
"diag.filesOk": "Tous les fichiers du programme sont intacts.",
"diag.filesDiffer": "{n} fichier(s) du programme diffèrent de l’installation. Vos propres fichiers ne sont jamais listés ici. « Rechercher des mises à jour » restaure ceux qui manquent.",
"diag.fileMissing": "manquant",
"diag.fileChanged": "modifié",
// About Manager
"about.version": "Version {v}. Les mises à jour du programme ne modifient jamais votre serveur.",
"about.check": "Rechercher une nouvelle version",
"about.install": "Installer {v} et redémarrer",
"about.upToDate": "CoA Server Manager est à jour.",
"about.checkFailed": "Impossible de rechercher une nouvelle version. Vérifiez votre connexion internet et réessayez.",
"about.installFailed": "La mise à jour n’a pas pu être installée. Votre serveur n’a pas été touché.",
// Backups
"bk.title": "Sauvegardes",
"bk.trigger.manual": "Sauvegarde manuelle",
"bk.trigger.automatic": "Sauvegarde automatique",
"bk.trigger.before-update": "Avant la mise à jour",
"bk.trigger.before-restore": "Copie de sécurité avant une restauration",
"bk.trigger.before-migration": "Avant la mise à jour de la base de données",
"bk.trigger.before-bots": "Avant l’installation des compagnons",
"bk.trigger.before-repair": "Avant la réparation",
"bk.trigger.before-dangerous-change": "Avant un changement risqué",
"bk.kind.quick": "Personnages, comptes et paramètres",
"bk.kind.full": "Tout, y compris la base de données du monde",
"bk.kind.config": "Paramètres uniquement",
"bk.kind.database": "Personnages et comptes",
"bk.db.characters": "Personnages",
"bk.db.auth": "Comptes",
"bk.db.world": "Données du monde",
"bk.today": "Aujourd’hui {time}",
"bk.yesterday": "Hier {time}",
"bk.created": "Sauvegarde créée.",
"bk.last": "Dernière sauvegarde : {when}",
"bk.none": "Aucune sauvegarde pour l’instant",
"bk.keptNext": "Les sauvegardes sont conservées à côté de votre serveur et n’écrasent jamais vos données actives.",
"bk.backUpNow": "Sauvegarder maintenant",
"bk.full": "Sauvegarde complète",
"bk.fullHint": "Enregistre aussi la grande base de données du monde",
"bk.settingsOnly": "Paramètres uniquement",
"bk.working": "En cours…",
"bk.failed": "Cela n’a pas fonctionné",
"bk.restoreFrom": "Restaurer depuis « {what} », {when}",
"bk.restoreNote": "Rien n’est supprimé. Vos données actuelles sont d’abord sauvegardées, et une base remplacée est conservée sous un nouveau nom.",
"bk.stopFirst": "Arrêtez d’abord le serveur : les bases de données ne peuvent être restaurées que serveur arrêté.",
"bk.settingsRestored": "Paramètres restaurés. Une copie de sécurité des paramètres précédents a été enregistrée.",
"bk.restoreSettings": "Restaurer les paramètres",
"bk.confirmDb": "Restaurer la base « {db} » depuis cette sauvegarde ? La progression depuis {when} sera mise de côté (pas supprimée).",
"bk.dbRestored": "{n} tables restaurées. Les données précédentes sont conservées sous {schema}.",
"bk.restoreDb": "Restaurer : {db}",
"bk.loading": "Chargement…",
"bk.empty": "Vos sauvegardes apparaîtront ici.",
"bk.restore": "Restaurer",
"bk.verify": "Vérifier",
"bk.intact": "Cette sauvegarde est intacte.",
"bk.problem": "Problème détecté : {details}",
"bk.delete": "Supprimer",
"bk.confirmDelete": "Supprimer cette sauvegarde ? Seule cette sauvegarde est supprimée ; votre serveur n’est pas affecté.",
// Friends
"fr.title": "Jouer avec des amis",
"fr.looking": "Analyse de votre connexion…",
"fr.ok": "OK",
"fr.notYet": "pas encore",
"fr.mode.lan.title": "Réseau local",
"fr.mode.lan.text": "Amis sur le même réseau domestique ou Wi-Fi.",
"fr.mode.direct.title": "Via Internet",
"fr.mode.direct.text": "Amis où qu’ils soient, via votre connexion internet. Votre routeur doit l’autoriser.",
"fr.mode.private.title": "Réseau privé",
"fr.mode.private.text": "Amis où qu’ils soient, sans configurer le routeur. Utilise l’application gratuite Tailscale.",
"fr.restartToApply": "Redémarrez le serveur pour appliquer cela.",
"fr.ready": "Prêt pour vos amis.",
"fr.exposedTitle": "Un élément privé est accessible depuis votre réseau",
"fr.exposedText": "{what} acceptent des connexions depuis d’autres ordinateurs. Redémarrez le serveur depuis ce programme pour les fermer.",
"fr.what.database": "base de données",
"fr.what.console": "console du serveur",
"fr.and": " et ",
"fr.status": "État",
"fr.st.running": "Le serveur fonctionne",
"fr.st.open": "Les serveurs de connexion et de jeu sont ouverts aux autres ordinateurs",
"fr.st.firewall": "Le pare-feu Windows autorise les ports du jeu",
"fr.st.private": "La base de données et la console du serveur restent privées à cet ordinateur",
"fr.inUse": "Utilisé",
"fr.yourLan": "Votre adresse sur ce réseau :",
"fr.unknown": "inconnue",
"fr.checkConn": "Vérifier ma connexion",
"fr.cgnat": "Votre fournisseur d’accès ne permet pas l’hébergement direct. Utilisez plutôt le réseau privé.",
"fr.publicAddr": "Votre adresse publique :",
"fr.noRouter": " · votre routeur ne peut pas être configuré automatiquement ; redirigez les deux ports du jeu à la main",
"fr.noInternet": "Impossible d’accéder à internet pour trouver votre adresse.",
"fr.tsMissing": "Tailscale n’est pas installé. Installez l’application gratuite depuis tailscale.com/download, connectez-vous, puis revenez.",
"fr.tsOff": "Tailscale est installé mais non connecté. Connectez-vous d’abord.",
"fr.privateAddr": "Votre adresse privée :",
"fr.checkFirst": "Vérifiez d’abord votre connexion",
"fr.reapply": "Réappliquer",
"fr.enable": "Activer",
"fr.onlyLocal": "Seul cet ordinateur peut se connecter maintenant.",
"fr.stopSharing": "Arrêter le partage (cet ordinateur uniquement)",
"fr.giveTitle": "Donnez ceci à votre ami",
"fr.giveText": "Il place cette ligne dans le fichier realmlist.wtf de son jeu. Les mots de passe et paramètres ne sont jamais partagés.",
"fr.copied": "Copié",
"fr.copy": "Copier les informations de connexion",
"fr.pkg": "Créer le paquet pour ami (zip)",
"fr.pkgSaved": "Enregistré : {path}",
// Console
"con.title": "Console",
"con.tab.world": "Monde",
"con.tab.auth": "Connexion",
"con.tab.database": "Base de données",
"con.tab.manager": "Manager",
"con.searchLabel": "Rechercher dans le journal",
"con.search": "Rechercher…",
"con.follow": "Suivre",
"con.copied": "Copié",
"con.copyErrors": "Copier les erreurs",
"con.empty": "Rien à afficher.",
"con.commandsNote": "Les commandes vont directement au serveur de monde en cours d’exécution. Les commandes risquées (arrêt, suppression, bannissement) demandent confirmation.",
"con.commandLabel": "Commande",
"con.send": "Envoyer",
"con.confirmRisky": "« {cmd} » peut tout arrêter ou modifier de nombreux enregistrements. L’envoyer quand même ?",
// Server updates
"upd.act.create": "Nouveau fichier",
"upd.act.replace": "Mis à jour",
"upd.act.merge-config": "Nouveaux paramètres ajoutés",
"upd.act.skip": "Inchangé",
"upd.act.conflict": "Nécessite votre décision",
"upd.updatedTo": "Mis à jour vers la version {v}.",
"upd.confirmBack": "Revenir à la version précédente ? Vos personnages et comptes ne sont pas modifiés.",
"upd.wentBack": "Retour à la version précédente effectué. Vos données n’ont pas été touchées.",
"upd.dialogTitle": "Choisissez un dossier de paquet de mise à jour",
"upd.pendingBad": "Le serveur mis à jour n’a pas démarré correctement",
"upd.pendingUnfinished": "Une mise à jour précédente ne s’est pas terminée",
"upd.safeBack": "Vous pouvez revenir en toute sécurité à la version précédente.",
"upd.backNote": "Le retour restaure les fichiers du programme et les paramètres. Les personnages et comptes ne sont jamais restaurés automatiquement.",
"upd.goBackTo": "Revenir à la version {v}",
"upd.goBackBefore": "Revenir à la version d’avant la mise à jour",
"upd.title": "Mises à jour du serveur",
"upd.text": "Les mises à jour sont vérifiées, sauvegardées au préalable et peuvent être annulées.",
"upd.check": "Rechercher des mises à jour",
"upd.folderLabel": "Dossier du paquet de mise à jour",
"upd.folderHint": "Dossier du paquet de mise à jour (laisser vide pour la source officielle)",
"upd.available": "La version {to} est disponible",
"upd.availableFrom": "La version {to} est disponible (vous avez {from})",
"upd.summary": "Téléchargement {size} · {files} fichier(s) modifié(s)",
"upd.summaryDb": "Téléchargement {size} · {files} fichier(s) modifié(s) · {db} mise(s) à jour de la base",
"upd.conflict": "Ce fichier a été modifié en dehors de CoA Server Manager.",
"upd.keep": "Garder mon fichier",
"upd.replace": "Remplacer par la mise à jour",
"upd.now": "Mettre à jour maintenant",
"upd.stopNote": "Le serveur est arrêté pendant la mise à jour puis redémarré pour vérifier qu’il fonctionne.",
// Settings editor
"set.restart.runtime": "S’applique immédiatement",
"set.restart.world": "Nécessite un redémarrage du serveur de monde",
"set.restart.full": "Nécessite un redémarrage complet du serveur",
"set.on": "Activé",
"set.off": "Désactivé",
"set.enterNumber": "Saisissez un nombre",
"set.enterInt": "Saisissez un nombre entier",
"set.atLeast": "Doit être au moins {n}",
"set.atMost": "Doit être au plus {n}",
"set.careful": "Prudence",
"set.changed": "Modifié",
"set.default": "Par défaut : {v}",
"set.range": "Plage {min}–{max}",
"set.badValue": "Le fichier contient une valeur inutilisable ({problem}) ; la valeur par défaut est affichée.",
"set.drift": "Modifié à la main dans le fichier généré — le lanceur le réinitialisera au prochain démarrage sauf si vous l’enregistrez ici.",
"set.reset": "Rétablir la valeur par défaut",
"set.resetItem": "Rétablir « {name} » par défaut",
"set.nothingYet": "Rien à configurer pour l’instant",
"set.loading": "Chargement des paramètres…",
"set.confirmCareful": "Vous modifiez {n} paramètre(s) marqué(s) « Prudence ». Un instantané de la configuration actuelle est enregistré d’abord, l’opération peut donc être annulée. Continuer ?",
"set.driftTitle": "{n} paramètre(s) modifié(s) à la main",
"set.driftText": "Le lanceur du serveur reconstruit worldserver.conf à partir de son modèle à chaque démarrage ; ces modifications manuelles seront donc perdues :",
"set.presets": "Préréglages :",
"set.restoreDefaults": "Rétablir les valeurs recommandées",
"set.matches": "Rien à modifier — vos paramètres correspondent déjà.",
"set.willChange_one": "Cela modifiera {n} paramètre :",
"set.willChange_few": "Cela modifiera {n} paramètres :",
"set.willChange_many": "Cela modifiera {n} paramètres :",
"set.willChange_other": "Cela modifiera {n} paramètres :",
"set.apply": "Appliquer",
"set.nothingChanged": "Rien n’a changé.",
"set.saved": "Enregistré.",
"set.restartRequired_one": "Redémarrage requis pour appliquer {n} paramètre.",
"set.restartRequired_few": "Redémarrage requis pour appliquer {n} paramètres.",
"set.restartRequired_many": "Redémarrage requis pour appliquer {n} paramètres.",
"set.restartRequired_other": "Redémarrage requis pour appliquer {n} paramètres.",
"set.appliesNextStart": "Les modifications s’appliqueront au prochain démarrage du serveur.",
"set.restartNow": "Redémarrer maintenant",
"set.later": "Plus tard",
"set.notSaved": "Rien n’a été enregistré. Corrigez les paramètres en surbrillance et réessayez.",
"set.advanced": "Paramètres avancés ({n})",
"set.unknownKept": "{n} autre(s) paramètre(s) du fichier de configuration sont conservés tels quels.",
"set.unsaved_one": "{n} modification non enregistrée",
"set.unsaved_few": "{n} modifications non enregistrées",
"set.unsaved_many": "{n} modifications non enregistrées",
"set.unsaved_other": "{n} modifications non enregistrées",
"set.discard": "Annuler les modifications",
"set.save": "Enregistrer les modifications",
// Download errors
"err.package_not_published.title": "Ce paquet serveur n’est pas encore disponible",
"err.package_not_published.message": "Rien n’a encore été publié à l’emplacement de téléchargement. Réessayez plus tard ou installez depuis un dossier de paquet local (Avancé).",
"err.network_unreachable.title": "Impossible de joindre le serveur de téléchargement",
"err.network_unreachable.message": "Vérifiez votre connexion internet et réessayez.",
// Manager self-update
"selfupd.ready": "Manager {v} est prêt à être installé",
"selfupd.onClose": "Il sera installé à la fermeture du Manager. Vos serveurs continuent de fonctionner.",
"selfupd.installing": "Installation… le Manager va se fermer.",
"selfupd.now": "Installer maintenant",
"about.auto": "Télécharger les mises à jour en arrière-plan et les installer à la fermeture du Manager",
"about.autoHint": "Une mise à jour du Manager n’arrête ni ne modifie jamais vos serveurs.",
// Friends line
"fr.copyLine": "Copier la ligne",
};
export default fr;
+335
View File
@@ -98,6 +98,341 @@ const ru: Partial<Record<keyof typeof en, string>> = {
"err.path_rejected.message": "Запрошенный файл находится за пределами папки сервера.",
"err.unknown.title": "Что-то пошло не так",
"err.unknown.message": "Смотрите технические подробности.",
// Import server
"import.title": "Добавить существующий сервер",
"import.subtitle": "Выберите папку, из которой запускается ваш сервер. Она будет только прочитана.",
"import.dialogTitle": "Выберите папку сервера",
"import.choose": "Выбрать папку…",
"import.chooseAnother": "Выбрать другую папку",
"import.looking": "Изучаю ваш сервер…",
"import.healthy.title": "Найден существующий сервер",
"import.healthy.text": "Найдено всё необходимое для запуска этого сервера.",
"import.partial.title": "Сервер найден частично",
"import.partial.text": "Некоторых частей не хватает. Сервер всё равно можно добавить; автоматически ничего исправляться не будет.",
"import.custom.title": "Найден нестандартный сервер",
"import.custom.text": "Эта сборка не распознана. Часть функций обновления и установки будет отключена.",
"import.incompatible.title": "Это не папка сервера",
"import.incompatible.text": "Выберите папку, в которой лежат Core, Data и mysql (или ваш worldserver.exe).",
"import.techDetails": "Показать технические подробности",
"import.detected": "Найдено",
"import.notInstalled": "Не установлено",
"import.notFound": "Не найдено",
"import.noChanges": "При импорте никакие файлы не изменяются.",
"import.add": "Добавить сервер",
// Install server
"install.title": "Установка нового сервера",
"install.subtitle": "Выберите папку или оставьте предложенную. Всё остальное настроится само.",
"install.installTo": "Куда установить",
"install.browse": "Обзор…",
"install.dialogTitle": "Выберите, куда установить сервер",
"install.pkgDialogTitle": "Выберите папку с пакетом сервера",
"install.ready": "Папка подходит. Свободно {gb} ГБ.",
"install.failedTitle": "Не удалось завершить установку",
"install.nothingInstalled": "Ничего не установлено. Можно попробовать ещё раз; скачанные файлы сохранены.",
"install.showTech": "Показать технические подробности",
"install.hideTech": "Скрыть технические подробности",
"install.advanced": "Дополнительно",
"install.localPkg": "Установить из локальной папки с пакетом вместо скачивания",
"install.localPkgHint": "(оставьте пустым, чтобы скачать)",
"install.button": "Установить",
"install.progressTitle": "Подготовка сервера",
"install.progressText": "Это может занять несколько минут. Окно можно не закрывать.",
"install.step.checking": "Проверка компьютера",
"install.step.downloading": "Загрузка сервера",
"install.step.unpacking": "Распаковка",
"install.step.database": "Подготовка базы данных",
"install.step.finishing": "Завершение",
"install.doneTitle": "Ваш сервер готов",
"install.doneText": "Всё установлено. Запустите сервер на следующем экране.",
"install.open": "ОТКРЫТЬ МОЙ СЕРВЕР",
// Players
"players.title": "Игроки",
"players.createTitle": "Создайте свою учётную запись",
"players.createText": "Это имя и пароль, с которыми вы входите в игру.",
"players.startFirst": "Сначала запустите сервер — учётные записи создаются, пока он работает.",
"players.username": "Имя пользователя",
"players.password": "Пароль",
"players.admin": "Сделать эту учётную запись администратором",
"players.adminHint": "Администраторы могут использовать команды гейм-мастера в игре. Делайте это только для тех, кому доверяете.",
"players.create": "Создать учётную запись",
"players.created": "Учётная запись «{name}» создана. Теперь с ней можно войти в игру.",
// Companions
"comp.title": "ИИ-компаньоны",
"comp.population": "Сейчас в сети: {online} · всего создано: {total}",
"comp.reading": "Считываю текущее количество…",
"comp.startToSee": "Запустите сервер, чтобы увидеть, сколько компаньонов в сети.",
"comp.wantMore": "Хотите больше компаньонов?",
"comp.custom": "Своё число",
"comp.numberLabel": "Количество компаньонов",
"comp.largeWarning": "Большое количество может потребовать больше процессора и памяти. Увеличивайте постепенно.",
"comp.hardware": "Этот компьютер: ядер — {cores}, памяти — {ram} ГБ.",
"comp.add": "Добавить компаньонов: {n}",
"comp.addPlain": "Добавить компаньонов",
"comp.stoppedHint": "Сервер остановлен: компаньоны будут созданы при следующем запуске.",
"comp.spawned": "Создаю компаньонов: {n}. Они появятся постепенно в течение нескольких минут.",
"comp.saved": "Сохранено. Компаньоны ({n}) войдут в игру при запуске сервера.",
// Client
"client.title": "Клиент игры",
"client.looking": "Ищу…",
"client.intro": "Укажите, где установлена игра, чтобы появилась кнопка «Играть». Файлы игры не изменяются, кроме адреса сервера и аддона компаньонов.",
"client.chooseFolder": "Выбрать папку игры…",
"client.dialogTitle": "Выберите папку клиента игры",
"client.connectsTo": "Подключается к",
"client.thisComputer": "✓ этот компьютер",
"client.notThisServer": "не этот сервер",
"client.addon": "Аддон компаньонов",
"client.installedVersion": "Установлен (версия {v})",
"client.installed": "Установлен",
"client.addonNotInstalled": "Не установлен",
"client.updateAvailable": "доступно обновление",
"client.otherAddons": "Другие аддоны",
"client.leftAsIs": "{n} — остаются без изменений",
"client.pointLocal": "Направить игру на этот сервер",
"client.pointedNote": "Теперь игра подключается к этому компьютеру. Прежний адрес сохранён.",
"client.installAddon": "Установить аддон компаньонов",
"client.updateAddon": "Обновить аддон компаньонов",
"client.addonNote": "Аддон компаньонов установлен. Другие аддоны не затронуты.",
"client.changeFolder": "Сменить папку…",
// Diagnostics
"diag.title": "Диагностика",
"diag.text": "Ищет типичные проблемы. Ничего не изменяется.",
"diag.run": "Запустить диагностику",
"diag.verify": "Проверить файлы сервера",
"diag.export": "Экспортировать пакет диагностики",
"diag.saved": "Сохранено для отчёта об ошибке: {path}",
"diag.allGood": "Всё в порядке.",
"diag.problems_one": "Стоит проверить: {n}",
"diag.problems_few": "Стоит проверить: {n}",
"diag.problems_many": "Стоит проверить: {n}",
"diag.problems_other": "Стоит проверить: {n}",
"diag.word.ok": "В порядке",
"diag.word.warn": "Внимание",
"diag.word.fail": "Проблема",
"diag.filesOk": "Все файлы программы целы.",
"diag.filesDiffer": "Файлов программы, отличающихся от установленных: {n}. Ваши собственные файлы здесь не показываются. «Проверить обновления» восстановит отсутствующие.",
"diag.fileMissing": "отсутствует",
"diag.fileChanged": "изменён",
// About Manager
"about.version": "Версия {v}. Обновления программы никогда не меняют ваш сервер.",
"about.check": "Проверить наличие новой версии",
"about.install": "Установить {v} и перезапустить",
"about.upToDate": "У вас последняя версия CoA Server Manager.",
"about.checkFailed": "Не удалось проверить наличие новой версии. Проверьте подключение к интернету и повторите попытку.",
"about.installFailed": "Не удалось установить обновление. Ваш сервер не затронут.",
// Backups
"bk.title": "Резервные копии",
"bk.trigger.manual": "Копия, сделанная вручную",
"bk.trigger.automatic": "Автоматическая копия",
"bk.trigger.before-update": "Перед обновлением",
"bk.trigger.before-restore": "Страховочная копия перед восстановлением",
"bk.trigger.before-migration": "Перед обновлением базы данных",
"bk.trigger.before-bots": "Перед установкой компаньонов",
"bk.trigger.before-repair": "Перед восстановлением файлов",
"bk.trigger.before-dangerous-change": "Перед рискованным изменением",
"bk.kind.quick": "Персонажи, учётные записи и настройки",
"bk.kind.full": "Всё, включая базу данных мира",
"bk.kind.config": "Только настройки",
"bk.kind.database": "Персонажи и учётные записи",
"bk.db.characters": "Персонажи",
"bk.db.auth": "Учётные записи",
"bk.db.world": "Данные мира",
"bk.today": "Сегодня, {time}",
"bk.yesterday": "Вчера, {time}",
"bk.created": "Резервная копия создана.",
"bk.last": "Последняя копия: {when}",
"bk.none": "Резервных копий пока нет",
"bk.keptNext": "Копии хранятся рядом с сервером и никогда не перезаписывают ваши рабочие данные.",
"bk.backUpNow": "Сделать копию",
"bk.full": "Полная копия",
"bk.fullHint": "Также сохраняет большую базу данных мира",
"bk.settingsOnly": "Только настройки",
"bk.working": "Работаю…",
"bk.failed": "Не получилось",
"bk.restoreFrom": "Восстановить из копии «{what}», {when}",
"bk.restoreNote": "Ничего не удаляется. Сначала сохраняются ваши текущие данные, а заменённая база остаётся рядом под новым именем.",
"bk.stopFirst": "Сначала остановите сервер — базы данных можно восстановить только при остановленном сервере.",
"bk.settingsRestored": "Настройки восстановлены. Страховочная копия прежних настроек сохранена.",
"bk.restoreSettings": "Восстановить настройки",
"bk.confirmDb": "Восстановить базу данных «{db}» из этой копии? Всё, что произошло после {when}, будет отложено в сторону (не удалено).",
"bk.dbRestored": "Восстановлено таблиц: {n}. Прежние данные сохранены как {schema}.",
"bk.restoreDb": "Восстановить: {db}",
"bk.loading": "Загрузка…",
"bk.empty": "Ваши резервные копии появятся здесь.",
"bk.restore": "Восстановить",
"bk.verify": "Проверить",
"bk.intact": "Эта копия цела.",
"bk.problem": "Обнаружена проблема: {details}",
"bk.delete": "Удалить",
"bk.confirmDelete": "Удалить эту копию? Удаляется только она; ваш сервер не затрагивается.",
// Friends
"fr.title": "Игра с друзьями",
"fr.looking": "Проверяю ваше подключение…",
"fr.ok": "Готово",
"fr.notYet": "ещё нет",
"fr.mode.lan.title": "Локальная сеть",
"fr.mode.lan.text": "Друзья в той же домашней сети или Wi-Fi.",
"fr.mode.direct.title": "Через интернет",
"fr.mode.direct.text": "Друзья из любого места через ваше интернет-соединение. Нужно, чтобы роутер это разрешал.",
"fr.mode.private.title": "Частная сеть",
"fr.mode.private.text": "Друзья из любого места, без настройки роутера. Используется бесплатное приложение Tailscale.",
"fr.restartToApply": "Перезапустите сервер, чтобы применить это.",
"fr.ready": "Готово для друзей.",
"fr.exposedTitle": "Нечто приватное доступно из вашей сети",
"fr.exposedText": "Принимают подключения с других компьютеров: {what}. Перезапустите сервер из этой программы, чтобы закрыть доступ.",
"fr.what.database": "база данных",
"fr.what.console": "консоль сервера",
"fr.and": " и ",
"fr.status": "Состояние",
"fr.st.running": "Сервер запущен",
"fr.st.open": "Серверы входа и игры открыты для других компьютеров",
"fr.st.firewall": "Брандмауэр Windows пропускает игровые порты",
"fr.st.private": "База данных и консоль сервера доступны только на этом компьютере",
"fr.inUse": "Используется",
"fr.yourLan": "Ваш адрес в этой сети:",
"fr.unknown": "неизвестен",
"fr.checkConn": "Проверить моё подключение",
"fr.cgnat": "Ваш интернет-провайдер не разрешает прямое размещение сервера. Используйте частную сеть.",
"fr.publicAddr": "Ваш публичный адрес:",
"fr.noRouter": " · роутер нельзя настроить автоматически; пробросьте два игровых порта вручную",
"fr.noInternet": "Не удалось выйти в интернет, чтобы определить ваш адрес.",
"fr.tsMissing": "Tailscale не установлен. Установите бесплатное приложение с tailscale.com/download, войдите в него и вернитесь сюда.",
"fr.tsOff": "Tailscale установлен, но не подключён. Сначала войдите в него.",
"fr.privateAddr": "Ваш частный адрес:",
"fr.checkFirst": "Сначала проверьте подключение",
"fr.reapply": "Применить заново",
"fr.enable": "Включить",
"fr.onlyLocal": "Теперь подключиться может только этот компьютер.",
"fr.stopSharing": "Прекратить доступ (только этот компьютер)",
"fr.giveTitle": "Передайте это другу",
"fr.giveText": "Друг вписывает эту строку в файл realmlist.wtf своей игры. Пароли и настройки никогда не передаются.",
"fr.copied": "Скопировано",
"fr.copy": "Скопировать данные подключения",
"fr.pkg": "Создать пакет для друга (zip)",
"fr.pkgSaved": "Сохранено: {path}",
// Console
"con.title": "Консоль",
"con.tab.world": "Мир",
"con.tab.auth": "Вход",
"con.tab.database": "База данных",
"con.tab.manager": "Менеджер",
"con.searchLabel": "Поиск по журналу",
"con.search": "Поиск…",
"con.follow": "Следить",
"con.copied": "Скопировано",
"con.copyErrors": "Скопировать ошибки",
"con.empty": "Показывать нечего.",
"con.commandsNote": "Команды отправляются прямо на запущенный игровой сервер. Рискованные (выключение, удаление, бан) требуют подтверждения.",
"con.commandLabel": "Команда",
"con.send": "Отправить",
"con.confirmRisky": "Команда «{cmd}» может что-то выключить или изменить много записей. Всё равно отправить?",
// Server updates
"upd.act.create": "Новый файл",
"upd.act.replace": "Обновлён",
"upd.act.merge-config": "Добавлены новые настройки",
"upd.act.skip": "Без изменений",
"upd.act.conflict": "Нужно ваше решение",
"upd.updatedTo": "Обновлено до версии {v}.",
"upd.confirmBack": "Вернуться к предыдущей версии? Ваши персонажи и учётные записи не изменятся.",
"upd.wentBack": "Выполнен возврат к предыдущей версии. Ваши данные не затронуты.",
"upd.dialogTitle": "Выберите папку с пакетом обновления",
"upd.pendingBad": "Обновлённый сервер запустился некорректно",
"upd.pendingUnfinished": "Предыдущее обновление не завершилось",
"upd.safeBack": "Можно безопасно вернуться к предыдущей версии.",
"upd.backNote": "Возврат восстанавливает файлы программы и настройки. Персонажи и учётные записи автоматически не откатываются никогда.",
"upd.goBackTo": "Вернуться к версии {v}",
"upd.goBackBefore": "Вернуться к версии до обновления",
"upd.title": "Обновления сервера",
"upd.text": "Подлинность обновлений проверяется, перед ними делается резервная копия, и их можно отменить.",
"upd.check": "Проверить обновления",
"upd.folderLabel": "Папка с пакетом обновления",
"upd.folderHint": "Папка с пакетом обновления (оставьте пустым, чтобы использовать официальный источник)",
"upd.available": "Доступна версия {to}",
"upd.availableFrom": "Доступна версия {to} (у вас {from})",
"upd.summary": "Загрузка {size} · изменится файлов: {files}",
"upd.summaryDb": "Загрузка {size} · изменится файлов: {files} · обновлений базы данных: {db}",
"upd.conflict": "Этот файл был изменён вне CoA Server Manager.",
"upd.keep": "Оставить мой файл",
"upd.replace": "Заменить файлом из обновления",
"upd.now": "Обновить сейчас",
"upd.stopNote": "На время обновления сервер останавливается, а затем запускается снова для проверки его работы.",
// Settings editor
"set.restart.runtime": "Применяется сразу",
"set.restart.world": "Нужен перезапуск игрового сервера",
"set.restart.full": "Нужен полный перезапуск сервера",
"set.on": "Вкл.",
"set.off": "Выкл.",
"set.enterNumber": "Введите число",
"set.enterInt": "Введите целое число",
"set.atLeast": "Должно быть не меньше {n}",
"set.atMost": "Должно быть не больше {n}",
"set.careful": "Осторожно",
"set.changed": "Изменено",
"set.default": "По умолчанию: {v}",
"set.range": "Диапазон {min}–{max}",
"set.badValue": "В файле недопустимое значение ({problem}); показано значение по умолчанию.",
"set.drift": "Изменено вручную в сгенерированном файле — при следующем запуске лаунчер сбросит это значение, если вы не сохраните его здесь.",
"set.reset": "Сбросить к значению по умолчанию",
"set.resetItem": "Сбросить «{name}» к значению по умолчанию",
"set.nothingYet": "Пока нечего настраивать",
"set.loading": "Загрузка настроек…",
"set.confirmCareful": "Вы меняете настройки с пометкой «Осторожно»: {n}. Сначала сохраняется снимок текущей конфигурации, так что это можно отменить. Продолжить?",
"set.driftTitle": "Вручную изменено настроек: {n}",
"set.driftText": "Лаунчер сервера пересобирает worldserver.conf из шаблона при каждом запуске, поэтому эти ручные правки будут потеряны:",
"set.presets": "Пресеты:",
"set.restoreDefaults": "Восстановить рекомендуемые значения",
"set.matches": "Менять нечего — ваши настройки уже совпадают.",
"set.willChange_one": "Будет изменена {n} настройка:",
"set.willChange_few": "Будет изменено настроек: {n}:",
"set.willChange_many": "Будет изменено настроек: {n}:",
"set.willChange_other": "Будет изменено настроек: {n}:",
"set.apply": "Применить",
"set.nothingChanged": "Ничего не изменилось.",
"set.saved": "Сохранено.",
"set.restartRequired_one": "Чтобы применить {n} настройку, нужен перезапуск.",
"set.restartRequired_few": "Чтобы применить настройки ({n}), нужен перезапуск.",
"set.restartRequired_many": "Чтобы применить настройки ({n}), нужен перезапуск.",
"set.restartRequired_other": "Чтобы применить настройки ({n}), нужен перезапуск.",
"set.appliesNextStart": "Изменения применятся при следующем запуске сервера.",
"set.restartNow": "Перезапустить сейчас",
"set.later": "Позже",
"set.notSaved": "Ничего не сохранено. Исправьте выделенные настройки и повторите попытку.",
"set.advanced": "Дополнительные настройки ({n})",
"set.unknownKept": "Остальные настройки в файле конфигурации ({n}) остаются без изменений.",
"set.unsaved_one": "{n} несохранённое изменение",
"set.unsaved_few": "{n} несохранённых изменения",
"set.unsaved_many": "{n} несохранённых изменений",
"set.unsaved_other": "{n} несохранённых изменений",
"set.discard": "Отменить",
"set.save": "Сохранить изменения",
// Download errors
"err.package_not_published.title": "Этот пакет сервера пока недоступен",
"err.package_not_published.message": "В месте загрузки пока ничего не опубликовано. Повторите позже или установите из локальной папки с пакетом (Дополнительно).",
"err.network_unreachable.title": "Не удалось связаться с сервером загрузки",
"err.network_unreachable.message": "Проверьте подключение к интернету и повторите попытку.",
// Manager self-update
"selfupd.ready": "Менеджер {v} готов к установке",
"selfupd.onClose": "Он установится, когда вы закроете менеджер. Ваши серверы продолжат работать.",
"selfupd.installing": "Установка… менеджер закроется.",
"selfupd.now": "Установить сейчас",
"about.auto": "Скачивать обновления в фоне и устанавливать их, когда я закрою менеджер",
"about.autoHint": "Обновление менеджера никогда не останавливает и не меняет ваши серверы.",
// Friends line
"fr.copyLine": "Скопировать строку",
};
export default ru;
+6
View File
@@ -16,6 +16,12 @@
--font-sans: "Segoe UI Variable Text", "Segoe UI", system-ui, sans-serif;
}
/* Everything is sized in rem, so scaling the root font grows the whole interface with the window
(16px up to about 1280px wide, then gradually larger; capped at 26px). */
html {
font-size: clamp(16px, calc(0.75vw + 6.4px), 26px);
}
html,
body,
#root {
+138
View File
@@ -0,0 +1,138 @@
import { useSyncExternalStore } from "react";
import { getCurrentWindow } from "@tauri-apps/api/window";
import { check, type Update } from "@tauri-apps/plugin-updater";
import { relaunch } from "@tauri-apps/plugin-process";
/**
* Manager self-update: look for a new version in the background, download it quietly, and install it when the window is
* closed (or right away when asked). Servers are separate processes, so updating the Manager never touches them.
*/
export type Phase = "idle" | "checking" | "downloading" | "ready" | "installing" | "error" | "current";
export interface SelfUpdateState {
phase: Phase;
version?: string;
notes?: string;
percent: number | null;
/** Raw error text, kept for the details line (the UI shows a friendly message). */
error?: string;
}
const AUTO_KEY = "coa-auto-update";
let state: SelfUpdateState = { phase: "idle", percent: null };
let update: Update | null = null;
const listeners = new Set<() => void>();
function set(next: Partial<SelfUpdateState>) {
state = { ...state, ...next };
listeners.forEach((l) => l());
}
export function autoUpdateEnabled(): boolean {
try {
return localStorage.getItem(AUTO_KEY) !== "off";
} catch {
return true;
}
}
export function setAutoUpdate(on: boolean) {
try {
localStorage.setItem(AUTO_KEY, on ? "on" : "off");
} catch {
/* ignore */
}
listeners.forEach((l) => l());
}
/** Look for a new version. With `download` it also fetches the installer so it is ready to install on exit. */
export async function lookForUpdate(opts: { download: boolean }): Promise<void> {
if (state.phase === "checking" || state.phase === "downloading" || state.phase === "installing") return;
set({ phase: "checking", error: undefined, percent: null });
try {
const u = await check();
if (!u) {
update = null;
set({ phase: "current", version: undefined });
return;
}
update = u;
set({ version: u.version, notes: u.body ?? undefined });
if (!opts.download) {
set({ phase: "idle" });
return;
}
await downloadPending();
} catch (e) {
set({ phase: "error", error: String(e) });
}
}
async function downloadPending(): Promise<void> {
if (!update) return;
set({ phase: "downloading", percent: 0 });
let total = 0;
let done = 0;
try {
await update.download((e) => {
if (e.event === "Started") total = e.data.contentLength ?? 0;
if (e.event === "Progress") {
done += e.data.chunkLength;
if (total) set({ percent: Math.round((done / total) * 100) });
}
});
set({ phase: "ready", percent: 100 });
} catch (e) {
set({ phase: "error", error: String(e), percent: null });
}
}
/** Download (if needed) and install now. The installer ends this process; `relaunch` is the fallback. */
export async function installNow(): Promise<void> {
if (!update) return;
try {
if (state.phase !== "ready") await downloadPending();
if (state.phase !== "ready") return;
set({ phase: "installing" });
await update.install();
await relaunch();
} catch (e) {
set({ phase: "error", error: String(e) });
}
}
/** Install a downloaded update when the user closes the window. Call once at start-up. */
export function installOnClose(): () => void {
let stop: (() => void) | undefined;
try {
const win = getCurrentWindow();
void win
.onCloseRequested(async (event) => {
if (state.phase !== "ready" || !update || !autoUpdateEnabled()) return;
event.preventDefault();
try {
set({ phase: "installing" });
await update.install();
} catch (e) {
set({ phase: "error", error: String(e) });
await win.destroy();
}
})
.then((un) => {
stop = un;
})
.catch(() => {});
} catch {
/* not running inside the desktop shell (browser preview) */
}
return () => stop?.();
}
export function useSelfUpdate(): SelfUpdateState {
return useSyncExternalStore(
(l) => {
listeners.add(l);
return () => listeners.delete(l);
},
() => state,
);
}
+55 -56
View File
@@ -1,79 +1,78 @@
import { useEffect, useState } from "react";
import { getVersion } from "@tauri-apps/api/app";
import { check, type Update } from "@tauri-apps/plugin-updater";
import { relaunch } from "@tauri-apps/plugin-process";
import { Loader2 } from "lucide-react";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { useT } from "@/i18n";
import { autoUpdateEnabled, installNow, lookForUpdate, setAutoUpdate, useSelfUpdate } from "@/lib/selfUpdate";
export function AboutCard() {
const t = useT();
const s = useSelfUpdate();
const [version, setVersion] = useState("");
const [update, setUpdate] = useState<Update | null>(null);
const [busy, setBusy] = useState<"check" | "install" | null>(null);
const [percent, setPercent] = useState<number | null>(null);
const [note, setNote] = useState<string | null>(null);
const [error, setError] = useState<string | null>(null);
const [auto, setAuto] = useState(autoUpdateEnabled());
const [asked, setAsked] = useState(false);
useEffect(() => {
void getVersion().then(setVersion).catch(() => {});
}, []);
async function look() {
setBusy("check");
setError(null);
setNote(null);
try {
const u = await check();
setUpdate(u);
if (!u) setNote("CoA Server Manager is up to date.");
} catch {
setError("Could not check for a new version. Check your internet connection and try again.");
} finally {
setBusy(null);
}
}
async function install() {
if (!update) return;
setBusy("install");
setError(null);
let total = 0;
let done = 0;
try {
await update.downloadAndInstall((e) => {
if (e.event === "Started") total = e.data.contentLength ?? 0;
if (e.event === "Progress") {
done += e.data.chunkLength;
if (total) setPercent(Math.round((done / total) * 100));
}
});
await relaunch();
} catch {
setError("The update could not be installed. Your server was not touched.");
setBusy(null);
}
}
const busy = s.phase === "checking" || s.phase === "downloading" || s.phase === "installing";
return (
<Card className="mt-6 p-6">
<h2 className="font-semibold">CoA Server Manager</h2>
<p className="mt-1 text-sm text-muted">Version {version || "…"}. Updates to the program never change your server.</p>
<div className="mt-4 flex items-center gap-3">
<Button size="sm" disabled={!!busy} onClick={() => void look()}>
{busy === "check" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
Check for a new version
<h2 className="font-semibold">{t("app.name")}</h2>
<p className="mt-1 text-sm text-muted">{t("about.version", { v: version || "…" })}</p>
<label className="mt-3 flex cursor-pointer items-start gap-2 text-sm">
<input
type="checkbox"
className="mt-1"
checked={auto}
onChange={(e) => {
setAuto(e.target.checked);
setAutoUpdate(e.target.checked);
}}
/>
<span>
{t("about.auto")}
<span className="block text-xs text-muted">{t("about.autoHint")}</span>
</span>
</label>
<div className="mt-4 flex flex-wrap items-center gap-3">
<Button
size="sm"
disabled={busy}
onClick={() => {
setAsked(true);
void lookForUpdate({ download: false });
}}
>
{s.phase === "checking" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
{t("about.check")}
</Button>
{update && (
<Button size="sm" variant="primary" disabled={!!busy} onClick={() => void install()}>
{busy === "install" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
Install {update.version} and restart
{s.version && s.phase !== "current" && (
<Button size="sm" variant="primary" disabled={busy} onClick={() => void installNow()}>
{(s.phase === "downloading" || s.phase === "installing") && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
{t("about.install", { v: s.version })}
</Button>
)}
{percent !== null && busy === "install" && <span className="text-sm text-muted" role="status">{percent}%</span>}
{s.percent !== null && s.phase === "downloading" && (
<span className="text-sm text-muted" role="status">
{s.percent}%
</span>
)}
</div>
{update?.body && <p className="mt-3 whitespace-pre-line text-sm text-muted">{update.body}</p>}
{note && <p className="mt-3 text-sm text-ok" role="status">{note}</p>}
{error && <p className="mt-3 text-sm text-bad" role="alert">{error}</p>}
{s.version && s.notes && s.phase !== "current" && <p className="mt-3 whitespace-pre-line text-sm text-muted">{s.notes}</p>}
{s.phase === "ready" && <p className="mt-3 text-sm text-ok" role="status">{t("selfupd.onClose")}</p>}
{asked && s.phase === "current" && <p className="mt-3 text-sm text-ok" role="status">{t("about.upToDate")}</p>}
{s.phase === "error" && (
<div className="mt-3 text-sm text-bad" role="alert">
<p>{t("about.checkFailed")}</p>
{s.error && <p className="selectable mt-1 break-all text-xs text-muted">{s.error}</p>}
</div>
)}
</Card>
);
}
+44 -52
View File
@@ -4,26 +4,13 @@ import { Loader2, ShieldCheck } from "lucide-react";
import { api, asUiError, type BackupKind, type RecoveryPoint, type UiError } from "@/lib/api";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { useHuman, useI18n, type Key, type Locale } from "@/i18n";
const TRIGGER: Record<string, string> = {
manual: "Manual backup",
automatic: "Automatic backup",
"before-update": "Before update",
"before-restore": "Safety copy before a restore",
"before-migration": "Before database update",
"before-bots": "Before installing companions",
"before-repair": "Before repair",
"before-dangerous-change": "Before a risky change",
};
const TRIGGER_KEYS = ["manual", "automatic", "before-update", "before-restore", "before-migration", "before-bots", "before-repair", "before-dangerous-change"];
const KIND: Record<BackupKind, string> = {
quick: "Characters, accounts and settings",
full: "Everything, including the world database",
config: "Settings only",
database: "Characters and accounts",
};
const DB_KEYS = ["characters", "auth", "world"];
const DB_LABEL: Record<string, string> = { characters: "Characters", auth: "Accounts", world: "World data" };
type T = (k: Key, v?: Record<string, string | number>) => string;
function size(bytes: number): string {
if (bytes >= 1 << 30) return `${(bytes / (1 << 30)).toFixed(1)} GB`;
@@ -31,17 +18,22 @@ function size(bytes: number): string {
return `${Math.max(1, Math.round(bytes / 1024))} KB`;
}
function when(iso: string): string {
function when(iso: string, t: T, locale: Locale): string {
const d = new Date(iso);
const today = new Date();
const time = d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
if (d.toDateString() === today.toDateString()) return `Today ${time}`;
const time = d.toLocaleTimeString(locale, { hour: "2-digit", minute: "2-digit" });
if (d.toDateString() === today.toDateString()) return t("bk.today", { time });
const y = new Date(today.getTime() - 86400000);
if (d.toDateString() === y.toDateString()) return `Yesterday ${time}`;
return `${d.toLocaleDateString([], { day: "numeric", month: "short", year: "numeric" })} ${time}`;
if (d.toDateString() === y.toDateString()) return t("bk.yesterday", { time });
return `${d.toLocaleDateString(locale, { day: "numeric", month: "short", year: "numeric" })} ${time}`;
}
export function BackupsPage({ serverId }: { serverId: string }) {
const { t, locale } = useI18n();
const human = useHuman();
const w = (iso: string) => when(iso, t, locale);
const trigger = (x: string) => (TRIGGER_KEYS.includes(x) ? t(`bk.trigger.${x}` as Key) : x);
const dbLabel = (x: string) => (DB_KEYS.includes(x) ? t(`bk.db.${x}` as Key) : x);
const [points, setPoints] = useState<RecoveryPoint[] | null>(null);
const [busy, setBusy] = useState<string | null>(null);
const [step, setStep] = useState<string | null>(null);
@@ -84,54 +76,54 @@ export function BackupsPage({ serverId }: { serverId: string }) {
const create = (kind: BackupKind) =>
run("create", async () => {
await api.createBackup(serverId, kind);
return "Backup created.";
return t("bk.created");
});
const last = points?.[0];
return (
<div className="max-w-3xl">
<h1 className="text-2xl font-semibold">Backups</h1>
<p className="mt-1 text-muted">Is my data safe?</p>
<h1 className="text-2xl font-semibold">{t("bk.title")}</h1>
<p className="mt-1 text-muted">{t("q.backups")}</p>
<Card className="mt-6 p-6">
<div className="flex items-center gap-3">
<ShieldCheck className={last ? "h-6 w-6 text-ok" : "h-6 w-6 text-muted"} aria-hidden />
<div>
<p className="font-medium">{last ? `Last backup: ${when(last.created_at)}` : "No backups yet"}</p>
<p className="text-sm text-muted">Backups are kept next to your server and never overwrite your live data.</p>
<p className="font-medium">{last ? t("bk.last", { when: w(last.created_at) }) : t("bk.none")}</p>
<p className="text-sm text-muted">{t("bk.keptNext")}</p>
</div>
</div>
<div className="mt-5 flex flex-wrap items-center gap-3">
<Button variant="primary" disabled={!!busy} onClick={() => void create("quick")}>
{busy === "create" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
Back up now
{t("bk.backUpNow")}
</Button>
<Button disabled={!!busy} onClick={() => void create("full")} title="Also saves the large world database">
Full backup
<Button disabled={!!busy} onClick={() => void create("full")} title={t("bk.fullHint")}>
{t("bk.full")}
</Button>
<Button variant="ghost" disabled={!!busy} onClick={() => void create("config")}>
Settings only
{t("bk.settingsOnly")}
</Button>
{busy === "create" && <span className="text-sm text-muted" role="status">{step ?? "Working…"}</span>}
{busy === "create" && <span className="text-sm text-muted" role="status">{step ?? t("bk.working")}</span>}
</div>
</Card>
{notice && <p className="mt-3 text-sm text-ok" role="status">{notice}</p>}
{error && (
<Card className="mt-4 border-bad/40 p-4" role="alert">
<p className="font-medium text-bad">{error.human.code === "unknown" ? "That did not work" : error.human.title}</p>
<p className="mt-1 text-sm text-muted">{error.human.code === "unknown" ? error.technical : error.human.message}</p>
<p className="font-medium text-bad">{error.human.code === "unknown" ? t("bk.failed") : human(error.human).title}</p>
<p className="mt-1 text-sm text-muted">{error.human.code === "unknown" ? error.technical : human(error.human).message}</p>
</Card>
)}
{restoring && (
<Card className="mt-4 border-gold/40 p-5">
<p className="font-medium">Restore from {TRIGGER[restoring.trigger] ?? restoring.trigger}, {when(restoring.created_at)}</p>
<p className="font-medium">{t("bk.restoreFrom", { what: trigger(restoring.trigger), when: w(restoring.created_at) })}</p>
<p className="mt-1 text-sm text-muted">
Nothing is deleted. Your current data is saved first, and a replaced database is kept alongside under a new name.
{t("bk.restoreNote")}
</p>
{running && <p className="mt-2 text-sm text-warn">Stop the server first — databases can only be restored while it is stopped.</p>}
{running && <p className="mt-2 text-sm text-warn">{t("bk.stopFirst")}</p>}
<div className="mt-4 flex flex-wrap gap-2">
{restoring.components.map((c) =>
c.name === "configs" ? (
@@ -143,11 +135,11 @@ export function BackupsPage({ serverId }: { serverId: string }) {
void run("restore", async () => {
await api.restoreConfigs(serverId, restoring.id);
setRestoring(null);
return "Settings restored. A safety copy of the previous settings was saved.";
return t("bk.settingsRestored");
})
}
>
Restore settings
{t("bk.restoreSettings")}
</Button>
) : (
<Button
@@ -155,39 +147,39 @@ export function BackupsPage({ serverId }: { serverId: string }) {
size="sm"
disabled={!!busy || running}
onClick={() => {
if (!window.confirm(`Restore the ${DB_LABEL[c.name] ?? c.name} database from this backup? Progress made since ${when(restoring.created_at)} will be set aside (not deleted).`)) return;
if (!window.confirm(t("bk.confirmDb", { db: dbLabel(c.name), when: w(restoring.created_at) }))) return;
void run("restore", async () => {
const r = await api.restoreDatabase(serverId, restoring.id, c.name);
setRestoring(null);
return `Restored ${r.tables_restored} tables. The previous data is kept as ${r.previous_schema}.`;
return t("bk.dbRestored", { n: r.tables_restored, schema: r.previous_schema });
});
}}
>
Restore {DB_LABEL[c.name]?.toLowerCase() ?? c.name}
{t("bk.restoreDb", { db: dbLabel(c.name) })}
</Button>
),
)}
<Button size="sm" variant="ghost" onClick={() => setRestoring(null)}>
Cancel
{t("common.cancel")}
</Button>
</div>
</Card>
)}
<div className="mt-6 divide-y divide-line rounded-card border border-line bg-card/60">
{points === null && <p className="p-4 text-muted">Loading…</p>}
{points?.length === 0 && <p className="p-4 text-muted">Your backups will appear here.</p>}
{points === null && <p className="p-4 text-muted">{t("bk.loading")}</p>}
{points?.length === 0 && <p className="p-4 text-muted">{t("bk.empty")}</p>}
{points?.map((p) => (
<div key={p.id} className="flex items-center justify-between gap-4 p-4">
<div>
<p className="font-medium">{p.label && p.trigger === "manual" && p.label !== "e2e" ? p.label : (TRIGGER[p.trigger] ?? p.trigger)}</p>
<p className="font-medium">{p.label && p.trigger === "manual" && p.label !== "e2e" ? p.label : trigger(p.trigger)}</p>
<p className="text-sm text-muted">
{when(p.created_at)} · {KIND[p.kind]} · {size(p.components.reduce((a, c) => a + c.bytes, 0))}
{w(p.created_at)} · {t(`bk.kind.${p.kind}` as Key)} · {size(p.components.reduce((a, c) => a + c.bytes, 0))}
</p>
</div>
<div className="flex shrink-0 gap-1">
<Button size="sm" disabled={!!busy} onClick={() => setRestoring(p)}>
Restore
{t("bk.restore")}
</Button>
<Button
size="sm"
@@ -196,25 +188,25 @@ export function BackupsPage({ serverId }: { serverId: string }) {
onClick={() =>
void run("verify", async () => {
const v = await api.verifyBackup(serverId, p.id);
return v.ok ? "This backup is intact." : `Problem found: ${v.problems.join("; ")}`;
return v.ok ? t("bk.intact") : t("bk.problem", { details: v.problems.join("; ") });
})
}
>
Verify
{t("bk.verify")}
</Button>
<Button
size="sm"
variant="ghost"
disabled={!!busy}
onClick={() => {
if (window.confirm("Delete this backup? Only this backup is removed; your server is not affected.")) {
if (window.confirm(t("bk.confirmDelete"))) {
void run("delete", async () => {
await api.deleteBackup(serverId, p.id);
});
}
}}
>
Delete
{t("bk.delete")}
</Button>
</div>
</div>
+21 -18
View File
@@ -3,8 +3,11 @@ import { open } from "@tauri-apps/plugin-dialog";
import { api, asUiError, type ClientInfo, type UiError } from "@/lib/api";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { useHuman, useT } from "@/i18n";
export function ClientCard({ serverId }: { serverId: string }) {
const t = useT();
const human = useHuman();
const [info, setInfo] = useState<ClientInfo | null | undefined>(undefined);
const [error, setError] = useState<UiError | null>(null);
const [note, setNote] = useState<string | null>(null);
@@ -31,7 +34,7 @@ export function ClientCard({ serverId }: { serverId: string }) {
}
async function choose() {
const picked = await open({ directory: true, multiple: false, title: "Choose your game client folder" });
const picked = await open({ directory: true, multiple: false, title: t("client.dialogTitle") });
if (typeof picked === "string") await run(async () => void (await api.setClient(serverId, picked)));
}
@@ -40,48 +43,48 @@ export function ClientCard({ serverId }: { serverId: string }) {
return (
<Card className="mt-6 p-6">
<h2 className="font-semibold">Game client</h2>
{info === undefined && <p className="mt-2 text-sm text-muted">Looking…</p>}
<h2 className="font-semibold">{t("client.title")}</h2>
{info === undefined && <p className="mt-2 text-sm text-muted">{t("client.looking")}</p>}
{info === null && (
<>
<p className="mt-1 text-sm text-muted">Tell Manager where your game is installed to get a PLAY button. Your game files are never changed except the server address and the companion addon.</p>
<Button className="mt-4" onClick={() => void choose()} disabled={busy}>Choose game folder…</Button>
<p className="mt-1 text-sm text-muted">{t("client.intro")}</p>
<Button className="mt-4" onClick={() => void choose()} disabled={busy}>{t("client.chooseFolder")}</Button>
</>
)}
{info && (
<>
<p className="selectable mt-1 break-all text-sm text-muted">{info.path}</p>
<dl className="mt-4 grid grid-cols-[auto_1fr] gap-x-6 gap-y-2 text-sm">
<dt className="text-muted">Connects to</dt>
<dt className="text-muted">{t("client.connectsTo")}</dt>
<dd>
{hosts.length ? hosts.filter(Boolean).join(", ") : "—"}
{pointsLocal ? <span className="ml-2 text-ok">✓ this computer</span> : <span className="ml-2 text-warn">not this server</span>}
{pointsLocal ? <span className="ml-2 text-ok">{t("client.thisComputer")}</span> : <span className="ml-2 text-warn">{t("client.notThisServer")}</span>}
</dd>
<dt className="text-muted">Companion addon</dt>
<dt className="text-muted">{t("client.addon")}</dt>
<dd>
{info.addon.installed ? `Installed${info.addon.version ? ` (version ${info.addon.version})` : ""}` : "Not installed"}
{info.addon.up_to_date === false && <span className="ml-2 text-warn">an update is available</span>}
{info.addon.installed ? (info.addon.version ? t("client.installedVersion", { v: info.addon.version }) : t("client.installed")) : t("client.addonNotInstalled")}
{info.addon.up_to_date === false && <span className="ml-2 text-warn">{t("client.updateAvailable")}</span>}
</dd>
<dt className="text-muted">Other addons</dt>
<dd>{info.other_addons} — left exactly as they are</dd>
<dt className="text-muted">{t("client.otherAddons")}</dt>
<dd>{t("client.leftAsIs", { n: info.other_addons })}</dd>
</dl>
<div className="mt-4 flex flex-wrap gap-2">
{!pointsLocal && (
<Button size="sm" disabled={busy} onClick={() => void run(async () => { await api.setRealmlist(serverId, "127.0.0.1"); return "The game now connects to this computer. The previous address was saved."; })}>
Point the game at this server
<Button size="sm" disabled={busy} onClick={() => void run(async () => { await api.setRealmlist(serverId, "127.0.0.1"); return t("client.pointedNote"); })}>
{t("client.pointLocal")}
</Button>
)}
{(!info.addon.installed || info.addon.up_to_date === false) && (
<Button size="sm" disabled={busy} onClick={() => void run(async () => { await api.installAddon(serverId); return "Companion addon installed. Other addons were not touched."; })}>
{info.addon.installed ? "Update companion addon" : "Install companion addon"}
<Button size="sm" disabled={busy} onClick={() => void run(async () => { await api.installAddon(serverId); return t("client.addonNote"); })}>
{info.addon.installed ? t("client.updateAddon") : t("client.installAddon")}
</Button>
)}
<Button size="sm" variant="ghost" disabled={busy} onClick={() => void choose()}>Change folder…</Button>
<Button size="sm" variant="ghost" disabled={busy} onClick={() => void choose()}>{t("client.changeFolder")}</Button>
</div>
</>
)}
{note && <p className="mt-3 text-sm text-ok" role="status">{note}</p>}
{error && <p className="mt-3 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : error.human.message}</p>}
{error && <p className="mt-3 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : human(error.human).message}</p>}
</Card>
);
}
+16 -13
View File
@@ -3,8 +3,11 @@ import { Loader2 } from "lucide-react";
import { api, asUiError, type CompanionSizes, type Population, type UiError } from "@/lib/api";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { useHuman, useT } from "@/i18n";
export function CompanionsCard({ serverId }: { serverId: string }) {
const t = useT();
const human = useHuman();
const [sizes, setSizes] = useState<CompanionSizes | null>(null);
const [pop, setPop] = useState<Population | null>(null);
const [running, setRunning] = useState(false);
@@ -33,7 +36,7 @@ export function CompanionsCard({ serverId }: { serverId: string }) {
}, [serverId]);
const count = choice === "custom" ? Number(custom) : (sizes?.sizes.find((s) => s.id === choice)?.bots ?? 0);
const warning = choice === "custom" ? (count > 500 ? "Large populations may need more CPU and memory. Increase gradually." : null) : (sizes?.sizes.find((s) => s.id === choice)?.warning ?? null);
const warning = choice === "custom" ? (count > 500 ? t("comp.largeWarning") : null) : (sizes?.sizes.find((s) => s.id === choice)?.warning ?? null);
const valid = Number.isInteger(count) && count >= 1 && count <= 2000;
async function add() {
@@ -42,7 +45,7 @@ export function CompanionsCard({ serverId }: { serverId: string }) {
setNote(null);
try {
const r = await api.addCompanions(serverId, count);
setNote(r.spawned ? `Creating ${count} companions. They appear gradually over the next minutes.` : `Saved. ${count} companions will log in when the server starts.`);
setNote(r.spawned ? t("comp.spawned", { n: count }) : t("comp.saved", { n: count }));
} catch (e) {
setError(asUiError(e));
} finally {
@@ -52,17 +55,17 @@ export function CompanionsCard({ serverId }: { serverId: string }) {
return (
<Card className="mt-6 p-6">
<h2 className="font-semibold">AI companions</h2>
<h2 className="font-semibold">{t("comp.title")}</h2>
<p className="mt-1 text-sm text-muted">
{pop
? `${pop.bots_online} online now · ${pop.bots_total} created in total`
? t("comp.population", { online: pop.bots_online, total: pop.bots_total })
: running
? "Reading the current population…"
: "Start the server to see how many companions are online."}
? t("comp.reading")
: t("comp.startToSee")}
</p>
<fieldset className="mt-4">
<legend className="text-sm text-muted">Would you like more companions?</legend>
<legend className="text-sm text-muted">{t("comp.wantMore")}</legend>
<div className="mt-2 flex flex-wrap gap-2">
{sizes?.sizes.map((s) => (
<label key={s.id} className={`cursor-pointer rounded-md border px-3 py-2 text-sm ${choice === s.id ? "border-gold bg-gold/10" : "border-line hover:bg-white/5"}`}>
@@ -72,26 +75,26 @@ export function CompanionsCard({ serverId }: { serverId: string }) {
))}
<label className={`cursor-pointer rounded-md border px-3 py-2 text-sm ${choice === "custom" ? "border-gold bg-gold/10" : "border-line hover:bg-white/5"}`}>
<input type="radio" name="size" className="sr-only" checked={choice === "custom"} onChange={() => setChoice("custom")} />
Custom
{t("comp.custom")}
</label>
{choice === "custom" && (
<input aria-label="Number of companions" value={custom} onChange={(e) => setCustom(e.target.value)} inputMode="numeric" className="w-24 rounded-md border border-line bg-bg px-3 py-2 text-right text-sm outline-none focus:border-gold" />
<input aria-label={t("comp.numberLabel")} value={custom} onChange={(e) => setCustom(e.target.value)} inputMode="numeric" className="w-24 rounded-md border border-line bg-bg px-3 py-2 text-right text-sm outline-none focus:border-gold" />
)}
</div>
</fieldset>
{warning && <p className="mt-3 text-sm text-warn" role="status">{warning}</p>}
{sizes && <p className="mt-2 text-xs text-muted">This computer: {sizes.hardware.cores} cores, {sizes.hardware.ram_gb.toFixed(0)} GB memory.</p>}
{sizes && <p className="mt-2 text-xs text-muted">{t("comp.hardware", { cores: sizes.hardware.cores, ram: sizes.hardware.ram_gb.toFixed(0) })}</p>}
<div className="mt-4 flex items-center gap-3">
<Button variant="primary" disabled={busy || !valid} onClick={() => void add()}>
{busy && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
Add {valid ? count : ""} companions
{valid ? t("comp.add", { n: count }) : t("comp.addPlain")}
</Button>
{!running && <span className="text-xs text-muted">The server is stopped: they will be created the next time it runs.</span>}
{!running && <span className="text-xs text-muted">{t("comp.stoppedHint")}</span>}
</div>
{note && <p className="mt-3 text-sm text-ok" role="status">{note}</p>}
{error && <p className="mt-3 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : error.human.message}</p>}
{error && <p className="mt-3 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : human(error.human).message}</p>}
</Card>
);
}
+29 -26
View File
@@ -3,17 +3,20 @@ import { api, asUiError, type ConsoleLine, type ConsoleSource, type UiError } fr
import { cn } from "@/lib/utils";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { useHuman, useT, type Key } from "@/i18n";
const TABS: { id: ConsoleSource; label: string }[] = [
{ id: "world", label: "World" },
{ id: "auth", label: "Auth" },
{ id: "database", label: "Database" },
{ id: "manager", label: "Manager" },
const TABS: { id: ConsoleSource; label: Key }[] = [
{ id: "world", label: "con.tab.world" },
{ id: "auth", label: "con.tab.auth" },
{ id: "database", label: "con.tab.database" },
{ id: "manager", label: "con.tab.manager" },
];
const TONE = { info: "text-ink/80", warn: "text-warn", error: "text-bad" } as const;
export function ConsolePage({ serverId }: { serverId: string }) {
const t = useT();
const human = useHuman();
const [tab, setTab] = useState<ConsoleSource>("world");
const [filter, setFilter] = useState("");
const [lines, setLines] = useState<ConsoleLine[]>([]);
@@ -38,8 +41,8 @@ export function ConsolePage({ serverId }: { serverId: string }) {
useEffect(() => {
void load();
if (!live) return;
const t = setInterval(load, 2000);
return () => clearInterval(t);
const iv = setInterval(load, 2000);
return () => clearInterval(iv);
}, [load, live]);
useEffect(() => {
@@ -51,8 +54,8 @@ export function ConsolePage({ serverId }: { serverId: string }) {
setReply(null);
try {
const risk = await api.consoleRisk(cmd);
if (risk === "dangerous" && !window.confirm(`“${cmd}” can shut things down or change many records. Send it anyway?`)) return;
setReply((await api.consoleCommand(serverId, cmd, risk === "dangerous")) || "(no output)");
if (risk === "dangerous" && !window.confirm(t("con.confirmRisky", { cmd }))) return;
setReply((await api.consoleCommand(serverId, cmd, risk === "dangerous")) || t("common.noOutput"));
setCmd("");
} catch (e) {
setError(asUiError(e));
@@ -63,32 +66,32 @@ export function ConsolePage({ serverId }: { serverId: string }) {
return (
<div className="flex h-full max-w-4xl flex-col">
<h1 className="text-2xl font-semibold">Console</h1>
<p className="mt-1 text-muted">What is the server doing?</p>
<h1 className="text-2xl font-semibold">{t("con.title")}</h1>
<p className="mt-1 text-muted">{t("q.console")}</p>
<div className="mt-4 flex flex-wrap items-center gap-2">
<div className="flex gap-1" role="tablist">
{TABS.map((t) => (
{TABS.map((tb) => (
<button
key={t.id}
key={tb.id}
role="tab"
aria-selected={tab === t.id}
onClick={() => setTab(t.id)}
className={cn("cursor-pointer rounded-md px-3 py-1.5 text-sm", tab === t.id ? "bg-white/10 text-ink" : "text-muted hover:text-ink")}
aria-selected={tab === tb.id}
onClick={() => setTab(tb.id)}
className={cn("cursor-pointer rounded-md px-3 py-1.5 text-sm", tab === tb.id ? "bg-white/10 text-ink" : "text-muted hover:text-ink")}
>
{t.label}
{t(tb.label)}
</button>
))}
</div>
<input
aria-label="Search the log"
placeholder="Search…"
aria-label={t("con.searchLabel")}
placeholder={t("con.search")}
value={filter}
onChange={(e) => setFilter(e.target.value)}
className="ml-auto w-56 rounded-md border border-line bg-bg px-3 py-1.5 text-sm outline-none focus:border-gold"
/>
<label className="flex cursor-pointer items-center gap-1.5 text-sm text-muted">
<input type="checkbox" checked={live} onChange={(e) => setLive(e.target.checked)} /> Follow
<input type="checkbox" checked={live} onChange={(e) => setLive(e.target.checked)} /> {t("con.follow")}
</label>
<Button
size="sm"
@@ -96,12 +99,12 @@ export function ConsolePage({ serverId }: { serverId: string }) {
disabled={errors.length === 0}
onClick={() => void navigator.clipboard.writeText(errors.slice(-20).join("\n")).then(() => { setCopied(true); setTimeout(() => setCopied(false), 1500); })}
>
{copied ? "Copied" : "Copy errors"}
{copied ? t("con.copied") : t("con.copyErrors")}
</Button>
</div>
<div ref={box} className="selectable mt-3 min-h-64 flex-1 overflow-auto rounded-card border border-line bg-black/40 p-3 font-mono text-xs leading-5" role="log" aria-live="off">
{missing ? <p className="text-muted">{missing}</p> : lines.length === 0 ? <p className="text-muted">Nothing to show.</p> : lines.map((l, i) => (
{missing ? <p className="text-muted">{missing}</p> : lines.length === 0 ? <p className="text-muted">{t("con.empty")}</p> : lines.map((l, i) => (
<div key={i} className={cn("whitespace-pre-wrap break-all", TONE[l.level])}>
{l.level !== "info" && <span className="sr-only">{l.level}: </span>}
{l.text}
@@ -111,13 +114,13 @@ export function ConsolePage({ serverId }: { serverId: string }) {
{tab === "world" && (
<Card className="mt-3 p-4">
<p className="text-xs text-muted">Commands go straight to the running world server. Risky ones (shutdown, deleting or banning) ask for confirmation.</p>
<p className="text-xs text-muted">{t("con.commandsNote")}</p>
<form className="mt-2 flex gap-2" onSubmit={(e) => { e.preventDefault(); void send(); }}>
<input aria-label="Command" value={cmd} onChange={(e) => setCmd(e.target.value)} placeholder="server info" className="selectable flex-1 rounded-md border border-line bg-bg px-3 py-2 font-mono text-sm outline-none focus:border-gold" />
<Button variant="secondary" size="sm" type="submit" disabled={!cmd.trim()}>Send</Button>
<input aria-label={t("con.commandLabel")} value={cmd} onChange={(e) => setCmd(e.target.value)} placeholder="server info" className="selectable flex-1 rounded-md border border-line bg-bg px-3 py-2 font-mono text-sm outline-none focus:border-gold" />
<Button variant="secondary" size="sm" type="submit" disabled={!cmd.trim()}>{t("con.send")}</Button>
</form>
{reply && <pre className="selectable mt-2 max-h-40 overflow-auto whitespace-pre-wrap rounded bg-black/40 p-2 text-xs">{reply}</pre>}
{error && <p className="mt-2 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : error.human.message}</p>}
{error && <p className="mt-2 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : human(error.human).message}</p>}
</Card>
)}
</div>
+16 -13
View File
@@ -3,12 +3,15 @@ import { Check, Loader2, TriangleAlert, X } from "lucide-react";
import { api, asUiError, type DiagCheck, type UiError } from "@/lib/api";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { useHuman, useI18n } from "@/i18n";
const ICON = { ok: Check, warn: TriangleAlert, fail: X } as const;
const TONE = { ok: "text-ok", warn: "text-warn", fail: "text-bad" } as const;
const WORD = { ok: "OK", warn: "Attention", fail: "Problem" } as const;
const WORD = { ok: "diag.word.ok", warn: "diag.word.warn", fail: "diag.word.fail" } as const;
export function DiagnosticsCard({ serverId }: { serverId: string }) {
const { t, tn } = useI18n();
const human = useHuman();
const [checks, setChecks] = useState<DiagCheck[] | null>(null);
const [files, setFiles] = useState<{ path: string; kind: string }[] | null>(null);
const [busy, setBusy] = useState<string | null>(null);
@@ -32,24 +35,24 @@ export function DiagnosticsCard({ serverId }: { serverId: string }) {
return (
<Card className="mt-6 p-6">
<h2 className="font-semibold">Diagnostics</h2>
<p className="mt-1 text-sm text-muted">Looks for common problems. Nothing is changed.</p>
<h2 className="font-semibold">{t("diag.title")}</h2>
<p className="mt-1 text-sm text-muted">{t("diag.text")}</p>
<div className="mt-4 flex flex-wrap gap-2">
<Button variant="primary" disabled={!!busy} onClick={() => void run("diag", async () => setChecks((await api.runDiagnostics(serverId)).checks))}>
{busy === "diag" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
Run diagnostics
{t("diag.run")}
</Button>
<Button disabled={!!busy} onClick={() => void run("verify", async () => setFiles(await api.verifyFiles(serverId)))}>
Check server files
{t("diag.verify")}
</Button>
<Button variant="ghost" disabled={!!busy} onClick={() => void run("export", async () => setNote(`Saved for bug reports: ${await api.exportDiagnostics(serverId)}`))}>
Export diagnostic package
<Button variant="ghost" disabled={!!busy} onClick={() => void run("export", async () => setNote(t("diag.saved", { path: await api.exportDiagnostics(serverId) })))}>
{t("diag.export")}
</Button>
</div>
{checks && (
<div className="mt-4">
<p className="font-medium" role="status">{problems === 0 ? "Everything looks good." : `${problems} thing${problems === 1 ? "" : "s"} to look at`}</p>
<p className="font-medium" role="status">{problems === 0 ? t("diag.allGood") : tn("diag.problems", problems)}</p>
<ul className="mt-2 divide-y divide-line text-sm">
{checks.map((c) => {
const Icon = ICON[c.level];
@@ -58,7 +61,7 @@ export function DiagnosticsCard({ serverId }: { serverId: string }) {
<Icon className={`mt-0.5 h-4 w-4 shrink-0 ${TONE[c.level]}`} aria-hidden />
<div>
<span className="font-medium">{c.title}</span>
<span className="sr-only"> — {WORD[c.level]}</span>
<span className="sr-only"> — {t(WORD[c.level])}</span>
<p className="text-muted">{c.detail}</p>
</div>
</li>
@@ -71,14 +74,14 @@ export function DiagnosticsCard({ serverId }: { serverId: string }) {
{files && (
<div className="mt-4 border-t border-line pt-3 text-sm">
{files.length === 0 ? (
<p className="text-ok" role="status">All program files are intact.</p>
<p className="text-ok" role="status">{t("diag.filesOk")}</p>
) : (
<>
<p className="text-warn">{files.length} program file(s) differ from what was installed. Your own files are never listed here. "Check for updates" restores missing ones.</p>
<p className="text-warn">{t("diag.filesDiffer", { n: files.length })}</p>
<ul className="mt-2 max-h-40 overflow-auto">
{files.map((f) => (
<li key={f.path} className="selectable py-0.5">
{f.path} <span className="text-muted">— {f.kind === "missing" ? "missing" : "changed"}</span>
{f.path} <span className="text-muted">— {f.kind === "missing" ? t("diag.fileMissing") : t("diag.fileChanged")}</span>
</li>
))}
</ul>
@@ -87,7 +90,7 @@ export function DiagnosticsCard({ serverId }: { serverId: string }) {
</div>
)}
{note && <p className="mt-3 text-sm text-ok" role="status">{note}</p>}
{error && <p className="mt-3 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : error.human.message}</p>}
{error && <p className="mt-3 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : human(error.human).message}</p>}
</Card>
);
}
+71 -36
View File
@@ -3,24 +3,52 @@ import { Check, Loader2, Minus } from "lucide-react";
import { api, asUiError, type FriendsMode, type FriendsStatus, type InternetCheck, type UiError } from "@/lib/api";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { useHuman, useT, type Key } from "@/i18n";
function Line({ ok, children, warn }: { ok: boolean; warn?: boolean; children: React.ReactNode }) {
const t = useT();
return (
<li className="flex items-center gap-2 py-1.5 text-sm">
{ok ? <Check className="h-4 w-4 text-ok" aria-hidden /> : <Minus className={warn ? "h-4 w-4 text-warn" : "h-4 w-4 text-muted"} aria-hidden />}
<span className={ok ? "" : "text-muted"}>{children}</span>
<span className="sr-only">{ok ? "OK" : "not yet"}</span>
<span className="sr-only">{ok ? t("fr.ok") : t("fr.notYet")}</span>
</li>
);
}
const MODES: { id: FriendsMode; title: string; text: string }[] = [
{ id: "lan", title: "Local network", text: "Friends on the same home network or Wi-Fi." },
{ id: "direct", title: "Over the internet", text: "Friends anywhere, through your internet connection. Needs your router to allow it." },
{ id: "private", title: "Private network", text: "Friends anywhere, no router setup. Uses the free Tailscale app." },
const MODES: { id: FriendsMode; title: Key; text: Key }[] = [
{ id: "lan", title: "fr.mode.lan.title", text: "fr.mode.lan.text" },
{ id: "direct", title: "fr.mode.direct.title", text: "fr.mode.direct.text" },
{ id: "private", title: "fr.mode.private.title", text: "fr.mode.private.text" },
];
/** A ready-to-paste realmlist line for the friend, shown as soon as the address is known. */
function RealmlistLine({ host }: { host: string }) {
const t = useT();
const [copied, setCopied] = useState(false);
const line = `set realmlist ${host}`;
return (
<div className="mt-2 flex flex-wrap items-center gap-2">
<code className="selectable rounded bg-black/40 px-2 py-1 text-sm">{line}</code>
<Button
size="sm"
variant="ghost"
onClick={() =>
void navigator.clipboard.writeText(line).then(() => {
setCopied(true);
setTimeout(() => setCopied(false), 2000);
})
}
>
{copied ? t("fr.copied") : t("fr.copyLine")}
</Button>
</div>
);
}
export function FriendsPage({ serverId }: { serverId: string }) {
const t = useT();
const human = useHuman();
const [st, setSt] = useState<FriendsStatus | null>(null);
const [net, setNet] = useState<InternetCheck | null>(null);
const [busy, setBusy] = useState<string | null>(null);
@@ -56,10 +84,10 @@ export function FriendsPage({ serverId }: { serverId: string }) {
const enable = (mode: FriendsMode) =>
run(`enable-${mode}`, async () => {
const r = await api.friendsEnable(serverId, mode, net?.public_ip ?? undefined, mode === "direct" && !!net?.router_found);
return [r.restart_required ? "Restart the server to apply this." : null, r.note].filter(Boolean).join(" ") || "Ready for friends.";
return [r.restart_required ? t("fr.restartToApply") : null, r.note].filter(Boolean).join(" ") || t("fr.ready");
});
if (!st) return <p className="text-muted">{error ? error.human.message : "Looking at your connection…"}</p>;
if (!st) return <p className="text-muted">{error ? human(error.human).message : t("fr.looking")}</p>;
const cur = st.settings;
const exposed = st.exposure.filter((e) => (e.what === "database" || e.what === "server console") && e.reachable_from_network);
@@ -67,24 +95,24 @@ export function FriendsPage({ serverId }: { serverId: string }) {
return (
<div className="max-w-3xl">
<h1 className="text-2xl font-semibold">Play with Friends</h1>
<p className="mt-1 text-muted">How can my friend join?</p>
<h1 className="text-2xl font-semibold">{t("fr.title")}</h1>
<p className="mt-1 text-muted">{t("q.friends")}</p>
{exposed.length > 0 && (
<Card className="mt-5 border-bad/40 p-4" role="alert">
<p className="font-medium text-bad">Something private is reachable from your network</p>
<p className="mt-1 text-sm text-muted">{exposed.map((e) => e.what).join(" and ")} accept connections from other computers. Restart the server from this program to close them.</p>
<p className="font-medium text-bad">{t("fr.exposedTitle")}</p>
<p className="mt-1 text-sm text-muted">{t("fr.exposedText", { what: exposed.map((e) => t(e.what === "database" ? "fr.what.database" : "fr.what.console")).join(t("fr.and")) })}</p>
</Card>
)}
<Card className="mt-6 p-6">
<h2 className="font-semibold">Status</h2>
<h2 className="font-semibold">{t("fr.status")}</h2>
<ul className="mt-2 divide-y divide-line">
<Line ok={st.server_running}>Server is running</Line>
<Line ok={st.servers_open}>Login and game servers are open to other computers</Line>
<Line ok={st.firewall.auth && st.firewall.world}>Windows Firewall allows the game ports</Line>
<Line ok={st.server_running}>{t("fr.st.running")}</Line>
<Line ok={st.servers_open}>{t("fr.st.open")}</Line>
<Line ok={st.firewall.auth && st.firewall.world}>{t("fr.st.firewall")}</Line>
<Line ok={st.exposure.filter((e) => e.what === "database" || e.what === "server console").every((e) => !e.reachable_from_network)}>
Database and server console are private to this computer
{t("fr.st.private")}
</Line>
</ul>
</Card>
@@ -95,76 +123,83 @@ export function FriendsPage({ serverId }: { serverId: string }) {
<div className="flex items-start justify-between gap-4">
<div>
<h3 className="font-semibold">
{m.title} {cur.mode === m.id && <span className="ml-2 rounded bg-gold/15 px-1.5 py-0.5 text-xs font-normal text-gold">In use</span>}
{t(m.title)} {cur.mode === m.id && <span className="ml-2 rounded bg-gold/15 px-1.5 py-0.5 text-xs font-normal text-gold">{t("fr.inUse")}</span>}
</h3>
<p className="mt-0.5 text-sm text-muted">{m.text}</p>
<p className="mt-0.5 text-sm text-muted">{t(m.text)}</p>
{m.id === "lan" && <p className="mt-2 text-sm">Your address on this network: <b className="selectable">{st.lan_ip ?? "unknown"}</b></p>}
{m.id === "lan" && (
<>
<p className="mt-2 text-sm">{t("fr.yourLan")} <b className="selectable">{st.lan_ip ?? t("fr.unknown")}</b></p>
{st.lan_ip && cur.mode !== m.id && <RealmlistLine host={st.lan_ip} />}
</>
)}
{m.id === "direct" && (
<div className="mt-2 text-sm">
<Button size="sm" variant="ghost" disabled={!!busy} onClick={() => void check()}>
{busy === "check" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
Check my connection
{t("fr.checkConn")}
</Button>
{net && net.reachability === "cgnat" && (
<p className="mt-2 text-warn">
Your internet provider does not allow direct hosting. Use the private network instead.
{t("fr.cgnat")}
</p>
)}
{net?.public_ip && net.reachability !== "cgnat" && (
<p className="mt-2">Your public address: <b className="selectable">{net.public_ip}</b>{!net.router_found && <span className="text-muted"> · your router cannot be set up automatically; forward the two game ports by hand</span>}</p>
<p className="mt-2">{t("fr.publicAddr")} <b className="selectable">{net.public_ip}</b>{!net.router_found && <span className="text-muted">{t("fr.noRouter")}</span>}</p>
)}
{net && !net.public_ip && <p className="mt-2 text-warn">Could not reach the internet to find your address.</p>}
{net?.public_ip && net.reachability !== "cgnat" && cur.mode !== m.id && <RealmlistLine host={net.public_ip} />}
{net && !net.public_ip && <p className="mt-2 text-warn">{t("fr.noInternet")}</p>}
</div>
)}
{m.id === "private" && (
<p className="mt-2 text-sm">
{!st.tailscale.installed && <span className="text-muted">Tailscale is not installed. Install the free app from tailscale.com/download, sign in, then come back.</span>}
{st.tailscale.installed && !st.tailscale.connected && <span className="text-warn">Tailscale is installed but not connected. Sign in to it first.</span>}
{st.tailscale.connected && <>Your private address: <b className="selectable">{st.tailscale.ip}</b></>}
{!st.tailscale.installed && <span className="text-muted">{t("fr.tsMissing")}</span>}
{st.tailscale.installed && !st.tailscale.connected && <span className="text-warn">{t("fr.tsOff")}</span>}
{st.tailscale.connected && <>{t("fr.privateAddr")} <b className="selectable">{st.tailscale.ip}</b></>}
</p>
)}
{m.id === "private" && st.tailscale.connected && st.tailscale.ip && cur.mode !== m.id && <RealmlistLine host={st.tailscale.ip} />}
</div>
<Button
size="sm"
variant={m.id === "private" && net?.reachability === "cgnat" ? "primary" : "secondary"}
disabled={!!busy || (m.id === "direct" && !net?.public_ip) || (m.id === "private" && !st.tailscale.connected)}
onClick={() => void enable(m.id)}
title={m.id === "direct" && !net?.public_ip ? "Check your connection first" : undefined}
title={m.id === "direct" && !net?.public_ip ? t("fr.checkFirst") : undefined}
>
{busy === `enable-${m.id}` && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
{cur.mode === m.id ? "Re-apply" : "Enable"}
{cur.mode === m.id ? t("fr.reapply") : t("fr.enable")}
</Button>
</div>
</Card>
))}
{cur.mode !== "local" && (
<Button variant="ghost" size="sm" className="justify-self-start" disabled={!!busy} onClick={() => void run("local", async () => { await api.friendsEnable(serverId, "local", undefined, false); return "Only this computer can connect now."; })}>
Stop sharing (this computer only)
<Button variant="ghost" size="sm" className="justify-self-start" disabled={!!busy} onClick={() => void run("local", async () => { await api.friendsEnable(serverId, "local", undefined, false); return t("fr.onlyLocal"); })}>
{t("fr.stopSharing")}
</Button>
)}
</div>
{connection && (
<Card className="mt-6 p-6">
<h2 className="font-semibold">Give this to your friend</h2>
<p className="mt-1 text-sm text-muted">They put this line in their game's realmlist.wtf file. Passwords and settings are never shared.</p>
<h2 className="font-semibold">{t("fr.giveTitle")}</h2>
<p className="mt-1 text-sm text-muted">{t("fr.giveText")}</p>
<pre className="selectable mt-3 rounded bg-black/40 p-3 text-sm">{connection}</pre>
<div className="mt-3 flex flex-wrap gap-2">
<Button size="sm" onClick={() => void navigator.clipboard.writeText(connection).then(() => { setCopied(true); setTimeout(() => setCopied(false), 2000); })}>
{copied ? "Copied" : "Copy connection info"}
{copied ? t("fr.copied") : t("fr.copy")}
</Button>
<Button size="sm" variant="ghost" disabled={!!busy} onClick={() => void run("pkg", async () => `Saved: ${await api.friendsPackage(serverId)}`)}>
Create friend package (zip)
<Button size="sm" variant="ghost" disabled={!!busy} onClick={() => void run("pkg", async () => t("fr.pkgSaved", { path: await api.friendsPackage(serverId) }))}>
{t("fr.pkg")}
</Button>
</div>
</Card>
)}
{note && <p className="mt-4 text-sm text-ok" role="status">{note}</p>}
{error && <p className="mt-4 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : error.human.message}</p>}
{error && <p className="mt-4 text-sm text-bad" role="alert">{error.human.code === "unknown" ? error.technical : human(error.human).message}</p>}
</div>
);
}
+23 -32
View File
@@ -4,24 +4,13 @@ import { AlertTriangle, Check, Minus } from "lucide-react";
import { api, asUiError, type Classification, type ScanReport, type ServerSummary, type UiError } from "@/lib/api";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { useHuman, useT, type Key } from "@/i18n";
const HEADLINE: Record<Classification, { title: string; tone: string; text: string }> = {
healthy: { title: "Existing server detected", tone: "text-ok", text: "Everything needed to run this server was found." },
partial: {
title: "Server partly found",
tone: "text-warn",
text: "Some parts are missing. You can still add it; nothing will be fixed automatically.",
},
"unknown-custom": {
title: "Custom server detected",
tone: "text-warn",
text: "This build is not recognised. Some update and install features will be disabled.",
},
incompatible: {
title: "This is not a server folder",
tone: "text-bad",
text: "Choose the folder that contains Core, Data and mysql (or your worldserver.exe).",
},
const HEADLINE: Record<Classification, { title: Key; tone: string; text: Key }> = {
healthy: { title: "import.healthy.title", tone: "text-ok", text: "import.healthy.text" },
partial: { title: "import.partial.title", tone: "text-warn", text: "import.partial.text" },
"unknown-custom": { title: "import.custom.title", tone: "text-warn", text: "import.custom.text" },
incompatible: { title: "import.incompatible.title", tone: "text-bad", text: "import.incompatible.text" },
};
export function ImportServer(props: {
@@ -29,13 +18,15 @@ export function ImportServer(props: {
onCancel: () => void;
onAdded: (s: ServerSummary) => void | Promise<void>;
}) {
const t = useT();
const human = useHuman();
const [report, setReport] = useState<ScanReport | null>(null);
const [error, setError] = useState<UiError | null>(null);
const [busy, setBusy] = useState(false);
async function choose() {
setError(null);
const picked = await open({ directory: true, multiple: false, title: "Choose your server folder" });
const picked = await open({ directory: true, multiple: false, title: t("import.dialogTitle") });
if (typeof picked !== "string") return;
setBusy(true);
setReport(null);
@@ -64,29 +55,29 @@ export function ImportServer(props: {
return (
<main className="mx-auto flex h-full max-w-2xl flex-col justify-center gap-5 px-8 py-10">
<div>
<h1 className="text-2xl font-semibold">Add an existing server</h1>
<p className="mt-1 text-muted">Pick the folder your server runs from. It will only be read.</p>
<h1 className="text-2xl font-semibold">{t("import.title")}</h1>
<p className="mt-1 text-muted">{t("import.subtitle")}</p>
</div>
<div className="flex gap-3">
<Button variant="secondary" onClick={choose} disabled={busy}>
{report ? "Choose another folder" : "Choose folder…"}
{report ? t("import.chooseAnother") : t("import.choose")}
</Button>
{props.canCancel && (
<Button variant="ghost" onClick={props.onCancel}>
Cancel
{t("common.cancel")}
</Button>
)}
</div>
{busy && !report && <p className="text-muted">Looking at your server…</p>}
{busy && !report && <p className="text-muted">{t("import.looking")}</p>}
{error && (
<Card className="border-bad/40 p-4" role="alert">
<p className="font-medium text-bad">{error.human.title}</p>
<p className="mt-1 text-sm text-muted">{error.human.message}</p>
<p className="font-medium text-bad">{human(error.human).title}</p>
<p className="mt-1 text-sm text-muted">{human(error.human).message}</p>
<details className="mt-2 text-xs text-muted">
<summary className="cursor-pointer">Show technical details</summary>
<summary className="cursor-pointer">{t("import.techDetails")}</summary>
<pre className="mt-1 whitespace-pre-wrap">{error.technical}</pre>
</details>
</Card>
@@ -101,8 +92,8 @@ export function ImportServer(props: {
<AlertTriangle className={`mt-0.5 h-5 w-5 ${head.tone}`} aria-hidden />
)}
<div>
<h2 className="font-semibold">{head.title}</h2>
<p className="text-sm text-muted">{head.text}</p>
<h2 className="font-semibold">{t(head.title)}</h2>
<p className="text-sm text-muted">{t(head.text)}</p>
<p className="selectable mt-1 break-all text-xs text-muted">{report.path}</p>
</div>
</div>
@@ -115,11 +106,11 @@ export function ImportServer(props: {
{it.detail && <span className="text-xs">{it.detail}</span>}
{it.status === "found" ? (
<span className="flex items-center gap-1 text-ok">
<Check className="h-4 w-4" aria-hidden /> Detected
<Check className="h-4 w-4" aria-hidden /> {t("import.detected")}
</span>
) : (
<span className="flex items-center gap-1">
<Minus className="h-4 w-4" aria-hidden /> {it.key === "companions" ? "Not installed" : "Not found"}
<Minus className="h-4 w-4" aria-hidden /> {it.key === "companions" ? t("import.notInstalled") : t("import.notFound")}
</span>
)}
</span>
@@ -134,13 +125,13 @@ export function ImportServer(props: {
))}
<div className="mt-5 flex items-center justify-between border-t border-line pt-4">
<p className="text-sm text-muted">No files will be changed during import.</p>
<p className="text-sm text-muted">{t("import.noChanges")}</p>
<Button
variant="primary"
onClick={add}
disabled={busy || report.classification === "incompatible"}
>
Add server
{t("import.add")}
</Button>
</div>
</Card>
+37 -24
View File
@@ -5,10 +5,23 @@ import { Check, ChevronDown, ChevronRight, Loader2 } from "lucide-react";
import { api, asUiError, type InstallStep, type Preflight, type ServerSummary, type UiError } from "@/lib/api";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { useHuman, useT, type Key } from "@/i18n";
// The backend reports progress with these English step names; map the known ones to translations.
const STEP_KEYS: Record<string, Key> = {
"Preparing your server": "install.progressTitle",
"Checking your computer": "install.step.checking",
"Downloading server": "install.step.downloading",
Unpacking: "install.step.unpacking",
"Preparing database": "install.step.database",
Finishing: "install.step.finishing",
};
type Phase = "choose" | "installing" | "done";
export function InstallServer(props: { canCancel: boolean; onCancel: () => void; onDone: (s: ServerSummary) => void | Promise<void> }) {
const t = useT();
const human = useHuman();
const [dest, setDest] = useState("C:\\Games\\CoA Server");
const [pre, setPre] = useState<Preflight | null>(null);
const [phase, setPhase] = useState<Phase>("choose");
@@ -32,12 +45,12 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
}, []);
async function browse() {
const picked = await open({ directory: true, multiple: false, title: "Choose where to install your server" });
const picked = await open({ directory: true, multiple: false, title: t("install.dialogTitle") });
if (typeof picked === "string") setDest(picked.replace(/[\\/]+$/, "") + (picked.toLowerCase().includes("coa") ? "" : "\\CoA Server"));
}
async function browsePackage() {
const picked = await open({ directory: true, multiple: false, title: "Choose a server package folder" });
const picked = await open({ directory: true, multiple: false, title: t("install.pkgDialogTitle") });
if (typeof picked === "string") setPkg(picked);
}
@@ -58,12 +71,12 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
if (phase === "installing") {
return (
<main className="mx-auto flex h-full max-w-xl flex-col justify-center px-8">
<h1 className="text-2xl font-semibold">Preparing your server</h1>
<p className="mt-1 text-muted">This can take a few minutes. You can leave this window open.</p>
<h1 className="text-2xl font-semibold">{t("install.progressTitle")}</h1>
<p className="mt-1 text-muted">{t("install.progressText")}</p>
<Card className="mt-8 p-6">
<div className="flex items-center justify-between">
<span className="flex items-center gap-2 font-medium">
<Loader2 className="h-4 w-4 animate-spin text-gold" aria-hidden /> {step.step}
<Loader2 className="h-4 w-4 animate-spin text-gold" aria-hidden /> {STEP_KEYS[step.step] ? t(STEP_KEYS[step.step]) : step.step}
</span>
<span className="text-sm text-muted" role="status">{step.percent}%</span>
</div>
@@ -74,7 +87,7 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
</Card>
{step.step === "Downloading server" && (
<Button className="mt-4 self-start" variant="ghost" size="sm" onClick={() => void api.cancelInstall()}>
Cancel
{t("common.cancel")}
</Button>
)}
</main>
@@ -87,10 +100,10 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
<div className="flex h-14 w-14 items-center justify-center rounded-full bg-ok/15">
<Check className="h-7 w-7 text-ok" aria-hidden />
</div>
<h1 className="mt-5 text-2xl font-semibold">Your server is ready</h1>
<p className="mt-1 text-muted">Everything is installed. Start it from the next screen.</p>
<h1 className="mt-5 text-2xl font-semibold">{t("install.doneTitle")}</h1>
<p className="mt-1 text-muted">{t("install.doneText")}</p>
<Button className="mt-8" variant="primary" size="xl" onClick={() => void props.onDone(installed)}>
OPEN MY SERVER
{t("install.open")}
</Button>
</main>
);
@@ -99,12 +112,12 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
return (
<main className="mx-auto flex h-full max-w-2xl flex-col justify-center gap-5 px-8 py-10">
<div>
<h1 className="text-2xl font-semibold">Install a new server</h1>
<p className="mt-1 text-muted">Choose a folder, or keep the suggested one. Everything else is set up for you.</p>
<h1 className="text-2xl font-semibold">{t("install.title")}</h1>
<p className="mt-1 text-muted">{t("install.subtitle")}</p>
</div>
<div>
<label htmlFor="dest" className="text-sm text-muted">Install to</label>
<label htmlFor="dest" className="text-sm text-muted">{t("install.installTo")}</label>
<div className="mt-1 flex gap-2">
<input
id="dest"
@@ -112,7 +125,7 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
onChange={(e) => setDest(e.target.value)}
className="selectable flex-1 rounded-md border border-line bg-card px-3 py-2.5 text-[15px] outline-none focus:border-gold"
/>
<Button onClick={browse}>Browse…</Button>
<Button onClick={browse}>{t("install.browse")}</Button>
</div>
</div>
@@ -123,15 +136,15 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
))}
</Card>
)}
{pre?.ok && <p className="text-sm text-ok">This folder is ready. {Math.round(pre.free_bytes / (1 << 30))} GB free.</p>}
{pre?.ok && <p className="text-sm text-ok">{t("install.ready", { gb: Math.round(pre.free_bytes / (1 << 30)) })}</p>}
{error && (
<Card className="border-bad/40 p-4" role="alert">
<p className="font-medium text-bad">{error.human.code === "unknown" ? "The installation could not finish" : error.human.title}</p>
<p className="mt-1 text-sm text-muted">{error.human.code === "unknown" ? error.technical : error.human.message}</p>
<p className="mt-1 text-sm text-muted">Nothing was installed. You can try again; downloaded files are kept.</p>
<p className="font-medium text-bad">{error.human.code === "unknown" ? t("install.failedTitle") : human(error.human).title}</p>
<p className="mt-1 text-sm text-muted">{error.human.code === "unknown" ? error.technical : human(error.human).message}</p>
<p className="mt-1 text-sm text-muted">{t("install.nothingInstalled")}</p>
<button className="mt-2 cursor-pointer text-xs text-muted underline" onClick={() => setShowDetails((v) => !v)}>
{showDetails ? "Hide" : "Show"} technical details
{showDetails ? t("install.hideTech") : t("install.showTech")}
</button>
{showDetails && <pre className="mt-2 max-h-40 overflow-auto whitespace-pre-wrap rounded bg-black/40 p-2 text-xs">{error.technical}</pre>}
</Card>
@@ -140,14 +153,14 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
<div>
<button onClick={() => setShowAdvanced((v) => !v)} aria-expanded={showAdvanced} className="flex cursor-pointer items-center gap-1 text-sm text-muted hover:text-ink">
{showAdvanced ? <ChevronDown className="h-4 w-4" aria-hidden /> : <ChevronRight className="h-4 w-4" aria-hidden />}
Advanced
{t("install.advanced")}
</button>
{showAdvanced && (
<div className="mt-2">
<label htmlFor="pkg" className="text-sm text-muted">Install from a local package folder instead of downloading</label>
<label htmlFor="pkg" className="text-sm text-muted">{t("install.localPkg")}</label>
<div className="mt-1 flex gap-2">
<input id="pkg" value={pkg} onChange={(e) => setPkg(e.target.value)} placeholder="(leave empty to download)" className="selectable flex-1 rounded-md border border-line bg-card px-3 py-2 text-sm outline-none focus:border-gold" />
<Button size="sm" onClick={browsePackage}>Browse…</Button>
<input id="pkg" value={pkg} onChange={(e) => setPkg(e.target.value)} placeholder={t("install.localPkgHint")} className="selectable flex-1 rounded-md border border-line bg-card px-3 py-2 text-sm outline-none focus:border-gold" />
<Button size="sm" onClick={browsePackage}>{t("install.browse")}</Button>
</div>
</div>
)}
@@ -155,11 +168,11 @@ export function InstallServer(props: { canCancel: boolean; onCancel: () => void;
<div className="flex items-center gap-3">
<Button variant="primary" size="md" disabled={!pre?.ok} onClick={() => void install()}>
Install
{t("install.button")}
</Button>
{props.canCancel && (
<Button variant="ghost" onClick={props.onCancel}>
Cancel
{t("common.cancel")}
</Button>
)}
</div>
+15 -12
View File
@@ -2,8 +2,11 @@ import { useEffect, useState } from "react";
import { api, asUiError, type UiError } from "@/lib/api";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { useHuman, useT } from "@/i18n";
export function PlayersPage({ serverId }: { serverId: string }) {
const t = useT();
const human = useHuman();
const [online, setOnline] = useState<boolean | null>(null);
const [username, setUsername] = useState("");
const [password, setPassword] = useState("");
@@ -42,37 +45,37 @@ export function PlayersPage({ serverId }: { serverId: string }) {
const input = "w-72 rounded-md border border-line bg-bg px-3 py-2.5 text-[15px] outline-none focus:border-gold";
return (
<div className="max-w-xl">
<h1 className="text-2xl font-semibold">Players</h1>
<p className="mt-1 text-muted">Who is playing right now?</p>
<h1 className="text-2xl font-semibold">{t("players.title")}</h1>
<p className="mt-1 text-muted">{t("q.players")}</p>
<Card className="mt-6 p-6">
<h2 className="font-semibold">Create your account</h2>
<p className="mt-1 text-sm text-muted">This is the name and password you use to log in to the game.</p>
{online === false && <p className="mt-3 text-sm text-warn">Start the server first — accounts are created while it is running.</p>}
<h2 className="font-semibold">{t("players.createTitle")}</h2>
<p className="mt-1 text-sm text-muted">{t("players.createText")}</p>
{online === false && <p className="mt-3 text-sm text-warn">{t("players.startFirst")}</p>}
<div className="mt-4 flex flex-col gap-3">
<div>
<label htmlFor="acc-user" className="text-sm text-muted">Username</label>
<label htmlFor="acc-user" className="text-sm text-muted">{t("players.username")}</label>
<input id="acc-user" className={input + " mt-1 block"} value={username} onChange={(e) => setUsername(e.target.value)} autoComplete="off" />
</div>
<div>
<label htmlFor="acc-pass" className="text-sm text-muted">Password</label>
<label htmlFor="acc-pass" className="text-sm text-muted">{t("players.password")}</label>
<input id="acc-pass" type="password" className={input + " mt-1 block"} value={password} onChange={(e) => setPassword(e.target.value)} autoComplete="new-password" />
</div>
<label className="flex cursor-pointer items-start gap-2 text-sm">
<input type="checkbox" checked={admin} onChange={(e) => setAdmin(e.target.checked)} className="mt-1" />
<span>
Make this account an administrator
<span className="block text-xs text-muted">Administrators can use game-master commands in the game. Only do this for accounts you trust.</span>
{t("players.admin")}
<span className="block text-xs text-muted">{t("players.adminHint")}</span>
</span>
</label>
</div>
<Button className="mt-5" variant="primary" disabled={busy || !online || !username || !password} onClick={() => void create()}>
Create account
{t("players.create")}
</Button>
{done && <p className="mt-3 text-sm text-ok" role="status">Account “{done}” created. You can log in to the game with it now.</p>}
{done && <p className="mt-3 text-sm text-ok" role="status">{t("players.created", { name: done })}</p>}
{error && (
<p className="mt-3 text-sm text-bad" role="alert">
{error.human.code === "unknown" ? error.technical : error.human.message}
{error.human.code === "unknown" ? error.technical : human(error.human).message}
</p>
)}
</Card>
+32 -48
View File
@@ -8,22 +8,16 @@ import { Card } from "@/components/ui/card";
import { ClientCard } from "@/screens/ClientCard";
import { DiagnosticsCard } from "@/screens/DiagnosticsCard";
import { AboutCard } from "@/screens/AboutCard";
import { LOCALES, useI18n } from "@/i18n";
const ACTION_TEXT: Record<string, string> = {
create: "New file",
replace: "Updated",
"merge-config": "New settings added",
skip: "Unchanged",
conflict: "Needs your decision",
};
import { useHuman, useI18n, type Key } from "@/i18n";
import { LanguagePicker } from "@/components/LanguagePicker";
function mb(bytes: number) {
return bytes >= 1 << 20 ? `${(bytes / (1 << 20)).toFixed(1)} MB` : `${Math.max(1, Math.round(bytes / 1024))} KB`;
}
export function SettingsHome({ serverId }: { serverId: string }) {
const { t, locale, setLocale } = useI18n();
const { t } = useI18n();
const human = useHuman();
const [preview, setPreview] = useState<UpdatePreview | null>(null);
const [pending, setPending] = useState<UpdateTxn | null>(null);
const [busy, setBusy] = useState<"check" | "update" | "rollback" | null>(null);
@@ -65,7 +59,7 @@ export function SettingsHome({ serverId }: { serverId: string }) {
try {
const out = await api.applyUpdate(serverId, choices, source.trim() || undefined);
setPreview(null);
if (out.txn.state === "committed") setDone(`Updated to version ${out.txn.to_version}.`);
if (out.txn.state === "committed") setDone(t("upd.updatedTo", { v: out.txn.to_version ?? "" }));
else setPending(out.txn);
} catch (e) {
setError(asUiError(e));
@@ -76,14 +70,14 @@ export function SettingsHome({ serverId }: { serverId: string }) {
}
}
async function rollback(t: UpdateTxn) {
if (!window.confirm("Go back to the previous version? Your characters and accounts are not changed.")) return;
async function rollback(txn: UpdateTxn) {
if (!window.confirm(t("upd.confirmBack"))) return;
setBusy("rollback");
setError(null);
try {
await api.rollbackUpdate(serverId, t.id);
await api.rollbackUpdate(serverId, txn.id);
setPending(null);
setDone("Went back to the previous version. Your data was not touched.");
setDone(t("upd.wentBack"));
} catch (e) {
setError(asUiError(e));
} finally {
@@ -92,7 +86,7 @@ export function SettingsHome({ serverId }: { serverId: string }) {
}
async function browse() {
const p = await open({ directory: true, multiple: false, title: "Choose an update package folder" });
const p = await open({ directory: true, multiple: false, title: t("upd.dialogTitle") });
if (typeof p === "string") setSource(p);
}
@@ -104,13 +98,13 @@ export function SettingsHome({ serverId }: { serverId: string }) {
{pending && (
<Card className="mt-6 border-warn/40 p-5" role="alert">
<p className="font-medium text-warn">
{pending.state === "needs-decision" ? "The updated server did not start correctly" : "An earlier update did not finish"}
{pending.state === "needs-decision" ? t("upd.pendingBad") : t("upd.pendingUnfinished")}
</p>
<p className="mt-1 text-sm text-muted">{pending.message ?? "You can safely go back to the previous version."}</p>
<p className="mt-1 text-sm text-muted">Going back restores program files and settings. Characters and accounts are never rolled back automatically.</p>
<p className="mt-1 text-sm text-muted">{pending.message ?? t("upd.safeBack")}</p>
<p className="mt-1 text-sm text-muted">{t("upd.backNote")}</p>
<Button className="mt-3" size="sm" disabled={!!busy} onClick={() => void rollback(pending)}>
{busy === "rollback" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
Go back to version {pending.from_version ?? "before the update"}
{pending.from_version ? t("upd.goBackTo", { v: pending.from_version }) : t("upd.goBackBefore")}
</Button>
</Card>
)}
@@ -118,18 +112,7 @@ export function SettingsHome({ serverId }: { serverId: string }) {
<Card className="mt-6 p-6">
<h2 className="font-semibold">{t("settings.language")}</h2>
<p className="mt-1 text-sm text-muted">{t("settings.languageHint")}</p>
<select
aria-label={t("settings.language")}
value={locale}
onChange={(e) => setLocale(e.target.value as typeof locale)}
className="mt-3 rounded-md border border-line bg-bg px-3 py-2 text-sm outline-none focus:border-gold"
>
{LOCALES.map((l) => (
<option key={l.id} value={l.id}>
{l.name}
</option>
))}
</select>
<LanguagePicker className="mt-3" />
</Card>
<ClientCard serverId={serverId} />
@@ -139,57 +122,58 @@ export function SettingsHome({ serverId }: { serverId: string }) {
<AboutCard />
<Card className="mt-6 p-6">
<h2 className="font-semibold">Server updates</h2>
<p className="mt-1 text-sm text-muted">Updates are checked for authenticity, backed up first, and can be undone.</p>
<h2 className="font-semibold">{t("upd.title")}</h2>
<p className="mt-1 text-sm text-muted">{t("upd.text")}</p>
<div className="mt-4 flex items-center gap-3">
<Button variant="primary" disabled={!!busy} onClick={() => void check()}>
{busy === "check" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
Check for updates
{t("upd.check")}
</Button>
<button onClick={() => setAdvanced((v) => !v)} aria-expanded={advanced} className="flex cursor-pointer items-center gap-1 text-sm text-muted hover:text-ink">
{advanced ? <ChevronDown className="h-4 w-4" aria-hidden /> : <ChevronRight className="h-4 w-4" aria-hidden />}
Advanced
{t("install.advanced")}
</button>
</div>
{advanced && (
<div className="mt-3 flex gap-2">
<input aria-label="Update package folder" value={source} onChange={(e) => setSource(e.target.value)} placeholder="Update package folder (leave empty to use the official source)" className="selectable flex-1 rounded-md border border-line bg-bg px-3 py-2 text-sm outline-none focus:border-gold" />
<Button size="sm" onClick={browse}>Browse…</Button>
<input aria-label={t("upd.folderLabel")} value={source} onChange={(e) => setSource(e.target.value)} placeholder={t("upd.folderHint")} className="selectable flex-1 rounded-md border border-line bg-bg px-3 py-2 text-sm outline-none focus:border-gold" />
<Button size="sm" onClick={browse}>{t("install.browse")}</Button>
</div>
)}
{done && <p className="mt-4 text-sm text-ok" role="status">{done}</p>}
{error && (
<p className="mt-4 text-sm text-bad" role="alert">
{error.human.code === "unknown" ? error.technical : error.human.message}
{error.human.code === "unknown" ? error.technical : human(error.human).message}
</p>
)}
{preview && (
<div className="mt-5 border-t border-line pt-4">
<p className="font-medium">
Version {preview.to_version} is available{preview.from_version ? ` (you have ${preview.from_version})` : ""}
{preview.from_version ? t("upd.availableFrom", { to: preview.to_version, from: preview.from_version }) : t("upd.available", { to: preview.to_version })}
</p>
<p className="mt-1 text-sm text-muted">
Download {mb(preview.download_bytes)} · {preview.items.filter((i) => i.action !== "skip").length} file(s) change
{preview.migrations > 0 ? ` · ${preview.migrations} database update(s)` : ""}
{preview.migrations > 0
? t("upd.summaryDb", { size: mb(preview.download_bytes), files: preview.items.filter((i) => i.action !== "skip").length, db: preview.migrations })
: t("upd.summary", { size: mb(preview.download_bytes), files: preview.items.filter((i) => i.action !== "skip").length })}
</p>
<ul className="mt-3 max-h-56 divide-y divide-line overflow-auto text-sm">
{preview.items.filter((i) => i.action !== "skip").map((i) => (
<li key={i.path} className="py-2">
<div className="flex justify-between gap-3">
<span className="selectable break-all">{i.path}</span>
<span className={i.action === "conflict" ? "shrink-0 text-warn" : "shrink-0 text-muted"}>{ACTION_TEXT[i.action]}</span>
<span className={i.action === "conflict" ? "shrink-0 text-warn" : "shrink-0 text-muted"}>{t(`upd.act.${i.action}` as Key)}</span>
</div>
{i.action === "conflict" && (
<fieldset className="mt-2 flex flex-wrap gap-4 text-xs text-muted">
<legend className="sr-only">This file was modified outside CoA Server Manager</legend>
<span className="text-warn">This file was modified outside CoA Server Manager.</span>
<legend className="sr-only">{t("upd.conflict")}</legend>
<span className="text-warn">{t("upd.conflict")}</span>
{(["keep", "replace"] as const).map((c) => (
<label key={c} className="flex cursor-pointer items-center gap-1">
<input type="radio" name={i.path} checked={choices[i.path] === c} onChange={() => setChoices((x) => ({ ...x, [i.path]: c }))} />
{c === "keep" ? "Keep my file" : "Replace with update"}
{c === "keep" ? t("upd.keep") : t("upd.replace")}
</label>
))}
</fieldset>
@@ -199,9 +183,9 @@ export function SettingsHome({ serverId }: { serverId: string }) {
</ul>
<Button className="mt-4" variant="primary" disabled={!!busy} onClick={() => void update()}>
{busy === "update" && <Loader2 className="h-4 w-4 animate-spin" aria-hidden />}
Update now
{t("upd.now")}
</Button>
<p className="mt-2 text-xs text-muted">The server is stopped during the update and started again to check that it works.</p>
<p className="mt-2 text-xs text-muted">{t("upd.stopNote")}</p>
</div>
)}
+53 -46
View File
@@ -17,27 +17,31 @@ import { cn } from "@/lib/utils";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { CompanionsCard } from "@/screens/CompanionsCard";
import { useHuman, useI18n, useT, type Key } from "@/i18n";
const RESTART_LABEL = { runtime: "Applies immediately", world: "Needs a world server restart", full: "Needs a full server restart" } as const;
type T = (k: Key, v?: Record<string, string | number>) => string;
function fmt(v: JsonValue, s: { type: string; unit?: string | null; options: { value: JsonValue; label: string }[] }): string {
if (typeof v === "boolean") return v ? "On" : "Off";
const RESTART_LABEL = { runtime: "set.restart.runtime", world: "set.restart.world", full: "set.restart.full" } as const;
function fmt(t: T, v: JsonValue, s: { type: string; unit?: string | null; options: { value: JsonValue; label: string }[] }): string {
if (typeof v === "boolean") return v ? t("set.on") : t("set.off");
if (s.type === "enum") return s.options.find((o) => o.value === v)?.label ?? String(v);
return s.unit ? `${v} ${s.unit}` : String(v);
}
function clientCheck(s: SettingView, v: JsonValue): string | null {
function clientCheck(t: T, s: SettingView, v: JsonValue): string | null {
if (s.type === "int" || s.type === "float") {
if (typeof v !== "number" || Number.isNaN(v)) return "Enter a number";
if (s.type === "int" && !Number.isInteger(v)) return "Enter a whole number";
if (s.min !== undefined && v < s.min) return `Must be at least ${s.min}`;
if (s.max !== undefined && v > s.max) return `Must be at most ${s.max}`;
if (typeof v !== "number" || Number.isNaN(v)) return t("set.enterNumber");
if (s.type === "int" && !Number.isInteger(v)) return t("set.enterInt");
if (s.min !== undefined && v < s.min) return t("set.atLeast", { n: s.min });
if (s.max !== undefined && v > s.max) return t("set.atMost", { n: s.max });
}
return null;
}
function Field(props: { s: SettingView; value: JsonValue; error: string | null; onChange: (v: JsonValue) => void }) {
const { s, value, error, onChange } = props;
const t = useT();
const id = `f-${s.key}`;
const base = "rounded-md border bg-bg px-3 py-2 text-sm outline-none focus:border-gold";
if (s.type === "bool") {
@@ -50,7 +54,7 @@ function Field(props: { s: SettingView; value: JsonValue; error: string | null;
className={cn("relative h-7 w-14 cursor-pointer rounded-full transition-colors", value === true ? "bg-gold" : "bg-white/15")}
>
<span className={cn("absolute left-1 top-1 h-5 w-5 rounded-full bg-white transition-transform", value === true && "translate-x-7")} />
<span className="sr-only">{value === true ? "On" : "Off"}</span>
<span className="sr-only">{value === true ? t("set.on") : t("set.off")}</span>
</button>
);
}
@@ -80,8 +84,8 @@ function Field(props: { s: SettingView; value: JsonValue; error: string | null;
inputMode={numeric ? "decimal" : undefined}
aria-invalid={!!error}
onChange={(e) => {
const t = e.target.value;
onChange(numeric ? (t.trim() === "" || Number.isNaN(Number(t)) ? (t as unknown as number) : Number(t)) : t);
const raw = e.target.value;
onChange(numeric ? (raw.trim() === "" || Number.isNaN(Number(raw)) ? (raw as unknown as number) : Number(raw)) : raw);
}}
/>
{s.unit && <span className="text-xs text-muted">{s.unit}</span>}
@@ -91,6 +95,7 @@ function Field(props: { s: SettingView; value: JsonValue; error: string | null;
function Row(props: { s: SettingView; value: JsonValue; error: string | null; onChange: (v: JsonValue) => void; onReset: () => void }) {
const { s, value, error } = props;
const t = useT();
const changed = value !== s.value;
return (
<div className="grid grid-cols-[1fr_auto] items-start gap-x-6 gap-y-1 py-3.5">
@@ -99,18 +104,18 @@ function Row(props: { s: SettingView; value: JsonValue; error: string | null; on
{s.title}
{s.dangerous && (
<span className="inline-flex items-center gap-1 rounded bg-warn/15 px-1.5 py-0.5 text-[11px] font-normal text-warn">
<AlertTriangle className="h-3 w-3" aria-hidden /> Careful
<AlertTriangle className="h-3 w-3" aria-hidden /> {t("set.careful")}
</span>
)}
{changed && <span className="rounded bg-gold/15 px-1.5 py-0.5 text-[11px] font-normal text-gold">Changed</span>}
{changed && <span className="rounded bg-gold/15 px-1.5 py-0.5 text-[11px] font-normal text-gold">{t("set.changed")}</span>}
</label>
<p className="mt-0.5 max-w-xl text-sm text-muted">{s.description}</p>
<p className="mt-1 text-xs text-muted/80">
Default: {fmt(s.default, s)}
{s.min !== undefined && s.max !== undefined && s.type !== "bool" ? ` · Range ${s.min}–${s.max}` : ""} · {RESTART_LABEL[s.restartRequired]}
{t("set.default", { v: fmt(t, s.default, s) })}
{s.min !== undefined && s.max !== undefined && s.type !== "bool" ? ` · ${t("set.range", { min: s.min, max: s.max })}` : ""} · {t(RESTART_LABEL[s.restartRequired])}
</p>
{s.problem && <p className="mt-1 text-xs text-warn">The file has an unusable value ({s.problem}); showing the default.</p>}
{s.drift && <p className="mt-1 text-xs text-warn">Edited by hand in the generated file — the launcher will reset it at next start unless you save it here.</p>}
{s.problem && <p className="mt-1 text-xs text-warn">{t("set.badValue", { problem: s.problem })}</p>}
{s.drift && <p className="mt-1 text-xs text-warn">{t("set.drift")}</p>}
{error && (
<p role="alert" className="mt-1 text-xs text-bad">
{error}
@@ -120,8 +125,8 @@ function Row(props: { s: SettingView; value: JsonValue; error: string | null; on
<div className="flex items-center gap-2 pt-0.5">
<Field s={s} value={value} error={error} onChange={props.onChange} />
<button
title="Reset to default"
aria-label={`Reset ${s.title} to default`}
title={t("set.reset")}
aria-label={t("set.resetItem", { name: s.title })}
onClick={props.onReset}
disabled={value === s.default}
className="cursor-pointer rounded p-1.5 text-muted hover:bg-white/5 hover:text-ink disabled:opacity-25"
@@ -135,6 +140,8 @@ function Row(props: { s: SettingView; value: JsonValue; error: string | null; on
export function SettingsPage(props: { serverId: string; scope: Scope; title: string; question: string }) {
const { serverId, scope } = props;
const { t, tn } = useI18n();
const human = useHuman();
const [view, setView] = useState<SettingsView | null>(null);
const [draft, setDraft] = useState<Record<string, JsonValue>>({});
const [errors, setErrors] = useState<Record<string, string>>({});
@@ -177,13 +184,13 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
<div className="max-w-xl">
<h1 className="text-2xl font-semibold">{props.title}</h1>
<Card className="mt-6 p-5">
<p className="font-medium">{fatal.human.code === "unknown" ? "Nothing to configure yet" : fatal.human.title}</p>
<p className="mt-1 text-sm text-muted">{fatal.human.code === "unknown" ? fatal.technical : fatal.human.message}</p>
<p className="font-medium">{fatal.human.code === "unknown" ? t("set.nothingYet") : human(fatal.human).title}</p>
<p className="mt-1 text-sm text-muted">{fatal.human.code === "unknown" ? fatal.technical : human(fatal.human).message}</p>
</Card>
</div>
);
}
if (!view) return <p className="text-muted">Loading settings…</p>;
if (!view) return <p className="text-muted">{t("set.loading")}</p>;
const inCategory = view.settings.filter((s) => s.category === category);
const basic = inCategory.filter((s) => !s.advanced);
@@ -195,13 +202,13 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
const local: Record<string, string> = {};
for (const [k, v] of Object.entries(changes)) {
const s = view!.settings.find((x) => x.key === k)!;
const m = clientCheck(s, v);
const m = clientCheck(t, s, v);
if (m) local[k] = m;
}
setErrors(local);
if (Object.keys(local).length) return;
const dangerous = Object.keys(changes).filter((k) => view!.settings.find((s) => s.key === k)?.dangerous);
if (dangerous.length && !window.confirm(`You are changing ${dangerous.length} setting(s) marked Careful. A snapshot of the current configuration is saved first, so this can be undone. Continue?`)) return;
if (dangerous.length && !window.confirm(t("set.confirmCareful", { n: dangerous.length }))) return;
setBusy(true);
setSaveErr(null);
try {
@@ -247,9 +254,9 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
{view.drift_keys.length > 0 && (
<Card className="mt-5 border-warn/40 p-4" role="status">
<p className="font-medium text-warn">{view.drift_keys.length} setting(s) were edited by hand</p>
<p className="font-medium text-warn">{t("set.driftTitle", { n: view.drift_keys.length })}</p>
<p className="mt-1 text-sm text-muted">
The server launcher rebuilds worldserver.conf from its template every time it starts, so these manual edits will be lost:{" "}
{t("set.driftText")}{" "}
<span className="selectable">{view.drift_keys.slice(0, 6).join(", ")}</span>
{view.drift_keys.length > 6 ? "…" : ""}
</p>
@@ -257,14 +264,14 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
)}
<div className="mt-5 flex flex-wrap items-center gap-2">
<span className="text-sm text-muted">Presets:</span>
<span className="text-sm text-muted">{t("set.presets")}</span>
{presets.map((p) => (
<Button key={p.id} size="sm" title={p.description} onClick={() => void openPreset(p.id)}>
{p.title}
</Button>
))}
<Button size="sm" variant="ghost" onClick={() => void openPreset("defaults")}>
Restore recommended defaults
{t("set.restoreDefaults")}
</Button>
</div>
@@ -273,11 +280,11 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
<p className="font-medium">{preview.title}</p>
<p className="text-sm text-muted">{preview.description}</p>
{preview.changes.length === 0 ? (
<p className="mt-3 text-sm">Nothing to change — your settings already match.</p>
<p className="mt-3 text-sm">{t("set.matches")}</p>
) : (
<>
<p className="mt-3 text-sm">
This will change <b>{preview.changes.length}</b> setting{preview.changes.length === 1 ? "" : "s"}:
{tn("set.willChange", preview.changes.length)}
</p>
<ul className="mt-2 max-h-56 divide-y divide-line overflow-auto text-sm">
{preview.changes.map((c) => {
@@ -286,7 +293,7 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
<li key={c.key} className="flex justify-between gap-4 py-1.5">
<span>{c.title}</span>
<span className="text-muted">
{fmt(c.from, s)} → <span className="text-ink">{fmt(c.to, s)}</span>
{fmt(t, c.from, s)} → <span className="text-ink">{fmt(t, c.to, s)}</span>
</span>
</li>
);
@@ -302,11 +309,11 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
disabled={busy}
onClick={() => void save(Object.fromEntries(preview.changes.map((c) => [c.key, c.to])))}
>
Apply
{t("set.apply")}
</Button>
)}
<Button size="sm" variant="ghost" onClick={() => setPreview(null)}>
Cancel
{t("common.cancel")}
</Button>
</div>
</Card>
@@ -315,22 +322,22 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
{saved && (
<Card className="mt-4 border-ok/40 p-4" role="status">
{saved.changed.length === 0 ? (
<p>Nothing changed.</p>
<p>{t("set.nothingChanged")}</p>
) : (
<>
<p className="font-medium text-ok">Saved.</p>
<p className="font-medium text-ok">{t("set.saved")}</p>
<p className="mt-1 text-sm text-muted">
{running && saved.restart
? `Restart required to apply ${saved.changed.length} setting${saved.changed.length === 1 ? "" : "s"}.`
: "The changes will apply the next time the server starts."}
? tn("set.restartRequired", saved.changed.length)
: t("set.appliesNextStart")}
</p>
{running && saved.restart && (
<div className="mt-3 flex gap-2">
<Button size="sm" variant="primary" disabled={busy} onClick={() => void restartNow()}>
Restart now
{t("set.restartNow")}
</Button>
<Button size="sm" variant="ghost" onClick={() => setSaved(null)}>
Later
{t("set.later")}
</Button>
</div>
)}
@@ -341,8 +348,8 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
{saveErr && (
<Card className="mt-4 border-bad/40 p-4" role="alert">
<p className="font-medium text-bad">{saveErr.human.title}</p>
<p className="mt-1 text-sm text-muted">Nothing was saved. Fix the highlighted settings and try again.</p>
<p className="font-medium text-bad">{human(saveErr.human).title}</p>
<p className="mt-1 text-sm text-muted">{t("set.notSaved")}</p>
</Card>
)}
@@ -386,7 +393,7 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
className="flex cursor-pointer items-center gap-1 text-sm text-muted hover:text-ink"
>
{showAdvanced ? <ChevronDown className="h-4 w-4" aria-hidden /> : <ChevronRight className="h-4 w-4" aria-hidden />}
Advanced settings ({advanced.length})
{t("set.advanced", { n: advanced.length })}
</button>
{showAdvanced && (
<div className="divide-y divide-line">
@@ -406,18 +413,18 @@ export function SettingsPage(props: { serverId: string; scope: Scope; title: str
)}
{view.unknown_keys > 0 && (
<p className="mt-6 text-xs text-muted">{view.unknown_keys} other setting(s) in the configuration file are kept exactly as they are.</p>
<p className="mt-6 text-xs text-muted">{t("set.unknownKept", { n: view.unknown_keys })}</p>
)}
{dirtyKeys.length > 0 && (
<div className="fixed bottom-0 left-60 right-0 flex items-center justify-between border-t border-line bg-[#0b0c0e]/95 px-10 py-3">
<span className="text-sm text-muted">{dirtyKeys.length} unsaved change{dirtyKeys.length === 1 ? "" : "s"}</span>
<span className="text-sm text-muted">{tn("set.unsaved", dirtyKeys.length)}</span>
<div className="flex gap-2">
<Button variant="ghost" size="sm" onClick={() => { setDraft({}); setErrors({}); }}>
Discard
{t("set.discard")}
</Button>
<Button variant="primary" size="sm" disabled={busy} onClick={() => void save(Object.fromEntries(dirtyKeys.map((k) => [k, draft[k]])))}>
Save changes
{t("set.save")}
</Button>
</div>
</div>
+3 -1
View File
@@ -1,10 +1,12 @@
import { FolderSearch, Download } from "lucide-react";
import { useT } from "@/i18n";
import { LanguagePicker } from "@/components/LanguagePicker";
export function Welcome({ onImport, onInstall, onBack }: { onImport: () => void; onInstall: () => void; onBack?: () => void }) {
const t = useT();
return (
<main className="flex h-full flex-col items-center justify-center px-8">
<main className="relative flex h-full flex-col items-center justify-center px-8">
<LanguagePicker className="absolute right-6 top-5" />
<div className="mb-10 text-center">
<div className="mx-auto mb-5 h-12 w-12 rounded-full border-2 border-gold/80 bg-card-2" aria-hidden />
<h1 className="text-3xl font-semibold tracking-tight">{t("welcome.title")}</h1>
+41
View File
@@ -0,0 +1,41 @@
// Checks the UI translation files: every locale key must exist in en.ts, {placeholders} must match the English text,
// and the coverage of each language is reported. Exit code 1 on structural errors (missing key in en, placeholder mismatch).
// Usage: node tools/check-i18n.mjs
import { readFileSync } from "node:fs";
import { join, dirname } from "node:path";
import { fileURLToPath } from "node:url";
const dir = join(dirname(fileURLToPath(import.meta.url)), "..", "src", "i18n", "locales");
function load(locale) {
const src = readFileSync(join(dir, `${locale}.ts`), "utf8");
const map = new Map();
// "key": "value", — values are JSON string literals
for (const m of src.matchAll(/^\s*("(?:[^"\\]|\\.)*")\s*:\s*("(?:[^"\\]|\\.)*")\s*,?\s*$/gm)) {
map.set(JSON.parse(m[1]), JSON.parse(m[2]));
}
return map;
}
const vars = (s) => [...s.matchAll(/\{(\w+)\}/g)].map((m) => m[1]).sort().join(",");
const en = load("en");
let errors = 0;
console.log(`en: ${en.size} keys (source of truth)`);
for (const loc of ["ru", "de", "fr", "es"]) {
const d = load(loc);
let missing = 0;
for (const [k, v] of d) {
if (!en.has(k)) {
console.error(`${loc}: key not in en.ts: ${k}`);
errors++;
} else if (vars(v) !== vars(en.get(k))) {
console.error(`${loc}: placeholders differ for ${k}: {${vars(v)}} vs en {${vars(en.get(k))}}`);
errors++;
}
}
for (const k of en.keys()) if (!d.has(k)) missing++;
const pct = ((100 * (en.size - missing)) / en.size).toFixed(1);
console.log(`${loc}: ${en.size - missing}/${en.size} translated (${pct}%), ${missing} fall back to English`);
}
process.exit(errors ? 1 : 0);