no clue what the current status is

Cargo.toml

@@ -14,6 +14,12 @@ edition.workspace = true
 repository.workspace = true
 license.workspace = true
 
+[workspace.lints.clippy]
+type_complexity = "allow"
+
+[lints]
+workspace = true
+
 # Enable a small amount of optimization in debug mode
 [profile.dev]
 opt-level = 1
@@ -23,15 +29,28 @@ opt-level = 1
 opt-level = 3
 
 [workspace.dependencies]
-bevy = { version = "0.12", features = [
+bevy = { version = "0.12", default-features = false, features = [
-    "dynamic_linking",
+    #    "dynamic_linking",
     "multi-threaded",
     "trace",
 ] }
-tokio = { version = "1.34", features = ["macros", "rt-multi-thread", "signal"] }
 dcs-grpc = { path = "./crates/dcs-grpc" }
+guardian_commands = { path = "./crates/guardian_commands" }
+guardian_core = { path = "./crates/guardian_core" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tokio = { version = "1.34", features = ["macros", "rt-multi-thread", "signal"] }
+clap = { version = "4.4", features = ["derive"] }
+shlex = "1.2"
+tracing = "0.1.40"
 
 [dependencies]
-guardian_core = { path = "./crates/guardian_core" }
 bevy.workspace = true
+clap = { workspace = true, features = ["derive"] }
 tokio.workspace = true
+serde.workspace = true
+guardian_commands.workspace = true
+guardian_core.workspace = true
+tracing.workspace = true
+toml = "0.8"
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }

config.toml

@@ -0,0 +1,13 @@
+[srs]
+server = "192.168.0.100:5003"
+
+[grpc]
+url = "http://192.168.0.100:50053/"
+poll_rate = 10
+
+[stt]
+url = "http://192.168.0.2:3000/"
+
+[channels.Magic1-1]
+frequency = 266250000
+modulation = "Am"

crates/dcs-grpc/Cargo.toml

@@ -3,7 +3,7 @@ name = "dcs-grpc"
 version.workspace = true
 edition.workspace = true
 repository.workspace = true
-license.workspace = true
+license = "AGPL-3.0-or-later"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -12,9 +12,13 @@ bevy.workspace = true
 tonic = "0.10"
 prost = "0.12"
 prost-types = "0.12"
-serde = { version = "1.0", features = ["derive"] }
+serde.workspace = true
-serde_json = "1.0"
+serde_json.workspace = true
 
 [build-dependencies]
 tonic-build = "0.10.2"
 protoc-bundled = { git = "https://github.com/rkusa/protoc-bundled.git", rev = "3.21.6" }
+
+[dev-dependencies]
+serde.workspace = true
+serde_json.workspace = true

crates/dcs-grpc/LICENSE

@@ -0,0 +1,661 @@
+                    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/>.

crates/dcs-grpc/build.rs

@@ -2,20 +2,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     std::env::set_var("PROTOC", protoc_bundled::PROTOC);
     std::env::set_var("PROTOC_INCLUDE", protoc_bundled::PROTOC_INCLUDE);
 
-    println!("cargo:rerun-if-changed=migrations");
     println!("cargo:rerun-if-changed=protos/dcs");
 
     build_dcs_grpc_db()?;
 
-    // build_commands()?;
-
     Ok(())
 }
 
-// fn build_commands() -> Result<(), Box<dyn std::error::Error>> {
-//     Ok(())
-// }
-
 fn build_dcs_grpc_db() -> Result<(), Box<dyn std::error::Error>> {
     tonic_build::configure()
         .type_attribute(".", "#[derive(::serde::Serialize, ::serde::Deserialize)]")

crates/dcs-grpc/protos/dcs/common/v0/common.proto

@@ -246,6 +246,8 @@ message Group {
   string name = 2;  // The name of the group as assigned in the mission editor
   Coalition coalition = 3;     // The coalition of the group
   GroupCategory category = 4;  // The group category.
+  uint32 frequency = 5;
+  uint32 modulation = 6;
 }
 
 /**

crates/dcs-grpc/src/dcs/mod.rs

@@ -3,19 +3,6 @@
 #![allow(clippy::derive_partial_eq_without_eq)]
 #![allow(clippy::large_enum_variant)]
 
-// use crate::{call::Element, dcs::net::v0::SendChatRequest};
-// use std::{cmp::Ordering, collections::HashMap, sync::Arc, time::Duration};
-// use tokio::{sync::RwLock, time::sleep};
-
-// use self::{
-//     common::v0::Coalition,
-//     mission::v0::{
-//         mission_service_client::MissionServiceClient, stream_units_response::Update,
-//         StreamUnitsRequest,
-//     },
-//     net::v0::net_service_client::NetServiceClient,
-// };
-
 pub mod atmosphere;
 pub mod coalition;
 pub mod common;
@@ -31,248 +18,3 @@ pub mod trigger;
 pub mod unit;
 mod utils;
 pub mod world;
-
-// // In the general part of the world DCS is set in, the compass drift is about 5 degrees
-// // This should probably be configurable as it depends on the map.
-// // (I just remember reading somewhere that the heading drift is about 5°, cant find proof now but in testing it lines up)
-// // https://en.wikipedia.org/wiki/Magnetic_declination
-// // https://github.com/DCS-gRPC/rust-server/issues/197
-// const COMPASS_DRIFT: i32 = -5;
-
-// #[derive(Debug, Clone)]
-// pub struct Position {
-//     pub lat: f64,
-//     pub long: f64,
-//     pub altitude: f64,
-// }
-
-// impl Position {
-//     pub fn distance_to_km(&self, other: &Position) -> f64 {
-//         let radius_of_earth_in_km: f64 = 6371.0;
-//         let delta_lat = (other.lat - self.lat).to_radians();
-//         let delta_long = (other.long - self.long).to_radians();
-
-//         let a = (delta_lat / 2.0).sin() * (delta_lat / 2.0).sin()
-//             + self.lat.to_radians().cos()
-//                 * other.lat.to_radians().cos()
-//                 * (delta_long / 2.0).sin()
-//                 * (delta_long / 2.0).sin();
-
-//         let c = 2.0 * (a.sqrt().atan2((1.0 - a).sqrt()));
-//         radius_of_earth_in_km * c
-//     }
-
-//     pub fn distance_to_nmi(&self, other: &Position) -> f64 {
-//         self.distance_to_km(other) * 0.5399568035
-//     }
-
-//     pub fn get_bearing_to(&self, other: &Position) -> i32 {
-//         let delta_long = (other.long - self.long).to_radians();
-
-//         let y =
-//             (other.long.to_radians() - self.long.to_radians()).sin() * other.lat.to_radians().cos();
-//         let x = self.lat.to_radians().cos() * other.lat.to_radians().sin()
-//             - self.lat.to_radians().sin() * other.lat.to_radians().cos() * delta_long.cos();
-
-//         (((y.atan2(x).to_degrees() + 360.0) % 360.0) as i32) + COMPASS_DRIFT
-//     }
-
-//     pub fn feet(&self) -> f64 {
-//         self.altitude * 3.28084
-//     }
-
-//     pub fn angels(&self) -> i32 {
-//         (self.feet() / 1000.0).round() as i32
-//     }
-// }
-
-// #[derive(Debug, Clone)]
-// pub struct Unit {
-//     pub id: u32,
-//     pub name: String,
-//     pub player: Option<String>,
-//     pub callsign: String,
-//     pub group_name: Option<String>,
-//     pub coalition: i32,
-//     pub r#type: String,
-//     pub position: Position,
-//     pub heading: f64,
-//     pub speed: f64,
-// }
-
-// #[derive(Clone)]
-// pub struct RpcClient {
-//     base_url: String,
-//     units: Arc<RwLock<HashMap<u32, Unit>>>,
-// }
-
-// impl RpcClient {
-//     pub fn new(base_url: &str) -> Self {
-//         let units = Arc::new(RwLock::new(HashMap::new()));
-
-//         let db = units.clone();
-//         let url = base_url.to_owned();
-//         tokio::spawn(async move {
-//             loop {
-//                 let Ok(mut client) = MissionServiceClient::connect(url.clone()).await else {
-//                     eprintln!("Unable to connect to DCS. Make sure Dcs-gRPC is installed and available, retry in 5 seconds..");
-//                     sleep(Duration::from_secs(5)).await; // retry in 5 seconds
-//                     continue;
-//                 };
-
-//                 let Ok(mut stream) = client
-//                     .stream_units(StreamUnitsRequest {
-//                         poll_rate: Some(10),
-//                         max_backoff: Some(30),
-//                         category: common::v0::GroupCategory::Airplane as i32,
-//                     })
-//                     .await
-//                 else {
-//                     continue;
-//                 };
-
-//                 let mut message = stream.get_mut().message().await;
-//                 while let Ok(Some(next)) = &message {
-//                     if let Some(update) = &next.update {
-//                         match update {
-//                             Update::Gone(unit) => {
-//                                 db.write().await.remove(&unit.id);
-//                             }
-//                             Update::Unit(unit) => {
-//                                 let group_name = unit.group.as_ref().map(|g| g.name.clone());
-
-//                                 let lat = unit.position.as_ref().map_or(0.0, |p| p.lat);
-//                                 let long = unit.position.as_ref().map_or(0.0, |p| p.lon);
-//                                 let altitude = unit.position.as_ref().map_or(0.0, |p| p.alt);
-
-//                                 let heading = unit.orientation.as_ref().map_or(0.0, |o| o.heading);
-//                                 let speed = unit.velocity.as_ref().map_or(0.0, |v| v.speed);
-
-//                                 // println!("updated: {}", &unit.callsign);
-
-//                                 db.write().await.insert(
-//                                     unit.id,
-//                                     Unit {
-//                                         id: unit.id,
-//                                         name: unit.name.clone(),
-//                                         player: unit.player_name.clone(),
-//                                         callsign: unit.callsign.clone(),
-//                                         group_name,
-//                                         coalition: unit.coalition,
-//                                         r#type: unit.r#type.clone(),
-//                                         position: Position {
-//                                             lat,
-//                                             long,
-//                                             altitude,
-//                                         },
-//                                         heading,
-//                                         speed,
-//                                     },
-//                                 );
-//                             }
-//                         }
-//                     }
-//                     message = stream.get_mut().message().await;
-//                 }
-//                 // if we get here, something went wrong, reconnect
-//                 eprintln!("Connection lost");
-//             }
-//         });
-
-//         Self {
-//             base_url: base_url.to_string(),
-//             units,
-//         }
-//     }
-
-//     // Change to TransmitMessage when it becomes available in gRPC
-//     // https://github.com/DCS-gRPC/rust-server/blob/main/STATUS.md?plain=1#L519
-//     pub async fn send_text_message(&self, message: &str) {
-//         let Ok(mut client) = NetServiceClient::connect(self.base_url.clone()).await else {
-//             return;
-//         };
-
-//         let request = SendChatRequest {
-//             message: message.to_string(),
-//             coalition: Coalition::All as i32,
-//             // target_player_id: player_id,
-//         };
-
-//         client.send_chat(request).await.ok();
-//     }
-
-//     pub async fn get_unit_by_element(&self, element: &Element) -> Option<Unit> {
-//         // Return a unit, do the math in the command code
-//         let units = self.units.read().await;
-
-//         units
-//             .iter()
-//             .filter(|u| u.1.coalition == Coalition::Blue as i32)
-//             .map(|u| u.1)
-//             .find(|e| {
-//                 e.callsign.to_lowercase()
-//                     == format!(
-//                         "{}{}{}",
-//                         element.squadron.to_string(),
-//                         element.group,
-//                         element.unit
-//                     )
-//                     .to_lowercase()
-//             })
-//             .cloned()
-//     }
-
-//     pub async fn get_unit_by_pilot(&self, pilot: &str) -> Option<Unit> {
-//         // Return a unit, do the math in the command code
-//         let units = self.units.read().await;
-//         let pilot = pilot.to_string();
-
-//         units
-//             .iter()
-//             .filter(|u| u.1.coalition == Coalition::Blue as i32)
-//             .map(|u| u.1)
-//             .find(|e| {
-//                 let Some(player) = &e.player else {
-//                     return false;
-//                 };
-
-//                 player == &pilot
-//             })
-//             .cloned()
-//     }
-
-//     pub async fn get_nearest_hostile(&self, unit: &Unit) -> Option<Unit> {
-//         let units = self.units.read().await;
-
-//         units
-//             .iter()
-//             .filter(|u| u.1.coalition == Coalition::Red as i32) // only reds
-//             .map(|u| u.1)
-//             .min_by(|a, b| {
-//                 let a_pos = &a.position; // some hostile A position
-//                 let b_pos = &b.position; // some hostile B position
-
-//                 let a_dist = a_pos.distance_to_km(&unit.position);
-//                 let b_dist = b_pos.distance_to_km(&unit.position);
-
-//                 a_dist.partial_cmp(&b_dist).unwrap()
-//             })
-//             .cloned()
-//     }
-
-//     pub async fn get_hostiles_in_range_from(&self, unit: &Unit, distance: f64) -> Vec<Unit> {
-//         let units = self.units.read().await;
-
-//         units
-//             .iter()
-//             .filter(|u| u.1.coalition == Coalition::Red as i32) // only reds
-//             .map(|u| u.1)
-//             .filter(|a| {
-//                 let a_pos = &a.position; // some hostile A position
-//                 let a_dist = a_pos.distance_to_nmi(&unit.position);
-//                 a_dist.partial_cmp(&distance).unwrap() == Ordering::Less
-//             })
-//             .cloned()
-//             .collect::<Vec<_>>()
-//     }
-// }

crates/dcs-grpc/src/lib.rs

@@ -1 +1,3 @@
+// From https://github.com/DCS-gRPC/rust-server/
+
 pub mod dcs;

crates/guardian_commands/Cargo.toml

@@ -0,0 +1,19 @@
+# This packages is loosely(or not) based on https://github.com/RichoDemus/bevy-console
+
+[package]
+name = "guardian_commands"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap.workspace = true
+bevy.workspace = true
+shlex.workspace = true
+nom = "7.1"
+
+[lints]
+workspace = true

crates/guardian_commands/src/call.rs

@@ -0,0 +1,451 @@
+use std::fmt::Display;
+
+use nom::branch::alt;
+use nom::bytes::complete::{tag, tag_no_case};
+use nom::character::complete::{alpha1, alphanumeric1, char, multispace0};
+use nom::combinator::{map, opt, recognize};
+use nom::error::ErrorKind;
+use nom::sequence::tuple;
+use nom::{Err as NomError, IResult};
+
+#[derive(Debug)]
+pub enum Awacs {
+    Overlord,
+    Magic,
+    Wizard,
+    Focus,
+    Darkstar,
+}
+
+#[derive(Debug)]
+pub enum Receiver {
+    Awacs(Awacs),
+    Atc(String), //airfield name
+}
+
+impl Display for Receiver {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Receiver::Awacs(Awacs::Overlord) => write!(f, "Overlord"),
+            Receiver::Awacs(Awacs::Magic) => write!(f, "Magic"),
+            Receiver::Awacs(Awacs::Wizard) => write!(f, "Wizard"),
+            Receiver::Awacs(Awacs::Focus) => write!(f, "Focus"),
+            Receiver::Awacs(Awacs::Darkstar) => write!(f, "Darkstar"),
+            Receiver::Atc(airfield) => write!(f, "{}", airfield.to_owned()),
+        }
+    }
+}
+
+// impl ToString for Receiver {
+//     fn to_string(&self) -> String {
+//         match self {
+//             Receiver::Awacs(Awacs::Overlord) => "Overlord".to_string(),
+//             Receiver::Awacs(Awacs::Darkstar) => "Darkstar".to_string(),
+//             Receiver::Atc(airfield) => airfield.to_owned(),
+//         }
+//     }
+// }
+
+fn parse_receiver(input: &str) -> IResult<&str, Receiver> {
+    alt((
+        map(tag_no_case("overlord"), |_| {
+            Receiver::Awacs(Awacs::Overlord)
+        }),
+        map(tag_no_case("magic"), |_| Receiver::Awacs(Awacs::Magic)),
+        map(tag_no_case("wizard"), |_| Receiver::Awacs(Awacs::Wizard)),
+        map(tag_no_case("focus"), |_| Receiver::Awacs(Awacs::Focus)),
+        map(tag_no_case("darkstar"), |_| {
+            Receiver::Awacs(Awacs::Darkstar)
+        }),
+        map(alphanumeric1, |e: &str| Receiver::Atc(e.to_owned())), // anything else = airfield? airfields _can_ contain spaces though.. soo w... hmm... parsing that is a bitch
+    ))(input)
+}
+
+#[derive(Debug)]
+pub enum Squadron {
+    Enfield,
+    Springfield,
+    Uzi,
+    Colt,
+    Dodge,
+    Ford,
+    Chevy,
+    Pontiac,
+    Viper,
+    Venom,
+    Lobo,
+    Cowboy,
+    Python,
+    Rattler,
+    Panther,
+    Wolf,
+    Weasel,
+    Wild,
+    Ninja,
+    Jedi,
+    Hawg,
+    Boar,
+    Pig,
+    Tusk,
+    ArmyAir,
+    Apache,
+    Crow,
+    Chaos,
+    Sioux,
+    Gatling,
+    Gunslinger,
+    Hammerhead,
+    Bootleg,
+    Palehorse,
+    Carnivore,
+    Saber,
+    Hornet,
+    Squid,
+    Ragin,
+    Roman,
+    Sting,
+    Jury,
+    Joker,
+    Ram,
+    Hawk,
+    Devil,
+    Check,
+    Snake,
+    Custom(String),
+}
+
+impl ToString for Squadron {
+    fn to_string(&self) -> String {
+        match self {
+            Squadron::Enfield => "Enfield".to_string(),
+            Squadron::Springfield => "Springfield".to_string(),
+            Squadron::Uzi => "Uzi".to_string(),
+            Squadron::Colt => "Colt".to_string(),
+            Squadron::Dodge => "Dodge".to_string(),
+            Squadron::Ford => "Ford".to_string(),
+            Squadron::Chevy => "Chevy".to_string(),
+            Squadron::Hornet => "Hornet".to_string(),
+            Squadron::Pontiac => "Pontiac".to_string(),
+            Squadron::Viper => "Viper".to_string(),
+            Squadron::Venom => "Venom".to_string(),
+            Squadron::Lobo => "Lobo".to_string(),
+            Squadron::Cowboy => "Cowboy".to_string(),
+            Squadron::Python => "Python".to_string(),
+            Squadron::Rattler => "Rattler".to_string(),
+            Squadron::Panther => "Panther".to_string(),
+            Squadron::Wolf => "Wolf".to_string(),
+            Squadron::Weasel => "Weasel".to_string(),
+            Squadron::Wild => "Wild".to_string(),
+            Squadron::Ninja => "Ninja".to_string(),
+            Squadron::Jedi => "Jedi".to_string(),
+            Squadron::Hawg => "Hawg".to_string(),
+            Squadron::Boar => "Boar".to_string(),
+            Squadron::Pig => "Pig".to_string(),
+            Squadron::Tusk => "Tusk".to_string(),
+            Squadron::ArmyAir => "ArmyAir".to_string(),
+            Squadron::Apache => "Apache".to_string(),
+            Squadron::Crow => "Crow".to_string(),
+            Squadron::Chaos => "Chaos".to_string(),
+            Squadron::Sioux => "Sioux".to_string(),
+            Squadron::Gatling => "Gatling".to_string(),
+            Squadron::Gunslinger => "Gunslinger".to_string(),
+            Squadron::Hammerhead => "Hammerhead".to_string(),
+            Squadron::Bootleg => "Bootleg".to_string(),
+            Squadron::Palehorse => "Palehorse".to_string(),
+            Squadron::Carnivore => "Carnivore".to_string(),
+            Squadron::Saber => "Saber".to_string(),
+            Squadron::Squid => "Squid".to_string(),
+            Squadron::Ragin => "Ragin".to_string(),
+            Squadron::Roman => "Roman".to_string(),
+            Squadron::Sting => "Sting".to_string(),
+            Squadron::Jury => "Jury".to_string(),
+            Squadron::Joker => "Joker".to_string(),
+            Squadron::Ram => "Ram".to_string(),
+            Squadron::Hawk => "Hawk".to_string(),
+            Squadron::Devil => "Devil".to_string(),
+            Squadron::Check => "Check".to_string(),
+            Squadron::Snake => "Snake".to_string(),
+            Squadron::Custom(c) => c.to_string(),
+        }
+    }
+}
+
+impl std::str::FromStr for Squadron {
+    type Err = Box<dyn std::error::Error + Send + Sync>;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "Enfield" => Ok(Squadron::Enfield),
+            "Springfield" => Ok(Squadron::Springfield),
+            "Uzi" => Ok(Squadron::Uzi),
+            "Colt" => Ok(Squadron::Colt),
+            "Dodge" => Ok(Squadron::Dodge),
+            "Ford" => Ok(Squadron::Ford),
+            "Chevy" => Ok(Squadron::Chevy),
+            "Hornet" => Ok(Squadron::Hornet),
+            "Pontiac" => Ok(Squadron::Pontiac),
+            "Viper" => Ok(Squadron::Viper),
+            "Venom" => Ok(Squadron::Venom),
+            "Lobo" => Ok(Squadron::Lobo),
+            "Cowboy" => Ok(Squadron::Cowboy),
+            "Python" => Ok(Squadron::Python),
+            "Rattler" => Ok(Squadron::Rattler),
+            "Panther" => Ok(Squadron::Panther),
+            "Wolf" => Ok(Squadron::Wolf),
+            "Weasel" => Ok(Squadron::Weasel),
+            "Wild" => Ok(Squadron::Wild),
+            "Ninja" => Ok(Squadron::Ninja),
+            "Jedi" => Ok(Squadron::Jedi),
+            "Hawg" => Ok(Squadron::Hawg),
+            "Boar" => Ok(Squadron::Boar),
+            "Pig" => Ok(Squadron::Pig),
+            "Tusk" => Ok(Squadron::Tusk),
+            "ArmyAir" => Ok(Squadron::ArmyAir),
+            "Apache" => Ok(Squadron::Apache),
+            "Crow" => Ok(Squadron::Crow),
+            "Chaos" => Ok(Squadron::Chaos),
+            "Sioux" => Ok(Squadron::Sioux),
+            "Gatling" => Ok(Squadron::Gatling),
+            "Gunslinger" => Ok(Squadron::Gunslinger),
+            "Hammerhead" => Ok(Squadron::Hammerhead),
+            "Bootleg" => Ok(Squadron::Bootleg),
+            "Palehorse" => Ok(Squadron::Palehorse),
+            "Carnivore" => Ok(Squadron::Carnivore),
+            "Saber" => Ok(Squadron::Saber),
+            "Squid" => Ok(Squadron::Squid),
+            "Ragin" => Ok(Squadron::Ragin),
+            "Roman" => Ok(Squadron::Roman),
+            "Sting" => Ok(Squadron::Sting),
+            "Jury" => Ok(Squadron::Jury),
+            "Joker" => Ok(Squadron::Joker),
+            "Ram" => Ok(Squadron::Ram),
+            "Hawk" => Ok(Squadron::Hawk),
+            "Devil" => Ok(Squadron::Devil),
+            "Check" => Ok(Squadron::Check),
+            "Snake" => Ok(Squadron::Snake),
+            c => Ok(Squadron::Custom(c.to_string())),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Element {
+    pub squadron: Squadron,
+    pub group: u8,
+    pub unit: u8,
+}
+
+impl Display for Element {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{} {} {}",
+            self.squadron.to_string(),
+            self.group,
+            self.unit
+        )
+    }
+}
+
+fn add_spaces_around_numbers(input: &str) -> String {
+    let mut result = String::new();
+    let mut chars = input.chars().peekable();
+
+    while let Some(c) = chars.next() {
+        result.push(c);
+
+        if let Some(next_char) = chars.peek() {
+            if next_char.is_numeric() {
+                result.push(' ');
+            }
+        }
+    }
+
+    result
+}
+
+impl std::str::FromStr for Element {
+    type Err = Box<dyn std::error::Error + Send + Sync>;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let d = add_spaces_around_numbers(s);
+        let mut d = d.split(' ');
+        let squadron: Squadron = d.next().unwrap().parse()?;
+        let group: u8 = d.next().unwrap().parse()?;
+        let unit: u8 = d.next().unwrap().parse()?;
+
+        Ok(Element {
+            squadron,
+            group,
+            unit,
+        })
+    }
+}
+
+fn parse_element(input: &str) -> IResult<&str, Element> {
+    let mut parser = tuple((
+        alpha1,           // Squadron name
+        opt(multispace0), // Optional whitespace
+        opt(tuple((
+            // Optional group
+            opt(multispace0),
+            parse_group_unit,
+            opt(multispace0),
+        ))),
+        opt(char('-')),
+        opt(tuple((
+            // Optional unit
+            opt(multispace0),
+            parse_group_unit,
+            opt(multispace0),
+        ))),
+    ));
+
+    let (remainder, (squadron_str, _, group_str, _, unit_str)) = parser(input)?;
+
+    let squadron = match squadron_str.to_lowercase().as_str() {
+        "enfield" => Squadron::Enfield,
+        "springfield" => Squadron::Springfield,
+        "uzi" => Squadron::Uzi,
+        "colt" => Squadron::Colt,
+        "dodge" => Squadron::Dodge,
+        "ford" => Squadron::Ford,
+        "chevy" => Squadron::Chevy,
+        "hornet" => Squadron::Hornet,
+        "pontiac" => Squadron::Pontiac,
+        "viper" => Squadron::Viper,
+        "venom" => Squadron::Venom,
+        "lobo" => Squadron::Lobo,
+        "cowboy" => Squadron::Cowboy,
+        "python" => Squadron::Python,
+        "rattler" => Squadron::Rattler,
+        "panther" => Squadron::Panther,
+        "wolf" => Squadron::Wolf,
+        "weasel" => Squadron::Weasel,
+        "wild" => Squadron::Wild,
+        "ninja" => Squadron::Ninja,
+        "jedi" => Squadron::Jedi,
+        "hawg" => Squadron::Hawg,
+        "boar" => Squadron::Boar,
+        "pig" => Squadron::Pig,
+        "tusk" => Squadron::Tusk,
+        "armyair" => Squadron::ArmyAir,
+        "apache" => Squadron::Apache,
+        "crow" => Squadron::Crow,
+        "chaos" => Squadron::Chaos,
+        "sioux" => Squadron::Sioux,
+        "gatling" => Squadron::Gatling,
+        "gunslinger" => Squadron::Gunslinger,
+        "hammerhead" => Squadron::Hammerhead,
+        "bootleg" => Squadron::Bootleg,
+        "palehorse" => Squadron::Palehorse,
+        "carnivore" => Squadron::Carnivore,
+        "saber" => Squadron::Saber,
+        "squid" => Squadron::Squid,
+        "ragin" => Squadron::Ragin,
+        "roman" => Squadron::Roman,
+        "sting" => Squadron::Sting,
+        "jury" => Squadron::Jury,
+        "joker" => Squadron::Joker,
+        "ram" => Squadron::Ram,
+        "hawk" => Squadron::Hawk,
+        "devil" => Squadron::Devil,
+        "check" => Squadron::Check,
+        "snake" => Squadron::Snake,
+        c => Squadron::Custom(c.to_string()),
+    };
+    // _ => {
+    //     return Err(NomError::Error(nom::error::Error {
+    //         input: squadron_str,
+    //         code: ErrorKind::Alpha,
+    //     }))
+    // }
+
+    let group = group_str.unwrap_or((None, 0, None)).1;
+    let unit = unit_str.unwrap_or((None, 0, None)).1;
+
+    Ok((
+        remainder,
+        Element {
+            squadron,
+            group,
+            unit,
+        },
+    ))
+}
+
+fn parse_group_unit(input: &str) -> IResult<&str, u8> {
+    let parse_digit = map(
+        recognize(alt((
+            char('0'),
+            char('1'),
+            char('2'),
+            char('3'),
+            char('4'),
+            char('5'),
+            char('6'),
+            char('7'),
+            char('8'),
+            char('9'),
+        ))),
+        |s: &str| s.parse::<u8>().unwrap(),
+    );
+
+    let parse_word = alt((
+        map(tag("one"), |_| 1),
+        map(tag("two"), |_| 2),
+        map(tag("three"), |_| 3),
+        map(tag("four"), |_| 4),
+        map(tag("five"), |_| 5),
+        map(tag("six"), |_| 6),
+        map(tag("seven"), |_| 7),
+        map(tag("eight"), |_| 8),
+        map(tag("nine"), |_| 9),
+    ));
+
+    alt((parse_digit, parse_word))(input)
+}
+
+// #[derive(Debug)]
+// pub enum Unit {
+//     NauticalMiles,
+//     Kilometers,
+// }
+
+// #[derive(Debug)]
+// pub enum Call {
+//     RadioCheck(Awacs, Element),
+//     Shopping(Awacs, Element),
+//     LocateAirfield(Awacs, Element, String),
+//     LocateFriendly(Awacs, Element, Element),
+//     Tripwire(Awacs, Element, Option<i32>, Unit),
+// }
+
+#[derive(Debug)]
+pub struct Call {
+    pub receiver: Receiver,
+    pub element: Element,
+    pub command: String,
+}
+
+pub fn parse_call(input: &str) -> IResult<&str, Call> {
+    let mut parser = tuple((parse_receiver, multispace0, parse_element));
+
+    let (command, (receiver, _, element)) = parser(input)?;
+
+    if element.group == 0 || element.unit == 0 {
+        return Err(NomError::Error(nom::error::Error {
+            input: command,
+            code: ErrorKind::Digit,
+        }));
+    }
+
+    Ok((
+        "",
+        Call {
+            receiver,
+            element,
+            command: command.to_string(),
+        },
+    ))
+}

crates/guardian_commands/src/console.rs

@@ -0,0 +1,549 @@
+use bevy::{
+    app::{App, Startup, Update},
+    ecs::{
+        component::Tick,
+        entity::Entity,
+        event::{Event, EventReader},
+        schedule::IntoSystemConfigs,
+        system::{ResMut, Resource, SystemMeta, SystemParam},
+        world::{unsafe_world_cell::UnsafeWorldCell, World},
+    },
+    log::warn,
+};
+// use bevy::{input::keyboard::KeyboardInput, prelude::*};
+// use bevy_egui::egui::{self, Align, ScrollArea, TextEdit};
+// use bevy_egui::egui::{text::LayoutJob, text_edit::CCursorRange};
+// use bevy_egui::egui::{Context, Id};
+// use bevy_egui::{
+//     egui::{epaint::text::cursor::CCursor, Color32, FontId, TextFormat},
+//     EguiContexts,
+// };
+use clap::{builder::StyledStr, CommandFactory, FromArgMatches};
+use std::collections::BTreeMap;
+use std::marker::PhantomData;
+use std::mem;
+
+use crate::{parser, ConsoleSet};
+
+type ConsoleCommandEnteredReaderSystemParam = EventReader<'static, 'static, ConsoleCommandEntered>;
+
+/// A super-trait for command like structures
+pub trait Command: NamedCommand + CommandFactory + FromArgMatches + Sized + Resource {}
+impl<T: NamedCommand + CommandFactory + FromArgMatches + Sized + Resource> Command for T {}
+
+/// Trait used to allow uniquely identifying commands at compile time
+pub trait NamedCommand {
+    /// Return the unique command identifier (same as the command "executable")
+    fn name() -> &'static str;
+}
+
+/// Executed parsed console command.
+///
+/// Used to capture console commands which implement [`CommandName`], [`CommandArgs`] & [`CommandHelp`].
+/// These can be easily implemented with the [`ConsoleCommand`](bevy_console_derive::ConsoleCommand) derive macro.
+///
+/// # Example
+///
+/// ```
+/// # use bevy_console::ConsoleCommand;
+/// # use clap::Parser;
+/// /// Prints given arguments to the console.
+/// #[derive(Parser, ConsoleCommand)]
+/// #[command(name = "log")]
+/// struct LogCommand {
+///     /// Message to print
+///     msg: String,
+///     /// Number of times to print message
+///     num: Option<i64>,
+/// }
+///
+/// fn log_command(mut log: ConsoleCommand<LogCommand>) {
+///     if let Some(Ok(LogCommand { msg, num })) = log.take() {
+///         log.ok();
+///     }
+/// }
+/// ```
+pub struct ConsoleCommand<T> {
+    command: Option<Result<T, clap::Error>>,
+    pub raw: Option<String>,
+    pub pilot: Option<Entity>,
+    pub operator: Option<Entity>,
+}
+
+impl<T> ConsoleCommand<T> {
+    /// Returns Some(T) if the command was executed and arguments were valid.
+    ///
+    /// This method should only be called once.
+    /// Consecutive calls will return None regardless if the command occurred.
+    pub fn take(&mut self) -> Option<Result<T, clap::Error>> {
+        mem::take(&mut self.command)
+    }
+}
+
+pub struct ConsoleCommandState<T> {
+    #[allow(clippy::type_complexity)]
+    event_reader: <ConsoleCommandEnteredReaderSystemParam as SystemParam>::State,
+    marker: PhantomData<T>,
+}
+
+unsafe impl<T: Command> SystemParam for ConsoleCommand<T> {
+    type State = ConsoleCommandState<T>;
+    type Item<'w, 's> = ConsoleCommand<T>;
+
+    fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
+        let event_reader = ConsoleCommandEnteredReaderSystemParam::init_state(world, system_meta);
+        ConsoleCommandState {
+            event_reader,
+            marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    unsafe fn get_param<'w, 's>(
+        state: &'s mut Self::State,
+        system_meta: &SystemMeta,
+        world: UnsafeWorldCell<'w>,
+        change_tick: Tick,
+    ) -> Self::Item<'w, 's> {
+        let mut event_reader = ConsoleCommandEnteredReaderSystemParam::get_param(
+            &mut state.event_reader,
+            system_meta,
+            world,
+            change_tick,
+        );
+
+        let command = event_reader.read().find_map(|command| {
+            for name in parser::parse(T::name()) {
+                if name == command.command_name {
+                    let clap_command = T::command().no_binary_name(true);
+                    let arg_matches = clap_command.try_get_matches_from(command.args.iter());
+
+                    match arg_matches {
+                        Ok(matches) => match T::from_arg_matches(&matches) {
+                            Ok(from_arg_matches) => {
+                                return Some(Ok((
+                                    from_arg_matches,
+                                    command.raw.clone(),
+                                    command.pilot,
+                                    command.operator,
+                                )));
+                            }
+                            Err(err) => return Some(Err(err)),
+                        },
+                        Err(err) => {
+                            return Some(Err(err));
+                        }
+                    }
+                }
+            }
+
+            None
+        });
+
+        if let Some(Ok(command)) = command {
+            return ConsoleCommand {
+                command: Some(Ok(command.0)),
+                raw: Some(command.1),
+                pilot: Some(command.2),
+                operator: Some(command.3),
+            };
+        }
+
+        ConsoleCommand {
+            command: None,
+            raw: None,
+            pilot: None,
+            operator: None,
+        }
+    }
+}
+/// Parsed raw console command into `command` and `args`.
+#[derive(Clone, Debug, Event)]
+pub struct ConsoleCommandEntered {
+    /// the command definition
+    pub command_name: String,
+    /// the raw input string
+    pub raw: String,
+    /// Raw parsed arguments
+    pub args: Vec<String>,
+    /// Pilot making the request
+    pub pilot: Entity,
+    /// Operator responding
+    pub operator: Entity,
+}
+
+/// Events to print to the console.
+#[derive(Clone, Debug, Eq, Event, PartialEq)]
+pub struct PrintConsoleLine {
+    /// Console line
+    pub line: StyledStr,
+}
+
+impl PrintConsoleLine {
+    /// Creates a new console line to print.
+    pub const fn new(line: StyledStr) -> Self {
+        Self { line }
+    }
+}
+
+/// Console configuration
+#[derive(Clone, Resource, Default)]
+pub struct ConsoleConfiguration {
+    /// Registered console commands
+    pub commands: BTreeMap<String, clap::Command>,
+}
+
+/// Add a console commands to Bevy app.
+pub trait AddConsoleCommand {
+    /// Add a console command with a given system.
+    ///
+    /// This registers the console command so it will print with the built-in `help` console command.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::prelude::*;
+    /// # use bevy_console::{AddConsoleCommand, ConsoleCommand};
+    /// # use clap::Parser;
+    /// App::new()
+    ///     .add_console_command::<LogCommand, _>(log_command);
+    /// #
+    /// # /// Prints given arguments to the console.
+    /// # #[derive(Parser, ConsoleCommand)]
+    /// # #[command(name = "log")]
+    /// # struct LogCommand;
+    /// #
+    /// # fn log_command(mut log: ConsoleCommand<LogCommand>) {}
+    /// ```
+    fn add_console_command<T: Command, Params>(
+        &mut self,
+        system: impl IntoSystemConfigs<Params>,
+    ) -> &mut Self;
+}
+
+impl AddConsoleCommand for App {
+    fn add_console_command<T: Command, Params>(
+        &mut self,
+        system: impl IntoSystemConfigs<Params>,
+    ) -> &mut Self {
+        let sys = move |mut config: ResMut<ConsoleConfiguration>| {
+            for name in crate::parser::parse(T::name()) {
+                let command = T::command().no_binary_name(true);
+                if config.commands.contains_key(&name) {
+                    warn!(
+                        "console command '{}' already registered and was overwritten",
+                        name
+                    );
+                }
+                config.commands.insert(name.clone(), command);
+            }
+        };
+
+        self.add_systems(Startup, sys)
+            .add_systems(Update, system.in_set(ConsoleSet::Commands))
+    }
+}
+
+// /// Console open state
+// #[derive(Default, Resource)]
+// pub struct ConsoleOpen {
+//     /// Console open
+//     pub open: bool,
+// }
+
+// #[derive(Resource)]
+// pub(crate) struct ConsoleState {
+//     pub(crate) buf: String,
+//     pub(crate) scrollback: Vec<StyledStr>,
+//     pub(crate) history: VecDeque<StyledStr>,
+//     pub(crate) history_index: usize,
+// }
+
+// impl Default for ConsoleState {
+//     fn default() -> Self {
+//         ConsoleState {
+//             buf: String::default(),
+//             scrollback: Vec::new(),
+//             history: VecDeque::from([StyledStr::new()]),
+//             history_index: 0,
+//         }
+//     }
+// }
+
+// pub(crate) fn console_ui(
+//     mut egui_context: EguiContexts,
+//     config: Res<ConsoleConfiguration>,
+//     mut keyboard_input_events: EventReader<KeyboardInput>,
+//     keys: Res<Input<KeyCode>>,
+//     mut state: ResMut<ConsoleState>,
+//     mut command_entered: EventWriter<ConsoleCommandEntered>,
+//     mut console_open: ResMut<ConsoleOpen>,
+// ) {
+//     let keyboard_input_events = keyboard_input_events.iter().collect::<Vec<_>>();
+//     let ctx = egui_context.ctx_mut();
+
+//     let pressed = keyboard_input_events
+//         .iter()
+//         .any(|code| console_key_pressed(code, &config.keys));
+
+//     // always close if console open
+//     // avoid opening console if typing in another text input
+//     if pressed && (console_open.open || !ctx.wants_keyboard_input()) {
+//         console_open.open = !console_open.open;
+//     }
+
+//     if console_open.open {
+//         egui::Window::new("Console")
+//             .collapsible(false)
+//             .default_pos([config.left_pos, config.top_pos])
+//             .default_size([config.width, config.height])
+//             .resizable(true)
+//             .show(ctx, |ui| {
+//                 ui.vertical(|ui| {
+//                     let scroll_height = ui.available_height() - 30.0;
+
+//                     // Scroll area
+//                     ScrollArea::vertical()
+//                         .auto_shrink([false, false])
+//                         .stick_to_bottom(true)
+//                         .max_height(scroll_height)
+//                         .show(ui, |ui| {
+//                             ui.vertical(|ui| {
+//                                 for line in &state.scrollback {
+//                                     let mut text = LayoutJob::default();
+
+//                                     text.append(
+//                                         &line.to_string(), //TOOD: once clap supports custom styling use it here
+//                                         0f32,
+//                                         TextFormat::simple(FontId::monospace(14f32), Color32::GRAY),
+//                                     );
+
+//                                     ui.label(text);
+//                                 }
+//                             });
+
+//                             // Scroll to bottom if console just opened
+//                             if console_open.is_changed() {
+//                                 ui.scroll_to_cursor(Some(Align::BOTTOM));
+//                             }
+//                         });
+
+//                     // Separator
+//                     ui.separator();
+
+//                     // Input
+//                     let text_edit = TextEdit::singleline(&mut state.buf)
+//                         .desired_width(f32::INFINITY)
+//                         .lock_focus(true)
+//                         .font(egui::TextStyle::Monospace);
+
+//                     // Handle enter
+//                     let text_edit_response = ui.add(text_edit);
+//                     if text_edit_response.lost_focus()
+//                         && ui.input(|i| i.key_pressed(egui::Key::Enter))
+//                     {
+//                         if state.buf.trim().is_empty() {
+//                             state.scrollback.push(StyledStr::new());
+//                         } else {
+//                             let msg = format!("{}{}", config.symbol, state.buf);
+//                             state.scrollback.push(msg.into());
+//                             let cmd_string = state.buf.clone();
+//                             state.history.insert(1, cmd_string.into());
+//                             if state.history.len() > config.history_size + 1 {
+//                                 state.history.pop_back();
+//                             }
+
+//                             let mut args = Shlex::new(&state.buf).collect::<Vec<_>>();
+
+//                             if !args.is_empty() {
+//                                 let command_name = args.remove(0);
+//                                 debug!("Command entered: `{command_name}`, with args: `{args:?}`");
+
+//                                 let command = config.commands.get(command_name.as_str());
+
+//                                 if command.is_some() {
+//                                     command_entered
+//                                         .send(ConsoleCommandEntered { command_name, args });
+//                                 } else {
+//                                     debug!(
+//                                         "Command not recognized, recognized commands: `{:?}`",
+//                                         config.commands.keys().collect::<Vec<_>>()
+//                                     );
+
+//                                     state.scrollback.push("error: Invalid command".into());
+//                                 }
+//                             }
+
+//                             state.buf.clear();
+//                         }
+//                     }
+
+//                     // Clear on ctrl+l
+//                     if keyboard_input_events
+//                         .iter()
+//                         .any(|&k| k.state.is_pressed() && k.key_code == Some(KeyCode::L))
+//                         && (keys.any_pressed([KeyCode::ControlLeft, KeyCode::ControlRight]))
+//                     {
+//                         state.scrollback.clear();
+//                     }
+
+//                     // Handle up and down through history
+//                     if text_edit_response.has_focus()
+//                         && ui.input(|i| i.key_pressed(egui::Key::ArrowUp))
+//                         && state.history.len() > 1
+//                         && state.history_index < state.history.len() - 1
+//                     {
+//                         if state.history_index == 0 && !state.buf.trim().is_empty() {
+//                             *state.history.get_mut(0).unwrap() = state.buf.clone().into();
+//                         }
+
+//                         state.history_index += 1;
+//                         let previous_item = state.history.get(state.history_index).unwrap().clone();
+//                         state.buf = previous_item.to_string();
+
+//                         set_cursor_pos(ui.ctx(), text_edit_response.id, state.buf.len());
+//                     } else if text_edit_response.has_focus()
+//                         && ui.input(|i| i.key_pressed(egui::Key::ArrowDown))
+//                         && state.history_index > 0
+//                     {
+//                         state.history_index -= 1;
+//                         let next_item = state.history.get(state.history_index).unwrap().clone();
+//                         state.buf = next_item.to_string();
+
+//                         set_cursor_pos(ui.ctx(), text_edit_response.id, state.buf.len());
+//                     }
+
+//                     // Focus on input
+//                     ui.memory_mut(|m| m.request_focus(text_edit_response.id));
+//                 });
+//             });
+//     }
+// }
+
+// pub(crate) fn receive_console_line(
+//     mut console_state: ResMut<ConsoleState>,
+//     mut events: EventReader<PrintConsoleLine>,
+// ) {
+//     for event in events.iter() {
+//         let event: &PrintConsoleLine = event;
+//         console_state.scrollback.push(event.line.clone());
+//     }
+// }
+
+// fn console_key_pressed(
+//     keyboard_input: &KeyboardInput,
+//     configured_keys: &[ToggleConsoleKey],
+// ) -> bool {
+//     if !keyboard_input.state.is_pressed() {
+//         return false;
+//     }
+
+//     for configured_key in configured_keys {
+//         match configured_key {
+//             ToggleConsoleKey::KeyCode(configured_key_code) => match keyboard_input.key_code {
+//                 None => continue,
+//                 Some(pressed_key) => {
+//                     if configured_key_code == &pressed_key {
+//                         return true;
+//                     }
+//                 }
+//             },
+//             ToggleConsoleKey::ScanCode(configured_scan_code) => {
+//                 if &keyboard_input.scan_code == configured_scan_code {
+//                     return true;
+//                 }
+//             }
+//         }
+//     }
+
+//     false
+// }
+
+// fn set_cursor_pos(ctx: &Context, id: Id, pos: usize) {
+//     if let Some(mut state) = TextEdit::load_state(ctx, id) {
+//         state.set_ccursor_range(Some(CCursorRange::one(CCursor::new(pos))));
+//         state.store(ctx, id);
+//     }
+// }
+
+// #[cfg(test)]
+// mod tests {
+//     use bevy::input::ButtonState;
+
+//     use super::*;
+
+//     #[test]
+//     fn test_console_key_pressed_scan_code() {
+//         let input = KeyboardInput {
+//             scan_code: 41,
+//             key_code: None,
+//             state: ButtonState::Pressed,
+//             window: Entity::PLACEHOLDER,
+//         };
+
+//         let config = vec![ToggleConsoleKey::ScanCode(41)];
+
+//         let result = console_key_pressed(&input, &config);
+//         assert!(result);
+//     }
+
+//     #[test]
+//     fn test_console_wrong_key_pressed_scan_code() {
+//         let input = KeyboardInput {
+//             scan_code: 42,
+//             key_code: None,
+//             state: ButtonState::Pressed,
+//             window: Entity::PLACEHOLDER,
+//         };
+
+//         let config = vec![ToggleConsoleKey::ScanCode(41)];
+
+//         let result = console_key_pressed(&input, &config);
+//         assert!(!result);
+//     }
+
+//     #[test]
+//     fn test_console_key_pressed_key_code() {
+//         let input = KeyboardInput {
+//             scan_code: 0,
+//             key_code: Some(KeyCode::Grave),
+//             state: ButtonState::Pressed,
+//             window: Entity::PLACEHOLDER,
+//         };
+
+//         let config = vec![ToggleConsoleKey::KeyCode(KeyCode::Grave)];
+
+//         let result = console_key_pressed(&input, &config);
+//         assert!(result);
+//     }
+
+//     #[test]
+//     fn test_console_wrong_key_pressed_key_code() {
+//         let input = KeyboardInput {
+//             scan_code: 0,
+//             key_code: Some(KeyCode::A),
+//             state: ButtonState::Pressed,
+//             window: Entity::PLACEHOLDER,
+//         };
+
+//         let config = vec![ToggleConsoleKey::KeyCode(KeyCode::Grave)];
+
+//         let result = console_key_pressed(&input, &config);
+//         assert!(!result);
+//     }
+
+//     #[test]
+//     fn test_console_key_right_key_but_not_pressed() {
+//         let input = KeyboardInput {
+//             scan_code: 0,
+//             key_code: Some(KeyCode::Grave),
+//             state: ButtonState::Released,
+//             window: Entity::PLACEHOLDER,
+//         };
+
+//         let config = vec![ToggleConsoleKey::KeyCode(KeyCode::Grave)];
+
+//         let result = console_key_pressed(&input, &config);
+//         assert!(!result);
+//     }
+// }

crates/guardian_commands/src/lib.rs

@@ -0,0 +1,46 @@
+pub mod call;
+
+use bevy::prelude::*;
+// pub use bevy_console_derive::ConsoleCommand;
+// use bevy_egui::EguiPlugin;
+
+// use crate::commands::clear::{clear_command, ClearCommand};
+// use crate::commands::exit::{exit_command, ExitCommand};
+// use crate::commands::help::{help_command, HelpCommand};
+pub use crate::console::{
+    AddConsoleCommand, Command, ConsoleCommand, ConsoleCommandEntered, ConsoleConfiguration,
+    NamedCommand, PrintConsoleLine,
+};
+// pub use color::{Style, StyledStr};
+
+// use crate::console::ConsoleState;
+
+// mod color;
+// mod commands;
+mod console;
+mod parser;
+// mod macros;
+
+/// Console plugin.
+pub struct CommandsPlugin;
+
+#[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)]
+/// The SystemSet for console/command related systems
+pub enum ConsoleSet {
+    /// Systems executing console commands (the functionality layer).
+    /// All command handler systems are added to this set
+    Commands,
+}
+
+/// Run condition which does not run any command systems if no command was entered
+fn have_commands(commands: EventReader<ConsoleCommandEntered>) -> bool {
+    !commands.is_empty()
+}
+
+impl Plugin for CommandsPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<ConsoleConfiguration>()
+            .add_event::<ConsoleCommandEntered>()
+            .configure_sets(Update, ConsoleSet::Commands.run_if(have_commands));
+    }
+}

crates/guardian_commands/src/parser.rs

@@ -0,0 +1,194 @@
+use nom::{
+    bytes::complete::tag,
+    error::{Error, ErrorKind, ParseError},
+    sequence::delimited,
+    IResult,
+};
+
+// from https://github.com/getreu/parse-hyperlinks/blob/5af034d14aa72ffb9e705da13bf557a564b1bebf/parse-hyperlinks/src/lib.rs#L41
+fn take_until_unbalanced(
+    opening_bracket: char,
+    closing_bracket: char,
+) -> impl Fn(&str) -> IResult<&str, &str> {
+    move |i: &str| {
+        let mut index = 0;
+        let mut bracket_counter = 0;
+        while let Some(n) = &i[index..].find(&[opening_bracket, closing_bracket, '\\'][..]) {
+            index += n;
+            let mut it = i[index..].chars();
+            match it.next() {
+                Some('\\') => {
+                    // Skip the escape char `\`.
+                    index += '\\'.len_utf8();
+                    // Skip also the following char.
+                    if let Some(c) = it.next() {
+                        index += c.len_utf8();
+                    }
+                }
+                Some(c) if c == opening_bracket => {
+                    bracket_counter += 1;
+                    index += opening_bracket.len_utf8();
+                }
+                Some(c) if c == closing_bracket => {
+                    // Closing bracket.
+                    bracket_counter -= 1;
+                    index += closing_bracket.len_utf8();
+                }
+                // Can not happen.
+                _ => unreachable!(),
+            };
+            // We found the unmatched closing bracket.
+            if bracket_counter == -1 {
+                // We do not consume it.
+                index -= closing_bracket.len_utf8();
+                return Ok((&i[index..], &i[0..index]));
+            };
+        }
+
+        if bracket_counter == 0 {
+            Ok(("", i))
+        } else {
+            Err(nom::Err::Error(Error::from_error_kind(
+                i,
+                ErrorKind::TakeUntil,
+            )))
+        }
+    }
+}
+
+fn split(input: &str) -> IResult<&str, &str> {
+    let mut parser = delimited(tag("["), take_until_unbalanced('[', ']'), tag("]"));
+    parser(input)
+}
+
+fn inner_parse(input: &str, depth: usize) -> Vec<String> {
+    let mut output = vec![];
+    let start_idx = input.find('[').unwrap_or(input.len());
+
+    if start_idx > 0 && depth == 0 {
+        output.push(input[..start_idx].to_string());
+    }
+
+    if start_idx == input.len() {
+        return output;
+    }
+
+    let input = &input[start_idx..];
+
+    let splitted = split(input).unwrap();
+
+    let variants: Vec<String> = splitted
+        .1
+        .split('|')
+        .map(|v| v.to_string())
+        .collect::<Vec<_>>();
+
+    let mut temp = vec![];
+    let mut temp_str = String::new();
+    for v in &variants {
+        if v.contains('[') || v.contains(']') {
+            temp_str.push_str(v);
+            temp_str.push('|');
+        } else {
+            let len = temp_str.len();
+            if len > 0 {
+                temp.push(temp_str[..len - 1].to_string());
+                temp.push(v.to_string());
+            }
+            temp_str.clear();
+        }
+    }
+
+    let variants = if temp.is_empty() { variants } else { temp };
+
+    // check if variants need expanding
+    let mut temp = vec![];
+    for v in variants {
+        if v.contains('[') {
+            let index = v.find('[').unwrap_or(0);
+            let prepend = &v[..index];
+
+            let remainder = inner_parse(&v, depth + 1);
+            for r in &remainder {
+                let l = format!("{}{}", prepend, r);
+                temp.push(l);
+            }
+        } else {
+            temp.push(v);
+        }
+    }
+
+    let remainder = splitted.0;
+    let backup = output.clone();
+    output.clear();
+
+    for variant in temp {
+        if remainder.contains('[') {
+            let index = remainder.find('[').unwrap_or(0);
+            let prepend = &remainder[..index];
+
+            let r2 = inner_parse(remainder, depth + 1);
+
+            if !backup.is_empty() {
+                for o in &backup {
+                    for r in &r2 {
+                        let l = format!("{}{}{}{}", o, variant, prepend, r);
+                        output.push(l);
+                    }
+                }
+            } else {
+                for r in &r2 {
+                    let l = format!("{}{}{}", variant, prepend, r);
+                    output.push(l);
+                }
+            }
+        } else if !backup.is_empty() {
+            for o in &backup {
+                output.push(format!("{}{}{}", o, variant, remainder));
+            }
+        } else {
+            output.push(format!("{}{}", variant, remainder));
+        }
+    }
+
+    output
+}
+
+pub fn parse(input: &str) -> Vec<String> {
+    inner_parse(input, 0)
+}
+
+#[test]
+fn parse_test() {
+    // This works
+    assert_eq!(
+        parse("[Hello|Goodbye], World!"),
+        vec!["Hello, World!", "Goodbye, World!"]
+    );
+
+    assert_eq!(
+        parse("[Hello|Goodbye], [World|Moon]!"),
+        vec![
+            "Hello, World!",
+            "Hello, Moon!",
+            "Goodbye, World!",
+            "Goodbye, Moon!",
+        ]
+    );
+
+    assert_eq!(
+        parse("[[Heading|Bearing] [to|for]|Where is] that"),
+        vec![
+            "Heading to that",
+            "Heading for that",
+            "Bearing to that",
+            "Bearing for that",
+            "Where is that",
+        ]
+    );
+
+    assert_eq!(
+        parse("set [warning|tripwire]"),
+        vec!["set warning", "set tripwire"]
+    );
+}

crates/guardian_core/Cargo.toml

@@ -5,12 +5,37 @@ edition.workspace = true
 repository.workspace = true
 license.workspace = true
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lints]
+workspace = true
 
 [dependencies]
 bevy.workspace = true
 dcs-grpc.workspace = true
+guardian_commands.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+shlex.workspace = true
 tokio.workspace = true
+tracing.workspace = true
 async-compat = "0.2.1"
+serde_repr = "0.1"
 crossbeam-channel = "0.5.9"
 tonic = "0.10"
+tokio-util = { version = "0.7", features = ["codec", "net"] }
+tokio-stream = { version = "0.1", features = ["sync"] }
+futures-util = { version = "0.3", features = ["sink"] }
+futures-core = { version = "0.3" }
+base64 = "0.21.5"
+byteorder = "1"
+bytes = "1"
+uuid = { version = "1.1", features = ["v4"] }
+reqwest = { version = "0.11.22", features = ["blocking", "multipart"] }
+audiopus = "0.3.0-rc.0"
+thiserror = "1.0"
+symspell = "0.4.3"
+simsearch = "0.2"
+
+hound = "3.5.1"
+dasp = { version = "0.11.0", features = ["all"] }
+urlencoding = "2.1.3"
+samplerate = "0.2.4"

crates/guardian_core/src/components/awacs.rs

@@ -0,0 +1,4 @@
+use bevy::ecs::component::Component;
+
+#[derive(Component)]
+pub struct Awacs;

crates/guardian_core/src/components/callsign.rs

@@ -0,0 +1,105 @@
+use std::{
+    borrow::Cow,
+    hash::{Hash, Hasher},
+};
+
+use bevy::{
+    ecs::{component::Component, reflect::ReflectComponent},
+    reflect::{std_traits::ReflectDefault, Reflect},
+    utils::AHasher,
+};
+
+#[derive(Reflect, Component, Clone)]
+#[reflect(Component, Default, Debug)]
+pub struct Callsign {
+    hash: u64,
+    value: Cow<'static, str>,
+}
+
+impl Default for Callsign {
+    fn default() -> Self {
+        Callsign::new("")
+    }
+}
+
+fn add_spaces_around_numbers(input: &str) -> String {
+    let mut result = String::new();
+    let mut chars = input.chars().peekable();
+
+    while let Some(c) = chars.next() {
+        result.push(c);
+
+        if let Some(next_char) = chars.peek() {
+            if next_char.is_numeric() {
+                result.push(' ');
+            }
+        }
+    }
+
+    result
+}
+
+impl Callsign {
+    /// Creates a new [`Callsign`] from any string-like type.
+    ///
+    /// The internal hash will be computed immediately.
+    pub fn new(value: impl Into<Cow<'static, str>>) -> Self {
+        let value = value.into();
+
+        let mut value = Callsign { value, hash: 0 };
+        value.update_hash();
+        value
+    }
+
+    pub fn to_voice(&self) -> String {
+        let value: String = self.value.to_string();
+        let value = value.replace(' ', "");
+        let value = value.replace('-', "");
+
+        add_spaces_around_numbers(&value)
+    }
+
+    /// Sets the entity's value.
+    ///
+    /// The internal hash will be re-computed.
+    #[inline(always)]
+    pub fn set(&mut self, value: impl Into<Cow<'static, str>>) {
+        *self = Callsign::new(value);
+    }
+
+    /// Updates the value of the entity in place.
+    ///
+    /// This will allocate a new string if the value was previously
+    /// created from a borrow.
+    #[inline(always)]
+    pub fn mutate<F: FnOnce(&mut String)>(&mut self, f: F) {
+        f(self.value.to_mut());
+        self.update_hash();
+    }
+
+    /// Gets the value of the entity as a `&str`.
+    #[inline(always)]
+    pub fn as_str(&self) -> &str {
+        &self.value
+    }
+
+    fn update_hash(&mut self) {
+        let mut hasher = AHasher::default();
+        self.value.hash(&mut hasher);
+        self.hash = hasher.finish();
+    }
+}
+
+impl std::fmt::Display for Callsign {
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.value, f)
+    }
+}
+
+impl std::fmt::Debug for Callsign {
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Debug::fmt(&self.value, f)
+    }
+}

crates/guardian_core/src/components/group.rs

@@ -0,0 +1,7 @@
+use bevy::ecs::component::Component;
+
+#[derive(Debug, Component)]
+pub struct Group {
+    pub id: u32,
+    pub unit: u32,
+}

crates/guardian_core/src/components/grpc_base_url.rs

@@ -0,0 +1,94 @@
+use std::{
+    borrow::Cow,
+    hash::{Hash, Hasher},
+};
+
+use bevy::{
+    ecs::{reflect::ReflectResource, system::Resource},
+    reflect::{std_traits::ReflectDefault, Reflect},
+    utils::AHasher,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Reflect, Resource, Clone, Deserialize, Serialize)]
+#[reflect(Resource, Default, Debug)]
+pub struct GrpcBaseUrl {
+    #[serde(skip)]
+    hash: u64,
+    /// The URL of the DCS-gRPC Server
+    url: Cow<'static, str>,
+    /// The poll rate for updating the mission situation in secononds.
+    /// Lower values might cause noticeable ingame lag spikes
+    poll_rate: Option<u32>,
+}
+
+impl Default for GrpcBaseUrl {
+    fn default() -> Self {
+        GrpcBaseUrl::new("http://127.0.0.1:50051/", Some(10))
+    }
+}
+
+impl GrpcBaseUrl {
+    /// Creates a new [`GrpcBaseUrl`] from any string-like type.
+    ///
+    /// The internal hash will be computed immediately.
+    pub fn new(url: impl Into<Cow<'static, str>>, poll_rate: Option<u32>) -> Self {
+        let url = url.into();
+        let mut url = GrpcBaseUrl {
+            url,
+            hash: 0,
+            poll_rate,
+        };
+        url.update_hash();
+        url
+    }
+
+    /// Sets the entity's url.
+    ///
+    /// The internal hash will be re-computed.
+    #[inline(always)]
+    pub fn set(&mut self, url: impl Into<Cow<'static, str>>) {
+        *self = GrpcBaseUrl::new(url, self.poll_rate);
+    }
+
+    /// Updates the url of the entity in place.
+    ///
+    /// This will allocate a new string if the url was previously
+    /// created from a borrow.
+    #[inline(always)]
+    pub fn mutate<F: FnOnce(&mut String)>(&mut self, f: F) {
+        f(self.url.to_mut());
+        self.update_hash();
+    }
+
+    /// Gets the url of the entity as a `&str`.
+    #[inline(always)]
+    pub fn as_str(&self) -> &str {
+        &self.url
+    }
+
+    #[inline(always)]
+    pub fn poll_rate(&self) -> Option<u32> {
+        self.poll_rate
+    }
+
+    fn update_hash(&mut self) {
+        let mut hasher = AHasher::default();
+        self.url.hash(&mut hasher);
+        self.hash = hasher.finish();
+    }
+}
+
+impl std::fmt::Display for GrpcBaseUrl {
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.url, f)
+    }
+}
+
+impl std::fmt::Debug for GrpcBaseUrl {
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Debug::fmt(&self.url, f)
+    }
+}

crates/guardian_core/src/components/heading.rs

@@ -0,0 +1,4 @@
+use bevy::ecs::component::Component;
+
+#[derive(Debug, Component)]
+pub struct Heading(pub f64);

crates/guardian_core/src/components/id.rs

@@ -0,0 +1,22 @@
+use bevy::ecs::component::Component;
+
+#[derive(Debug, Component, Copy, Clone, PartialEq)]
+pub struct Id(u32);
+
+impl Id {
+    pub fn new(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<&Id> for u32 {
+    fn from(value: &Id) -> Self {
+        value.0
+    }
+}
+
+impl From<Id> for u32 {
+    fn from(value: Id) -> Self {
+        value.0
+    }
+}

crates/guardian_core/src/components/mod.rs

@@ -0,0 +1,27 @@
+mod awacs;
+mod callsign;
+mod group;
+mod grpc_base_url;
+mod heading;
+mod id;
+mod player;
+mod position;
+mod side;
+mod srs_socket_addr;
+mod stt_base_url;
+mod unit_type;
+mod velocity;
+
+pub use awacs::*;
+pub use callsign::*;
+pub use group::*;
+pub use grpc_base_url::*;
+pub use heading::*;
+pub use id::*;
+pub use player::*;
+pub use position::*;
+pub use side::*;
+pub use srs_socket_addr::*;
+pub use stt_base_url::*;
+pub use unit_type::*;
+pub use velocity::*;

crates/guardian_core/src/components/player.rs

@@ -0,0 +1,79 @@
+use std::{
+    borrow::Cow,
+    hash::{Hash, Hasher},
+};
+
+use bevy::{
+    ecs::{component::Component, reflect::ReflectComponent},
+    reflect::{std_traits::ReflectDefault, Reflect},
+    utils::AHasher,
+};
+
+#[derive(Reflect, Component, Clone)]
+#[reflect(Component, Default, Debug)]
+pub struct Player {
+    hash: u64,
+    value: Cow<'static, str>,
+}
+
+impl Default for Player {
+    fn default() -> Self {
+        Player::new("")
+    }
+}
+
+impl Player {
+    /// Creates a new [`Player`] from any string-like type.
+    ///
+    /// The internal hash will be computed immediately.
+    pub fn new(value: impl Into<Cow<'static, str>>) -> Self {
+        let value = value.into();
+        let mut value = Player { value, hash: 0 };
+        value.update_hash();
+        value
+    }
+
+    /// Sets the entity's value.
+    ///
+    /// The internal hash will be re-computed.
+    #[inline(always)]
+    pub fn set(&mut self, value: impl Into<Cow<'static, str>>) {
+        *self = Player::new(value);
+    }
+
+    /// Updates the value of the entity in place.
+    ///
+    /// This will allocate a new string if the value was previously
+    /// created from a borrow.
+    #[inline(always)]
+    pub fn mutate<F: FnOnce(&mut String)>(&mut self, f: F) {
+        f(self.value.to_mut());
+        self.update_hash();
+    }
+
+    /// Gets the value of the entity as a `&str`.
+    #[inline(always)]
+    pub fn as_str(&self) -> &str {
+        &self.value
+    }
+
+    fn update_hash(&mut self) {
+        let mut hasher = AHasher::default();
+        self.value.hash(&mut hasher);
+        self.hash = hasher.finish();
+    }
+}
+
+impl std::fmt::Display for Player {
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.value, f)
+    }
+}
+
+impl std::fmt::Debug for Player {
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Debug::fmt(&self.value, f)
+    }
+}

crates/guardian_core/src/components/position.rs

@@ -0,0 +1,49 @@
+use bevy::ecs::component::Component;
+
+#[derive(Debug, Component, Clone)]
+pub struct Position {
+    pub lat: f64,
+    pub long: f64,
+    pub altitude: f64,
+}
+const COMPASS_DRIFT: i32 = -5;
+
+impl Position {
+    pub fn distance_to_km(&self, other: &Position) -> f64 {
+        let radius_of_earth_in_km: f64 = 6371.0;
+        let delta_lat = (other.lat - self.lat).to_radians();
+        let delta_long = (other.long - self.long).to_radians();
+
+        let a = (delta_lat / 2.0).sin() * (delta_lat / 2.0).sin()
+            + self.lat.to_radians().cos()
+                * other.lat.to_radians().cos()
+                * (delta_long / 2.0).sin()
+                * (delta_long / 2.0).sin();
+
+        let c = 2.0 * (a.sqrt().atan2((1.0 - a).sqrt()));
+        radius_of_earth_in_km * c
+    }
+
+    pub fn distance_to_nmi(&self, other: &Position) -> f64 {
+        self.distance_to_km(other) * 0.5399568035
+    }
+
+    pub fn get_bearing_to(&self, other: &Position) -> i32 {
+        let delta_long = (other.long - self.long).to_radians();
+
+        let y =
+            (other.long.to_radians() - self.long.to_radians()).sin() * other.lat.to_radians().cos();
+        let x = self.lat.to_radians().cos() * other.lat.to_radians().sin()
+            - self.lat.to_radians().sin() * other.lat.to_radians().cos() * delta_long.cos();
+
+        (((y.atan2(x).to_degrees() + 360.0) % 360.0) as i32) + COMPASS_DRIFT
+    }
+
+    pub fn feet(&self) -> f64 {
+        self.altitude * 3.28084
+    }
+
+    pub fn angels(&self) -> i32 {
+        (self.feet() / 1000.0).round() as i32
+    }
+}

crates/guardian_core/src/components/side.rs

@@ -0,0 +1,10 @@
+use bevy::ecs::component::Component;
+
+#[derive(Debug, Component)]
+pub struct All;
+#[derive(Debug, Component)]
+pub struct Neutral;
+#[derive(Debug, Component)]
+pub struct Red;
+#[derive(Debug, Component)]
+pub struct Blue;

crates/guardian_core/src/components/srs_socket_addr.rs

@@ -0,0 +1,34 @@
+use std::net::SocketAddr;
+
+use bevy::ecs::system::Resource;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Resource, Clone, Deserialize, Serialize)]
+pub struct SrsSocketAddr(
+    /// The server details for DCS-SRS
+    SocketAddr,
+);
+
+impl Default for SrsSocketAddr {
+    fn default() -> Self {
+        Self("127.0.0.1:5002".parse().unwrap())
+    }
+}
+
+impl SrsSocketAddr {
+    pub fn new(addr: SocketAddr) -> Self {
+        Self(addr)
+    }
+}
+
+impl From<SocketAddr> for SrsSocketAddr {
+    fn from(value: SocketAddr) -> Self {
+        Self(value)
+    }
+}
+
+impl From<SrsSocketAddr> for SocketAddr {
+    fn from(value: SrsSocketAddr) -> Self {
+        value.0
+    }
+}

crates/guardian_core/src/components/stt_base_url.rs

@@ -8,27 +8,30 @@ use bevy::{
     reflect::{std_traits::ReflectDefault, Reflect},
     utils::AHasher,
 };
+use serde::{Deserialize, Serialize};
 
-#[derive(Reflect, Resource, Clone)]
+#[derive(Reflect, Resource, Clone, Deserialize, Serialize)]
 #[reflect(Resource, Default, Debug)]
-pub struct GrpcBaseUrl {
+pub struct SttBaseUrl {
+    #[serde(skip)]
     hash: u64,
+    /// The url to the [whisper-web](https://git.avii.nl/Guardian/whisper-web) instance
     url: Cow<'static, str>,
 }
 
-impl Default for GrpcBaseUrl {
+impl Default for SttBaseUrl {
     fn default() -> Self {
-        GrpcBaseUrl::new("http://127.0.0.1:50051/")
+        SttBaseUrl::new("http://127.0.0.1:3000/")
     }
 }
 
-impl GrpcBaseUrl {
+impl SttBaseUrl {
-    /// Creates a new [`GrpcBaseUrl`] from any string-like type.
+    /// Creates a new [`SttBaseUrl`] from any string-like type.
     ///
     /// The internal hash will be computed immediately.
     pub fn new(url: impl Into<Cow<'static, str>>) -> Self {
         let url = url.into();
-        let mut url = GrpcBaseUrl { url, hash: 0 };
+        let mut url = SttBaseUrl { url, hash: 0 };
         url.update_hash();
         url
     }
@@ -38,7 +41,7 @@ impl GrpcBaseUrl {
     /// The internal hash will be re-computed.
     #[inline(always)]
     pub fn set(&mut self, url: impl Into<Cow<'static, str>>) {
-        *self = GrpcBaseUrl::new(url);
+        *self = SttBaseUrl::new(url);
     }
 
     /// Updates the url of the entity in place.
@@ -64,14 +67,14 @@ impl GrpcBaseUrl {
     }
 }
 
-impl std::fmt::Display for GrpcBaseUrl {
+impl std::fmt::Display for SttBaseUrl {
     #[inline(always)]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         std::fmt::Display::fmt(&self.url, f)
     }
 }
 
-impl std::fmt::Debug for GrpcBaseUrl {
+impl std::fmt::Debug for SttBaseUrl {
     #[inline(always)]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         std::fmt::Debug::fmt(&self.url, f)

crates/guardian_core/src/components/unit_type.rs

@@ -0,0 +1,79 @@
+use std::{
+    borrow::Cow,
+    hash::{Hash, Hasher},
+};
+
+use bevy::{
+    ecs::{component::Component, reflect::ReflectComponent},
+    reflect::{std_traits::ReflectDefault, Reflect},
+    utils::AHasher,
+};
+
+#[derive(Reflect, Component, Clone)]
+#[reflect(Component, Default, Debug)]
+pub struct UnitType {
+    hash: u64,
+    value: Cow<'static, str>,
+}
+
+impl Default for UnitType {
+    fn default() -> Self {
+        UnitType::new("")
+    }
+}
+
+impl UnitType {
+    /// Creates a new [`UnitType`] from any string-like type.
+    ///
+    /// The internal hash will be computed immediately.
+    pub fn new(value: impl Into<Cow<'static, str>>) -> Self {
+        let value = value.into();
+        let mut value = UnitType { value, hash: 0 };
+        value.update_hash();
+        value
+    }
+
+    /// Sets the entity's value.
+    ///
+    /// The internal hash will be re-computed.
+    #[inline(always)]
+    pub fn set(&mut self, value: impl Into<Cow<'static, str>>) {
+        *self = UnitType::new(value);
+    }
+
+    /// Updates the value of the entity in place.
+    ///
+    /// This will allocate a new string if the value was previously
+    /// created from a borrow.
+    #[inline(always)]
+    pub fn mutate<F: FnOnce(&mut String)>(&mut self, f: F) {
+        f(self.value.to_mut());
+        self.update_hash();
+    }
+
+    /// Gets the value of the entity as a `&str`.
+    #[inline(always)]
+    pub fn as_str(&self) -> &str {
+        &self.value
+    }
+
+    fn update_hash(&mut self) {
+        let mut hasher = AHasher::default();
+        self.value.hash(&mut hasher);
+        self.hash = hasher.finish();
+    }
+}
+
+impl std::fmt::Display for UnitType {
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.value, f)
+    }
+}
+
+impl std::fmt::Debug for UnitType {
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Debug::fmt(&self.value, f)
+    }
+}

crates/guardian_core/src/components/velocity.rs

@@ -0,0 +1,14 @@
+use bevy::ecs::component::Component;
+use dcs_grpc::dcs::common::v0::Vector;
+
+#[derive(Debug, Component)]
+pub struct Velocity(pub Vector);
+
+impl Velocity {
+    pub fn speed(&self) -> f64 {
+        let x = self.0.x;
+        let y = self.0.y;
+        let z = self.0.z;
+        (x * x + y * y + z * z).sqrt()
+    }
+}

crates/guardian_core/src/dcs.rs

@@ -1,14 +1,15 @@
-mod mission;
+pub mod mission;
-mod text;
+pub mod text;
-mod voice;
 
-use crate::GrpcBaseUrl;
+use crate::components::GrpcBaseUrl;
 
-pub use self::mission::*;
+use mission::MissionPlugin;
-pub use self::text::*;
+use text::TextPlugin;
+
+// Re-export
+pub use dcs_grpc::dcs::common::v0::Coalition;
 
 use bevy::app::{App, Plugin, ScheduleRunnerPlugin};
-pub use dcs_grpc::dcs::common::v0::{Coalition, Unit};
 use std::time::Duration;
 
 pub struct DcsPlugin;

crates/guardian_core/src/dcs/mission.rs

@@ -1,24 +1,32 @@
 use std::time::Duration;
 
-use crate::{GrpcBaseUrl, TokioResource};
+use crate::{components::*, TokioResource};
 use bevy::{
-    app::{App, Plugin, PreStartup, PreUpdate},
+    app::{App, Plugin, PostUpdate, PreStartup, PreUpdate},
     core::Name,
     ecs::{
         component::Component,
         entity::Entity,
         event::{Event, EventReader, EventWriter},
+        query::With,
         system::{Commands, Query, Res},
     },
 };
 use crossbeam_channel::{unbounded, Receiver};
 use dcs_grpc::dcs::{
-    common::v0::{Coalition, GroupCategory::Airplane, Unit},
+    common::v0::{Coalition, GroupCategory, Unit},
     mission::v0::{
         mission_service_client::MissionServiceClient, stream_units_response::Update,
         StreamUnitsRequest,
     },
 };
+use tracing::{error, info, warn};
+
+#[derive(Clone)]
+enum Response {
+    Disconnected,
+    Update(Box<Update>),
+}
 
 pub struct MissionPlugin;
 
@@ -31,7 +39,8 @@ impl Plugin for MissionPlugin {
         app.add_systems(
             PreUpdate,
             (consume_stream_message, update_units, despawn_units),
-        );
+        )
+        .add_systems(PostUpdate, cleanup_after_disconnect);
     }
 }
 
@@ -40,36 +49,48 @@ fn connect_to_grpc(mut commands: Commands, tokio: Res<TokioResource>, url: Res<G
 
     let (tx, task) = unbounded();
 
+    let poll_rate = url.poll_rate();
     let url = url.to_string();
+
     handle.spawn(async move {
         loop {
             let Ok(mut client) = MissionServiceClient::connect(url.clone()).await else {
-                eprintln!("Connection failed: {}", url);
+                warn!("Connection failed: {}", url); // warn
                 tokio::time::sleep(Duration::from_secs(5)).await;
                 continue;
             };
+            info!("Connected to DCS: {}", url);
 
             let Ok(mut stream) = client
                 .stream_units(StreamUnitsRequest {
-                    poll_rate: Some(10),
+                    poll_rate,
                     max_backoff: Some(30),
-                    category: Airplane as i32,
+                    category: GroupCategory::Airplane as i32,
                 })
                 .await
             else {
                 return;
             };
 
-            let mut message = stream.get_mut().message().await;
+            loop {
-            while let Ok(Some(next)) = &message {
+                match stream.get_mut().message().await {
+                    Ok(Some(next)) => {
                         if let Some(update) = &next.update {
-                    tx.send(update.clone()).ok();
+                            tx.send(Response::Update(Box::new(update.clone()))).ok();
+                        }
+                    }
+                    Ok(None) => {
+                        break;
+                    }
+                    Err(e) => {
+                        error!("Error from gRPC: {:?}", e); // verbose or debug log
+                        break;
+                    }
+                }
             }
 
-                message = stream.get_mut().message().await;
+            warn!("Disconnected from DCS: {}", url); // warn
-            }
+            tx.send(Response::Disconnected).ok();
-
-            eprintln!("Disconnected");
             tokio::time::sleep(Duration::from_secs(5)).await;
         }
     });
@@ -77,7 +98,23 @@ fn connect_to_grpc(mut commands: Commands, tokio: Res<TokioResource>, url: Res<G
     commands.spawn(UnitsRequestMessage(task));
 }
 
-pub(crate) fn consume_stream_message(
+fn cleanup_after_disconnect(
+    mut commands: Commands,
+    disconnected: Query<Entity, With<Disconnected>>,
+    entitiews: Query<Entity, With<Id>>,
+) {
+    for d in disconnected.iter() {
+        // if there is one
+        commands.entity(d).despawn();
+
+        for ent in entitiews.iter() {
+            commands.entity(ent).despawn();
+        }
+    }
+}
+
+fn consume_stream_message(
+    mut commands: Commands,
     requests: Query<&UnitsRequestMessage>,
     mut ev_unit_updated: EventWriter<UnitUpdatedEvent>,
     mut ev_unit_gone: EventWriter<UnitGoneEvent>,
@@ -85,18 +122,23 @@ pub(crate) fn consume_stream_message(
     for stream in requests.iter() {
         if let Ok(update) = stream.0.try_recv() {
             match update {
+                Response::Update(boxed) => match *boxed {
                     Update::Gone(unit) => {
                         ev_unit_gone.send(UnitGoneEvent(unit.id));
                     }
                     Update::Unit(unit) => {
                         ev_unit_updated.send(UnitUpdatedEvent(unit));
                     }
+                },
+                Response::Disconnected => {
+                    commands.spawn(Disconnected);
+                }
             }
         }
     }
 }
 
-pub(crate) fn update_units(
+fn update_units(
     mut commands: Commands,
     units: Query<(Entity, &Id)>,
     mut ev: EventReader<UnitUpdatedEvent>,
@@ -106,14 +148,14 @@ pub(crate) fn update_units(
 
         let mut e: Option<_> = None;
         for (ent, id) in units.iter() {
-            if id.0 == event.id {
+            if &Id::new(event.id) == id {
                 e = commands.get_entity(ent);
                 break;
             }
         }
 
         if e.is_none() {
-            e = Some(commands.spawn((Id(event.id), Callsign(event.callsign.clone()))));
+            e = Some(commands.spawn((Id::new(event.id), Callsign::new(event.callsign.clone()))));
         }
 
         let Some(mut e) = e else {
@@ -132,8 +174,29 @@ pub(crate) fn update_units(
             e.insert(Heading(orientation.heading));
         }
 
+        if let Some(velocity) = &event.velocity {
+            if let Some(velocity) = &velocity.velocity {
+                e.insert(Velocity(velocity.clone()));
+            }
+        }
+
         if let Some(playername) = &event.player_name {
-            e.insert(Player(playername.clone()));
+            let playername = playername.clone();
+            e.insert(Player::new(playername.clone()));
+
+            if let Some(index) = playername.find('|') {
+                let custom_callsign = playername[..index].trim().to_string();
+
+                // testing callsign validity
+                if guardian_commands::call::parse_call(&format!(
+                    "Overlord {} radio check",
+                    custom_callsign
+                ))
+                .is_ok()
+                {
+                    e.insert(Callsign::new(custom_callsign.clone()));
+                }
+            }
         }
 
         if let Some(group) = &event.group {
@@ -145,23 +208,36 @@ pub(crate) fn update_units(
 
         e.insert(Name::new(event.name.clone()));
 
-        e.insert(UnitType(event.r#type.clone()));
+        if ["A-50", "E-3A", "E-2C", "KJ-2000"].contains(&event.r#type.as_str()) {
+            e.insert(Awacs);
+        }
 
-        e.insert(Side(
+        e.insert(UnitType::new(event.r#type.clone()));
-            Coalition::try_from(event.coalition).expect("Coalition to be correct"),
+
-        ));
+        {
+            e.remove::<All>();
+            e.remove::<Neutral>();
+            e.remove::<Red>();
+            e.remove::<Blue>();
+            match Coalition::try_from(event.coalition).expect("Coalition to be correct") {
+                Coalition::All => e.insert(All),
+                Coalition::Neutral => e.insert(Neutral),
+                Coalition::Red => e.insert(Red),
+                Coalition::Blue => e.insert(Blue),
+            };
+        }
     }
 }
 
-pub(crate) fn despawn_units(
+fn despawn_units(
     mut commands: Commands,
     units: Query<(Entity, &Id)>,
     mut ev: EventReader<UnitGoneEvent>,
 ) {
     for event in ev.read() {
-        let gid = &event.0;
+        let gid = event.0;
         for (ent, id) in units.iter() {
-            if gid == &id.0 {
+            if &Id::new(gid) == id {
                 commands.entity(ent).despawn();
             }
         }
@@ -169,83 +245,13 @@ pub(crate) fn despawn_units(
 }
 
 #[derive(Event)]
-pub(crate) struct UnitUpdatedEvent(Unit);
+struct UnitUpdatedEvent(Unit);
 
 #[derive(Event)]
-pub(crate) struct UnitGoneEvent(u32);
+struct UnitGoneEvent(u32);
 
 #[derive(Component)]
-pub(crate) struct UnitsRequestMessage(Receiver<Update>);
+struct UnitsRequestMessage(Receiver<Response>);
 
-#[derive(Debug, Component)]
+#[derive(Component)]
-pub struct Id(pub u32);
+struct Disconnected;
-
-#[derive(Debug, Component)]
-pub struct Callsign(pub String);
-
-#[derive(Debug, Component)]
-pub struct UnitType(pub String);
-
-#[derive(Debug, Component)]
-pub struct Player(pub String);
-
-#[derive(Debug, Component)]
-pub struct Side(pub Coalition);
-
-#[derive(Debug, Component)]
-pub struct Position {
-    pub lat: f64,
-    pub long: f64,
-    pub altitude: f64,
-}
-
-#[derive(Debug, Component)]
-pub struct Heading(pub f64);
-
-#[derive(Debug, Component)]
-pub struct Group {
-    pub id: u32,
-    pub unit: u32,
-}
-
-const COMPASS_DRIFT: i32 = -5;
-
-impl Position {
-    pub fn distance_to_km(&self, other: &Position) -> f64 {
-        let radius_of_earth_in_km: f64 = 6371.0;
-        let delta_lat = (other.lat - self.lat).to_radians();
-        let delta_long = (other.long - self.long).to_radians();
-
-        let a = (delta_lat / 2.0).sin() * (delta_lat / 2.0).sin()
-            + self.lat.to_radians().cos()
-                * other.lat.to_radians().cos()
-                * (delta_long / 2.0).sin()
-                * (delta_long / 2.0).sin();
-
-        let c = 2.0 * (a.sqrt().atan2((1.0 - a).sqrt()));
-        radius_of_earth_in_km * c
-    }
-
-    pub fn distance_to_nmi(&self, other: &Position) -> f64 {
-        self.distance_to_km(other) * 0.5399568035
-    }
-
-    pub fn get_bearing_to(&self, other: &Position) -> i32 {
-        let delta_long = (other.long - self.long).to_radians();
-
-        let y =
-            (other.long.to_radians() - self.long.to_radians()).sin() * other.lat.to_radians().cos();
-        let x = self.lat.to_radians().cos() * other.lat.to_radians().sin()
-            - self.lat.to_radians().sin() * other.lat.to_radians().cos() * delta_long.cos();
-
-        (((y.atan2(x).to_degrees() + 360.0) % 360.0) as i32) + COMPASS_DRIFT
-    }
-
-    pub fn feet(&self) -> f64 {
-        self.altitude * 3.28084
-    }
-
-    pub fn angels(&self) -> i32 {
-        (self.feet() / 1000.0).round() as i32
-    }
-}

crates/guardian_core/src/dcs/text.rs

@@ -15,12 +15,16 @@ use bevy::{
     reflect::{std_traits::ReflectDefault, Reflect},
     utils::AHasher,
 };
-use dcs_grpc::dcs::{
+use dcs_grpc::dcs::trigger::v0::{
-    common::v0::Coalition,
+    trigger_service_client::TriggerServiceClient, OutTextForUnitRequest,
-    net::v0::{net_service_client::NetServiceClient, SendChatRequest},
 };
 
-use crate::{GrpcBaseUrl, TokioResource};
+use tracing::info;
+
+use crate::{
+    components::{GrpcBaseUrl, Id},
+    TokioResource,
+};
 
 pub struct TextPlugin;
 
@@ -32,35 +36,38 @@ impl Plugin for TextPlugin {
 
 fn send_text_message(
     mut commands: Commands,
-    query: Query<(Entity, &TextMessage), Added<TextMessage>>,
+    query: Query<(Entity, &Id, &TextMessage), Added<TextMessage>>,
     url: Res<GrpcBaseUrl>,
     tokio: Res<TokioResource>,
 ) {
+    for (ent, id, msg) in query.iter() {
         let url = url.to_string();
 
-    for (ent, msg) in query.iter() {
         if msg.as_str().is_empty() {
-            commands.entity(ent).remove::<TextMessage>().despawn();
+            commands.entity(ent).remove::<TextMessage>();
             continue;
         }
 
         let message = msg.clone();
         let url = url.clone();
+        let id: u32 = id.into();
         tokio.0.spawn(async move {
-            let Ok(mut client) = NetServiceClient::connect(url.to_string()).await else {
+            let Ok(mut client) = TriggerServiceClient::connect(url.to_string()).await else {
                 return;
             };
 
-            let request = SendChatRequest {
+            let request = OutTextForUnitRequest {
-                message: message.to_string(),
+                text: message.to_string(),
-                coalition: Coalition::All as i32,
+                display_time: 15,
-                // target_player_id: player_id,
+                clear_view: false,
+                unit_id: id,
             };
 
-            client.send_chat(request).await.ok();
+            info!("> {}", message);
+            client.out_text_for_unit(request).await.ok();
         });
 
-        commands.entity(ent).remove::<TextMessage>().despawn();
+        commands.entity(ent).remove::<TextMessage>();
     }
 }
 

crates/guardian_core/src/lib.rs

@@ -1,12 +1,15 @@
-mod dcs;
+pub mod components;
-mod grpc_base_url;
+pub mod dcs;
+pub mod srs;
+mod tts;
 
-pub use dcs::*;
+use dcs::DcsPlugin;
-pub use grpc_base_url::*;
+use srs::SrsPlugin;
 
-use bevy::app::PluginGroup;
+use bevy::{
-use bevy::app::PluginGroupBuilder;
+    app::{PluginGroup, PluginGroupBuilder},
-use bevy::ecs::system::Resource;
+    ecs::system::Resource,
+};
 use tokio::runtime::Handle;
 
 pub struct DefaultPlugins;
@@ -14,7 +17,9 @@ pub struct DefaultPlugins;
 impl PluginGroup for DefaultPlugins {
     fn build(self) -> PluginGroupBuilder {
         #[allow(unused_mut)]
-        let mut group = PluginGroupBuilder::start::<Self>().add(DcsPlugin);
+        let mut group = PluginGroupBuilder::start::<Self>()
+            .add(DcsPlugin)
+            .add(SrsPlugin);
 
         group
     }

crates/guardian_core/src/srs.rs

@@ -0,0 +1,592 @@
+pub mod frame_queue;
+mod message;
+mod messages_codec;
+pub mod voice;
+mod voice_codec;
+mod voice_command;
+
+use guardian_commands::{call::parse_call, ConsoleCommandEntered, ConsoleConfiguration};
+use simsearch::SimSearch;
+use tracing::{debug, error, info, warn};
+pub use voice_command::VoiceCommand;
+
+use crossbeam_channel::Receiver;
+pub use message::{Modulation, RadioInfo};
+
+use std::{
+    collections::{hash_map::Entry, HashMap},
+    net::SocketAddr,
+    sync::Arc,
+    time::Duration,
+};
+
+const SRS_VERSION: &str = "1.9.0.0";
+
+use bevy::{
+    app::{Plugin, PostUpdate, Update},
+    ecs::{
+        component::Component,
+        entity::Entity,
+        event::EventWriter,
+        query::{Added, Changed, With},
+        system::{Commands, Query, Res},
+    },
+};
+use futures_util::{SinkExt, StreamExt};
+use tokio::{
+    net::{TcpStream, UdpSocket},
+    sync::{mpsc::Sender, RwLock},
+    task::JoinHandle,
+    time::sleep,
+};
+
+use tokio_util::{
+    codec::{FramedRead, FramedWrite},
+    udp::UdpFramed,
+};
+
+use crate::{
+    components::*,
+    srs::{
+        message::{Message, SyncMessage, VersionMismatchMessage},
+        voice_codec::{Encryption, Frequency},
+    },
+    tts::synthesize,
+    TokioResource,
+};
+
+use self::{
+    frame_queue::FrameQueue,
+    message::{
+        create_sguid, Client, Coalition, MessageRequest, MsgType, RadioUpdateMessage,
+        SyncMessageRequest, UpdateMessage,
+    },
+    messages_codec::MessagesCodec,
+    voice::VoiceMessage,
+    voice_codec::{VoiceCodec, VoicePacket},
+};
+
+pub struct SrsPlugin;
+
+#[derive(Component)]
+struct MessageComponent(Receiver<ReceivedMessage>);
+
+#[derive(Debug, Clone)]
+pub struct ReceivedMessage {
+    pub unit_sguid: String,
+    pub message: String,
+}
+
+impl Plugin for SrsPlugin {
+    fn build(&self, app: &mut bevy::prelude::App) {
+        app.world
+            .get_resource_or_insert_with(SrsSocketAddr::default);
+        app.add_systems(Update, (listen_srs, update_srs_position, consume_message));
+        app.add_systems(
+            PostUpdate,
+            (transmit_message, update_client_radio, handle_voice_command),
+        );
+    }
+}
+
+fn listen_srs(
+    mut commands: Commands,
+    mut units: Query<
+        (
+            Entity,
+            &Id,
+            &Callsign,
+            &Position,
+            &mut Radio,
+            Option<&Red>,
+            Option<&Blue>,
+        ),
+        Added<Radio>,
+    >,
+    tokio: Res<TokioResource>,
+    addr: Res<SrsSocketAddr>,
+    stt_url: Res<SttBaseUrl>,
+) {
+    for (ent, id, callsign, position, mut radio, red, blue) in units.iter_mut() {
+        let addr: SocketAddr = addr.clone().into();
+        let callsign = callsign.as_str().to_string();
+
+        let coalition = if red.is_some() {
+            Coalition::Red
+        } else if blue.is_some() {
+            Coalition::Blue
+        } else {
+            continue; // no coalition, no comms
+        };
+
+        let (tx, task) = crossbeam_channel::unbounded();
+        commands.entity(ent).insert(MessageComponent(task));
+
+        let client = Client {
+            client_guid: radio.sguid.clone(),
+            name: callsign.clone(),
+            seat: 0,
+            coalition,
+            allow_record: false,
+            radio_info: Some(RadioInfo {
+                radios: vec![message::Radio {
+                    enc: false,
+                    enc_key: 1,
+                    freq: radio.frequency as f64,
+                    modulation: radio.modulation,
+                    sec_freq: 1.0,
+                    retransmit: false,
+                }],
+                unit: callsign.clone(),
+                unit_id: id.into(),
+                iff: Default::default(),
+            }),
+            lat_lng_position: message::Position {
+                lat: position.lat,
+                lon: position.long,
+                alt: position.altitude,
+            },
+        };
+
+        let mut sguid = [0; 22];
+        sguid.clone_from_slice(radio.sguid.as_bytes());
+
+        let (voice_sink, mut voice_handle) = tokio::sync::mpsc::channel(128);
+        let (message_sink, mut message_handle) = tokio::sync::mpsc::channel(128);
+        let (client_sink, client_handle) = crossbeam_channel::unbounded();
+
+        radio.voice_sink = Some(voice_sink);
+        radio.message_sink = Some(message_sink);
+        commands.entity(ent).insert(ClientHandler(client_handle));
+
+        let frequency = radio.frequency;
+        let modulation = radio.modulation;
+        let id = *id;
+        let stt_url = stt_url.as_str().to_string();
+        radio.handle = Some(tokio.0.spawn(async move {
+            loop {
+                let Ok(tcp) = TcpStream::connect(addr).await else {
+                    warn!("Connection failed: {}", addr);
+                    sleep(Duration::from_secs(5)).await;
+                    continue;
+                };
+
+                let (tcp_stream, tcp_sink) = tcp.into_split();
+                let mut messages_sink = FramedWrite::new(tcp_sink, MessagesCodec::new());
+                let mut messages_stream = FramedRead::new(tcp_stream, MessagesCodec::new());
+
+                let udp = UdpSocket::bind(SocketAddr::from(([0, 0, 0, 0], 0))).await?;
+                udp.connect(addr).await?;
+
+                let mut voice_ping_interval = tokio::time::interval(Duration::from_secs(15));
+                let (mut voice_sink, mut voice_stream) = UdpFramed::new(udp, VoiceCodec::new()).split();
+
+                let mut packet_id = 1;
+
+                if let Err(e) = messages_sink.send(MessageRequest::Sync(SyncMessageRequest {
+                    msg_type: MsgType,
+                    client: client.clone(),
+                    version: SRS_VERSION.to_string(),
+                })).await {
+                    error!("Srs error: {:?}", e);
+                    sleep(Duration::from_secs(5)).await;
+                    continue;
+                };
+
+                let transmissions = Arc::new(RwLock::new(HashMap::<u32, Vec<VoicePacket>>::new()));
+
+                let frames: FrameQueue<Vec<Vec<u8>>> = FrameQueue::new();
+
+                loop {
+                    tokio::select! {
+                        Some(data) = frames.next() => {
+                            let start = tokio::time::Instant::now();
+                            for (i, frame) in data.into_iter().enumerate() {
+                                if frame.is_empty() {
+                                    continue;
+                                }
+
+                                let packet = VoicePacket {
+                                    audio_part: frame,
+                                    wav_audio_part: None,
+                                    frequencies: vec![Frequency {
+                                        freq: frequency as f64,
+                                        modulation: modulation.into(),
+                                        encryption: Encryption::None,
+                                    }],
+                                    unit_id: id.into(),
+                                    packet_id,
+                                    hop_count: 0,
+                                    transmission_sguid: sguid,
+                                    client_sguid: sguid,
+                                };
+                                voice_sink.send((packet.into(), addr)).await.ok();
+
+                                packet_id = packet_id.wrapping_add(1);
+
+                                let playtime = Duration::from_millis((i as u64 + 1) * 20); // 20m per frame count
+                                let elapsed = start.elapsed();
+                                if playtime > elapsed {
+                                    let s = playtime - elapsed;
+                                    sleep(s).await;
+                                }
+                            }
+                        }
+                        Some(data) = message_handle.recv() => {
+                            if messages_sink.send(data).await.is_err() {
+                                break;
+                            };
+                        }
+                        Some(data) = messages_stream.next() => {
+                            match data {
+                                Ok(data) => {
+                                    match &data {
+                                        Message::VersionMismatch(VersionMismatchMessage { version, .. }) => {
+                                            error!("Version mismatch {} != {}", SRS_VERSION, version);
+                                        },
+                                        Message::Sync(SyncMessage { clients, .. }) => {
+                                            for client in clients.iter() {
+                                                client_sink.send(client.clone()).ok();
+                                            }
+                                        }
+                                        Message::RadioUpdate(RadioUpdateMessage { client, .. })=> {
+                                            client_sink.send(client.clone()).ok();
+                                        }
+                                        _ => {},
+                                    }
+                                }
+                                Err(_) => {
+                                    break;
+                                }
+                            }
+                        }
+                        Some(data) = voice_handle.recv() => {
+                            // TODO: Make this configurable
+                            frames.push(synthesize("192.168.1.3:10200", data.as_str()).await?).await;
+                        }
+                        Some(data) = voice_stream.next() => {
+                            match data {
+                                Ok(data) => {
+                                    // Collect voice packets
+                                    let (data, _) = data;
+
+                                    let unit_id = data.unit_id;
+
+                                    let mut t = transmissions.write().await;
+                                    if let Entry::Vacant(e) = t.entry(unit_id)
+                                    {
+                                        e.insert(vec![data]);
+                                    } else {
+                                        let t1 = t.get_mut(&unit_id).unwrap();
+                                        t1.push(data);
+                                    }
+                                },
+                                Err(_) => {
+                                    break;
+                                }
+                            }
+                        }
+                        _ = tokio::time::sleep(Duration::from_millis(200)) => {
+                            // Process voice packets
+                            if transmissions.read().await.is_empty() {
+                                continue;
+                            }
+
+                            let mut transmissions = transmissions.write().await;
+                            for (_, data) in transmissions.iter() {
+                                let mut wav_data = vec![];
+                                let mut unit_sguid = String::new();
+                                for d in data {
+                                    unit_sguid = String::from_utf8_lossy(&d.client_sguid).to_string();
+                                    if let Some(wav) = &d.wav_audio_part {
+                                        wav_data.extend_from_slice(wav);
+                                    }
+                                }
+
+                                let Some(message) = whisper(&stt_url, &wav_data).await else {
+                                    continue;
+                                };
+
+                                tx.send(ReceivedMessage {
+                                    unit_sguid,
+                                    message
+                                }).ok();
+                            }
+                            transmissions.clear();
+                        }
+                        _ = voice_ping_interval.tick() => {
+                            if voice_sink.send((voice_codec::Packet::Ping(sguid), addr)).await.is_err() {
+                                break;
+                            };
+                        }
+                    };
+                }
+                warn!("Disconnected from SRS: {}", addr);
+            }
+            #[allow(unreachable_code)]
+            Ok(())
+        }));
+    }
+}
+
+fn consume_message(
+    mut commands: Commands,
+    messages: Query<(Entity, &MessageComponent)>,
+    units: Query<(Entity, &Sguid)>,
+) {
+    for (entity, message) in messages.iter() {
+        if let Ok(message) = message.0.try_recv() {
+            for (ent, sguid) in units.iter() {
+                if sguid.0 == message.unit_sguid {
+                    commands
+                        .entity(ent)
+                        .insert(VoiceCommand::new(message.message.clone(), entity));
+                    break;
+                }
+            }
+        }
+    }
+}
+
+fn transmit_message(
+    mut commands: Commands,
+    messages: Query<(Entity, &Radio, &VoiceMessage), Added<VoiceMessage>>,
+) {
+    for (ent, radio, msg) in messages.iter() {
+        if let Some(sink) = &radio.voice_sink {
+            sink.blocking_send(msg.clone()).ok();
+            commands.entity(ent).remove::<VoiceMessage>();
+        }
+    }
+}
+
+#[derive(Component)]
+struct Sguid(String);
+
+fn update_client_radio(
+    mut commands: Commands,
+    players: Query<(Entity, &Player), With<Player>>,
+    clients: Query<&ClientHandler>,
+) {
+    let Some(client) = clients.iter().next() else {
+        return; // there is no client handler, and if there is, we only need one
+    };
+
+    if let Ok(client) = client.0.try_recv() {
+        for (ent, player) in players.iter() {
+            if player.as_str() == client.name {
+                commands
+                    .entity(ent)
+                    .insert(Sguid(client.client_guid.clone()));
+                if let Some(radio_info) = &client.radio_info {
+                    commands.entity(ent).insert(radio_info.clone());
+                }
+            }
+        }
+    }
+}
+
+fn update_srs_position(
+    units: Query<
+        (
+            &Id,
+            &Callsign,
+            &Position,
+            &Radio,
+            Option<&Red>,
+            Option<&Blue>,
+        ),
+        Changed<Position>,
+    >,
+) {
+    for (id, callsign, position, radio, red, blue) in units.iter() {
+        let Some(message) = &radio.message_sink else {
+            continue; // no sink available
+        };
+
+        let coalition = if red.is_some() {
+            Coalition::Red
+        } else if blue.is_some() {
+            Coalition::Blue
+        } else {
+            continue; // no coalition, no comms
+        };
+
+        let callsign = callsign.as_str().to_string();
+
+        let client = Client {
+            client_guid: radio.sguid.clone(),
+            name: callsign.clone(),
+            seat: 0,
+            coalition,
+            allow_record: false,
+            radio_info: Some(RadioInfo {
+                radios: vec![message::Radio {
+                    enc: false,
+                    enc_key: 1,
+                    freq: radio.frequency as f64,
+                    modulation: radio.modulation,
+                    sec_freq: 1.0,
+                    retransmit: false,
+                }],
+                unit: callsign.clone(),
+                unit_id: id.into(),
+                iff: Default::default(),
+            }),
+            lat_lng_position: message::Position {
+                lat: position.lat,
+                lon: position.long,
+                alt: position.altitude,
+            },
+        };
+
+        message
+            .blocking_send(MessageRequest::Update(UpdateMessage {
+                msg_type: MsgType,
+                client: client.clone(),
+                version: SRS_VERSION.to_string(),
+            }))
+            .ok();
+
+        message
+            .blocking_send(MessageRequest::RadioUpdate(RadioUpdateMessage {
+                msg_type: MsgType,
+                client: client.clone(),
+                version: SRS_VERSION.to_string(),
+            }))
+            .ok();
+    }
+}
+
+fn handle_voice_command(
+    awacs: Query<(Entity, &Callsign)>,
+    cmds: Query<(Entity, &Callsign, &VoiceCommand), Changed<VoiceCommand>>,
+    config: Res<ConsoleConfiguration>,
+    mut command_entered: EventWriter<ConsoleCommandEntered>,
+) {
+    for (ent, callsign, voice_command) in cmds.iter() {
+        let Ok((awacs_ent, awacs)) = awacs.get(*voice_command.get_entity()) else {
+            continue;
+        };
+
+        let all_commands = config.commands.keys().collect::<Vec<_>>();
+
+        let rawr = voice_command.as_str().to_lowercase();
+        let rawr = rawr.replace(&['(', ')', ',', '\"', '.', ';', ':', '\'', '?'][..], " ");
+
+        if rawr.is_empty() {
+            continue;
+        }
+
+        let mut engine: SimSearch<String> = SimSearch::new();
+        for cmd in &all_commands {
+            let awacs = awacs.to_voice();
+            let awacs = awacs.split(' ').next().unwrap();
+            let str = format!("{} {} {}", awacs, callsign.to_voice(), cmd);
+            engine.insert(str.to_string(), &str);
+        }
+        let results = engine.search(&rawr);
+
+        let Some(cmd) = results.first() else {
+            // no command, casual conversations?
+            continue;
+        };
+
+        let raw = rawr.trim().to_string();
+
+        info!("Received: {}", raw);
+        info!("Interpreted as: {}", cmd);
+
+        let call = match parse_call(cmd) {
+            Ok((_, call)) => call,
+            Err(e) => {
+                debug!("Error parsing call: {:?}", e);
+                return;
+            }
+        };
+
+        let cmd = call.command;
+
+        if config.commands.get(&cmd).is_some() {
+            command_entered.send(ConsoleCommandEntered {
+                command_name: cmd.clone(),
+                raw,
+                args: vec![],
+                pilot: ent,
+                operator: awacs_ent,
+            });
+        }
+    }
+}
+
+#[derive(Component)]
+pub struct ClientHandler(Receiver<Client>);
+
+#[derive(Debug, Component)]
+pub struct Radio {
+    pub frequency: u64, // the way srs wants it
+    pub modulation: Modulation,
+    sguid: String,
+    voice_sink: Option<Sender<VoiceMessage>>,
+    message_sink: Option<Sender<MessageRequest>>,
+    handle: Option<JoinHandle<std::result::Result<(), Box<dyn std::error::Error + Send + Sync>>>>,
+}
+
+impl Radio {
+    pub fn new(frequency: u64, modulation: impl Into<Modulation>) -> Self {
+        let modulation = modulation.into();
+        Self {
+            frequency,
+            modulation,
+            sguid: create_sguid(),
+            voice_sink: None,
+            message_sink: None,
+            handle: None,
+        }
+    }
+}
+
+impl Drop for Radio {
+    fn drop(&mut self) {
+        if let Some(handle) = &self.handle {
+            handle.abort();
+        }
+    }
+}
+
+async fn whisper(url: &str, data: &[i16]) -> Option<String> {
+    use byteorder::{LittleEndian, WriteBytesExt};
+    // convert i16 to u8
+    let mut result: Vec<u8> = Vec::new();
+    for &n in data {
+        let _ = result.write_i16::<LittleEndian>(n);
+    }
+
+    let file_part = reqwest::multipart::Part::bytes(result);
+    let client = reqwest::ClientBuilder::new()
+        .timeout(Duration::from_secs(30))
+        .build()
+        .unwrap();
+    let form = reqwest::multipart::Form::new().part("file", file_part);
+    let res = client
+        .post(url.to_owned())
+        .multipart(form)
+        .header("Content-Type", "multipart/form-data")
+        .send()
+        .await;
+
+    res.ok()?.text().await.ok()?.trim().to_string().non_empty()
+}
+
+trait NonEmpty {
+    fn non_empty(self) -> Option<String>;
+}
+
+impl NonEmpty for String {
+    fn non_empty(self) -> Option<String> {
+        if self.is_empty() {
+            return None;
+        }
+        Some(self)
+    }
+}

crates/guardian_core/src/srs/frame_queue.rs

@@ -0,0 +1,32 @@
+// a queue we can push to at will
+// we need to take an item and read async,stream?
+// pull from the front, push to the back
+
+use std::{collections::VecDeque, sync::Arc};
+
+use tokio::sync::RwLock;
+
+pub struct FrameQueue<T> {
+    backend: Arc<RwLock<VecDeque<T>>>,
+}
+
+impl<T> FrameQueue<T> {
+    pub fn new() -> Self {
+        Self {
+            backend: Arc::new(RwLock::new(VecDeque::new())),
+        }
+    }
+    pub async fn push(&self, item: T) {
+        self.backend.write().await.push_back(item);
+    }
+
+    pub async fn next(&self) -> Option<T> {
+        self.backend.write().await.pop_front()
+    }
+}
+
+impl<T> Default for FrameQueue<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/guardian_core/src/srs/message.rs

@@ -0,0 +1,337 @@
+use base64::{
+    alphabet::URL_SAFE,
+    engine::{general_purpose::NO_PAD, GeneralPurpose},
+    Engine,
+};
+use bevy::ecs::component::Component;
+use serde::{Deserialize, Serialize};
+use serde_repr::{Deserialize_repr, Serialize_repr};
+use std::{
+    collections::HashMap,
+    error::Error,
+    fmt::{self, Display},
+};
+use uuid::Uuid;
+
+pub(crate) const BASE64: GeneralPurpose = base64::engine::GeneralPurpose::new(&URL_SAFE, NO_PAD);
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase", untagged)]
+pub enum Message {
+    Update(UpdateMessage),
+    Ping(PingMessage),
+    Sync(SyncMessage),
+    RadioUpdate(RadioUpdateMessage),
+    ServerSettings(ServerSettingsMessage),
+    ClientDisconnect(ClientDisconnectMessage),
+    VersionMismatch(VersionMismatchMessage),
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase", untagged)]
+pub enum MessageRequest {
+    Update(UpdateMessage),
+    Sync(SyncMessageRequest),
+    RadioUpdate(RadioUpdateMessage),
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct UpdateMessage {
+    pub msg_type: MsgType<0>,
+    pub client: Client,
+    pub version: String,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct PingMessage {
+    pub msg_type: MsgType<1>,
+    pub version: String,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct SyncMessage {
+    pub msg_type: MsgType<2>,
+    pub clients: Vec<Client>,
+    pub server_settings: HashMap<String, String>,
+    pub version: String,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct SyncMessageRequest {
+    pub msg_type: MsgType<2>,
+    pub client: Client,
+    pub version: String,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct RadioUpdateMessage {
+    pub msg_type: MsgType<3>,
+    pub client: Client,
+    pub version: String,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct ServerSettingsMessage {
+    pub msg_type: MsgType<4>,
+    pub server_settings: HashMap<String, String>,
+    pub version: String,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct ClientDisconnectMessage {
+    pub msg_type: MsgType<5>,
+    pub client: Client,
+    pub version: String,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct VersionMismatchMessage {
+    pub msg_type: MsgType<6>,
+    pub version: String,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Coalition {
+    Spectator,
+    Blue,
+    Red,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Radio {
+    pub enc: bool,
+    pub enc_key: u8,
+    pub freq: f64,
+    pub modulation: Modulation,
+    pub sec_freq: f64,
+    pub retransmit: bool,
+}
+
+impl Default for Radio {
+    fn default() -> Self {
+        Radio {
+            enc: false,
+            enc_key: 0,
+            freq: 1.0,
+            modulation: Modulation::Disabled,
+            sec_freq: 1.0,
+            retransmit: false,
+        }
+    }
+}
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Serialize_repr, Deserialize_repr)]
+#[repr(u8)]
+pub enum Modulation {
+    Am = 0,
+    Fm = 1,
+    Intercom = 2,
+    #[default]
+    Disabled = 3,
+    HaveQuick = 4,
+    Satcom = 5,
+    Mids = 6,
+}
+
+#[derive(Component, Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RadioInfo {
+    pub radios: Vec<Radio>,
+    pub unit: String,
+    pub unit_id: u32,
+    pub iff: Transponder,
+}
+
+#[derive(Debug, PartialEq, Default, Clone, Copy, Serialize_repr, Deserialize_repr)]
+#[repr(u8)]
+pub enum RadioSwitchControls {
+    #[default]
+    Hotas = 0,
+    InCockpit = 1,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct Client {
+    pub client_guid: String,
+    pub name: String,
+    pub seat: u32,
+    pub coalition: Coalition,
+    pub allow_record: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub radio_info: Option<RadioInfo>,
+    pub lat_lng_position: Position,
+}
+
+#[derive(Debug, PartialEq, Default, Clone, Serialize, Deserialize)]
+pub struct Position {
+    pub lat: f64,
+    #[serde(rename = "lng")]
+    pub lon: f64,
+    pub alt: f64,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Transponder {
+    control: IffControlMode,
+    mode1: i32,
+    mode3: i32,
+    mode4: bool,
+    mic: i32,
+    status: IffStatus,
+}
+
+#[derive(Debug, Serialize_repr, Deserialize_repr, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum IffControlMode {
+    Cockpit = 0,
+    Overlay = 1,
+    Disabled = 2,
+}
+
+#[derive(Debug, Serialize_repr, Deserialize_repr, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum IffStatus {
+    Off = 0,
+    Normal = 1,
+    Ident = 2,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct MsgType<const V: u8>;
+
+#[derive(Debug)]
+struct MsgTypeError;
+impl Error for MsgTypeError {}
+impl Display for MsgTypeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Invalid message type")
+    }
+}
+
+impl<const V: u8> Serialize for MsgType<V> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_u8(V)
+    }
+}
+
+impl<'de, const V: u8> Deserialize<'de> for MsgType<V> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = u8::deserialize(deserializer)?;
+        if value == V {
+            Ok(MsgType::<V>)
+        } else {
+            Err(serde::de::Error::custom(MsgTypeError))
+        }
+    }
+}
+
+impl Default for Transponder {
+    fn default() -> Self {
+        Transponder {
+            control: IffControlMode::Disabled,
+            mode1: -1,
+            mode3: -1,
+            mode4: false,
+            mic: -1,
+            status: IffStatus::Off,
+        }
+    }
+}
+
+impl ::serde::Serialize for Coalition {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: ::serde::Serializer,
+    {
+        // Serialize the enum as a u64.
+        serializer.serialize_u64(match *self {
+            Coalition::Spectator => 0,
+            Coalition::Red => 1,
+            Coalition::Blue => 2,
+        })
+    }
+}
+
+impl<'de> ::serde::Deserialize<'de> for Coalition {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: ::serde::Deserializer<'de>,
+    {
+        struct Visitor;
+
+        impl<'de> ::serde::de::Visitor<'de> for Visitor {
+            type Value = Coalition;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("positive integer or string")
+            }
+
+            fn visit_u64<E>(self, value: u64) -> Result<Coalition, E>
+            where
+                E: ::serde::de::Error,
+            {
+                // Rust does not come with a simple way of converting a
+                // number to an enum, so use a big `match`.
+                match value {
+                    0 => Ok(Coalition::Spectator),
+                    1 => Ok(Coalition::Red),
+                    2 => Ok(Coalition::Blue),
+                    _ => Err(E::custom(format!(
+                        "unknown {} value: {}",
+                        stringify!(Coalition),
+                        value
+                    ))),
+                }
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                let value = value.to_lowercase().clone();
+                let value = value.as_str();
+
+                match value {
+                    "spectator" => Ok(Coalition::Spectator),
+                    "red" => Ok(Coalition::Red),
+                    "blue" => Ok(Coalition::Blue),
+                    _ => Err(E::custom(format!(
+                        "unknown {} value: {}",
+                        stringify!(Coalition),
+                        value
+                    ))),
+                }
+            }
+        }
+
+        // Deserialize the enum from a u64.
+        deserializer.deserialize_u64(Visitor)
+    }
+}
+
+pub fn create_sguid() -> String {
+    let sguid = Uuid::new_v4();
+    // let sguid = base64::encode_config(sguid.as_bytes(), base64::URL_SAFE_NO_PAD);
+
+    let sguid = BASE64.encode(sguid.as_bytes());
+
+    assert_eq!(sguid.len(), 22);
+    sguid
+}

crates/guardian_core/src/srs/messages_codec.rs

@@ -0,0 +1,97 @@
+use std::{error, fmt, io};
+
+use bytes::BytesMut;
+use tokio_util::codec::{Decoder, Encoder, LinesCodec, LinesCodecError};
+
+use super::message::{Message, MessageRequest};
+
+pub struct MessagesCodec {
+    lines_codec: LinesCodec,
+}
+
+impl MessagesCodec {
+    pub fn new() -> Self {
+        MessagesCodec {
+            lines_codec: LinesCodec::new(),
+        }
+    }
+}
+
+impl Decoder for MessagesCodec {
+    type Item = Message;
+    type Error = MessagesCodecError;
+
+    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if let Some(line) = self.lines_codec.decode(buf)? {
+            match serde_json::from_str(&line) {
+                Ok(msg) => Ok(Some(msg)),
+                Err(err) => Err(MessagesCodecError::JsonDecode(err, line)),
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if let Some(line) = self.lines_codec.decode_eof(buf)? {
+            match serde_json::from_str(&line) {
+                Ok(msg) => Ok(Some(msg)),
+                Err(err) => Err(MessagesCodecError::JsonDecode(err, line)),
+            }
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+impl Encoder<MessageRequest> for MessagesCodec {
+    type Error = MessagesCodecError;
+
+    fn encode(&mut self, msg: MessageRequest, buf: &mut BytesMut) -> Result<(), Self::Error> {
+        let json = serde_json::to_string(&msg).map_err(MessagesCodecError::JsonEncode)?;
+        self.lines_codec.encode(json, buf)?;
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub enum MessagesCodecError {
+    JsonDecode(serde_json::Error, String),
+    JsonEncode(serde_json::Error),
+    LinesCodec(LinesCodecError),
+    Io(io::Error),
+}
+
+impl fmt::Display for MessagesCodecError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            MessagesCodecError::JsonDecode(_, json) => write!(f, "failed to decode JSON: {json}"),
+            MessagesCodecError::JsonEncode(_) => write!(f, "failed to encode JSON"),
+            MessagesCodecError::LinesCodec(err) => err.fmt(f),
+            MessagesCodecError::Io(err) => err.fmt(f),
+        }
+    }
+}
+
+impl error::Error for MessagesCodecError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self {
+            MessagesCodecError::JsonDecode(ref err, _) => Some(err),
+            MessagesCodecError::JsonEncode(ref err) => Some(err),
+            MessagesCodecError::LinesCodec(ref err) => Some(err),
+            MessagesCodecError::Io(ref err) => Some(err),
+        }
+    }
+}
+
+impl From<io::Error> for MessagesCodecError {
+    fn from(err: io::Error) -> Self {
+        MessagesCodecError::Io(err)
+    }
+}
+
+impl From<LinesCodecError> for MessagesCodecError {
+    fn from(err: LinesCodecError) -> Self {
+        MessagesCodecError::LinesCodec(err)
+    }
+}

crates/guardian_core/src/srs/voice.rs

@@ -4,24 +4,11 @@ use std::{
 };
 
 use bevy::{
-    app::Plugin,
     ecs::{component::Component, reflect::ReflectComponent},
     reflect::{std_traits::ReflectDefault, Reflect},
     utils::AHasher,
 };
 
-pub struct SrsPlugin;
-
-impl Plugin for SrsPlugin {
-    fn build(&self, app: &mut bevy::prelude::App) {
-        todo!()
-    }
-}
-
-fn connect_srs() {
-    // will emit strings as commands
-}
-
 #[derive(Reflect, Component, Clone)]
 #[reflect(Component, Default, Debug)]
 pub struct VoiceMessage {
@@ -35,6 +22,7 @@ impl Default for VoiceMessage {
     }
 }
 
+#[allow(unused)]
 impl VoiceMessage {
     /// Creates a new [`VoiceMessage`] from any string-like type.
     ///

crates/guardian_core/src/srs/voice_codec.rs

@@ -0,0 +1,324 @@
+use std::{
+    io::{self, Cursor, Read, Write},
+    mem::size_of,
+};
+
+use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+use bytes::{BufMut, BytesMut};
+use tokio_util::codec::{Decoder, Encoder, LengthDelimitedCodec};
+
+use super::message;
+
+pub const GUID_LENGTH: usize = 22;
+
+pub const PACKET_HEADER_LENGTH: usize = size_of::<u16>() // UInt16 Packet Length - 2 bytes
+    + size_of::<u16>() // UInt16 AudioPart1 Length - 2 bytes
+    + size_of::<u16>(); // UInt16 FrequencyPart Length - 2 bytes
+
+pub const FREQUENCY_SEGMENT_LENGTH: usize = size_of::<f64>() // double Frequency - 8 bytes
+    + size_of::<u8>() // byte Modulation - 1 byte
+    + size_of::<u8>(); // byte Encryption - 1 byte
+
+pub const FIXED_PACKET_LENGTH: usize = size_of::<u32>() // UInt UnitId - 4 bytes
+    + size_of::<u64>() // UInt64 PacketId - 8 bytes
+    + size_of::<u8>() // Byte indicating number of hops for this message // default is 0
+    + GUID_LENGTH // Bytes / ASCII String Transmission GUID - 22 bytes
+    + GUID_LENGTH; // Bytes / ASCII String GUID - 22 bytes
+
+pub const PACKET_NON_AUDIO_DATA_SIZE: usize =
+    PACKET_HEADER_LENGTH + FIXED_PACKET_LENGTH + FREQUENCY_SEGMENT_LENGTH;
+
+pub struct VoiceCodec {
+    inner: LengthDelimitedCodec,
+    is_head: bool,
+}
+
+impl VoiceCodec {
+    pub fn new() -> Self {
+        VoiceCodec {
+            inner: LengthDelimitedCodec::builder()
+                .length_field_offset(0)
+                .length_field_length(2)
+                .length_adjustment(-2)
+                .little_endian()
+                .new_codec(),
+            is_head: true,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Modulation {
+    Am,
+    Fm,
+    Intercom,
+    Disabled,
+}
+
+impl From<message::Modulation> for Modulation {
+    fn from(value: message::Modulation) -> Self {
+        match value {
+            super::Modulation::Am => Modulation::Am,
+            super::Modulation::Fm => Modulation::Fm,
+            super::Modulation::Intercom => Modulation::Intercom,
+            super::Modulation::Disabled => Modulation::Disabled,
+            super::Modulation::HaveQuick => Modulation::Disabled,
+            super::Modulation::Satcom => Modulation::Disabled,
+            super::Modulation::Mids => Modulation::Disabled,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Encryption {
+    None,
+    JustOverlay,
+    Full,
+    CockpitToggleOverlayCode,
+}
+
+#[derive(Debug, Clone)]
+pub struct Frequency {
+    pub freq: f64,
+    pub modulation: Modulation,
+    pub encryption: Encryption,
+}
+
+#[derive(Debug)]
+pub enum Packet {
+    Ping([u8; 22]),
+    Voice(VoicePacket),
+}
+
+#[derive(Debug)]
+pub struct VoicePacket {
+    // TODO: use Bytes instead?
+    pub audio_part: Vec<u8>,
+    pub wav_audio_part: Option<Vec<i16>>,
+    pub frequencies: Vec<Frequency>,
+    pub unit_id: u32,
+    pub packet_id: u64,
+    pub hop_count: u8,
+    pub transmission_sguid: [u8; 22],
+    pub client_sguid: [u8; 22],
+}
+
+impl Decoder for VoiceCodec {
+    type Item = VoicePacket;
+    type Error = io::Error;
+
+    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        // discard ping messages
+        if self.is_head && buf.len() <= 22 {
+            return Ok(None);
+        }
+
+        if buf.len() < PACKET_NON_AUDIO_DATA_SIZE {
+            return Ok(None);
+        }
+
+        if let Some(bytes) = self.inner.decode(buf)? {
+            self.is_head = true;
+
+            let len = bytes.len() as u64;
+            let mut rd = Cursor::new(bytes);
+
+            let len_audio_part = rd.read_u16::<LittleEndian>()? as u64;
+            let len_frequencies = rd.read_u16::<LittleEndian>()? as u64;
+
+            assert_eq!(
+                len,
+                4 + len_audio_part + len_frequencies + 4 + 8 + 1 + 22 + 22
+            );
+
+            let mut audio_part = vec![0u8; len_audio_part as usize];
+            rd.read_exact(&mut audio_part)?;
+
+            let wav_audio_part = opus_to_wav(&audio_part).unwrap();
+
+            let len_before = rd.position();
+            let mut frequencies = Vec::new();
+            while rd.position() - len_before < len_frequencies {
+                let freq = rd.read_f64::<LittleEndian>()?;
+                let modulation = match rd.read_u8()? {
+                    0 => Modulation::Am,
+                    1 => Modulation::Fm,
+                    2 => Modulation::Intercom,
+                    3 => Modulation::Disabled,
+                    _ => Modulation::Am,
+                };
+                let encryption = match rd.read_u8()? {
+                    0 => Encryption::None,
+                    1 => Encryption::JustOverlay,
+                    2 => Encryption::Full,
+                    3 => Encryption::CockpitToggleOverlayCode,
+                    _ => Encryption::None,
+                };
+                frequencies.push(Frequency {
+                    freq,
+                    modulation,
+                    encryption,
+                });
+            }
+
+            let unit_id = rd.read_u32::<LittleEndian>()?;
+            let packet_id = rd.read_u64::<LittleEndian>()?;
+            let hop_count = rd.read_u8()?;
+
+            let mut transmission_sguid = [0; 22];
+            rd.read_exact(&mut transmission_sguid)?;
+
+            let mut client_sguid = [0; 22];
+            rd.read_exact(&mut client_sguid)?;
+
+            assert_eq!(rd.position(), len);
+
+            Ok(Some(VoicePacket {
+                audio_part,
+                wav_audio_part: Some(wav_audio_part),
+                frequencies,
+                unit_id,
+                packet_id,
+                hop_count,
+                transmission_sguid,
+                client_sguid,
+            }))
+        } else {
+            self.is_head = false;
+            Ok(None)
+        }
+    }
+
+    fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        self.decode(buf)
+    }
+}
+
+impl Encoder<Packet> for VoiceCodec {
+    type Error = io::Error;
+
+    fn encode(&mut self, packet: Packet, buf: &mut BytesMut) -> Result<(), Self::Error> {
+        let packet = match packet {
+            Packet::Ping(sguid) => {
+                buf.put_slice(&sguid);
+                return Ok(());
+            }
+            Packet::Voice(packet) => packet,
+        };
+
+        // Packet format as specified in
+        // https://github.com/ciribob/DCS-SimpleRadioStandalone/blob/1.9.3.0/DCS-SR-Common/Network/UDPVoicePacket.cs#L9
+        /*
+         * UDP PACKET LAYOUT
+         *
+         * - HEADER SEGMENT
+         * UInt16 Packet Length - 2 bytes
+         * UInt16 AudioPart1 Length - 2 bytes
+         * UInt16 FrequencyPart Length - 2 bytes
+         * - AUDIO SEGMENT
+         * Bytes AudioPart1 - variable bytes
+         * - FREQUENCY SEGMENT (one or multiple)
+         * double Frequency - 8 bytes
+         * byte Modulation - 1 byte
+         * byte Encryption - 1 byte
+         * - FIXED SEGMENT
+         * UInt UnitId - 4 bytes
+         * UInt64 PacketId - 8 bytes
+         * byte Retransmit / node / hop count - 1 byte
+         * Bytes / ASCII String TRANSMISSION GUID - 22 bytes used for transmission relay
+         * Bytes / ASCII String CLIENT GUID - 22 bytes
+         */
+
+        // NOTE: the final packet will start with the total packet length, but this will be added
+        // by the inner fixed codec
+        let header_length = 2 + 2;
+        let frequency_length = 8 + 1 + 1;
+        let audio_length = packet.audio_part.len();
+        let fixed_segment_length = 4 + 8 + 1 + 22 + 22;
+
+        let capacity = header_length
+            + audio_length
+            + frequency_length * packet.frequencies.len()
+            + fixed_segment_length;
+        let mut wd = Cursor::new(Vec::with_capacity(capacity));
+
+        // header segment will be written at the end
+        wd.set_position(4);
+
+        // - AUDIO SEGMENT
+        let len_before = wd.position();
+        wd.write_all(&packet.audio_part)?;
+        let len_audio_part = wd.position() - len_before;
+
+        // - FREQUENCY SEGMENT
+        let len_before = wd.position();
+        for f in packet.frequencies {
+            wd.write_f64::<LittleEndian>(f.freq)?;
+
+            wd.write_u8(match f.modulation {
+                Modulation::Am => 0,
+                Modulation::Fm => 1,
+                Modulation::Intercom => 2,
+                Modulation::Disabled => 3,
+            })?;
+            wd.write_u8(match f.encryption {
+                Encryption::None => 0,
+                Encryption::JustOverlay => 1,
+                Encryption::Full => 2,
+                Encryption::CockpitToggleOverlayCode => 3,
+            })?;
+        }
+
+        let len_frequency = wd.position() - len_before;
+
+        // - FIXED SEGMENT
+        wd.write_u32::<LittleEndian>(packet.unit_id)?;
+        wd.write_u64::<LittleEndian>(packet.packet_id)?;
+        wd.write_u8(packet.hop_count)?; // retransmission hop count
+        wd.write_all(&packet.transmission_sguid)?; // transmission guid
+        wd.write_all(&packet.client_sguid)?; // client guid
+
+        // - HEADER SEGMENT
+        wd.set_position(0);
+
+        // Packet Length:
+        // the final packet will start with the total packet length, but this will be added by
+        // the inner fixed codec
+
+        // AudioPart1 Length
+        wd.write_u16::<LittleEndian>(len_audio_part as u16)?;
+        // FrequencyPart Length
+        wd.write_u16::<LittleEndian>(len_frequency as u16)?;
+
+        let frame = wd.into_inner();
+        assert_eq!(frame.len(), capacity);
+
+        self.inner.encode(frame.into(), buf)
+    }
+}
+
+impl From<VoicePacket> for Packet {
+    fn from(p: VoicePacket) -> Self {
+        Packet::Voice(p)
+    }
+}
+
+const INPUT_SAMPLE_RATE: usize = 16000;
+const INPUT_AUDIO_LENGTH: usize = 20; //ms
+const FRAME_SIZE: usize = INPUT_SAMPLE_RATE / 1000 * INPUT_AUDIO_LENGTH;
+
+pub(crate) fn opus_to_wav(opus: &[u8]) -> Result<Vec<i16>, Box<dyn std::error::Error>> {
+    use audiopus::coder::Decoder;
+    use audiopus::packet::Packet;
+    use audiopus::{Channels, MutSignals, SampleRate};
+
+    let packet: Packet = opus.try_into()?;
+
+    let mut pcm_audio_short = vec![0i16; FRAME_SIZE * 2]; //[0i16; FRAME_SIZE];
+    let signals = MutSignals::try_from(&mut pcm_audio_short)?;
+
+    let mut decoder = Decoder::new(SampleRate::Hz16000, Channels::Mono)?;
+    decoder.decode(Some(packet), signals, false)?; // BadArgument, huh?!
+
+    Ok(pcm_audio_short)
+}

crates/guardian_core/src/srs/voice_command.rs

@@ -0,0 +1,81 @@
+use std::{
+    borrow::Cow,
+    hash::{Hash, Hasher},
+};
+
+use bevy::{
+    ecs::{component::Component, entity::Entity},
+    utils::AHasher,
+};
+
+#[derive(Component, Clone)]
+pub struct VoiceCommand {
+    hash: u64,
+    message: Cow<'static, str>,
+    entity: Entity,
+}
+
+#[allow(unused)]
+impl VoiceCommand {
+    /// Creates a new [`VoiceCommand`] from any string-like type.
+    ///
+    /// The internal hash will be computed immediately.
+    pub fn new(message: impl Into<Cow<'static, str>>, entity: Entity) -> Self {
+        let message = message.into();
+        let mut message = VoiceCommand {
+            message,
+            hash: 0,
+            entity,
+        };
+        message.update_hash();
+        message
+    }
+
+    /// Sets the entity's message.
+    ///
+    /// The internal hash will be re-computed.
+    #[inline(always)]
+    pub fn set(&mut self, message: impl Into<Cow<'static, str>>) {
+        *self = VoiceCommand::new(message, self.entity);
+    }
+
+    pub fn get_entity(&self) -> &Entity {
+        &self.entity
+    }
+
+    /// Updates the message of the entity in place.
+    ///
+    /// This will allocate a new string if the message was previously
+    /// created from a borrow.
+    #[inline(always)]
+    pub fn mutate<F: FnOnce(&mut String)>(&mut self, f: F) {
+        f(self.message.to_mut());
+        self.update_hash();
+    }
+
+    /// Gets the message of the entity as a `&str`.
+    #[inline(always)]
+    pub fn as_str(&self) -> &str {
+        &self.message
+    }
+
+    fn update_hash(&mut self) {
+        let mut hasher = AHasher::default();
+        self.message.hash(&mut hasher);
+        self.hash = hasher.finish();
+    }
+}
+
+impl std::fmt::Display for VoiceCommand {
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.message, f)
+    }
+}
+
+impl std::fmt::Debug for VoiceCommand {
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Debug::fmt(&self.message, f)
+    }
+}

crates/guardian_core/src/tts.rs

@@ -0,0 +1,209 @@
+use std::io::Cursor;
+
+use bevy::log;
+use dasp::interpolate::sinc::Sinc;
+use dasp::ring_buffer;
+use dasp::signal;
+use dasp::Sample;
+use dasp::Signal;
+
+use hound::WavSpec;
+use hound::WavWriter;
+use tokio::io::AsyncReadExt;
+use tokio::io::AsyncWriteExt;
+use tokio::net::TcpStream;
+use tokio::net::ToSocketAddrs;
+
+use serde::Deserialize;
+use serde::Serialize;
+
+#[derive(Debug, Deserialize)]
+pub struct Packet {
+    #[serde(rename = "type")]
+    pub r#type: String,
+    pub version: String,
+    pub data_length: Option<usize>,
+    pub payload_length: Option<usize>,
+}
+
+#[derive(Serialize)]
+struct RequestData {
+    text: String,
+}
+
+#[derive(Serialize)]
+struct Request {
+    r#type: String,
+    data: RequestData,
+}
+
+pub async fn synthesize<A: ToSocketAddrs>(
+    addr: A,
+    text: &str,
+) -> Result<Vec<Vec<u8>>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+    let stream = TcpStream::connect(addr).await?;
+
+    let (mut read, mut write) = tokio::io::split(stream);
+
+    let request = Request {
+        r#type: "synthesize".to_string(),
+        data: RequestData {
+            text: text.to_string(),
+        },
+    };
+
+    let mut request = serde_json::to_string(&request)?;
+    request.push('\n');
+
+    write.write_all(request.as_bytes()).await?;
+
+    let mut str = String::new();
+    let mut pcm_buffer: Vec<u8> = Vec::new();
+    loop {
+        let Ok(c) = read.read_u8().await else {
+            log::error!("Unable to read byte");
+            break;
+        };
+
+        if c == b'\n' {
+            let Ok(packet) = serde_json::from_str::<Packet>(&str) else {
+                log::error!("Unable to read packet from: {}", str);
+                break;
+            };
+            str = String::new();
+
+            if let Some(length) = packet.data_length {
+                let mut buf = (0..length).map(|_| 0u8).collect::<Vec<_>>();
+
+                if let Err(e) = read.read_exact(&mut buf).await {
+                    log::error!("Unable to read data: {:?}", e);
+                    break;
+                }
+            };
+
+            if let Some(length) = packet.payload_length {
+                let mut buf = (0..length).map(|_| 0u8).collect::<Vec<_>>();
+
+                if let Err(e) = read.read_exact(&mut buf).await {
+                    log::error!("Unable to read data: {:?}", e);
+                    break;
+                }
+
+                pcm_buffer.append(&mut buf);
+            }
+
+            match packet.r#type.as_str() {
+                "audio-start" => {
+                    pcm_buffer.clear();
+                }
+                "audio-stop" => {
+                    log::info!("Audio received, start post-processing");
+                    break;
+                }
+                _ => {}
+            }
+        }
+        str.push(c.into());
+    }
+
+    let wav = to_wav(&pcm_buffer)?;
+
+    let Ok(reader) = hound::WavReader::new(&*wav) else {
+        log::error!("Error opening reader");
+        return Err("Error opening reader".into());
+    };
+
+    // pcm_buffer is 22050Hz, need to convert this to 16000Hz
+    let samples = reader
+        .into_samples()
+        .filter_map(Result::ok)
+        .map(i16::to_sample::<f64>);
+
+    let signal = signal::from_interleaved_samples_iter(samples);
+
+    let ring_buffer = ring_buffer::Fixed::from([[0.0]; 100]);
+    let sinc = Sinc::new(ring_buffer);
+
+    let new_signal = signal.from_hz_to_hz(sinc, 22050.0, 16000.0);
+
+    let spec = WavSpec {
+        channels: 1,
+        sample_rate: 16000,
+        bits_per_sample: 16,
+        sample_format: hound::SampleFormat::Int,
+    };
+
+    let new_wav: Vec<u8> = Vec::new();
+    let mut new_wav_cursor = Cursor::new(new_wav);
+
+    let mut writer = WavWriter::new(&mut new_wav_cursor, spec).unwrap();
+
+    for frame in new_signal.until_exhausted() {
+        writer.write_sample(frame[0].to_sample::<i16>()).unwrap();
+    }
+
+    writer.flush().unwrap();
+
+    drop(writer);
+
+    let wav = new_wav_cursor.into_inner();
+    let wav = bytes::Bytes::copy_from_slice(&wav);
+
+    Ok(wav_to_opus(wav).await?)
+}
+
+async fn wav_to_opus(wav: bytes::Bytes) -> Result<Vec<Vec<u8>>, audiopus::Error> {
+    use audiopus::coder::Encoder;
+    use audiopus::{Application, Channels, SampleRate};
+
+    tokio::task::spawn_blocking(move || {
+        let audio_stream = wav
+            .chunks(2)
+            .map(|bytes| i16::from_le_bytes(bytes.try_into().unwrap()))
+            .collect::<Vec<_>>();
+
+        const MONO_20MS: usize = 16000 /* 1 channel */ * 20 / 1000;
+        let enc = Encoder::new(SampleRate::Hz16000, Channels::Mono, Application::Voip)?;
+        let mut pos = 0;
+        let mut output = [0; 256];
+        let mut frames = Vec::new();
+
+        while pos + MONO_20MS < audio_stream.len() {
+            let len = enc.encode(&audio_stream[pos..(pos + MONO_20MS)], &mut output)?;
+            frames.push(output[..len].to_vec());
+
+            pos += MONO_20MS;
+        }
+
+        Ok::<_, audiopus::Error>(frames)
+    })
+    .await
+    .unwrap()
+}
+
+fn to_wav(data: &[u8]) -> Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync + 'static>> {
+    let input_buffer: Vec<u8> = Vec::new();
+    let mut input_buffer_cursor = Cursor::new(input_buffer);
+
+    let input_spec = WavSpec {
+        channels: 1,
+        sample_rate: 22050,
+        bits_per_sample: 16,
+        sample_format: hound::SampleFormat::Int,
+    };
+
+    let mut input = hound::WavWriter::new(&mut input_buffer_cursor, input_spec)?;
+
+    let audio_stream = data
+        .chunks(2)
+        .map(|bytes| i16::from_le_bytes(bytes.try_into().unwrap()))
+        .collect::<Vec<_>>();
+
+    for frame in audio_stream {
+        input.write_sample(frame.to_sample::<i16>()).unwrap();
+    }
+
+    drop(input);
+
+    Ok(input_buffer_cursor.into_inner())
+}

rust-toolchain.toml

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "nightly"
+channel = "stable"

src/braa.rs

@@ -0,0 +1,97 @@
+use std::fmt::Display;
+
+use guardian_core::components::{Heading, Position};
+
+#[derive(Clone)]
+pub enum Aspect {
+    Hot,
+    Flank,
+    Cold,
+}
+
+impl std::fmt::Display for Aspect {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Hot => write!(f, "Hot"),
+            Self::Flank => write!(f, "Flank"),
+            Self::Cold => write!(f, "Cold"),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct Braa {
+    bearing: i32,
+    range: i32,
+    angels: i32,
+    aspect: Aspect,
+}
+
+impl Display for Braa {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.to_text())
+    }
+}
+
+#[allow(unused)]
+impl Braa {
+    pub fn new(unit_a: &Position, unit_b: &Position, heading_b: &Heading) -> Self {
+        let bearing = unit_a.get_bearing_to(unit_b);
+        let range = unit_a.distance_to_nmi(unit_b).round() as i32;
+        let angels = unit_b.angels();
+        let aspect = {
+            let bearing = unit_b.get_bearing_to(unit_a);
+            let angle = (bearing - heading_b.0 as i32) % 360;
+            if (45..135).contains(&angle) {
+                Aspect::Flank
+            } else if (135..225).contains(&angle) {
+                Aspect::Cold
+            } else if (225..315).contains(&angle) {
+                Aspect::Flank
+            } else if !(45..=315).contains(&angle) {
+                Aspect::Hot
+            } else {
+                Aspect::Cold
+            }
+        };
+
+        Self {
+            bearing,
+            range,
+            angels,
+            aspect,
+        }
+    }
+
+    pub fn to_text(&self) -> String {
+        format!(
+            "BRA {}° for {}NM at {} thousand {}",
+            self.bearing, self.range, self.angels, self.aspect
+        )
+    }
+
+    pub fn to_voice(&self) -> String {
+        let bearing = split(&self.bearing.to_string(), 1);
+        let range = split(&self.range.to_string(), 1);
+        format!(
+            "BRA . . . {} . . . {} . . . {} thousand . . . {}",
+            bearing, range, self.angels, self.aspect
+        )
+    }
+}
+
+fn split(input: &str, n: usize) -> String {
+    input
+        .chars()
+        .enumerate()
+        .flat_map(|(i, c)| {
+            if i != 0 && i % n == 0 {
+                Some(' ')
+            } else {
+                None
+            }
+            .into_iter()
+            .chain(std::iter::once(c))
+        })
+        .collect::<String>()
+}

src/commands/bogeydope.rs

@@ -0,0 +1,93 @@
+use bevy::ecs::{
+    query::{With, Without},
+    system::{Commands, Query, Resource},
+};
+use clap::Parser;
+use guardian_commands::{ConsoleCommand, NamedCommand};
+use guardian_core::{components::*, dcs::text::TextMessage, srs::voice::VoiceMessage};
+use tracing::debug;
+
+use crate::braa::Braa;
+
+#[derive(Parser, Debug)]
+pub struct BogeyDope;
+
+impl NamedCommand for BogeyDope {
+    fn name() -> &'static str {
+        "[shopping|bogey dope]"
+    }
+}
+
+impl Resource for BogeyDope {}
+
+pub fn bogey_dope(
+    mut commands: Commands,
+    mut cmd: ConsoleCommand<BogeyDope>,
+    awacs: Query<&Callsign>,
+    player: Query<(&Callsign, &Position)>,
+    npc: Query<(&Position, &Heading, &Velocity), (Without<Player>, With<Red>)>,
+) {
+    let Some(Ok(BogeyDope)) = cmd.take() else {
+        return;
+    };
+    let Some(pilot) = &cmd.pilot else {
+        return; // no pilot
+    };
+    let Some(operator) = &cmd.operator else {
+        return;
+    };
+
+    let Ok((p_callsign, p_pos)) = player.get(*pilot) else {
+        debug!("no player, died?");
+        return;
+    };
+
+    let Ok(a_callsign) = awacs.get(*operator) else {
+        debug!("no awacs, they died?");
+        return;
+    };
+
+    let mut distance: f64 = f64::MAX;
+    let mut n = (None, None);
+    for (n_pos, n_heading, n_velocity) in npc.iter() {
+        if n_velocity.speed() < 10.0 {
+            // ignore slow/on-ground units
+            continue;
+        }
+        let d = p_pos.distance_to_nmi(n_pos);
+        if d < distance {
+            distance = d;
+            n = (Some(n_pos), Some(n_heading));
+        }
+    }
+
+    let (Some(n_position), Some(n_heading)) = n else {
+        let message = format!("{}, {}, {}", p_callsign, a_callsign, "Skies are clear");
+        let voice_message = format!(
+            "{} . . . {} . . . {}",
+            p_callsign.to_voice(),
+            a_callsign.to_voice(),
+            "Skies are clear"
+        );
+
+        commands.entity(*pilot).insert(TextMessage::new(message));
+        commands
+            .entity(*operator)
+            .insert(VoiceMessage::new(voice_message));
+        return;
+    };
+
+    let bra = Braa::new(p_pos, n_position, n_heading);
+    let message = format!("{}, {}, {}", p_callsign, a_callsign, bra);
+    let voice_message = format!(
+        "{} . . . {} . . . {}",
+        p_callsign.to_voice(),
+        a_callsign.to_voice(),
+        bra.to_voice()
+    );
+
+    commands.entity(*pilot).insert(TextMessage::new(message));
+    commands
+        .entity(*operator)
+        .insert(VoiceMessage::new(voice_message));
+}

src/commands/cleartripwire.rs

@@ -0,0 +1,60 @@
+use bevy::ecs::system::{Commands, Query, Resource};
+use clap::Parser;
+use guardian_commands::{ConsoleCommand, NamedCommand};
+use guardian_core::{components::*, dcs::text::TextMessage, srs::voice::VoiceMessage};
+use tracing::debug;
+
+use crate::tripwire::Tripwire;
+
+#[derive(Parser, Debug)]
+pub struct ClearTripwireCommand;
+
+impl NamedCommand for ClearTripwireCommand {
+    fn name() -> &'static str {
+        "clear [tripwire|warning]"
+    }
+}
+
+impl Resource for ClearTripwireCommand {}
+
+pub fn clear_tripwire(
+    mut commands: Commands,
+    mut cmd: ConsoleCommand<ClearTripwireCommand>,
+    callsign: Query<&Callsign>,
+) {
+    let Some(Ok(ClearTripwireCommand)) = cmd.take() else {
+        return;
+    };
+    let Some(pilot) = &cmd.pilot else {
+        debug!("no pilot");
+        return;
+    };
+    let Some(operator) = &cmd.operator else {
+        debug!("no operator");
+        return;
+    };
+
+    let Ok(p_callsign) = callsign.get(*pilot) else {
+        debug!("no player, died?");
+        return;
+    };
+
+    let Ok(a_callsign) = callsign.get(*operator) else {
+        debug!("no awacs, they died?");
+        return;
+    };
+
+    commands.entity(*pilot).remove::<Tripwire>();
+
+    let message = format!("{}, {}, tripwire cleared", p_callsign, a_callsign);
+    let message_voice = format!(
+        "{}, {}, tripwire cleared",
+        p_callsign.to_voice(),
+        a_callsign.to_voice(),
+    );
+
+    commands.entity(*pilot).insert(TextMessage::new(message));
+    commands
+        .entity(*operator)
+        .insert(VoiceMessage::new(message_voice));
+}

src/commands/mod.rs

@@ -0,0 +1,23 @@
+use bevy::app::Plugin;
+use guardian_commands::AddConsoleCommand;
+
+mod bogeydope;
+mod cleartripwire;
+mod radiocheck;
+mod tripwire;
+
+use bogeydope::*;
+use cleartripwire::*;
+use radiocheck::*;
+use tripwire::*;
+pub struct CommandsPlugin;
+
+impl Plugin for CommandsPlugin {
+    fn build(&self, app: &mut bevy::prelude::App) {
+        app.add_plugins(guardian_commands::CommandsPlugin);
+        app.add_console_command::<BogeyDope, _>(bogey_dope);
+        app.add_console_command::<RadioCheck, _>(radio_check);
+        app.add_console_command::<TripwireCommand, _>(set_tripwire);
+        app.add_console_command::<ClearTripwireCommand, _>(clear_tripwire);
+    }
+}

src/commands/radiocheck.rs

@@ -0,0 +1,57 @@
+use bevy::ecs::system::{Commands, Query, Resource};
+use clap::Parser;
+use guardian_commands::{ConsoleCommand, NamedCommand};
+use guardian_core::{components::*, dcs::text::TextMessage, srs::voice::VoiceMessage};
+use tracing::debug;
+
+#[derive(Parser, Debug)]
+pub struct RadioCheck;
+
+impl NamedCommand for RadioCheck {
+    fn name() -> &'static str {
+        "radio check"
+    }
+}
+
+impl Resource for RadioCheck {}
+
+pub fn radio_check(
+    mut commands: Commands,
+    mut cmd: ConsoleCommand<RadioCheck>,
+    callsign: Query<&Callsign>,
+) {
+    let Some(Ok(RadioCheck)) = cmd.take() else {
+        return;
+    };
+    let Some(pilot) = &cmd.pilot else {
+        debug!("no pilot");
+        return;
+    };
+    let Some(operator) = &cmd.operator else {
+        debug!("no operator");
+        return;
+    };
+
+    let Ok(p_callsign) = callsign.get(*pilot) else {
+        debug!("no player, died?");
+        return;
+    };
+
+    let Ok(a_callsign) = callsign.get(*operator) else {
+        debug!("no awacs, they died?");
+        return;
+    };
+
+    let message = format!("{}, {}, {}", p_callsign, a_callsign, "five by five");
+    let voice_message = format!(
+        "{} . . . {} . . . {}",
+        p_callsign.to_voice(),
+        a_callsign.to_voice(),
+        "five by five"
+    );
+
+    commands.entity(*pilot).insert(TextMessage::new(message));
+    commands
+        .entity(*operator)
+        .insert(VoiceMessage::new(voice_message));
+}

src/commands/tripwire.rs

@@ -0,0 +1,103 @@
+use bevy::ecs::system::{Commands, Query, Resource};
+use clap::Parser;
+use guardian_commands::{ConsoleCommand, NamedCommand};
+use guardian_core::{components::*, dcs::text::TextMessage, srs::voice::VoiceMessage};
+use tracing::debug;
+
+use crate::tripwire::Tripwire;
+
+#[derive(Parser, Debug)]
+pub struct TripwireCommand;
+
+impl NamedCommand for TripwireCommand {
+    fn name() -> &'static str {
+        "set [tripwire|warning]"
+    }
+}
+
+impl Resource for TripwireCommand {}
+
+pub fn set_tripwire(
+    mut commands: Commands,
+    mut cmd: ConsoleCommand<TripwireCommand>,
+    callsign: Query<&Callsign>,
+) {
+    let Some(Ok(TripwireCommand)) = cmd.take() else {
+        return;
+    };
+    let Some(pilot) = &cmd.pilot else {
+        debug!("no pilot");
+        return;
+    };
+    let Some(operator) = &cmd.operator else {
+        debug!("no operator");
+        return;
+    };
+
+    let Ok(p_callsign) = callsign.get(*pilot) else {
+        debug!("no player, died?");
+        return;
+    };
+
+    let Ok(a_callsign) = callsign.get(*operator) else {
+        debug!("no awacs, they died?");
+        return;
+    };
+    let Some(readback) = &cmd.raw else {
+        debug!("no readback");
+        return;
+    };
+
+    let mut parts = readback.split(' ');
+
+    // check the last part, if it's a number, interpret as miles
+    let Some(last) = parts.nth_back(0) else {
+        debug!("no last part");
+        return;
+    };
+
+    let distance = match last.parse::<i32>() {
+        Ok(distance) => distance, // a number is found, interpret as miles
+        Err(_) => {
+            let Some(maybe_number) = parts.nth_back(0) else {
+                // Report message garbled..
+                return;
+            };
+
+            match maybe_number.parse::<i32>() {
+                Ok(n) => {
+                    if last == "kilometers" || last == "km" {
+                        (n as f64 * 0.621371).round() as i32
+                    } else {
+                        n
+                    }
+                }
+                Err(_) => {
+                    // let message = format!("{}, {}. Unable to read, Say again.", caller, receiver);
+                    return;
+                }
+            }
+        }
+    };
+
+    // clamp distance between 0 and 120
+    let distance = distance.min(120).max(0);
+
+    commands.entity(*pilot).insert(Tripwire::new(distance));
+
+    let message = format!(
+        "{}, {}, tripwire set to {} miles",
+        p_callsign, a_callsign, distance
+    );
+    let message_voice = format!(
+        "{}, {}, tripwire set to {} miles",
+        p_callsign.to_voice(),
+        a_callsign.to_voice(),
+        distance
+    );
+
+    commands.entity(*pilot).insert(TextMessage::new(message));
+    commands
+        .entity(*operator)
+        .insert(VoiceMessage::new(message_voice));
+}

src/config.rs

@@ -0,0 +1,93 @@
+use std::{collections::HashMap, path::PathBuf};
+
+use bevy::ecs::system::Resource;
+use guardian_core::{
+    components::{GrpcBaseUrl, SrsSocketAddr, SttBaseUrl},
+    srs::Modulation as SrsModulation,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Resource, Clone, Debug, Deserialize, Serialize, Default)]
+pub struct Channels(pub HashMap<String, ChannelConfig>);
+
+#[derive(Clone, Debug, Deserialize, Serialize, Default)]
+pub struct Config {
+    pub srs: SrsConfig,
+    pub grpc: GrpcBaseUrl,
+    pub stt: SttBaseUrl,
+    pub channels: Channels,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Default)]
+pub struct SrsConfig {
+    pub server: SrsSocketAddr,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, Default)]
+pub struct ChannelConfig {
+    pub frequency: u64,
+    pub modulation: Modulation, // 0=AM, 1=FM?
+}
+
+impl TryFrom<PathBuf> for Config {
+    type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
+
+    fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
+        use std::io::Read;
+        let mut config = std::fs::File::open(value)?;
+        let mut config_str = String::new();
+        config.read_to_string(&mut config_str)?;
+        Ok(toml::from_str(&config_str)?)
+    }
+}
+
+impl Config {
+    pub fn load(file: PathBuf) -> Result<Self, Box<dyn std::error::Error + Send + Sync + 'static>> {
+        if file.exists() {
+            return file.try_into();
+        }
+
+        use std::io::Write;
+
+        let mut defaults = Config::default();
+
+        defaults.channels.0.insert(
+            "Overlord1-1".to_string(),
+            ChannelConfig {
+                frequency: 251000000,
+                modulation: Modulation::Am,
+            },
+        );
+
+        // write the file
+        std::fs::File::create(file)?.write_all(toml::to_string_pretty(&defaults)?.as_bytes())?;
+
+        Ok(defaults)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Serialize, Default)]
+pub enum Modulation {
+    #[default]
+    Am,
+    Fm,
+    Intercom,
+    Disabled,
+    HaveQuick,
+    Satcom,
+    Mids,
+}
+
+impl From<Modulation> for SrsModulation {
+    fn from(value: Modulation) -> Self {
+        match value {
+            Modulation::Am => SrsModulation::Am,
+            Modulation::Fm => SrsModulation::Fm,
+            Modulation::Intercom => SrsModulation::Intercom,
+            Modulation::Disabled => SrsModulation::Disabled,
+            Modulation::HaveQuick => SrsModulation::HaveQuick,
+            Modulation::Satcom => SrsModulation::Satcom,
+            Modulation::Mids => SrsModulation::Mids,
+        }
+    }
+}

src/main.rs

@@ -1,158 +1,95 @@
+mod braa;
+mod commands;
+mod config;
+mod tripwire;
+
+use std::path::PathBuf;
+
 use bevy::{
     app::{App, Update},
     ecs::{
-        component::Component,
         entity::Entity,
-        query::{Added, With, Without},
+        query::{With, Without},
-        system::{Commands, Query},
+        system::{Commands, Query, Res},
     },
 };
-use guardian_core::*;
+use clap::Parser;
+use commands::CommandsPlugin;
+use config::{Channels, Config};
+use guardian_core::{
+    components::{Awacs, Callsign},
+    srs::Radio,
+    DefaultPlugins, TokioResource,
+};
 use tokio::runtime::Handle;
+use tracing::info;
+use tripwire::TripwirePlugin;
 
-// Every incomming (voice) message is an event
+#[derive(Parser, Debug)]
-// Systems can handle the events, eg bogey dope, set tripwire or radio check
+struct CommandLineArguments {
-// voice responses; srs should be a resource?
+    #[arg(short, long)]
-// |- srs plugin adds a resource to use to send messages i guess
+    config: Option<PathBuf>,
-// |-- or spawn an entity with a message commands.spawn((VoiceMessage("Hello World"), TextMessage("Hello World!")))
+}
-// |-- srs plugin will check if these components are Added<VoiceMessage> or w/e and handle accordingly
 
 #[tokio::main]
-async fn main() {
+async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    App::new()
+    let subscriber = tracing_subscriber::FmtSubscriber::builder()
-        .insert_resource(TokioResource(Handle::current()))
+        .with_env_filter(
-        .add_plugins(DefaultPlugins)
+            "trace,bevy=error,tokio_util=error,h2=error,hyper=error,tower=error,tonic=error",
-        .add_systems(Update, (add_tripwire, tripwire))
+        )
-        .run();
+        // .with_span_events(tracing_subscriber::fmt::format::FmtSpan::CLOSE)
-}
+        .with_file(false)
+        .with_line_number(false)
+        .with_target(true)
+        .finish();
 
-// this will be on a tripwire command event (from srs), instead of Added<Player>, not everyone may want it; opt-in over opt-out
+    tracing::subscriber::set_global_default(subscriber)?;
-fn add_tripwire(mut commands: Commands, players: Query<Entity, Added<Player>>) {
+
-    for ent in players.iter() {
+    let args = CommandLineArguments::parse();
-        commands.entity(ent).insert(Tripwire {
+
-            range: 30.0,
+    let config = match args.config {
-            reported: vec![],
+        Some(c) => {
-        });
+            if !c.try_exists()? {
+                return Err(format!("Config file {} not found", c.display()).into());
             }
-}
+            c
-
-fn tripwire(
-    mut commands: Commands,
-    mut players: Query<(&Id, &Callsign, &Position, &mut Tripwire), With<Player>>,
-    npc: Query<(&Id, &Position, &Heading, &Side), Without<Player>>,
-) {
-    for (p_id, p_callsign, p_position, mut p_tripwire) in players.iter_mut() {
-        let _p_id = &p_id.0;
-        let _p_callsign = &p_callsign.0;
-        for (n_id, n_position, n_heading, side) in npc.iter() {
-            if side.0 != Coalition::Red {
-                continue;
-            }
-
-            let n_id = &n_id.0;
-
-            let distance = n_position.distance_to_nmi(p_position);
-            if distance <= p_tripwire.range && !p_tripwire.reported.contains(n_id) {
-                p_tripwire.reported.push(*n_id);
-
-                let bra = Braa::new(p_position, n_position, n_heading);
-                commands.spawn(TextMessage::new(bra.to_text()));
-            } else if distance > p_tripwire.range && p_tripwire.reported.contains(n_id) {
-                p_tripwire.reported.retain(|b| b != n_id);
-            }
-        }
-    }
-}
-
-#[derive(Component)]
-struct Tripwire {
-    range: f64,
-    reported: Vec<u32>,
-}
-
-#[derive(Clone)]
-pub enum Aspect {
-    Hot,
-    Flank,
-    Cold,
-}
-
-impl std::fmt::Display for Aspect {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Hot => write!(f, "Hot"),
-            Self::Flank => write!(f, "Flank"),
-            Self::Cold => write!(f, "Cold"),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct Braa {
-    bearing: i32,
-    range: i32,
-    angels: i32,
-    aspect: Aspect,
-}
-
-impl Braa {
-    pub fn new(unit_a: &Position, unit_b: &Position, heading_b: &Heading) -> Self {
-        let bearing = unit_a.get_bearing_to(unit_b);
-        let range = unit_a.distance_to_nmi(unit_b).round() as i32;
-        let angels = unit_b.angels();
-        let aspect = {
-            let bearing = unit_b.get_bearing_to(unit_a);
-            let angle = (bearing - heading_b.0 as i32) % 360;
-            if (45..135).contains(&angle) {
-                Aspect::Flank
-            } else if (135..225).contains(&angle) {
-                Aspect::Cold
-            } else if (225..315).contains(&angle) {
-                Aspect::Flank
-            } else if !(45..=315).contains(&angle) {
-                Aspect::Hot
-            } else {
-                Aspect::Cold
         }
+        None => "config.toml".into(),
     };
 
-        Self {
+    info!("Loading config {}", config.display());
-            bearing,
-            range,
-            angels,
-            aspect,
-        }
-    }
 
-    pub fn to_text(&self) -> String {
+    let config = Config::load(config)?;
-        format!(
-            "BRA {}° for {}NM at {} thousand {}",
-            self.bearing, self.range, self.angels, self.aspect
-        )
-    }
 
-    pub fn to_voice(&self) -> String {
+    App::new()
-        let bearing = split(&self.bearing.to_string(), 1);
+        .insert_resource(config.srs.server)
-        let range = split(&self.range.to_string(), 1);
+        .insert_resource(config.stt)
-        format!(
+        .insert_resource(config.grpc)
-            "BRA <break time=\"250ms\"/> {} <break /> {} <break /> {} thousand <break /> {}",
+        .insert_resource(config.channels)
-            bearing, range, self.angels, self.aspect
+        .insert_resource(TokioResource(Handle::current()))
-        )
+        .add_plugins(DefaultPlugins)
-    }
+        .add_plugins(TripwirePlugin)
+        .add_plugins(CommandsPlugin)
+        .add_systems(Update, give_awacs_radio)
+        .run();
+
+    Ok(())
 }
 
-fn split(input: &str, n: usize) -> String {
+fn give_awacs_radio(
-    input
+    mut commands: Commands,
-        .chars()
+    channels: Res<Channels>,
-        .enumerate()
+    units: Query<(Entity, &Callsign), (With<Awacs>, Without<Radio>)>,
-        .flat_map(|(i, c)| {
+) {
-            if i != 0 && i % n == 0 {
+    for (ent, callsign) in units.iter() {
-                Some(' ')
+        let Some(channel) = channels.0.get(callsign.as_str()) else {
-            } else {
+            continue; // not configured for this unit
-                None
+        };
+
+        bevy::log::info!("{} now has a radio", callsign);
+
+        commands
+            .entity(ent)
+            .insert(Radio::new(channel.frequency, channel.modulation));
     }
-            .into_iter()
-            .chain(std::iter::once(c))
-        })
-        .collect::<String>()
 }

src/tripwire.rs

@@ -0,0 +1,91 @@
+use bevy::{
+    app::{Plugin, Update},
+    ecs::{
+        component::Component,
+        entity::Entity,
+        query::{With, Without},
+        system::{Commands, Query},
+    },
+};
+use guardian_core::{
+    components::*,
+    dcs::text::TextMessage,
+    srs::{voice::VoiceMessage, Radio, RadioInfo},
+};
+
+use crate::braa::Braa;
+
+pub struct TripwirePlugin;
+
+impl Plugin for TripwirePlugin {
+    fn build(&self, app: &mut bevy::prelude::App) {
+        app.add_systems(Update, tripwire);
+    }
+}
+
+fn tripwire(
+    mut commands: Commands,
+    awacs: Query<(Entity, &Callsign, &Radio), (With<Awacs>, With<Blue>, With<Radio>)>,
+    mut players: Query<(Entity, &Callsign, &Position, &RadioInfo, &mut Tripwire), With<Player>>,
+    npc: Query<(&Id, &Position, &Heading, &Velocity), (Without<Player>, With<Red>)>,
+) {
+    // get the players radio frequencies
+    // match the tuned frequency with one of the awacs'
+    // broadcast message on that ferquency and as that awacs
+
+    for (ent, awacs, radio) in awacs.iter() {
+        for (p_ent, p_callsign, p_position, radioinfo, mut p_tripwire) in players.iter_mut() {
+            // check if user is on the same frequency as awacs
+            if !radioinfo
+                .radios
+                .iter()
+                .any(|f| f.freq as u64 == radio.frequency && f.modulation == radio.modulation)
+            {
+                continue;
+            }
+
+            for (n_id, n_position, n_heading, n_velocity) in npc.iter() {
+                if n_velocity.speed() < 10.0 {
+                    // ignore slow/on-ground units
+                    continue;
+                }
+                let distance = n_position.distance_to_nmi(p_position);
+                if distance <= p_tripwire.range && !p_tripwire.reported.contains(n_id) {
+                    p_tripwire.reported.push(*n_id);
+
+                    let bra = Braa::new(p_position, n_position, n_heading);
+                    let message = format!("{}, {}, {}", p_callsign, awacs, bra);
+                    let voice_message = format!(
+                        "{} . . . {} . . . {}",
+                        p_callsign.to_voice(),
+                        awacs.to_voice(),
+                        bra.to_voice()
+                    );
+
+                    // commands.spawn((Id::new(player_id.into()), TextMessage::new(message)));
+                    commands.entity(p_ent).insert(TextMessage::new(message));
+                    commands
+                        .entity(ent)
+                        .insert(VoiceMessage::new(voice_message));
+                } else if distance > p_tripwire.range && p_tripwire.reported.contains(n_id) {
+                    p_tripwire.reported.retain(|b| b != n_id);
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug, Component)]
+pub struct Tripwire {
+    range: f64,
+    reported: Vec<Id>,
+}
+
+impl Tripwire {
+    pub fn new(distance: i32) -> Self {
+        Self {
+            range: distance as f64,
+            reported: vec![],
+        }
+    }
+}