Update Meteor to 1.2

This requires local copies of packages that are broken or not Polymer 0.5

.codio

@@ -0,0 +1,14 @@
+{
+// Configure your Run and Preview buttons here.
+
+// Run button configuration
+  "commands": {
+        "Run Meteor": "cd rpg-docs \n ROOT_URL=http://period-sheriff.codio.io:3000 meteor"
+  },
+
+// Preview button configuration
+  "preview": {
+      "Prieview": "http://period-sheriff-3000.codio.io",
+	  "Ungit": "https://period-sheriff-9501.codio.io/#/repository?path=/home/codio/workspace"
+  }
+}

.gitignore

@@ -1 +0,0 @@
-build

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,13 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="HtmlUnknownAttribute" enabled="false" level="WARNING" enabled_by_default="false">
+      <option name="myValues">
+        <value>
+          <list size="0" />
+        </value>
+      </option>
+      <option name="myCustomValuesEnabled" value="true" />
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,7 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="PROJECT_PROFILE" value="Project Default" />
+    <option name="USE_PROJECT_PROFILE" value="true" />
+    <version value="1.0" />
+  </settings>
+</component>

.jscsrc

@@ -0,0 +1,56 @@
+{
+	"requireOperatorBeforeLineBreak": true,
+	"requireCamelCaseOrUpperCaseIdentifiers": true,
+	"maximumLineLength": {
+		"value": 80,
+		"allowComments": true,
+		"allowRegex": true
+	},
+	"validateIndentation": "\t",
+	"validateQuoteMarks": "\"",
+
+	"disallowMultipleLineStrings": true,
+	"disallowMixedSpacesAndTabs": "smart",
+	"disallowTrailingWhitespace": true,
+	"disallowSpaceAfterPrefixUnaryOperators": true,
+	"disallowMultipleVarDecl": true,
+	"disallowNewlineBeforeBlockStatements": true,
+	"disallowKeywordsOnNewLine": ["else"],
+
+	"requireSpaceAfterKeywords": [
+		"if",
+		"else",
+		"for",
+		"while",
+		"do",
+		"switch",
+		"return",
+		"try",
+		"catch"
+	],
+	"requireSpaceBeforeBinaryOperators": [
+		"=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=",
+		"&=", "|=", "^=", "+=",
+
+		"+", "-", "*", "/", "%", "<<", ">>", ">>>", "&",
+		"|", "^", "&&", "||", "===", "==", ">=",
+		"<=", "<", ">", "!=", "!=="
+	],
+	"requireSpaceAfterBinaryOperators": true,
+	"requireSpacesInConditionalExpression": true,
+	"requireSpacesInForStatement": true,
+	"requireTrailingComma": {
+		"ignoreSingleValue": true,
+		"ignoreSingleLine": true
+	},
+	"requireLineFeedAtFileEnd": true,
+	"disallowSpacesInAnonymousFunctionExpression": {
+		"beforeOpeningRoundBrace": true
+	},
+	"disallowSpacesInsideObjectBrackets": "all",
+	"disallowSpacesInsideArrayBrackets": "all",
+	"disallowSpacesInsideParentheses": true,
+
+	"disallowMultipleLineBreaks": true,
+	"disallowNewlineBeforeBlockStatements": true
+}

.jshintrc

@@ -0,0 +1,3 @@
+{
+	"undef": false
+}

Dockerfile

@@ -1,14 +0,0 @@
-FROM ubuntu:latest
-RUN apt-get update --quiet \
-    && apt-get install --quiet --yes \
-    bsdtar \
-    curl \
-    git
-RUN ln --symbolic --force $(which bsdtar) $(which tar)
-RUN useradd --create-home --shell /bin/bash dicecloud
-USER dicecloud
-WORKDIR /home/dicecloud
-RUN curl https://install.meteor.com/?release=1.8.0.2 | sh
-ENV PATH="${PATH}:/home/dicecloud/.meteor"
-COPY dev.sh ./dev.sh
-ENTRYPOINT ./dev.sh

License.md

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

README.md

@@ -1,89 +1,4 @@
-DiceCloud
+RPG Docs
 ========
 
-This is the repo for [DiceCloud](dicecloud.com).
-
-DiceCloud is a free, auditable, real-time character sheet for D&D 5e.
-
-Philosophy
-----------
-
-Setting up your character on DiceCloud takes a little longer than
-just filling it in on a paper character sheet would. The goal of using an
-online sheet is to make actually playing the game more streamlined, and
-ultimately more fun. So putting a little extra effort into setting up a
-character now pays off over and over again once you're playing.
-
-The idea is to track where each number comes from, and allow you to easily make
-changes on the fly. Let's look at a hypothetical example.
-
-> You need to swim through a sunken section of dungeon to fetch the quest's Thing.
-> You'll need to take off your magical Plate Armor of +1 Constitution to swim
-> without sinking, of course.
->
-> Taking it off will take away that disadvantage on
-> stealth checks, change your armor class, your speed and your constitution, and
-> which in turn changes your hit points and your constitution saving throw.
-> Working out all those changes in the middle of a game will drag the game to a
-> halt.
->
-> Fortunately you have DiceCloud, so it's a matter of dragging
-> your Plate Armor +1 Con from your "equipment" box to your "backpack" box and
-> you're done. Your hitpoints change correctly, your saving throws are up to date,
-> your armor class goes back to reflecting the fact that you have natural armor
-> from being a dragonborn. Your character sheet keeps up and you
-> ultimately get more time to play the game. Huzzah!
-
-Getting started
----------------
-
-Running DiceCloud locally, either to host it yourself away from an internet
-connection, or to contribute to developing it further, is fairly
-straightforward and it should work on Linux, Windows, and Mac.
-
-You'll need to have installed:
-
-- [git](https://www.atlassian.com/git/tutorials/install-git)
-- [Meteor](https://www.meteor.com/install)
-
-Then, it's just a matter of cloning this repository into a folder, and running
-`meteor` in the app directory.
-
-`git clone https://github.com/ThaumRystra/DiceCloud dicecloud`  
-`cd dicecloud`  
-`cd app`  
-`meteor npm install`  
-`meteor`
-
-You should see this:
-
-```
-=> Started proxy.
-=> [HMR] Dev server listening on port 3003.
-=> Started MongoDB.
-=> Started your app.
-
-=> App running at: http://localhost:3000/
-```
-
-Environmental Variables
------------------------
-
-```
-MAIL_URL=smtp://<your smtp mail url>
-METEOR_SETTINGS={ "public": { "environment": "production", "patreon": { "clientId": "<your patreon client ID>", "campaignId": "<your campaign id>" } }, "patreon": { "clientSecret": "<your client secret>", "creatorAccessToken": "<your creator access token>" } }
-MONGO_OPLOG_URL=mongodb+srv://<your url for the oplog account of your mongo database>
-MONGO_URL=mongodb+srv://<your url for the read/write account of your mongo database>
-NPM_CONFIG_PRODUCTION=true
-PROJECT_DIR=app
-ROOT_URL=https://<url of your DiceCloud instance>
-DEFAULT_LIBRARIES=<comma separated list of library ids that will be subscribed by default: "abc123,def456">
-```
-
-To disable Patreon features and unlock all paid restrictions for all users of your deployment, replace
-`"patreon": { "clientId": ... }"` with `"disablePatreon": true` in the public key of the METEOR_SETTINGS environment variable.
-
-Alternatively run `meteor run --settings exampleMeteorSettings.json` to start the app with the example settings that disable Patreon by default.
-
-Now, visiting [](http://localhost:3000/) should show you an empty instance of
-DiceCloud running.
+This is the repo for [DiceCloud](dicecloud.com). The currently deployed version should always be the head of the master branch.

app/.gitignore

@@ -1,12 +0,0 @@
-.meteor/local
-.meteor/meteorite
-.demeteorized
-.cache
-.vscode
-settings.json
-public/components
-public/_imports.html
-private/oldClient
-nohup.out
-node_modules
-dump

app/.meteor/packages

@@ -1,50 +0,0 @@
-# Meteor packages used by this project, one per line.
-#
-# 'meteor add' and 'meteor remove' will edit this file for you,
-# but you can also edit it by hand.
-
-accounts-password@2.3.1
-random@1.2.0
-underscore@1.0.10
-dburles:mongo-collection-instances
-accounts-google@1.4.0
-email@2.2.1
-meteor-base@1.5.1
-mobile-experience@1.1.0
-mongo@1.15.0
-session@1.2.0
-tracker@1.2.0
-logging@1.3.1
-reload@1.3.1
-ejson@1.1.2
-check@1.3.1
-standard-minifier-js@2.8.0
-shell-server@0.5.0
-ecmascript@0.16.2
-es5-shim@4.8.0
-service-configuration@1.3.0
-dynamic-import@0.7.2
-ddp-rate-limiter@1.1.0
-rate-limit@1.0.9
-mdg:validated-method
-static-html@1.3.2
-aldeed:collection2
-aldeed:schema-index
-accounts-patreon
-bozhao:link-accounts
-peerlibrary:reactive-publish
-simple:rest
-simple:rest-method-mixin
-mikowals:batch-insert
-peerlibrary:subscription-data
-seba:minifiers-autoprefixer
-zer0th:meteor-vuetify-loader
-akryum:vue-component
-akryum:vue-router2
-percolate:migrations
-meteortesting:mocha
-ostrio:files
-simple:rest-bearer-token-parser
-simple:rest-json-error-handler
-littledata:synced-cron
-mdg:meteor-apm-agent

app/.meteor/release

@@ -1 +0,0 @@
-METEOR@2.7.3

app/.meteor/versions

@@ -1,129 +0,0 @@
-accounts-base@2.2.3
-accounts-google@1.4.0
-accounts-oauth@1.4.1
-accounts-password@2.3.1
-accounts-patreon@0.1.0
-akryum:npm-check@0.1.2
-akryum:vue-component@0.15.2
-akryum:vue-component-dev-client@0.4.7
-akryum:vue-component-dev-server@0.1.4
-akryum:vue-router2@0.2.3
-aldeed:collection2@3.5.0
-aldeed:schema-index@3.0.0
-allow-deny@1.1.1
-autoupdate@1.8.0
-babel-compiler@7.9.0
-babel-runtime@1.5.1
-base64@1.0.12
-binary-heap@1.0.11
-blaze-tools@1.1.3
-boilerplate-generator@1.7.1
-bozhao:link-accounts@2.6.1
-caching-compiler@1.2.2
-caching-html-compiler@1.2.1
-callback-hook@1.4.0
-check@1.3.1
-coffeescript@2.4.1
-coffeescript-compiler@2.4.1
-dburles:mongo-collection-instances@0.3.6
-ddp@1.4.0
-ddp-client@2.5.0
-ddp-common@1.4.0
-ddp-rate-limiter@1.1.0
-ddp-server@2.5.0
-diff-sequence@1.1.1
-dynamic-import@0.7.2
-ecmascript@0.16.2
-ecmascript-runtime@0.8.0
-ecmascript-runtime-client@0.12.1
-ecmascript-runtime-server@0.11.0
-ejson@1.1.2
-email@2.2.1
-es5-shim@4.8.0
-fetch@0.1.1
-geojson-utils@1.0.10
-google-oauth@1.4.2
-hot-code-push@1.0.4
-html-tools@1.1.3
-htmljs@1.1.1
-http@2.0.0
-id-map@1.1.1
-inter-process-messaging@0.1.1
-lai:collection-extensions@0.3.0
-launch-screen@1.3.0
-littledata:synced-cron@1.5.1
-livedata@1.0.18
-localstorage@1.2.0
-logging@1.3.1
-mdg:meteor-apm-agent@3.5.0
-mdg:validated-method@1.2.0
-meteor@1.10.0
-meteor-base@1.5.1
-meteortesting:browser-tests@1.3.5
-meteortesting:mocha@2.0.3
-meteortesting:mocha-core@8.1.2
-mikowals:batch-insert@1.3.0
-minifier-css@1.6.0
-minifier-js@2.7.4
-minimongo@1.8.0
-mobile-experience@1.1.0
-mobile-status-bar@1.1.0
-modern-browsers@0.1.8
-modules@0.18.0
-modules-runtime@0.13.0
-mongo@1.15.0
-mongo-decimal@0.1.3
-mongo-dev-server@1.1.0
-mongo-id@1.0.8
-mongo-livedata@1.0.12
-npm-mongo@4.3.1
-oauth@2.1.2
-oauth2@1.3.1
-ordered-dict@1.1.0
-ostrio:cookies@2.7.2
-ostrio:files@2.0.1
-patreon-oauth@0.1.0
-peerlibrary:assert@0.3.0
-peerlibrary:check-extension@0.7.0
-peerlibrary:computed-field@0.10.0
-peerlibrary:data-lookup@0.3.0
-peerlibrary:extend-publish@0.6.0
-peerlibrary:fiber-utils@0.10.0
-peerlibrary:reactive-mongo@0.4.1
-peerlibrary:reactive-publish@0.10.0
-peerlibrary:server-autorun@0.8.0
-peerlibrary:subscription-data@0.8.0
-percolate:migrations@1.0.3
-promise@0.12.0
-raix:eventemitter@1.0.0
-random@1.2.0
-rate-limit@1.0.9
-react-fast-refresh@0.2.3
-reactive-dict@1.3.0
-reactive-var@1.0.11
-reload@1.3.1
-retry@1.1.0
-routepolicy@1.1.1
-seba:minifiers-autoprefixer@2.0.1
-service-configuration@1.3.0
-session@1.2.0
-sha@1.0.9
-shell-server@0.5.0
-simple:json-routes@2.3.1
-simple:rest@1.2.1
-simple:rest-bearer-token-parser@1.1.1
-simple:rest-json-error-handler@1.1.1
-simple:rest-method-mixin@1.1.0
-socket-stream-client@0.5.0
-spacebars-compiler@1.3.1
-standard-minifier-js@2.8.0
-static-html@1.3.2
-templating-tools@1.2.2
-tmeasday:check-npm-versions@1.0.2
-tracker@1.2.0
-typescript@4.5.4
-underscore@1.0.10
-url@1.3.2
-webapp@1.13.1
-webapp-hashing@1.1.0
-zer0th:meteor-vuetify-loader@0.1.41

app/client/index.html

@@ -1,3 +0,0 @@
-<body>
-  <div id="app"></div>
-</body>

app/client/main.js

@@ -1,7 +0,0 @@
-import '/imports/api/simpleSchemaConfig.js';
-import '/imports/ui/vueSetup.js';
-import '/imports/ui/styles/stylesIndex.js';
-import '/imports/client/config.js';
-import '/imports/client/serviceWorker.js';
-
-import 'ngraph.graph';

app/exampleMeteorSettings.json

@@ -1,6 +0,0 @@
-{
-  "public": {
-    "environment": "production",
-    "disablePatreon": true
-  }
-}

app/imports/api/creature/archive/ArchiveCreatureFiles.js

@@ -1,52 +0,0 @@
-import { createS3FilesCollection } from '/imports/api/files/s3FileStorage.js';
-import SimpleSchema from 'simpl-schema';
-import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed.js';
-import { CreaturePropertySchema } from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { CreatureSchema } from '/imports/api/creature/creatures/Creatures.js';
-
-const ArchiveCreatureFiles = createS3FilesCollection({
-  collectionName: 'archiveCreatureFiles',
-  storagePath: Meteor.isDevelopment ? '/DiceCloud/archiveCreatures/' : 'assets/app/archiveCreatures',
-  onBeforeUpload(file) {
-    // Allow upload files under 10MB, and only in json format
-    if (file.size > 10485760) {
-      return 'Please upload with size equal or less than 10MB';
-    }
-    if (!/json/i.test(file.extension)){
-      return 'Please upload only a JSON file';
-    }
-    return true;
-  },
-  onAfterUpload(file) {
-    if (Meteor.isServer) incrementFileStorageUsed(file.userId, file.size);
-  }
-});
-
-let archiveSchema = new SimpleSchema({
-  meta: {
-    type: Object,
-    blackbox: true,
-  },
-  creature: CreatureSchema,
-  properties: {
-    type: Array,
-  },
-  'properties.$': CreaturePropertySchema,
-  experiences: {
-    type: Array,
-  },
-  'experiences.$': {
-    type: Object,
-    blackbox: true,
-  },
-  logs: {
-    type: Array,
-  },
-  'logs.$': {
-    type: Object,
-    blackbox: true,
-  },
-});
-
-export default ArchiveCreatureFiles;
-export { archiveSchema };

app/imports/api/creature/archive/methods/archiveCreatureToFile.js

@@ -1,78 +0,0 @@
-import SCHEMA_VERSION from '/imports/constants/SCHEMA_VERSION.js';
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
-import Experiences from '/imports/api/creature/experience/Experiences.js';
-import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature.js';
-import ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles.js';
-
-export function getArchiveObj(creatureId){
-  // Build the archive document
-  const creature = Creatures.findOne(creatureId);
-  const properties = CreatureProperties.find({'ancestors.id': creatureId}).fetch();
-  const experiences = Experiences.find({creatureId}).fetch();
-  const logs = CreatureLogs.find({creatureId}).fetch();
-  let archiveCreature = {
-    meta: {
-      type: 'DiceCloud V2 Creature Archive',
-      schemaVersion: SCHEMA_VERSION,
-      archiveDate: new Date(),
-    },
-    creature,
-    properties,
-    experiences,
-    logs,
-  };
-
-  return archiveCreature;
-}
-
-export function archiveCreature(creatureId){
-  const archive = getArchiveObj(creatureId);
-  const buffer = Buffer.from(JSON.stringify(archive, null, 2));
-  ArchiveCreatureFiles.write(buffer, {
-    fileName: `${archive.creature.name || archive.creature._id}.json`,
-    type: 'application/json',
-    userId: archive.creature.owner,
-    meta: {
-      schemaVersion: SCHEMA_VERSION,
-      creatureId: archive.creature._id,
-      creatureName: archive.creature.name,
-    },
-  }, (error) => {
-    if (error){
-      throw error;
-    } else {
-      removeCreatureWork(creatureId);
-    }
-  }, true);
-}
-
-const archiveCreatureToFile = new ValidatedMethod({
-  name: 'Creatures.methods.archiveCreatureToFile',
-  validate: new SimpleSchema({
-    'creatureId': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  async run({creatureId}) {
-    assertOwnership(creatureId, this.userId);
-    if (Meteor.isServer){
-      archiveCreature(creatureId, this.userId);
-    } else {
-      removeCreatureWork(creatureId);
-    }
-  },
-});
-
-export default archiveCreatureToFile;

app/imports/api/creature/archive/methods/index.js

@@ -1,3 +0,0 @@
-import '/imports/api/creature/archive/methods/archiveCreatureToFile.js';
-import '/imports/api/creature/archive/methods/restoreCreatureFromFile.js';
-import '/imports/api/creature/archive/methods/removeArchiveCreature.js';

app/imports/api/creature/archive/methods/removeArchiveCreature.js

@@ -1,40 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles.js';
-import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed.js';
-
-const removeArchiveCreature = new ValidatedMethod({
-  name: 'ArchiveCreatureFiles.methods.removeArchiveCreature',
-  validate: new SimpleSchema({
-    'fileId': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  async run({ fileId }) {
-    // fetch the file
-    const file = ArchiveCreatureFiles.findOne({ _id: fileId }).get();
-    if (!file) {
-      throw new Meteor.Error('File not found',
-        'The requested creature archive does not exist');
-    }
-    // Assert ownership
-    const userId = file?.userId;
-    if (!userId || userId !== this.userId) {
-      throw new Meteor.Error('Permission denied',
-        'You can only restore creatures you own');
-    }
-    //Remove the archive once the restore succeeded
-    ArchiveCreatureFiles.remove({ _id: fileId });
-    // Update the user's file storage limits
-    incrementFileStorageUsed(userId, -file.size);
-  },
-});
-
-export default removeArchiveCreature;

app/imports/api/creature/archive/methods/restoreCreatureFromFile.js

@@ -1,104 +0,0 @@
-import SCHEMA_VERSION from '/imports/constants/SCHEMA_VERSION.js';
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
-import Experiences from '/imports/api/creature/experience/Experiences.js';
-import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature.js';
-import ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles.js';
-import assertHasCharactersSlots from '/imports/api/creature/creatures/methods/assertHasCharacterSlots.js';
-import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed.js';
-import verifyArchiveSafety from '/imports/api/creature/archive/methods/verifyArchiveSafety.js';
-
-let migrateArchive;
-if (Meteor.isServer){
-  migrateArchive = require('/imports/migrations/server/migrateArchive.js').default;
-}
-
-function restoreCreature(archive, userId){
-  if (SCHEMA_VERSION < archive.meta.schemaVersion){
-    throw new Meteor.Error('Incompatible',
-      'The archive file is from a newer version. Update required to read.')
-  }
-
-  // Migrate and verify the archive meets the current schema
-  migrateArchive(archive);
-
-  // Asset that the archive is safe
-  verifyArchiveSafety(archive);
-
-  // Don't upload creatures twice
-  const existingCreature = Creatures.findOne(archive.creature._id, {
-    fields: { _id: 1 }
-  });
-  if (existingCreature) throw new Meteor.Error('Already exists',
-    'The creature you are trying to restore already exists.')
-  
-  // Ensure the user owns the restored creature
-  archive.creature.owner = userId;
-
-  // Insert the creature sub documents
-  // They still have their original _id's
-  Creatures.insert(archive.creature);
-  try {
-    // Add all the properties
-    if (archive.properties && archive.properties.length){
-      CreatureProperties.batchInsert(archive.properties);
-    }
-    if (archive.experiences && archive.experiences.length){
-      Experiences.batchInsert(archive.experiences);
-    }
-    if (archive.logs && archive.logs.length){
-      CreatureLogs.batchInsert(archive.logs);
-    }
-  } catch (e) {
-    // If the above fails, delete the inserted creature
-    removeCreatureWork(archive.creature._id);
-    throw e;
-  }
-}
-
-const restoreCreaturefromFile = new ValidatedMethod({
-  name: 'Creatures.methods.restoreCreaturefromFile',
-  validate: new SimpleSchema({
-    'fileId': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  async run({fileId}) {
-    // fetch the file
-    const file = ArchiveCreatureFiles.findOne({_id: fileId}).get();
-    if (!file){
-      throw new Meteor.Error('File not found',
-      'The requested creature archive does not exist');
-    }
-    // Assert ownership
-    const userId = file?.userId;
-    if (!userId || userId !== this.userId){
-      throw new Meteor.Error('Permission denied',
-      'You can only restore creatures you own');
-    }
-
-    assertHasCharactersSlots(this.userId);
-
-    if (Meteor.isServer){
-      // Read the file data
-      const archive = await ArchiveCreatureFiles.readJSONFile(file);
-      restoreCreature(archive, this.userId);
-    }
-    //Remove the archive once the restore succeeded
-    ArchiveCreatureFiles.remove({ _id: fileId });
-    // Update the user's file storage limits
-    incrementFileStorageUsed(userId, -file.size);
-  },
-});
-
-export default restoreCreaturefromFile;

app/imports/api/creature/archive/methods/verifyArchiveSafety.js

@@ -1,28 +0,0 @@
-import { slice } from 'lodash';
-import PER_CREATURE_LOG_LIMIT from '/imports/api/creature/log/CreatureLogs.js';
-
-export default function verifyArchiveSafety({ meta, creature, properties, experiences, logs }){
-  const creatureId = creature._id;
-
-  // Check lengths of arrays
-  if (logs.length > PER_CREATURE_LOG_LIMIT) {
-    logs = slice(logs, 0, PER_CREATURE_LOG_LIMIT);
-  }
-
-  // Check that everything belongs to the right creature
-  logs.forEach(log => {
-    if (log.creatureId !== creatureId) {
-      throw new Meteor.Error('Malicious log', 'Log contains an entry for the wrong creature');
-    }
-  });
-  experiences.forEach(experience => {
-    if (experience.creatureId !== creatureId) {
-      throw new Meteor.Error('Malicious experience', 'Experiences contains an entry for the wrong creature');
-    }
-  });
-  properties.forEach(prop => {
-    if (prop.ancestors[0].id !== creatureId) {
-      throw new Meteor.Error('Malicious prop', 'Properties contains an entry for the wrong creature');
-    }
-  });
-}

app/imports/api/creature/creatureFolders/CreatureFolders.js

@@ -1,39 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-let CreatureFolders = new Mongo.Collection('creatureFolders');
-
-let creatureFolderSchema = new SimpleSchema({
-	name: {
-		type: String,
-		trim: false,
-		optional: true,
-    max: STORAGE_LIMITS.name,
-	},
-	creatures: {
-		type: Array,
-		defaultValue: [],
-	},
-	'creatures.$': {
-		type: String,
-		regEx: SimpleSchema.RegEx.Id,
-	},
-	owner: {
-		type: String,
-		regEx: SimpleSchema.RegEx.Id,
-    index: 1,
-	},
-  archived: {
-    type: Boolean,
-    optional: true,
-  },
-  order: {
-    type: Number,
-    defaultValue: 0,
-  },
-});
-
-CreatureFolders.attachSchema(creatureFolderSchema);
-
-import '/imports/api/creature/creatureFolders/methods.js/index.js';
-export default CreatureFolders;

app/imports/api/creature/creatureFolders/methods.js/index.js

@@ -1,4 +0,0 @@
-import '/imports/api/creature/creatureFolders/methods.js/insertCreatureFolder.js';
-import '/imports/api/creature/creatureFolders/methods.js/updateCreatureFolderName.js';
-import '/imports/api/creature/creatureFolders/methods.js/removeCreatureFolder.js';
-import '/imports/api/creature/creatureFolders/methods.js/moveCreatureToFolder.js';

app/imports/api/creature/creatureFolders/methods.js/insertCreatureFolder.js

@@ -1,46 +0,0 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-
-const insertCreatureFolder = new ValidatedMethod({
-  name: 'creatureFolders.methods.insert',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run() {
-    // Ensure logged in
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('creatureFolders.methods.insert.denied',
-      'You need to be logged in to insert a folder');
-    }
-    // Limit folders to 50 per user
-    let existingFolders = CreatureFolders.find({
-      owner: userId
-    }, {
-      fields: {order: 1},
-      sort: {order :-1}
-    });
-    if (existingFolders.count() >= 50){
-      throw new Meteor.Error('creatureFolders.methods.insert.denied',
-      'You can not have more than 50 folders');
-    }
-    // Make the new folder the last in the order
-    let order = 0;
-    let lastFolder = existingFolders.fetch()[0];
-    if (lastFolder){
-      order = (lastFolder.order || 0) + 1;
-    }
-    // Insert
-    return CreatureFolders.insert({
-      name: 'Folder',
-      owner: userId,
-      order,
-    });
-  },
-});
-
-export default insertCreatureFolder;

app/imports/api/creature/creatureFolders/methods.js/moveCreatureToFolder.js

@@ -1,45 +0,0 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-
-const moveCreatureToFolder = new ValidatedMethod({
-  name: 'creatureFolders.methods.moveCreatureToFolder',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({creatureId, folderId}) {
-    // Ensure logged in
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'You need to be logged in to remove a folder');
-    }
-    // Check that this folder is owned by the user
-    if (folderId){
-      let existingFolder = CreatureFolders.findOne(folderId);
-      if (existingFolder.owner !== userId){
-        throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-        'This folder does not belong to you');
-      }
-    }
-    // Remove from other folders
-    CreatureFolders.update({
-      owner: userId
-    }, {
-      $pull: {creatures: creatureId},
-    }, {
-      multi: true,
-    });
-    if (folderId){
-      // Add to this folder
-      CreatureFolders.update(folderId, {
-        $addToSet: {creatures: creatureId},
-      });
-    }
-  },
-});
-
-export default moveCreatureToFolder;

app/imports/api/creature/creatureFolders/methods.js/removeCreatureFolder.js

@@ -1,31 +0,0 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-
-const removeCreatureFolder = new ValidatedMethod({
-  name: 'creatureFolders.methods.remove',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id}) {
-    // Ensure logged in
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'You need to be logged in to remove a folder');
-    }
-    // Check that this folder is owned by the user
-    let existingFolder = CreatureFolders.findOne(_id);
-    if (existingFolder.owner !== userId){
-      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'This folder does not belong to you');
-    }
-    // Remove
-    return CreatureFolders.remove(_id);
-  },
-});
-
-export default removeCreatureFolder;

app/imports/api/creature/creatureFolders/methods.js/reorderCreatureFolder.js

@@ -1,43 +0,0 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-
-const reorderCreatureFolder = new ValidatedMethod({
-  name: 'creatureFolders.methods.reorder',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, order}) {
-    // Ensure logged in
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('creatureFolders.methods.reorder.denied',
-      'You need to be logged in to reorder a folder');
-    }
-    // Check that this folder is owned by the user
-    let existingFolder = CreatureFolders.findOne(_id);
-    if (existingFolder.owner !== userId){
-      throw new Meteor.Error('creatureFolders.methods.reorder.denied',
-      'This folder does not belong to you');
-    }
-    // First give it the new order, it should end in 0.5 putting it between two other docs
-    CreatureFolders.update(_id, {$set: {order}});
-    this.unblock();
-    // Reorder all the folders with integer numbers in this new order
-    CreatureFolders.find({
-      owner: userId
-    }, {
-      fields: {order: 1,},
-      sort: {order: -1}
-    }).forEach((folder, index) => {
-      if (folder.order !== index){
-        CreatureFolders.update(_id, {$set: {order: index}})
-      }
-    });
-  },
-});
-
-export default reorderCreatureFolder;

app/imports/api/creature/creatureFolders/methods.js/updateCreatureFolderName.js

@@ -1,31 +0,0 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-
-const updateCreatureFolderName = new ValidatedMethod({
-  name: 'creatureFolders.methods.updateName',
-  validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, name}) {
-    // Ensure logged in
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'You need to be logged in to update a folder');
-    }
-    // Check that this folder is owned by the user
-    let existingFolder = CreatureFolders.findOne(_id);
-    if (existingFolder.owner !== userId){
-      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'This folder does not belong to you');
-    }
-    // Update
-    return CreatureFolders.update(_id, {$set: {name}});
-  },
-});
-
-export default updateCreatureFolderName;

app/imports/api/creature/creatureProperties/CreatureProperties.js

@@ -1,112 +0,0 @@
-import { Mongo } from 'meteor/mongo';
-import SimpleSchema from 'simpl-schema';
-import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
-import ChildSchema from '/imports/api/parenting/ChildSchema.js';
-import SoftRemovableSchema from '/imports/api/parenting/SoftRemovableSchema.js';
-import propertySchemasIndex from '/imports/api/properties/computedPropertySchemasIndex.js';
-import { storedIconsSchema } from '/imports/api/icons/Icons.js';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-let CreatureProperties = new Mongo.Collection('creatureProperties');
-
-let CreaturePropertySchema = new SimpleSchema({
-  _id: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-  },
-  _migrationError: {
-    type: String,
-    optional: true,
-  },
-	type: {
-    type: String,
-    allowedValues: Object.keys(propertySchemasIndex),
-  },
-	tags: {
-		type: Array,
-		defaultValue: [],
-    maxCount: STORAGE_LIMITS.tagCount,
-	},
-	'tags.$': {
-		type: String,
-    max: STORAGE_LIMITS.tagLength,
-	},
-	disabled: {
-		type: Boolean,
-		optional: true,
-	},
-  icon: {
-    type: storedIconsSchema,
-    optional: true,
-    max: STORAGE_LIMITS.icon,
-  },
-  // Reference to the library node that this property was copied from
-  libraryNodeId: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    optional: true,
-  },
-});
-
-const DenormalisedOnlyCreaturePropertySchema = new SimpleSchema({
-  // Denormalised flag if this property is inactive on the sheet for any reason
-  // Including being disabled, or a decendent of a disabled property
-  inactive: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-    removeBeforeCompute: true,
-  },
-  // Denormalised flag if this property was made inactive by an inactive
-  // ancestor. True if this property has an inactive ancestor even if this
-  // property is itself inactive
-  deactivatedByAncestor: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-    removeBeforeCompute: true,
-  },
-  // Denormalised flag if this property was made inactive because of its own
-  // state
-  deactivatedBySelf: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-    removeBeforeCompute: true,
-  },
-  // Denormalised flag if this property was made inactive because of a toggle
-  // calculation. Either an ancestor toggle calculation or its own.
-  deactivatedByToggle: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-    removeBeforeCompute: true,
-  },
-  // When this is true on any property, the creature needs to be recomputed
-  dirty: {
-    type: Boolean,
-    // Default to true because new properties cause a recomputation
-    defaultValue: true,
-    optional: true,
-  },
-});
-
-CreaturePropertySchema.extend(DenormalisedOnlyCreaturePropertySchema);
-
-for (let key in propertySchemasIndex){
-	let schema = new SimpleSchema({});
-	schema.extend(propertySchemasIndex[key]);
-	schema.extend(CreaturePropertySchema);
-  schema.extend(ColorSchema);
-	schema.extend(ChildSchema);
-	schema.extend(SoftRemovableSchema);
-	CreatureProperties.attachSchema(schema, {
-		selector: {type: key}
-	});
-}
-
-export default CreatureProperties;
-export {
-  DenormalisedOnlyCreaturePropertySchema,
-	CreaturePropertySchema,
-};

app/imports/api/creature/creatureProperties/getRootCreatureAncestor.js

@@ -1,5 +0,0 @@
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-
-export default function getRootCreatureAncestor(property){
-  return Creatures.findOne(property.ancestors[0].id);
-}

app/imports/api/creature/creatureProperties/methods/adjustQuantity.js

@@ -1,63 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-
-const adjustQuantity = new ValidatedMethod({
-  name: 'creatureProperties.adjustQuantity',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id,
-    operation: {
-      type: String,
-      allowedValues: ['set', 'increment']
-    },
-    value: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, operation, value}) {
-    // Permissions
-		let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(property);
-		assertEditPermission(rootCreature, this.userId);
-
-    // Do work
-    adjustQuantityWork({property, operation, value});
-  },
-});
-
-export function adjustQuantityWork({property, operation, value}){
-  // Check if property has quantity
-  let schema = CreatureProperties.simpleSchema(property);
-  if (!schema.allowsKey('quantity')){
-    throw new Meteor.Error(
-      'Adjust quantity failed',
-      `Property of type "${property.type}" doesn't have a quantity`
-    );
-  }
-  if (operation === 'set'){
-    CreatureProperties.update(property._id, {
-      $set: {quantity: value, dirty: true}
-    }, {
-      selector: property
-    });
-  } else if (operation === 'increment'){
-    // value here is 'damage'
-    value = -value;
-    let currentQuantity = property.quantity;
-    if (currentQuantity + value < 0) value = -currentQuantity;
-    CreatureProperties.update(property._id, {
-      $inc: { quantity: value },
-      $set: { dirty: true }
-    }, {
-      selector: property
-    });
-  }
-}
-
-export default adjustQuantity;

app/imports/api/creature/creatureProperties/methods/damageProperty.js

@@ -1,139 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { applyTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import ActionContext from '/imports/api/engine/actions/ActionContext.js';
-
-const damageProperty = new ValidatedMethod({
-  name: 'creatureProperties.damage',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id,
-    operation: {
-      type: String,
-      allowedValues: ['set', 'increment']
-    },
-    value: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 20,
-    timeInterval: 5000,
-  },
-  run({ _id, operation, value }) {
-    
-    // Get action context
-    let prop = CreatureProperties.findOne(_id);
-    if (!prop) throw new Meteor.Error(
-      'Damage property failed', 'Property doesn\'t exist'
-    );
-    const creatureId = prop.ancestors[0].id;
-    const actionContext = new ActionContext(creatureId, [creatureId], this);
-    
-		// Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-
-		// Check if property can take damage
-		let schema = CreatureProperties.simpleSchema(prop);
-		if (!schema.allowsKey('damage')){
-			throw new Meteor.Error(
-				'Damage property failed',
-				`Property of type "${prop.type}" can't be damaged`
-			);
-    }
-
-    // Replace the prop by its actionContext counterpart if possible
-    if (prop.variableName) {
-      const actionContextProp = actionContext.scope[prop.variableName];
-      if (actionContextProp?._id === prop._id) {
-        prop = actionContextProp;
-      }
-    }
-    
-    const result = damagePropertyWork({ prop, operation, value, actionContext });
-  
-    // Insert the log
-    actionContext.writeLog();
-    return result;
-  },
-});
-
-export function damagePropertyWork({ prop, operation, value, actionContext }) {
-
-  // Save the value to the scope before applying the before triggers
-  if (operation === 'increment') {
-    if (value >= 0) {
-      actionContext.scope['$damage'] = value;
-    } else {
-      actionContext.scope['$healing'] = -value;
-    }
-  } else {
-    actionContext.scope['$set'] = value;
-  }
-
-  applyTriggers(actionContext.triggers?.damageProperty?.before, prop, actionContext);
-
-  // fetch the value from the scope after the before triggers, in case they changed them
-  if (operation === 'increment') {
-    if (value >= 0) {
-      value = actionContext.scope['$damage'];
-    } else {
-      value = -actionContext.scope['$healing'];
-    }
-  } else {
-    value = actionContext.scope['$set'];
-  }
-
-  let damage, newValue, increment;
-  if (operation === 'set'){
-    const total = prop.total || 0;
-    // Set represents what we want the value to be after damage
-    // So we need the actual damage to get to that value
-    damage = total - value;
-    // Damage can't exceed total value
-    if (damage > total && !prop.ignoreLowerLimit) damage = total;
-    // Damage must be positive
-    if (damage < 0 && !prop.ignoreUpperLimit) damage = 0;
-    newValue = prop.total - damage;
-    // Write the results
-    CreatureProperties.update(prop._id, {
-      $set: { damage, value: newValue, dirty: true }
-    }, {
-      selector: prop
-    });
-    // Also write it straight to the prop so that it is updated in the actionContext
-    prop.damage = damage;
-    prop.value = newValue;
-  } else if (operation === 'increment'){
-    let currentValue = prop.value || 0;
-    let currentDamage = prop.damage || 0;
-    increment = value;
-    // Can't increase damage above the remaining value
-    if (increment > currentValue && !prop.ignoreLowerLimit) increment = currentValue;
-    // Can't decrease damage below zero
-    if (-increment > currentDamage && !prop.ignoreUpperLimit) increment = -currentDamage;
-    damage = currentDamage + increment;
-    newValue = prop.total - damage;
-    // Write the results
-    CreatureProperties.update(prop._id, {
-      $inc: { damage: increment, value: -increment },
-      $set: { dirty: true },
-    }, {
-      selector: prop
-    });
-    // Also write it straight to the prop so that it is updated in the actionContext
-    prop.damage += increment;
-    prop.value -= increment;
-  }
-
-  applyTriggers(actionContext.triggers?.damageProperty?.after, prop, actionContext);
-
-  if (operation === 'set') {
-    return damage;
-  } else if (operation === 'increment') {
-    return increment;
-  }
-}
-
-export default damageProperty;

app/imports/api/creature/creatureProperties/methods/duplicateProperty.js

@@ -1,96 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import {
-	setLineageOfDocs,
-	renewDocIds
-} from '/imports/api/parenting/parenting.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-var snackbar;
-if (Meteor.isClient){
-  snackbar = require(
-    '/imports/ui/components/snackbars/SnackbarQueue.js'
-  ).snackbar
-}
-
-const DUPLICATE_CHILDREN_LIMIT = 50;
-
-const duplicateProperty = new ValidatedMethod({
-  name: 'creatureProperties.duplicate',
-  validate: new SimpleSchema({
-    _id: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    }
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id}) {
-    let property = CreatureProperties.findOne(_id);
-    let creature = getRootCreatureAncestor(property);
-
-    assertEditPermission(creature, this.userId);
-
-    // Renew the doc ID
-    let randomSrc = DDP.randomStream('duplicateProperty');
-    let propertyId = randomSrc.id();
-    property._id = propertyId;
-
-    // Get all the descendants
-    let nodes = CreatureProperties.find({
-			'ancestors.id': _id,
-			removed: {$ne: true},
-		}, {
-      limit: DUPLICATE_CHILDREN_LIMIT + 1,
-      sort: {order: 1},
-    }).fetch();
-
-    // Alert the user if the limit was hit
-    if (nodes.length > DUPLICATE_CHILDREN_LIMIT){
-      nodes.pop();
-      if (Meteor.isClient){
-        snackbar({
-          text: `Only the first ${DUPLICATE_CHILDREN_LIMIT} children were duplicated`,
-        });
-      }
-    }
-
-    // re-map all the ancestors
-    setLineageOfDocs({
-			docArray: nodes,
-			newAncestry : [
-        ...property.ancestors,
-        {id: propertyId, collection: 'creatureProperties'}
-      ],
-			oldParent : {id: _id, collection: 'creatureProperties'},
-		});
-
-    // Give the docs new IDs without breaking internal references
-    renewDocIds({docArray: nodes});
-
-    // Order the root node
-    property.order += 0.5;
-    
-    // Mark the sheet as needing recompute
-    property.dirty = true;
-
-    // Insert the properties
-		CreatureProperties.batchInsert([property, ...nodes]);
-
-    // Tree structure changed by inserts, reorder the tree
-    reorderDocs({
-      collection: CreatureProperties,
-      ancestorId: property.ancestors[0].id,
-    });
-
-    return propertyId;
-  },
-});
-
-export default duplicateProperty;

app/imports/api/creature/creatureProperties/methods/equipItem.js

@@ -1,51 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { organizeDoc } from '/imports/api/parenting/organizeMethods.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import BUILT_IN_TAGS from '/imports/constants/BUILT_IN_TAGS.js';
-import getParentRefByTag from '/imports/api/creature/creatureProperties/methods/getParentRefByTag.js';
-
-// Equipping or unequipping an item will also change its parent
-const equipItem = new ValidatedMethod({
-  name: 'creatureProperties.equip',
-  validate({_id, equipped}){
-		if (!_id) throw new Meteor.Error('No _id', '_id is required');
-    if (equipped !== true && equipped !== false) {
-      throw new Meteor.Error('No equipped', 'equipped is required to be true or false');
-    }
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, equipped}) {
-    let item = CreatureProperties.findOne(_id);
-    if (item.type !== 'item') throw new Meteor.Error('wrong type',
-    'Equip and unequip can only be performed on items');
-    let creature = getRootCreatureAncestor(item);
-    assertEditPermission(creature, this.userId);
-    CreatureProperties.update(_id, {
-      $set: { equipped, dirty: true },
-    }, {
-			selector: {type: 'item'},
-		});
-    let tag = equipped ? BUILT_IN_TAGS.equipment : BUILT_IN_TAGS.carried;
-    let parentRef = getParentRefByTag(creature._id, tag);
-    if (!parentRef) parentRef = {id: creature._id, collection: 'creatures'};
-
-    organizeDoc.call({
-      docRef: {
-        id: _id,
-        collection: 'creatureProperties',
-      },
-      parentRef,
-      order: Number.MAX_SAFE_INTEGER,
-      skipRecompute: true,
-    });
-  },
-});
-
-export default equipItem;

app/imports/api/creature/creatureProperties/methods/flipToggle.js

@@ -1,45 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-
-const flipToggle = new ValidatedMethod({
-  name: 'creatureProperties.flipToggle',
-  validate({_id}){
-		if (!_id) throw new Meteor.Error('No _id', '_id is required');
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id}) {
-    // Permission
-    let property = CreatureProperties.findOne(_id, {
-      fields: {type: 1, ancestors: 1, enabled: 1, disabled: 1}
-    });
-    if (property.type !== 'toggle'){
-      throw new Meteor.Error('wrong property',
-        'This method can only be applied to toggles');
-    }
-    if (!property.enabled && !property.disabled){
-      throw new Meteor.Error('Computed toggle',
-        'Can\'t flip a toggle that is computed')
-    }
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    // Invert the current value, disabled is the canonical store of value
-    const currentValue = !property.disabled;
-		CreatureProperties.update(_id, {$set: {
-      enabled: !currentValue,
-      disabled: currentValue,
-      dirty: true,
-    }}, {
-			selector: {type: 'toggle'},
-		});
-  },
-});
-
-export default flipToggle;

app/imports/api/creature/creatureProperties/methods/getParentRefByTag.js

@@ -1,13 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-
-export default function getParentRefByTag(creatureId, tag){
-  let prop = CreatureProperties.findOne({
-    'ancestors.id': creatureId,
-    removed: {$ne: true},
-    inactive: {$ne: true},
-    tags: tag,
-  }, {
-    sort: {order: 1},
-  });
-  return prop && {id: prop._id, collection: 'creatureProperties'};
-}

app/imports/api/creature/creatureProperties/methods/getSlotFillFilter.js

@@ -1,63 +0,0 @@
-export default function getSlotFillFilter({slot, libraryIds}){
-  let filter = {
-    removed: {$ne: true},
-    $and: []
-  };
-  if (libraryIds){
-    filter['ancestors.id'] = {$in: libraryIds};
-  }
-  if (slot.slotType){
-    filter.$and.push({
-      $or: [{
-        type: slot.slotType
-      },{
-        type: 'slotFiller',
-        slotFillerType: slot.slotType,
-      }]
-    });
-  } else if (slot.type === 'class') {
-    filter.$and.push({
-      $or: [{
-        type: 'classLevel',
-      },{
-        type: 'slotFiller',
-        slotFillerType: 'classLevel',
-      }]
-    });
-    if (slot.variableName) { 
-      filter.variableName = slot.variableName;
-    }
-
-    // Only search for levels the class needs
-    if (slot.missingLevels && slot.missingLevels.length) {
-      filter.level = {$in: slot.missingLevels};
-    } else {
-      filter.level = (slot.level || 0) + 1;
-    }
-  }
-  let tagsOr = [];
-  let tagsNin = [];
-  if (slot.slotTags && slot.slotTags.length){
-    tagsOr.push({tags: {$all: slot.slotTags}});
-  }
-  if (slot.extraTags && slot.extraTags.length){
-    slot.extraTags.forEach(extra => {
-      if (!extra.tags || !extra.tags.length) return;
-      if (extra.operation === 'OR'){
-        tagsOr.push({tags: {$all: extra.tags}});
-      } else if (extra.operation === 'NOT'){
-        tagsNin.push(...extra.tags);
-      }
-    });
-  }
-  if (tagsOr.length){
-    filter.$or = tagsOr;
-  }
-  if (tagsNin.length){
-    filter.$and.push({tags: {$nin: tagsNin}});
-  }
-  if (!filter.$and.length){
-    delete filter.$and;
-  }
-  return filter;
-}

app/imports/api/creature/creatureProperties/methods/index.js

@@ -1,13 +0,0 @@
-import '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
-import '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import '/imports/api/creature/creatureProperties/methods/duplicateProperty.js';
-import '/imports/api/creature/creatureProperties/methods/equipItem.js';
-import '/imports/api/creature/creatureProperties/methods/insertProperty.js';
-import '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
-import '/imports/api/creature/creatureProperties/methods/pullFromProperty.js';
-import '/imports/api/creature/creatureProperties/methods/pushToProperty.js';
-import '/imports/api/creature/creatureProperties/methods/restoreProperty.js';
-import '/imports/api/creature/creatureProperties/methods/selectAmmoItem.js';
-import '/imports/api/creature/creatureProperties/methods/softRemoveProperty.js';
-import '/imports/api/creature/creatureProperties/methods/updateCreatureProperty.js';
-import '/imports/api/creature/creatureProperties/methods/flipToggle.js';

app/imports/api/creature/creatureProperties/methods/insertProperty.js

@@ -1,145 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import SimpleSchema from 'simpl-schema';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-import { getAncestry } from '/imports/api/parenting/parenting.js';
-import getParentRefByTag from '/imports/api/creature/creatureProperties/methods/getParentRefByTag.js';
-import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
-import { getHighestOrder } from '/imports/api/parenting/order.js';
-
-const insertProperty = new ValidatedMethod({
-  name: 'creatureProperties.insert',
-	validate: new SimpleSchema({
-    creatureProperty: {
-      type: Object,
-      blackbox: true,
-    },
-    parentRef: RefSchema,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({creatureProperty, parentRef}) {
-    // get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
-
-		// Check permission to edit
-    let rootCreature;
-		if (parentRef.collection === 'creatures'){
-      rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
-      rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
-    assertEditPermission(rootCreature, this.userId);
-
-    creatureProperty.parent = parentRef;
-    creatureProperty.ancestors = ancestors;
-
-		return insertPropertyWork({
-      property: creatureProperty,
-      creature: rootCreature,
-    });
-  },
-});
-
-const insertPropertyAsChildOfTag = new ValidatedMethod({
-  name: 'creatureProperties.insertAsChildOfTag',
-  validate: new SimpleSchema({
-    creatureProperty: {
-      type: Object,
-      blackbox: true,
-    },
-    creatureId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    tag: {
-      type: String,
-      max: 20,
-    },
-    tagDefaultName: {
-      type: String,
-      max: 20,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({creatureProperty, creatureId, tag, tagDefaultName}) {
-    let parentRef = getParentRefByTag(creatureId, tag);
-
-    if (!parentRef){
-      // Use the creature as the parent and mark that we need to insert the folder first later
-      var insertFolderFirst = true;
-      parentRef = {id: creatureId, collection: 'creatures'};
-    }
-
-    // get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
-
-    // Check permission to edit
-    let rootCreature;
-		if (parentRef.collection === 'creatures'){
-      rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
-      rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
-    assertEditPermission(rootCreature, this.userId);
-
-    // Add the folder first if we need to
-    if (insertFolderFirst){
-      let order = getHighestOrder({
-        collection: CreatureProperties,
-        ancestorId: parentRef.id,
-      }) + 1;
-      let id = CreatureProperties.insert({
-        type: 'folder',
-        name: tagDefaultName || (tag.charAt(0).toUpperCase() + tag.slice(1)),
-        tags: [tag],
-        parent: parentRef,
-        ancestors: [parentRef],
-        order,
-      });
-      // Make the folder our new parent
-      let newParentRef = {id, collection: 'creatureProperties'};
-      ancestors = [parentRef, newParentRef];
-      parentRef = newParentRef;
-      creatureProperty.order = order + 1;
-    }
-
-    creatureProperty.parent = parentRef;
-    creatureProperty.ancestors = ancestors;
-
-		return insertPropertyWork({
-      property: creatureProperty,
-      creature: rootCreature,
-    });
-  },
-});
-
-export function insertPropertyWork({property, creature}){
-  delete property._id;
-  property.dirty = true;
-  let _id = CreatureProperties.insert(property);
-  // Tree structure changed by insert, reorder the tree
-  reorderDocs({
-    collection: CreatureProperties,
-    ancestorId: creature._id,
-  });
-  return _id;
-}
-
-export default insertProperty;
-export { insertPropertyAsChildOfTag };

app/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js

@@ -1,245 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import LibraryNodes from '/imports/api/library/LibraryNodes.js';
-import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import {
-	setLineageOfDocs,
-	getAncestry,
-	renewDocIds
-} from '/imports/api/parenting/parenting.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-import { setDocToLastOrder } from '/imports/api/parenting/order.js';
-import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
-
-const insertPropertyFromLibraryNode = new ValidatedMethod({
-	name: 'creatureProperties.insertPropertyFromLibraryNode',
-	validate: new SimpleSchema({
-    nodeIds: {
-      type: Array,
-      max: 20,
-    },
-		'nodeIds.$': {
-			type: String,
-			regEx: SimpleSchema.RegEx.Id,
-		},
-		parentRef: {
-			type: RefSchema,
-		},
-    order: {
-      type: Number,
-      optional: true,
-    },
-	}).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({nodeIds, parentRef, order}) {
-		// get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
-
-		// Check permission to edit
-    let rootCreature;
-		if (parentRef.collection === 'creatures'){
-      rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
-      rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
-    assertEditPermission(rootCreature, this.userId);
-
-    // {libraryId: hasViewPermission}
-    //let libraryPermissionMemoir = {};
-    let node;
-		nodeIds.forEach(nodeId => {
-      // TODO: Check library view permission for each node before starting
-      node = insertPropertyFromNode(nodeId, ancestors, order);
-    });
-
-    // get one of the root inserted docs
-    let rootId = node._id;
-
-    // Tree structure changed by inserts, reorder the tree
-    reorderDocs({
-      collection: CreatureProperties,
-      ancestorId: rootCreature._id,
-    });
-		// Return the docId of the last property, the inserted root property
-		return rootId;
-	},
-});
-
-function insertPropertyFromNode(nodeId, ancestors, order){
-  // Fetch the library node and its decendents, provided they have not been
-  // removed
-  // TODO: Check permission to read the library this node is in
-  let node = LibraryNodes.findOne({
-    _id: nodeId,
-    removed: {$ne: true},
-  });
-  if (!node) {
-    if (Meteor.isClient) return;
-    else {
-      throw new Meteor.Error(
-        'Insert property from library failed',
-        `No library document with id '${nodeId}' was found`
-      );
-    }
-  }
-  let oldParent = node.parent;
-  let nodes = LibraryNodes.find({
-    'ancestors.id': nodeId,
-    removed: {$ne: true},
-  }).fetch();
-
-  // Convert all references into actual nodes
-  nodes = reifyNodeReferences(nodes);
-
-  // The root node is first in the array of nodes
-  // It must get the first generated ID to prevent flickering
-  nodes = [node, ...nodes];
-
-  // set libraryNodeIds
-  storeLibraryNodeReferences(nodes);
-
-  // re-map all the ancestors
-  setLineageOfDocs({
-    docArray: nodes,
-    newAncestry: ancestors,
-    oldParent,
-  });
-
-  // Give the docs new IDs without breaking internal references
-  renewDocIds({
-    docArray: nodes,
-    collectionMap: {'libraryNodes': 'creatureProperties'}
-  });
-
-  // Order the root node
-  if (order === undefined){
-    setDocToLastOrder({
-      collection: CreatureProperties,
-      doc: node,
-    });
-  } else {
-    node.order = order;
-  }
-
-  // Mark all nodes as dirty
-  dirtyNodes(nodes);
-
-  // Insert the creature properties
-  CreatureProperties.batchInsert(nodes);
-  return node;
-}
-
-function storeLibraryNodeReferences(nodes){
-  nodes.forEach(node => {
-    if (node.libraryNodeId) return;
-    node.libraryNodeId = node._id;
-  });
-}
-
-function dirtyNodes(nodes) {
-  nodes.forEach(node => {
-    node.dirty = true;
-  });
-}
-
-// Covert node references into actual nodes
-// TODO: check permissions for each library a reference node references
-function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0){
-  depth += 1;
-  // New nodes added this function
-  let newNodes = [];
-
-  // Filter out the reference nodes we replace
-  let resultingNodes = nodes.filter(node => {
-    // This isn't a reference node, continue as normal
-    if (node.type !== 'reference') return true;
-
-    // We have gone too deep, keep the reference node as an error
-    if (depth >= 10){
-      if (Meteor.isClient) console.warn('Reference depth limit exceeded');
-      node.cache = {error: 'Reference depth limit exceeded'};
-      return true;
-    }
-
-    let referencedNode
-    try {
-      referencedNode = fetchDocByRef(node.ref);
-      referencedNode.order = node.order;
-      // We are definitely replacing this node, so add it to the list
-      visitedRefs.add(node._id);
-    } catch (e){
-      node.cache = {error: e.reason || e.message || e.toString()};
-      return true;
-    }
-
-    // Get all the descendants of the referenced node
-    let descendents = LibraryNodes.find({
-      'ancestors.id': referencedNode._id,
-      removed: {$ne: true},
-    }, {
-      sort: {order: 1},
-    }).fetch();
-
-    // We are adding the referenced node and its descendants
-    let addedNodes = [referencedNode, ...descendents];
-
-    // re-map all the ancestors to parent the new sub-tree into our existing
-    // node tree
-		setLineageOfDocs({
-			docArray: addedNodes,
-			newAncestry: node.ancestors,
-			oldParent: referencedNode.parent,
-		});
-
-    // Filter all the looped references
-    addedNodes = addedNodes.filter(addedNode => {
-      // Add all non-reference nodes
-      if (addedNode.type !== 'reference'){
-        return true;
-      }
-      // If this exact reference has already been resolved before, filter it out
-      if (visitedRefs.has(addedNode._id)){
-        return false;
-      } else {
-        // Otherwise mark it as visited, and keep it
-        visitedRefs.add(addedNode._id);
-        return true;
-      }
-    });
-
-    // Before renewing Ids make sure the library node reference is stored
-    storeLibraryNodeReferences(addedNodes);
-
-    // Give the new referenced sub-tree new ids
-    // The referenced node must get the id of the ref node so that the
-    // descendants of the ref node keep their ancestry intact
-    renewDocIds({
-      docArray: addedNodes,
-      idMap: { [referencedNode._id]: node._id },
-    });
-
-    // Reify the subtree as well with recursion
-    addedNodes = reifyNodeReferences(addedNodes, visitedRefs, depth);
-
-    // Store the new nodes from this inner loop without altering the array
-    // we are looping over
-    newNodes.push(...addedNodes);
-  });
-
-  // We are done filtering the array, we can add the new nodes to it
-  resultingNodes.push(...newNodes);
-
-  return resultingNodes;
-}
-
-export default insertPropertyFromLibraryNode;

app/imports/api/creature/creatureProperties/methods/pullFromProperty.js

@@ -1,32 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-
-const pullFromProperty = new ValidatedMethod({
-	name: 'creatureProperties.pull',
-	validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({_id, path, itemId}){
-    // Permissions
-		let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    // Do work
-		CreatureProperties.update(_id, {
-      $pull: { [path.join('.')]: { _id: itemId } },
-      $set: { dirty: true }
-		}, {
-			selector: {type: property.type},
-			getAutoValues: false,
-		});
-	}
-});
-
-export default pullFromProperty;

app/imports/api/creature/creatureProperties/methods/pushToProperty.js

@@ -1,49 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { get } from 'lodash';
-
-const pushToProperty = new ValidatedMethod({
-	name: 'creatureProperties.push',
-	validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({_id, path, value}){
-    // Permissions
-		let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    let joinedPath = path.join('.');
-
-    // Respect maxCount
-    let schema = CreatureProperties.simpleSchema(property);
-    let maxCount = schema.get(joinedPath, 'maxCount');
-
-    if (Number.isFinite(maxCount)){
-      let array = get(property, path);
-      let currentCount = array ? array.length : 0;
-      if (currentCount >= maxCount){
-        throw new Meteor.Error(
-          'Array is full',
-          `Cannot have more than ${maxCount} values`
-        );
-      }
-    }
-
-    // Do work
-		CreatureProperties.update(_id, {
-      $push: { [joinedPath]: value },
-      $set: { dirty: true },
-		}, {
-			selector: {type: property.type},
-		});
-	}
-});
-
-export default pushToProperty;

app/imports/api/creature/creatureProperties/methods/restoreProperty.js

@@ -1,36 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { restore } from '/imports/api/parenting/softRemove.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-
-const restoreProperty = new ValidatedMethod({
-	name: 'creatureProperties.restore',
-	validate: new SimpleSchema({
-		_id: SimpleSchema.RegEx.Id
-	}).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({_id}){
-    // Permissions
-		let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    // Do work
-    restore({
-      _id,
-      collection: CreatureProperties,
-      extraUpdates: {
-        $set: { dirty: true }
-      },
-    });
-	}
-});
-
-export default restoreProperty;

app/imports/api/creature/creatureProperties/methods/selectAmmoItem.js

@@ -1,46 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-
-const selectAmmoItem = new ValidatedMethod({
-  name: 'creatureProperties.selectAmmoItem',
-  validate: new SimpleSchema({
-    actionId: SimpleSchema.RegEx.Id,
-    itemId: SimpleSchema.RegEx.Id,
-    itemConsumedIndex: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({actionId, itemId, itemConsumedIndex}) {
-    // Permissions
-		let action = CreatureProperties.findOne(actionId);
-    let rootCreature = getRootCreatureAncestor(action);
-		assertEditPermission(rootCreature, this.userId);
-
-    // Check that this index has a document to edit
-    let itemConsumed = action.resources.itemsConsumed[itemConsumedIndex];
-    if (!itemConsumed){
-      throw new Meteor.Error('Resouce not found',
-        'Could not set ammo, because the ammo document was not found');
-    }
-    let itemToLink = CreatureProperties.findOne(itemId);
-    if (!itemToLink){
-      throw new Meteor.Error('Item not found',
-        'Could not set ammo: the item was not found');
-    }
-    let path = `resources.itemsConsumed.${itemConsumedIndex}.itemId`;
-    CreatureProperties.update(actionId, {
-      $set: { [path]: itemId, dirty: true }
-    }, {
-      selector: action,
-    });
-  },
-});
-
-export default selectAmmoItem;

app/imports/api/creature/creatureProperties/methods/softRemoveProperty.js

@@ -1,30 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { softRemove } from '/imports/api/parenting/softRemove.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-
-const softRemoveProperty = new ValidatedMethod({
-	name: 'creatureProperties.softRemove',
-	validate: new SimpleSchema({
-		_id: SimpleSchema.RegEx.Id
-	}).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({_id}){
-    // Permissions
-		let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    // Do work
-		softRemove({_id, collection: CreatureProperties});
-	}
-});
-
-export default softRemoveProperty;

app/imports/api/creature/creatureProperties/methods/updateCreatureProperty.js

@@ -1,49 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-
-const updateCreatureProperty = new ValidatedMethod({
-  name: 'creatureProperties.update',
-  validate({_id, path}){
-		if (!_id) throw new Meteor.Error('No _id', '_id is required');
-		// We cannot change these fields with a simple update
-		switch (path[0]){
-			case 'type':
-      case 'order':
-      case 'parent':
-      case 'ancestors':
-			case 'damage':
-				throw new Meteor.Error('Permission denied',
-				'This property can\'t be updated directly');
-		}
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, path, value}) {
-    // Permission
-    let property = CreatureProperties.findOne(_id, {
-      fields: {type: 1, ancestors: 1}
-    });
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-
-    let pathString = path.join('.');
-    let modifier;
-    // unset empty values
-    if (value === null || value === undefined){
-      modifier = { $unset: {[pathString]: 1}, $set: { dirty: true } };
-    } else {
-      modifier = { $set: {[pathString]: value, dirty: true } };
-    }
-		CreatureProperties.update(_id, modifier, {
-			selector: {type: property.type},
-		});
-  },
-});
-
-export default updateCreatureProperty;

app/imports/api/creature/creatureProperties/recomputeCreaturesByProperty.js

@@ -1,12 +0,0 @@
-import computeCreature from '/imports/api/engine/computeCreature.js';
-
-/**
- * Recomputes all ancestor creatures of this property
- */
-export default function recomputeCreaturesByProperty(property){
-	for (let ref of property.ancestors){
-		if (ref.collection === 'creatures') {
-			computeCreature.call(ref.id);
-		}
-	}
-}

app/imports/api/creature/creatures/CreatureVariables.js

@@ -1,21 +0,0 @@
-//set up the collection for creature variables
-let CreatureVariables = new Mongo.Collection('creatureVariables');
-
-// Unique index on _creatureId
-if (Meteor.isServer) {
-  CreatureVariables._ensureIndex({ _creatureId: 1 }, { unique: true })
-}
-
-/** No schema because the structure isn't known until compute time
- * Expect documents to looke like:
- * {
- *   _id: "nE8Ngd6K4L4jSxLY2",
- *   _creatureId: "nE8Ngd6K4L4jSxLY2", // indexed reference to the creature
- *   explicitlyDefinedVariableName: {...some creatureProperty}
- *   implicitVariableName: {value: 10},
- *   undefinedVariableName: {},
- * }
- * Where top level fields that don't start with `_` are variables on the sheet
-**/
-
-export default CreatureVariables;

app/imports/api/creature/creatures/Creatures.js

@@ -1,198 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import deathSaveSchema from '/imports/api/properties/subSchemas/DeathSavesSchema.js'
-import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
-import SharingSchema from '/imports/api/sharing/SharingSchema.js';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-//set up the collection for creatures
-let Creatures = new Mongo.Collection('creatures');
-
-let CreatureSettingsSchema = new SimpleSchema({
-	//slowed down by carrying too much?
-	useVariantEncumbrance: {
-		type: Boolean,
-		optional: true,
-	},
-	//hide spellcasting tab
-	hideSpellcasting: {
-		type: Boolean,
-		optional: true,
-	},
-	// Swap around the modifier and stat
-	swapStatAndModifier: {
-		type: Boolean,
-		optional: true,
-	},
-  // Hide all the unused stats
-  hideUnusedStats: {
-    type: Boolean,
-    optional: true,
-  },
-  // Show the tree tab
-  showTreeTab: {
-    type: Boolean,
-    optional: true,
-  },
-  // Hide the spells tab
-  hideSpellsTab: {
-    type: Boolean,
-    optional: true,
-  },
-  // Hide calculation errors
-  hideCalculationErrors: {
-    type: Boolean,
-    optional: true,
-  },
-  // How much each hitDice resets on a long rest
-  hitDiceResetMultiplier: {
-    type: Number,
-    optional: true,
-    min: 0,
-    max: 1,
-  },
-  discordWebhook: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.url,
-  },
-});
-
-let CreatureSchema = new SimpleSchema({
-	// Strings
-	name: {
-		type: String,
-		defaultValue: '',
-		optional: true,
-    max: STORAGE_LIMITS.name,
-	},
-	alignment: {
-		type: String,
-		optional: true,
-    max: STORAGE_LIMITS.name,
-	},
-	gender: {
-		type: String,
-		optional: true,
-    max: STORAGE_LIMITS.name,
-	},
-	picture: {
-		type: String,
-		optional: true,
-    max: STORAGE_LIMITS.url,
-	},
-  avatarPicture: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.url,
-  },
-
-  // Libraries
-  allowedLibraries: {
-    type: Array,
-    optional: true,
-		maxCount: 100,
-	},
-	'allowedLibraries.$': {
-		type: String,
-    regEx: SimpleSchema.RegEx.Id,
-	},
-	allowedLibraryCollections: {
-		type: Array,
-    optional: true,
-		maxCount: 100,
-	},
-	'allowedLibraryCollections.$': {
-		type: String,
-    regEx: SimpleSchema.RegEx.Id,
-  },
-
-	// Mechanics
-	deathSave: {
-		type: deathSaveSchema,
-		defaultValue: {},
-	},
-  // Stats that are computed and denormalised outside of recomputation
-  denormalizedStats: {
-    type: Object,
-    defaultValue: {},
-  },
-  // Sum of all XP gained by this character
-	'denormalizedStats.xp': {
-		type: SimpleSchema.Integer,
-		defaultValue: 0,
-	},
-  // Sum of all levels granted by milestone XP
-  'denormalizedStats.milestoneLevels': {
-    type: SimpleSchema.Integer,
-    defaultValue: 0,
-  },
-  // Does the character need a recompute?
-  dirty: {
-    type: Boolean,
-    optional: true,
-  },
-  // Version of computation engine that was last used to compute this creature
-  computeVersion: {
-		type: String,
-    optional: true,
-	},
-	type: {
-		type: String,
-		defaultValue: 'pc',
-		allowedValues: ['pc', 'npc', 'monster'],
-	},
-  damageMultipliers: {
-    type: Object,
-		blackbox: true,
-		defaultValue: {}
-  },
-	variables: {
-		type: Object,
-		blackbox: true,
-		defaultValue: {}
-	},
-  computeErrors: {
-    type: Array,
-    optional: true,
-  },
-  'computeErrors.$': {
-    type: Object,
-  },
-  'computeErrors.$.type': {
-    type: String,
-  },
-  'computeErrors.$.details' : {
-    type: Object,
-    blackbox: true,
-    optional: true,
-  },
-
-  // Tabletop
-  tabletop: {
-    type: String,
-    regEx: SimpleSchema.RegEx.id,
-    optional: true,
-  },
-  initiativeRoll: {
-    type: SimpleSchema.Integer,
-    optional: true,
-  },
-
-	// Settings
-	settings: {
-		type: CreatureSettingsSchema,
-		defaultValue: {},
-	},
-});
-
-CreatureSchema.extend(ColorSchema);
-CreatureSchema.extend(SharingSchema);
-
-Creatures.attachSchema(CreatureSchema);
-
-
-
-export default Creatures;
-export { CreatureSchema };
-
-import '/imports/api/engine/actions/doAction.js';

app/imports/api/creature/creatures/creaturePermissions.js

@@ -1,29 +0,0 @@
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import {
-  assertEditPermission as editPermission,
-  assertViewPermission as viewPermission,
-  assertOwnership as ownership
-} from '/imports/api/sharing/sharingPermissions.js';
-
-function getCreature(creature, fields){
-  if (typeof creature === 'string'){
-    return Creatures.findOne(creature, {fields});
-  } else {
-    return creature;
-  }
-}
-
-export function assertOwnership(creature, userId){
-  creature = getCreature(creature, {owner: 1});
-  ownership(creature, userId);
-}
-
-export function assertEditPermission(creature, userId) {
-  creature = getCreature(creature, {owner: 1, writers: 1});
-  editPermission(creature, userId);
-}
-
-export function assertViewPermission(creature, userId) {
-  creature = getCreature(creature, {owner: 1, readers:1, writers: 1, public: 1});
-  viewPermission(creature, userId);
-}

app/imports/api/creature/creatures/defaultCharacterProperties.js

@@ -1,47 +0,0 @@
-import BUILT_IN_TAGS from '/imports/constants/BUILT_IN_TAGS.js';
-
-export default function defaultCharacterProperties(creatureId){
-  if (!creatureId) throw 'creatureId is required';
-  const creatureRef = {collection: 'creatures', id: creatureId};
-  let randomSrc = DDP.randomStream('defaultProperties');
-  const inventoryId = randomSrc.id();
-  const inventoryRef = {collection: 'creatureProperties', id: inventoryId};
-  return [
-    {
-      type: 'propertySlot',
-      name: 'Ruleset',
-      description: {text: 'Choose a starting point for your character, this will define the basic setup of your character sheet. Without a base ruleset, your sheet will be empty.'},
-      slotTags: ['base'],
-      tags: [],
-      quantityExpected: {calculation: '1'},
-      hideWhenFull: true,
-      spaceLeft: 1,
-      totalFilled: 0,
-      order: 0,
-      parent: creatureRef,
-      ancestors: [creatureRef],
-    }, {
-      _id: inventoryId,
-      type: 'folder',
-      name: 'Inventory',
-      tags: [BUILT_IN_TAGS.inventory],
-      order: 1,
-      parent: creatureRef,
-      ancestors: [creatureRef],
-    }, {
-      type: 'folder',
-      name: 'Equipment',
-      tags: [BUILT_IN_TAGS.equipment],
-      order: 2,
-      parent: inventoryRef,
-      ancestors: [creatureRef, inventoryRef],
-    }, {
-      type: 'folder',
-      name: 'Carried',
-      tags: [BUILT_IN_TAGS.carried],
-      order: 3,
-      parent: inventoryRef,
-      ancestors: [creatureRef, inventoryRef],
-    },
-  ];
-}

app/imports/api/creature/creatures/getCreatureUrlName.js

@@ -1,5 +0,0 @@
-import getSlug from 'speakingurl';
-
-export default function getCreatureUrlName({name}){
-  return getSlug(name, {maintainCase: true}) || '-';
-}

app/imports/api/creature/creatures/methods/assertHasCharacterSlots.js

@@ -1,22 +0,0 @@
-import { getUserTier } from '/imports/api/users/patreon/tiers.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-
-export default function assertHasCharactersSlots(userId) {
-  if (characterSlotsRemaining(userId) <= 0) {
-    throw new Meteor.Error('characterSlotLimit',
-      'No character slots left')
-  }
-}
-
-export function characterSlotsRemaining(userId) {
-  let tier = getUserTier(userId);
-  const currentCharacterCount = Creatures.find({
-    owner: userId,
-  }, {
-    fields: { _id: 1 },
-  }).count();
-  if (tier.characterSlots === -1) {
-    return Number.POSITIVE_INFINITY;
-  }
-  return tier.characterSlots - currentCharacterCount;
-}

app/imports/api/creature/creatures/methods/changeAllowedLibraries.js

@@ -1,90 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import {assertEditPermission} from '/imports/api/sharing/sharingPermissions.js';
-import SimpleSchema from 'simpl-schema';
-import simpleSchemaMixin from '/imports/api/creature/mixins/simpleSchemaMixin.js';
-
-const changeAllowedLibraries = new ValidatedMethod({
-  name: 'creatures.changeAllowedLibraries',
-  mixins: [RateLimiterMixin, simpleSchemaMixin],
-  schema: new SimpleSchema({
-    _id: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    allowedLibraries: {
-      type: Array,
-      optional: true,
-      maxCount: 100,
-    },
-    'allowedLibraries.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    allowedLibraryCollections: {
-      type: Array,
-      optional: true,
-      maxCount: 100,
-    },
-    'allowedLibraryCollections.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }),
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({_id, allowedLibraries, allowedLibraryCollections}) {
-		let creature = Creatures.findOne(_id);
-    assertEditPermission(creature, this.userId);
-    let $set;
-    if (allowedLibraries) {
-      $set = { allowedLibraries }
-    }
-    if (allowedLibraryCollections) {
-      if (!$set) $set = {};
-      $set.allowedLibraryCollections = allowedLibraryCollections;
-    }
-    if (!$set) return;
-    Creatures.update(_id, {$set});
-  },
-});
-
-const toggleAllUserLibraries = new ValidatedMethod({
-  name: 'creatures.removeLibraryLimits',
-  mixins: [RateLimiterMixin, simpleSchemaMixin],
-  schema: new SimpleSchema({
-    _id: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    value: {
-      type: Boolean,
-    },
-  }),
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({_id, value}) {
-    if (value) {
-      Creatures.update(_id, {
-        $unset: {
-          allowedLibraryCollections: 1,
-          allowedLibraries: 1,
-        },
-      });
-    } else {
-      Creatures.update(_id, {
-        $set: {
-          allowedLibraryCollections: [],
-          allowedLibraries: [],
-        },
-      });
-    }
-  },
-});
-
-export {changeAllowedLibraries, toggleAllUserLibraries};

app/imports/api/creature/creatures/methods/index.js

@@ -1,5 +0,0 @@
-import '/imports/api/creature/creatures/methods/insertCreature.js';
-import '/imports/api/creature/creatures/methods/removeCreature.js';
-import '/imports/api/creature/creatures/methods/restCreature.js';
-import '/imports/api/creature/creatures/methods/updateCreature.js';
-import '/imports/api/creature/creatures/methods/changeAllowedLibraries.js';

app/imports/api/creature/creatures/methods/insertCreature.js

@@ -1,104 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import simpleSchemaMixin from '/imports/api/creature/mixins/simpleSchemaMixin.js';
-import Creatures, { CreatureSchema } from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import defaultCharacterProperties from '/imports/api/creature/creatures/defaultCharacterProperties.js';
-import insertPropertyFromLibraryNode from '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
-import assertHasCharactersSlots from '/imports/api/creature/creatures/methods/assertHasCharacterSlots.js';
-import getSlotFillFilter from '/imports/api/creature/creatureProperties/methods/getSlotFillFilter.js';
-import getCreatureLibraryIds from '/imports/api/library/getCreatureLibraryIds.js';
-import LibraryNodes from '/imports/api/library/LibraryNodes.js';
-import { insertExperienceForCreature } from '/imports/api/creature/experience/Experiences.js';
-import SimpleSchema from 'simpl-schema';
-
-const insertCreature = new ValidatedMethod({
-  name: 'creatures.insertCreature',
-  mixins: [RateLimiterMixin, simpleSchemaMixin],
-  schema: CreatureSchema.pick(
-    'name',
-    'gender',
-    'alignment',
-    'allowedLibraries',
-    'allowedLibraryCollections',
-  ).extend({
-    'startingLevel': {
-      type: SimpleSchema.Integer,
-      min: 0,
-    },
-  }),
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-
-  run({ name, gender, alignment, startingLevel,
-    allowedLibraries, allowedLibraryCollections }) {
-    const userId = this.userId
-    if (!userId) {
-      throw new Meteor.Error('Creatures.methods.insert.denied',
-        'You need to be logged in to insert a creature');
-    }
-
-    assertHasCharactersSlots(userId);
-
-    // Create the creature document
-    let creatureId = Creatures.insert({
-      owner: userId,
-      name,
-      gender,
-      alignment,
-      allowedLibraries,
-      allowedLibraryCollections,
-    });
-    
-    // Insert experience to get character to starting level
-    if (startingLevel) {
-      insertExperienceForCreature({
-        experience: {
-          name: 'Starting level',
-          levels: startingLevel,
-          creatureId
-        },
-        creatureId,
-        userId,
-      });
-    }
-
-    // Insert the default properties
-    // Not batchInsert because we want the properties cleaned by the schema
-    let baseId, rulesetSlot;
-    defaultCharacterProperties(creatureId).forEach(prop => {
-      let id = CreatureProperties.insert(prop);
-      if (prop.name === 'Ruleset'){
-        baseId = id;
-        rulesetSlot = prop;
-      }
-    });
-
-    // If the user only has a single ruleset subscribed, use it by default
-    if (Meteor.isServer) {
-      insertDefaultRuleset(creatureId, baseId, userId, rulesetSlot);
-    }
-
-		return creatureId;
-  },
-});
-
-// If the user only has a single ruleset subscribed, insert it by default
-function insertDefaultRuleset(creatureId, baseId, userId, slot) {
-  const libraryIds = getCreatureLibraryIds(creatureId, userId);
-  const filter = getSlotFillFilter({ slot, libraryIds });
-  const fillCursor = LibraryNodes.find(filter, { fields: { _id: 1 } });
-  const numRulesets = fillCursor.count();
-  if (numRulesets === 1) {
-    const ruleset = fillCursor.fetch()[0]
-    insertPropertyFromLibraryNode.call({
-      nodeIds: [ruleset._id],
-      parentRef: {id: baseId, collection: 'creatureProperties'},
-      order: 0.5,
-    });
-  }
-}
-
-export default insertCreature;

app/imports/api/creature/creatures/methods/removeCreature.js

@@ -1,43 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureVariables from '/imports/api/creature/creatures/CreatureVariables.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
-import Experiences from '/imports/api/creature/experience/Experiences.js';
-
-function removeRelatedDocuments(creatureId){
-  CreatureVariables.remove({_creatureId: creatureId});
-  CreatureProperties.remove({'ancestors.id': creatureId});
-  CreatureLogs.remove({creatureId});
-  Experiences.remove({creatureId});
-}
-
-const removeCreature = new ValidatedMethod({
-  name: 'Creatures.methods.removeCreature', // DDP method name
-  validate: new SimpleSchema({
-    charId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({charId}) {
-    assertOwnership(charId, this.userId)
-    this.unblock();
-    removeCreatureWork(charId)
-  },
-});
-
-export function removeCreatureWork(creatureId){
-  Creatures.remove(creatureId);
-  removeRelatedDocuments(creatureId);
-}
-
-export default removeCreature;

app/imports/api/creature/creatures/methods/restCreature.js

@@ -1,144 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { union } from 'lodash';
-import ActionContext from '/imports/api/engine/actions/ActionContext.js';
-import { applyTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-const restCreature = new ValidatedMethod({
-  name: 'creature.methods.rest',
-  validate: new SimpleSchema({
-    creatureId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    restType: {
-      type: String,
-      allowedValues: ['shortRest', 'longRest'],
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ creatureId, restType }) {
-    // Get action context
-    const actionContext = new ActionContext(creatureId, [creatureId], this);
-    // Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-
-    // Join, sort, and apply before triggers
-    const beforeTriggers = union(
-      actionContext.triggers.anyRest?.before, actionContext.triggers[restType]?.before
-    ).sort((a, b) => a.order - b.order);
-    applyTriggers(beforeTriggers, null, actionContext);
-
-    // Rest
-    actionContext.addLog({
-      name: restType === 'shortRest' ? 'Short rest' : 'Long rest',
-    });
-    doRestWork(restType, actionContext);
-
-    // Join, sort, and apply after triggers
-    const afterTriggers = union(
-      actionContext.triggers.anyRest?.after, actionContext.triggers[restType]?.after
-    ).sort((a, b) => a.order - b.order);
-    applyTriggers(afterTriggers, null, actionContext);
-
-    // Insert log
-    actionContext.writeLog();    
-  },
-});
-
-function doRestWork(restType, actionContext) {
-  const creatureId = actionContext.creature._id;
-  // Long rests reset short rest properties as well
-  let resetFilter;
-  if (restType === 'shortRest'){
-    resetFilter = 'shortRest'
-  } else {
-    resetFilter = {$in: ['shortRest', 'longRest']}
-  }
-  // Only apply to active properties
-  let filter = {
-    'ancestors.id': creatureId,
-    reset: resetFilter,
-    removed: { $ne: true },
-    inactive: { $ne: true },
-  };
-  // update all attribute's damage
-  filter.type = 'attribute';
-  CreatureProperties.update(filter, {
-    $set: {
-      damage: 0,
-      dirty: true,
-    }
-  }, {
-    selector: {type: 'attribute'},
-    multi: true,
-  });
-  // Update all action-like properties' usesUsed
-  filter.type = {$in: [
-    'action',
-    'attack',
-    'spell'
-  ]};
-  CreatureProperties.update(filter, {
-    $set: {
-      usesUsed: 0,
-      dirty: true,
-    }
-  }, {
-    selector: {type: 'action'},
-    multi: true,
-  });
-  // Reset half hit dice on a long rest, starting with the highest dice
-  if (restType === 'longRest'){
-    let hitDice = CreatureProperties.find({
-      'ancestors.id': creatureId,
-      type: 'attribute',
-      attributeType: 'hitDice',
-      removed: {$ne: true},
-      inactive: {$ne: true},
-    }, {
-      fields: {
-        hitDiceSize: 1,
-        damage: 1,
-        total: 1,
-      }
-    }).fetch();
-    // Use a collator to do sorting in natural order
-    let collator = new Intl.Collator('en', {
-      numeric: true, sensitivity: 'base'
-    });
-    // Get the hit dice in decending order of hitDiceSize
-    let compare = (a, b) => collator.compare(b.hitDiceSize, a.hitDiceSize)
-    hitDice.sort(compare);
-    // Get the total number of hit dice that can be recovered this rest
-    let totalHd = hitDice.reduce((sum, hd) => sum + (hd.total || 0), 0);
-    let resetMultiplier = actionContext.creature.settings.hitDiceResetMultiplier || 0.5;
-    let recoverableHd = Math.max(Math.floor(totalHd*resetMultiplier), 1);
-    // recover each hit dice in turn until the recoverable amount is used up
-    let amountToRecover, resultingDamage;
-    hitDice.forEach(hd => {
-      if (!recoverableHd) return;
-      amountToRecover = Math.min(recoverableHd, hd.damage || 0);
-      if (!amountToRecover) return;
-      recoverableHd -= amountToRecover;
-      resultingDamage = hd.damage - amountToRecover;
-      CreatureProperties.update(hd._id, {
-        $set: {
-          damage: resultingDamage,
-          dirty: true,
-        }
-      }, {
-        selector: {type: 'attribute'},
-      });
-    });
-  }
-}
-
-export default restCreature;

app/imports/api/creature/creatures/methods/updateCreature.js

@@ -1,45 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import {assertEditPermission} from '/imports/api/sharing/sharingPermissions.js';
-
-const updateCreature = new ValidatedMethod({
-  name: 'creatures.update',
-  validate({_id, path}){
-		if (!_id) return false;
-		// Allowed fields
-		let allowedFields = [
-      'name',
-      'alignment',
-      'gender',
-      'picture',
-      'avatarPicture',
-      'color',
-      'settings',
-    ];
-		if (!allowedFields.includes(path[0])){
-			throw new Meteor.Error('Creatures.methods.update.denied',
-      'This field can\'t be updated using this method');
-		}
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, path, value}) {
-		let creature = Creatures.findOne(_id);
-    assertEditPermission(creature, this.userId);
-    if (value === undefined || value === null){
-      Creatures.update(_id, {
-        $unset: {[path.join('.')]: 1},
-      });
-    } else {
-      Creatures.update(_id, {
-        $set: {[path.join('.')]: value},
-      });
-    }
-  },
-});
-
-export default updateCreature;

app/imports/api/creature/experience/Experiences.js

@@ -1,184 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-let Experiences = new Mongo.Collection('experiences');
-
-let ExperienceSchema = new SimpleSchema({
-	name: {
-		type: String,
-		optional: true,
-    max: STORAGE_LIMITS.name,
-	},
-	// The amount of XP this experience gives
-	xp: {
-		type: SimpleSchema.Integer,
-		optional: true,
-    min: 0,
-	},
-  // Setting levels instead of value grants whole levels
-  levels: {
-    type: SimpleSchema.Integer,
-    optional: true,
-    min: 0,
-    index: 1,
-  },
-	// The real-world date that it occured, usually sorted by date
-	date: {
-		type: Date,
-		autoValue: function() {
-			// If the date isn't set, set it to now
-			if (!this.isSet) {
-				return new Date();
-			}
-		},
-    index: 1,
-	},
-  creatureId: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    index: 1,
-  },
-});
-
-Experiences.attachSchema(ExperienceSchema);
-
-const insertExperienceForCreature = function({experience, creatureId, userId}){
-  if (experience.xp){
-    Creatures.update(creatureId, {
-      $inc: { 'denormalizedStats.xp': experience.xp },
-      $set: { dirty: true },
-    });
-  }
-  if (experience.levels) {
-    Creatures.update(creatureId, {
-      $inc: { 'denormalizedStats.milestoneLevels': experience.levels },
-      $set: { dirty: true },
-    });
-  }
-  experience.creatureId = creatureId;
-  let id = Experiences.insert(experience);
-  return id;
-};
-
-const insertExperience = new ValidatedMethod({
-  name: 'experiences.insert',
-  validate: new SimpleSchema({
-    experience: {
-      type: ExperienceSchema.omit('creatureId'),
-    },
-    creatureIds: {
-      type: Array,
-      max: 12,
-    },
-    'creatureIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({experience, creatureIds}) {
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('Experiences.methods.insert.denied',
-      'You need to be logged in to insert an experience');
-    }
-    let insertedIds = [];
-    creatureIds.forEach(creatureId => {
-      assertEditPermission(creatureId, userId);
-      let id = insertExperienceForCreature({experience, creatureId, userId});
-      insertedIds.push(id);
-    });
-    return insertedIds;
-  },
-});
-
-const removeExperience = new ValidatedMethod({
-  name: 'experiences.remove',
-  validate: new SimpleSchema({
-    experienceId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({experienceId}) {
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('Experiences.methods.remove.denied',
-      'You need to be logged in to remove an experience');
-    }
-    let experience = Experiences.findOne(experienceId);
-    if (!experience) return;
-    let creatureId = experience.creatureId
-    assertEditPermission(creatureId, userId);
-    if (experience.xp){
-      Creatures.update(creatureId, {
-        $inc: { 'denormalizedStats.xp': -experience.xp },
-        $set: { dirty: true },
-      });
-    }
-    if (experience.levels) {
-      Creatures.update(creatureId, {
-        $inc: { 'denormalizedStats.milestoneLevels': -experience.levels },
-        $set: { dirty: true },
-      });
-    }
-    experience.creatureId = creatureId;
-    let numRemoved = Experiences.remove(experienceId);
-    return numRemoved;
-  },
-});
-
-const recomputeExperiences = new ValidatedMethod({
-  name: 'experiences.recompute',
-  validate: new SimpleSchema({
-    creatureId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({creatureId}) {
-    let userId = this.userId;
-    if (!userId) {
-      throw new Meteor.Error('Experiences.methods.recompute.denied',
-      'You need to be logged in to recompute a creature\'s experiences');
-    }
-    assertEditPermission(creatureId, userId);
-
-    let xp = 0;
-    let milestoneLevels = 0;
-    Experiences.find({
-      creatureId
-    }, {
-      fields: {xp: 1, levels: 1}
-    }).forEach(experience => {
-      xp += experience.xp || 0;
-      milestoneLevels += experience.levels || 0;
-    });
-    Creatures.update(creatureId, {$set: {
-      'denormalizedStats.xp': xp,
-      'denormalizedStats.milestoneLevels': milestoneLevels,
-      dirty: true,
-    }});
-  },
-});
-
-export default Experiences;
-export { ExperienceSchema, insertExperience, insertExperienceForCreature, removeExperience, recomputeExperiences };

app/imports/api/creature/journal/JournalEntry.js

@@ -1,50 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-let ExperienceSchema = new SimpleSchema({
-	title: {
-		type: String,
-		optional: true,
-    max: STORAGE_LIMITS.name,
-	},
-	// Potentially long description of the event
-	description: {
-		type: String,
-		optional: true,
-    max: STORAGE_LIMITS.description,
-	},
-	// The real-world date that it occured
-	date: {
-		type: Date,
-		autoValue: function() {
-			// If the date isn't set, set it to now
-			if (!this.isSet) {
-				return new Date();
-			}
-		},
-	},
-	// The date in-world of this event
-	worldDate: {
-		type: String,
-		optional: true,
-    max: STORAGE_LIMITS.name,
-	},
-  // Tags to better find this entry later
-  tags: {
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.tagCount,
-  },
-  'tags.$': {
-    type: String,
-    max: STORAGE_LIMITS.tagLength,
-  },
-  // ID of the journal this entry belongs to
-  journalId: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    index: 1,
-  }
-});
-
-export { ExperienceSchema };

app/imports/api/creature/log/CreatureLogs.js

@@ -1,214 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureVariables from '/imports/api/creature/creatures/CreatureVariables.js';
-import LogContentSchema from '/imports/api/creature/log/LogContentSchema.js';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import {assertEditPermission} from '/imports/api/creature/creatures/creaturePermissions.js';
-import {parse, prettifyParseError} from '/imports/parser/parser.js';
-import resolve, { toString } from '/imports/parser/resolve.js';
-const PER_CREATURE_LOG_LIMIT = 100;
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-if (Meteor.isServer){
-  var sendWebhookAsCreature = require('/imports/server/discord/sendWebhook.js').sendWebhookAsCreature;
-}
-
-let CreatureLogs = new Mongo.Collection('creatureLogs');
-
-let CreatureLogSchema = new SimpleSchema({
-  content: {
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.logContentCount,
-  },
-  'content.$': {
-    type: LogContentSchema,
-  },
-	// The real-world date that it occured, usually sorted by date
-	date: {
-		type: Date,
-		autoValue: function() {
-			// If the date isn't set, set it to now
-			if (!this.isSet) {
-				return new Date();
-			}
-		},
-    index: 1,
-	},
-  creatureId: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    index: 1,
-  },
-  creatureName: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-});
-
-CreatureLogs.attachSchema(CreatureLogSchema);
-
-function removeOldLogs(creatureId){
-  // Find the first log that is over the limit
-  let firstExpiredLog = CreatureLogs.find({
-    creatureId
-  }, {
-    sort: {date: -1},
-    skip: PER_CREATURE_LOG_LIMIT,
-  });
-  if (!firstExpiredLog) return;
-  // Remove all logs older than the one over the limit
-  CreatureLogs.remove({
-    creatureId,
-    date: {$lte: firstExpiredLog.date},
-  });
-}
-
-function logToMessageData(log){
-  let embed = {
-    fields: [],
-  };
-  log.content.forEach(field => {
-    if (!field.name) field.name = '\u200b';
-    if (!field.value) field.value = '\u200b';
-    embed.fields.push(field);
-  });
-  return { embeds: [embed] };
-}
-
-function logWebhook({log, creature}){
-  if (Meteor.isServer){
-    sendWebhookAsCreature({
-      creature,
-      data: logToMessageData(log),
-    });
-  }
-}
-
-const insertCreatureLog = new ValidatedMethod({
-  name: 'creatureLogs.methods.insert',
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	validate: new SimpleSchema({
-		log: CreatureLogSchema.omit('date'),
-	}).validator(),
-  run({log}){
-    const creatureId = log.creatureId;
-    const creature = Creatures.findOne(creatureId, {fields: {
-      readers: 1,
-      writers: 1,
-      owner: 1,
-      'settings.discordWebhook': 1,
-      name: 1,
-      avatarPicture: 1,
-    }});
-    assertEditPermission(creature, this.userId);
-    // Build the new log
-    let id = insertCreatureLogWork({log, creature, method: this})
-    return id;
-  },
-});
-
-export function insertCreatureLogWork({log, creature, method}){
-  // Build the new log
-  if (typeof log === 'string'){
-    log = {content: [{value: log}]};
-  }
-  if (!log.content?.length) return;
-  log.date = new Date();
-  // Insert it
-  let id = CreatureLogs.insert(log);
-  if (Meteor.isServer){
-    method?.unblock();
-    removeOldLogs(creature._id);
-    logWebhook({log, creature});
-  }
-  return id;
-}
-
-
-function equalIgnoringWhitespace(a, b){
-  if (typeof a !== 'string' || typeof b !== 'string') return a === b;
-  return a.replace(/\s/g,'') === b.replace(/\s/g, '');
-}
-
-const logRoll = new ValidatedMethod({
-  name: 'creatureLogs.methods.logForCreature',
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	validate: new SimpleSchema({
-		roll: {
-			type: String,
-		},
-		creatureId: {
-			type: String,
-			regEx: SimpleSchema.RegEx.Id,
-		},
-	}).validator(),
-  run({roll, creatureId}){
-    const creature = Creatures.findOne(creatureId, {fields: {
-      readers: 1,
-      writers: 1,
-      owner: 1,
-      'settings.discordWebhook': 1,
-      name: 1,
-      avatarPicture: 1,
-    }});
-    assertEditPermission(creature, this.userId);
-    const variables = CreatureVariables.findOne({ _creatureId: creatureId });
-    let logContent = []
-    let parsedResult = undefined;
-    try {
-      parsedResult = parse(roll);
-    } catch (e){
-      let error = prettifyParseError(e);
-      logContent.push({name: 'Parse Error', value: error});
-    }
-    if (parsedResult) try {
-      let {
-        result: compiled,
-        context
-      } = resolve('compile', parsedResult, variables);
-      const compiledString = toString(compiled);
-      if (!equalIgnoringWhitespace(compiledString, roll)) logContent.push({
-        value: roll
-      });
-      logContent.push({
-        value: compiledString
-      });
-      let {result: rolled} = resolve('roll', compiled, variables, context);
-      let rolledString = toString(rolled);
-      if (rolledString !== compiledString) logContent.push({
-        value: rolledString
-      });
-      let {result} = resolve('reduce', rolled, variables, context);
-      let resultString = toString(result);
-      if (resultString !== rolledString) logContent.push({
-        value: resultString
-      });
-    } catch (e){
-      console.error(e);
-      logContent = [{name: 'Calculation error'}];
-    }
-    const log = {
-      content: logContent,
-      creatureId,
-      date: new Date(),
-    };
-
-    let id = insertCreatureLogWork({log, creature, method: this});
-
-    return id;
-  },
-});
-
-export default CreatureLogs;
-export { CreatureLogSchema, insertCreatureLog, logRoll, PER_CREATURE_LOG_LIMIT};

app/imports/api/creature/log/LogContentSchema.js

@@ -1,51 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
-import RollDetailsSchema from '/imports/api/properties/subSchemas/RollDetailsSchema.js';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
-
-let LogContentSchema = new SimpleSchema({
-  // The name of the field, included in discord webhook message
-  name: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.name,
-  },
-  // The details of the field, included in discord webhook message
-  // Markdown support
-  value: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.summary,
-  },
-  // Inline with other content fields
-  inline: {
-    type: Boolean,
-    optional: true,
-  },
-  context: {
-    type: Object,
-    optional: true,
-  },
-  'context.errors':{
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.errorCount,
-  },
-  'context.errors.$': {
-    type: ErrorSchema,
-  },
-  'context.rolls': {
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.rollCount,
-  },
-  'context.rolls.$': {
-    type: RollDetailsSchema,
-  },
-  'context.doubleRolls': {
-    type: Boolean,
-    optional: true,
-  },
-});
-
-export default LogContentSchema;

app/imports/api/creature/mixins/creaturePermissionMixin.js

@@ -1,52 +0,0 @@
-import {
-  assertEditPermission,
-  assertViewPermission,
-  assertOwnership,
-} from '/imports/api/creature/creatures/creaturePermissions.js';
-
-// Checks if the method has permission to run on the document. If the document
-// has a charId, that creature is checked, otherwise if it has an _id and the
-// collection is defined in the method options, that document is fetched to
-// determine its charId, otherwise a getCharId method can be defined to perform
-// a special search for the required creature
-//
-// Because this mixin injects the charId into argument objects that don't
-// already contain it, it should always come last in the mixin list, so that it
-// the outermost wrapper of the run function
-export default function creaturePermissionMixin(methodOptions){
-  let assertPermission;
-  if (methodOptions.permission === 'owner'){
-    assertPermission = assertOwnership;
-  } else if (methodOptions.permission === 'edit'){
-    assertPermission = assertEditPermission;
-  } else if (methodOptions.permission === 'view'){
-    assertPermission = assertViewPermission;
-  } else {
-    throw "`permission` missing in method options";
-  }
-
-  let getCharId;
-  if (methodOptions.getCharId){
-    getCharId = methodOptions.getCharId;
-  } else if (methodOptions.collection) {
-    getCharId = function({_id}){
-      return methodOptions.collection.findOne(_id, {
-        fields: {charId: 1}
-      }).charId;
-    };
-  } else {
-    getCharId = function(){
-      throw "`getCharId` or `collection` missing in method options," +
-      " or {charId} missing in call";
-    };
-  }
-
-  let runFunc = methodOptions.run;
-  methodOptions.run = function(doc, ...rest){
-    // Store the charId on the doc for other mixins if it had to be fetched
-    doc.charId = doc.charId || getCharId.apply(this, arguments);
-    assertPermission(doc.charId, this.userId);
-    return runFunc.call(this, doc, ...rest);
-  };
-  return methodOptions;
-}

app/imports/api/creature/mixins/propagateInheritanceUpdateMixin.js

@@ -1,59 +0,0 @@
-import {
-  updateChildren,
-  updateDescendants,
-} from '/imports/api/parenting/parenting.js';
-import { inheritedFields } from '/imports/api/parenting/ChildSchema.js';
-import MONGO_OPERATORS from '/imports/constants/MONGO_OPERATORS.js';
-
-// This mixin can be safely applied to all update methods which are validated
-// with the updateSchemaMixin. It will propagate updates to fields which
-// are inherited and normalised on the parent or ancestor docs
-// It should have neglible performance impact for updates that aren't inherited
-function propagateInheritanceUpdate({_id, update}){
-  let childModifier = {};
-  let descendantModifier = {};
-  // For each operator
-  for (let operator of MONGO_OPERATORS){
-    // If the operator is in the update, for each field
-    if (update[operator]) for (let field in update[operator]){
-      // Get the top level field that was actually modified
-      const indexOfDot = field.indexOf('.');
-      let modifiedField;
-      if (indexOfDot !== -1) {
-        modifiedField = field.substring(0, indexOfDot);
-      } else {
-        modifiedField = field;
-      }
-      // If that field is updated and inherited
-      if (inheritedFields.has(modifiedField)){
-        // Perform the same update on the descendants
-        if (!childModifier[operator]) childModifier[operator] = {};
-        if (!descendantModifier[operator]) descendantModifier[operator] = {};
-        childModifier[operator][`parent.${field}`] = update[operator][field];
-        descendantModifier[operator][`ancestors.$.${field}`] = update[operator][field];
-      }
-    }
-  }
-
-  // Update the parent object of its children
-  updateChildren({
-    parentId: _id,
-    modifier: childModifier,
-  });
-
-  // Update the ancestors object of its descendants
-  updateDescendants({
-    ancestorId: _id,
-    modifier: descendantModifier,
-  });
-}
-
-export default function propagateInheritanceUpdateMixin(methodOptions){
-  let runFunc = methodOptions.run;
-  methodOptions.run = function({_id, update}){
-    const result = runFunc.apply(this, arguments);
-    propagateInheritanceUpdate({_id, update});
-    return result;
-  };
-  return methodOptions;
-}

app/imports/api/creature/mixins/recomputeCreatureMixin.js

@@ -1,17 +0,0 @@
-import computeCreature from '/imports/api/engine/computeCreature.js';
-
-export default function recomputeCreatureMixin(methodOptions){
-  let runFunc = methodOptions.run;
-  methodOptions.run = function({charId}){
-    const result = runFunc.apply(this, arguments);
-    if (
-      methodOptions.skipRecompute &&
-      methodOptions.skipRecompute.apply(this, arguments)
-    ) {
-      return result;
-    }
-    computeCreature(charId);
-    return result;
-  };
-  return methodOptions;
-}

app/imports/api/creature/mixins/setDocToLastMixin.js

@@ -1,27 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { setDocToLastOrder } from '/imports/api/parenting/order.js';
-
-export function setDocToLastMixin(methodOptions){
-  // Make sure the doc has a charId
-  // This mixin should come before simpleSchemaMixin so that it can extend the
-  // schema before it is turned into a validate function
-  if (methodOptions.validate){
-    throw new Meteor.Error(`setDocToLastMixin should come before simpleSchemaMixin`);
-  }
-  methodOptions.schema = new SimpleSchema({
-    charId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).extend(methodOptions.schema);
-  let collection = methodOptions.collection;
-  if (!collection){
-    throw new Meteor.Error("`collection` required in method options for setDocToLastMixin");
-  }
-  let runFunc = methodOptions.run;
-  methodOptions.run = function(doc){
-    setDocToLastOrder({collection, doc});
-    return runFunc.apply(this, arguments);
-  };
-  return methodOptions;
-}

app/imports/api/creature/mixins/simpleSchemaMixin.js

@@ -1,51 +0,0 @@
-// Copied from https://github.com/sethjgore/meteor-simple-schema-mixin
-// and updated to simpl-schema npm package
-import SimpleSchema from 'simpl-schema';
-
-export default function simpleSchemaMixin(methodOptions) {
-  // If the user didn't give us a schema and they did give us a validate, assume
-  // that they are choosing to use the validate way of doing things in this call.
-  //  If they've built a wrapper around ValidateMethod that includes this mixin
-  // all the time, this could happen semi-"intentionally". There may be times they
-  // just don't want to use a schema and have specified a "validate" option. So
-  // returning the unchanged options instead of an error seems proper.
-  if ((typeof methodOptions.schema === 'undefined'
-      && typeof methodOptions.validate !== 'undefined')
-    || (typeof methodOptions.schema !== 'undefined' && methodOptions.schema === null
-      && typeof methodOptions.validate !== 'undefined' && methodOptions.validate !== null)) {
-    return methodOptions;
-  }
-
-  // If they truly gave us both... that just doesn't seem proper.
-  if (methodOptions.validate && methodOptions.validate !== null) {
-    throw new Meteor.Error(
-      'simpleSchemaMixin.options',
-      '"schema" and "validate" options cannot be used together');
-  }
-
-  // Note that setting them both null will make it through, defaulting to the
-  // schema = null behavior (enforce no args) instead of the validate = null
-  // behavior (do no validation).
-
-  const newOptions = methodOptions;
-  newOptions.schemaValidatorOptions =
-    newOptions.schemaValidatorOptions ||
-    { clean: true, filter: false };
-  let simpleSchema;
-  if (!newOptions.schema || newOptions.schema === null) {
-    // Allow simply leaving off both the schema and validate specifications
-    // or setting them to "null" as a shorthand. In this case, unlike
-    // the straight default validate or typical coder's call to validator,
-    // we will ENFORCE the Method be called without parameters because of
-    // the "filter: false" above.
-    simpleSchema = new SimpleSchema({});
-  } else if (newOptions.schema instanceof SimpleSchema) {
-    // In this one case, we can save ourselves the time to make a schema out
-    // of the schema.
-    simpleSchema = newOptions.schema;
-  } else {
-    simpleSchema = new SimpleSchema(newOptions.schema);
-  }
-  newOptions.validate = simpleSchema.validator(newOptions.schemaValidatorOptions);
-  return newOptions;
-};

app/imports/api/creature/mixins/updateSchemaMixin.js

@@ -1,67 +0,0 @@
-const argumentSchema = new SimpleSchema({
-  _id: SimpleSchema.RegEx.Id,
-  update: {
-    type: Object,
-    blackbox: true,
-  },
-});
-
-// Modified simpleSchemaMixin
-import SimpleSchema from 'simpl-schema';
-
-export default function updateSchemaMixin(methodOptions) {
-  // If the user didn't give us a schema and they did give us a validate, assume
-  // that they are choosing to use the validate way of doing things in this call.
-  if ((
-    typeof methodOptions.schema === 'undefined' &&
-    typeof methodOptions.validate !== 'undefined'
-  ) || (
-    typeof methodOptions.schema !== 'undefined' &&
-    methodOptions.schema === null &&
-    typeof methodOptions.validate !== 'undefined' &&
-    methodOptions.validate !== null
-  )) {
-    return methodOptions;
-  }
-
-  // If they truly gave us both... that just doesn't seem proper.
-  if (methodOptions.validate && methodOptions.validate !== null) {
-    throw new Meteor.Error(
-      'simpleSchemaMixin.options',
-      '"schema" and "validate" options cannot be used together');
-  }
-
-  // Note that setting them both null will make it through, defaulting to the
-  // schema = null behavior (enforce no args) instead of the validate = null
-  // behavior (do no validation).
-
-  // Apply default validator options if none are provided
-  methodOptions.schemaValidatorOptions =
-    methodOptions.schemaValidatorOptions ||
-    { clean: true, modifier: true };
-
-  // Make the update schema a SimpleSchema, if it isn't already
-  let updateSchema;
-  if (methodOptions.schema instanceof SimpleSchema) {
-    updateSchema = methodOptions.schema;
-  } else {
-    updateSchema = new SimpleSchema(methodOptions.schema);
-  }
-
-  // Set up the new validation
-  methodOptions.validate = function(args){
-    argumentSchema.validate(args);
-    updateSchema.validate(
-      {$set: args.update},
-      methodOptions.schemaValidatorOptions
-    );
-  };
-
-  // Give a default run function if one isn't supplied
-  if (!methodOptions.run){
-    methodOptions.run = function({_id, update}){
-      return methodOptions.collection.update(_id, {$set: update});
-    };
-  }
-  return methodOptions;
-}

app/imports/api/engine/actions/ActionContext.js

@@ -1,78 +0,0 @@
-import { CreatureLogSchema, insertCreatureLogWork } from '/imports/api/creature/log/CreatureLogs.js';
-import {
-  getCreature, getVariables, getPropertiesOfType
-} from '/imports/api/engine/loadCreatures.js';
-import { groupBy, remove } from 'lodash';
-
-export default class ActionContext{
-  constructor(creatureId, targetIds = [], method) {
-    // Get the creature
-    this.creature = getCreature(creatureId)
-
-    if (!this.creature) {
-      throw new Meteor.Error('No Creature', `No creature could be found with id: ${creatureId}`)
-    }
-    // Create a log
-    this.log = CreatureLogSchema.clean({
-      creatureId: creatureId,
-      creatureName: this.creature.name,
-    });
-
-    // Get the variables of the acting creature
-    this.creature.variables = getVariables(creatureId);
-    delete this.creature.variables._id;
-    delete this.creature.variables._creatureId;
-    // Alias as scope
-    this.scope = this.creature.variables;
-
-    // Get the targets and their variables
-    this.targets = [];
-    targetIds.forEach(targetId => {
-      let target;
-      if (targetId === creatureId) {
-        target = this.creature;
-      } else {
-        target = getCreature(targetId);
-        target.variables = getVariables(targetId);
-        delete target.variables._id;
-        delete target.variables._creatureId;
-      }
-      this.targets.push(target);
-    });
-
-    // Store a reference to the method for inserting the log
-    this.method = method;
-
-    // Get triggers
-    this.triggers = getPropertiesOfType(creatureId, 'trigger');
-    // Remove deleted or inactive triggers
-    remove(this.triggers, trigger => trigger.removed || trigger.inactive);
-    // Sort triggers by order
-    this.triggers.sort((a, b) => a.order - b.order);
-    // Group the triggers into triggers.<event>.<timing> or
-    // triggers.doActionProperty.<propertyType>.<timing>
-    this.triggers = groupBy(this.triggers, 'event');
-    for (let event in this.triggers) {
-      if (event === 'doActionProperty') {
-        this.triggers[event] = groupBy(this.triggers[event], 'actionPropertyType');
-        for (let propertyType in this.triggers[event]) {
-          this.triggers[event][propertyType] = groupBy(this.triggers[event][propertyType], 'timing');
-        }
-      } else {
-        this.triggers[event] = groupBy(this.triggers[event], 'timing');
-      }
-    }
-  }
-  addLog(content) {
-    if (content.name || content.value){
-      this.log.content.push(content);
-    }
-  }
-  writeLog() {
-    insertCreatureLogWork({
-      log: this.log,
-      creature: this.creature,
-      method: this.method,
-    });
-  }
-}

app/imports/api/engine/actions/applyProperty.js

@@ -1,29 +0,0 @@
-import action from './applyPropertyByType/applyAction.js';
-import adjustment from './applyPropertyByType/applyAdjustment.js';
-import branch from './applyPropertyByType/applyBranch.js';
-import buff from './applyPropertyByType/applyBuff.js';
-import buffRemover from './applyPropertyByType/applyBuffRemover.js';
-import damage from './applyPropertyByType/applyDamage.js';
-import note from './applyPropertyByType/applyNote.js';
-import roll from './applyPropertyByType/applyRoll.js';
-import savingThrow from './applyPropertyByType/applySavingThrow.js';
-import toggle from './applyPropertyByType/applyToggle.js';
-
-const applyPropertyByType = {
-  action,
-  adjustment,
-  branch,
-  buff,
-  buffRemover,
-  damage,
-  note,
-  roll,
-  savingThrow,
-  spell: action,
-  toggle,
-};
-
-export default function applyProperty(node, actionContext, ...rest) {
-  actionContext.scope[`#${node.node.type}`] = node.node;
-  applyPropertyByType[node.node.type]?.(node, actionContext, ...rest);
-}

app/imports/api/engine/actions/applyPropertyByType/applyAction.js

@@ -1,301 +0,0 @@
-import recalculateInlineCalculations from './shared/recalculateInlineCalculations.js';
-import recalculateCalculation from './shared/recalculateCalculation.js';
-import rollDice from '/imports/parser/rollDice.js';
-import applyProperty from '../applyProperty.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { adjustQuantityWork } from '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import numberToSignedString from '/imports/ui/utility/numberToSignedString.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyAction(node, actionContext) {
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-  if (prop.target === 'self') actionContext.targets = [actionContext.creature];
-  const targets = actionContext.targets;
-
-  // Log the name and summary
-  let content = { name: prop.name };
-  if (prop.summary?.text){
-    recalculateInlineCalculations(prop.summary, actionContext);
-    content.value = prop.summary.value;
-  }
-  if (!prop.silent) actionContext.addLog(content);
-
-  // Spend the resources
-  const failed = spendResources(prop, actionContext);
-  if (failed) return;
-
-  const attack = prop.attackRoll || prop.attackRollBonus;
-
-  // Attack if there is an attack roll
-  if (attack && attack.calculation){
-    if (targets.length){
-      targets.forEach(target => {
-        applyAttackToTarget({attack, target, actionContext});
-        // Apply the children, but only to the current target
-        actionContext.targets = [target];
-        applyChildren(node, actionContext);
-      });
-    } else {
-      applyAttackWithoutTarget({attack, actionContext});
-      applyChildren(node, actionContext);
-    }
-  } else {
-    applyChildren(node, actionContext);
-  }
-}
-
-function applyAttackWithoutTarget({attack, actionContext}){
-  delete actionContext.scope['$attackHit'];
-  delete actionContext.scope['$attackMiss'];
-  delete actionContext.scope['$criticalHit'];
-  delete actionContext.scope['$criticalMiss'];
-  delete actionContext.scope['$attackRoll'];
-
-  recalculateCalculation(attack, actionContext);
-  const scope = actionContext.scope;
-  let {
-    resultPrefix,
-    result,
-    criticalHit,
-    criticalMiss,
-  } = rollAttack(attack, scope);
-  let name = criticalHit ? 'Critical Hit!' : criticalMiss ? 'Critical Miss!' : 'To Hit';
-  if (scope['$attackAdvantage'] === 1){
-    name += ' (Advantage)';
-  } else if(scope['$attackAdvantage'] === -1){
-    name += ' (Disadvantage)';
-  }
-  if (!criticalMiss){
-    scope['$attackHit'] = {value: true}
-  }
-  if (!criticalHit){
-    scope['$attackMiss'] = {value: true};
-  }
-
-  actionContext.addLog({
-    name,
-    value: `${resultPrefix}\n**${result}**`,
-    inline: true,
-  });
-}
-
-function applyAttackToTarget({attack, target, actionContext}){
-  const scope = actionContext.scope;
-  delete scope['$attackHit'];
-  delete scope['$attackMiss'];
-  delete scope['$criticalHit'];
-  delete scope['$criticalMiss'];
-  delete scope['$attackDiceRoll'];
-  delete scope['$attackRoll'];
-
-  recalculateCalculation(attack, actionContext);
-
-  let {
-    resultPrefix,
-    result,
-    criticalHit,
-    criticalMiss,
-  } = rollAttack(attack, scope);
-
-  if (target.variables.armor){
-    const armor = target.variables.armor.value;
-
-    let name = criticalHit ? 'Critical Hit!' :
-      criticalMiss ? 'Critical Miss!' :
-      result > armor ? 'Hit!' : 'Miss!';
-    if (scope['$attackAdvantage'] === 1){
-      name += ' (Advantage)';
-    } else if(scope['$attackAdvantage'] === -1){
-      name += ' (Disadvantage)';
-    }
-
-    actionContext.addLog({
-      name,
-      value: `${resultPrefix}\n**${result}**`,
-      inline: true,
-    });
-    if (criticalMiss || result < armor){
-      scope['$attackMiss'] = {value: true};
-    } else {
-      scope['$attackHit'] = {value: true};
-    }
-  } else {
-    actionContext.addLog({
-      name: 'Error',
-      value:'Target has no `armor`',
-    });
-    actionContext.addLog({
-      name: criticalHit ? 'Critical Hit!' : criticalMiss ? 'Critical Miss!' : 'To Hit',
-      value: `${resultPrefix}\n**${result}**`,
-      inline: true,
-    });
-  }
-}
-
-function rollAttack(attack, scope){
-  const rollModifierText = numberToSignedString(attack.value, true);
-  let value, resultPrefix;
-  if (scope['$attackAdvantage'] === 1){
-    const [a, b] = rollDice(2, 20);
-    if (a >= b) {
-      value = a;
-      resultPrefix = `1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
-    } else {
-      value = b;
-      resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
-    }
-  } else if (scope['$attackAdvantage'] === -1){
-    const [a, b] = rollDice(2, 20);
-    if (a <= b) {
-      value = a;
-      resultPrefix = `1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
-    } else {
-      value = b;
-      resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
-    }
-  } else {
-    value = rollDice(1, 20)[0];
-    resultPrefix = `1d20 [${value}] ${rollModifierText}`
-  }
-  scope['$attackRoll'] = {value};
-  const result = value + attack.value;
-  const {criticalHit, criticalMiss} = applyCrits(value, scope);
-  return {resultPrefix, result, value, criticalHit, criticalMiss};
-}
-
-function applyCrits(value, scope){
-  let criticalHitTarget = scope.criticalHitTarget?.value || 20;
-  let criticalHit = value >= criticalHitTarget;
-  let criticalMiss;
-  if (criticalHit){
-    scope['$criticalHit'] = {value: true};
-  } else {
-    criticalMiss = value === 1;
-    if (criticalMiss){
-      scope['$criticalMiss'] = {value: true};
-    }
-  }
-  return {criticalHit, criticalMiss};
-}
-
-function applyChildren(node, actionContext) {
-  applyNodeTriggers(node, 'after', actionContext);
-  node.children.forEach(child => applyProperty(child, actionContext));
-}
-
-function spendResources(prop, actionContext){
-  // Check Uses
-  if (prop.usesLeft <= 0){
-    if (!prop.silent) actionContext.addLog({
-      name: 'Error',
-      value: `${prop.name || 'action'} does not have enough uses left`,
-    });
-    return true;
-  }
-  // Resources
-  if (prop.insufficientResources){
-    if (!prop.silent) actionContext.addLog({
-      name: 'Error',
-      value: 'This creature doesn\'t have sufficient resources to perform this action',
-    });
-    return true;
-  }
-  // Items
-  let itemQuantityAdjustments = [];
-  let spendLog = [];
-  let gainLog = [];
-  try {
-    prop.resources.itemsConsumed.forEach(itemConsumed => {
-      recalculateCalculation(itemConsumed.quantity, actionContext);
-      if (!itemConsumed.itemId){
-        throw 'No ammo was selected for this prop';
-      }
-      let item = CreatureProperties.findOne(itemConsumed.itemId);
-      if (!item || item.ancestors[0].id !== prop.ancestors[0].id){
-        throw 'The prop\'s ammo was not found on the creature';
-      }
-      if (!item.equipped){
-        throw 'The selected ammo is not equipped';
-      }
-      if (
-        !itemConsumed.quantity.value ||
-        !isFinite(itemConsumed.quantity.value)
-      ) return;
-      itemQuantityAdjustments.push({
-        property: item,
-        operation: 'increment',
-        value: itemConsumed.quantity.value,
-      });
-      let logName = item.name;
-      if (itemConsumed.quantity.value > 1 || itemConsumed.quantity.value < -1){
-        logName = item.plural || logName;
-      }
-      if (itemConsumed.quantity.value > 0){
-        spendLog.push(logName + ': ' + itemConsumed.quantity.value);
-      } else if (itemConsumed.quantity.value < 0){
-        gainLog.push(logName + ': ' + -itemConsumed.quantity.value);
-      }
-    });
-  } catch (e){
-    actionContext.addLog({
-      name: 'Error',
-      value: e,
-    });
-    return true;
-  }
-  // No more errors should be thrown after this line
-  // Now that we have confirmed that there are no errors, do actual work
-  //Items
-  itemQuantityAdjustments.forEach(adjustQuantityWork);
-
-  // Use uses
-  if (prop.usesLeft){
-    CreatureProperties.update(prop._id, {
-      $inc: {usesUsed: 1}
-    }, {
-      selector: prop
-    });
-    if (!prop.silent) actionContext.addLog({
-      name: 'Uses left',
-      value: prop.usesLeft - 1,
-      inline: true,
-    });
-  }
-
-  // Damage stats
-  prop.resources.attributesConsumed.forEach(attConsumed => {
-    recalculateCalculation(attConsumed.quantity, actionContext);
-
-    if (!attConsumed.quantity?.value) return;
-    let stat = actionContext.scope[attConsumed.variableName];
-    if (!stat){
-      spendLog.push(stat.name + ': ' + ' not found');
-      return;
-    }
-    damagePropertyWork({
-      prop: stat,
-      operation: 'increment',
-      value: attConsumed.quantity.value,
-      actionContext,
-    });
-    if (attConsumed.quantity.value > 0){
-      spendLog.push(stat.name + ': ' + attConsumed.quantity.value);
-    } else if (attConsumed.quantity.value < 0){
-      gainLog.push(stat.name + ': ' + -attConsumed.quantity.value);
-    }
-  });
-
-  // Log all the spending
-  if (gainLog.length && !prop.silent) actionContext.addLog({
-    name: 'Gained',
-    value: gainLog.join('\n'),
-    inline: true,
-  });
-  if (spendLog.length && !prop.silent) actionContext.addLog({
-    name: 'Spent',
-    value: spendLog.join('\n'),
-    inline: true,
-  });
-}

app/imports/api/engine/actions/applyPropertyByType/applyAdjustment.js

@@ -1,61 +0,0 @@
-import applyProperty from '../applyProperty.js';
-import recalculateCalculation from './shared/recalculateCalculation.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyAdjustment(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-  const damageTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
-
-  if (!prop.amount) {
-    return applyChildren(node, actionContext);
-  }
-
-  // Evaluate the amount
-  recalculateCalculation(prop.amount, actionContext);
-
-  const value = +prop.amount.value;
-  if (!isFinite(value)) {
-    return applyChildren(node, actionContext);
-  }
-
-  if (damageTargets?.length) {
-    damageTargets.forEach(target => {
-      let stat = target.variables[prop.stat];
-      if (!stat?.type) {
-        if (!prop.silent) actionContext.addLog({
-          name: 'Error',
-          value: `Could not apply attribute damage, creature does not have \`${prop.stat}\` set`
-        });
-        return applyChildren(node, actionContext);
-      }
-      damagePropertyWork({
-        prop: stat,
-        operation: prop.operation,
-        value,
-        actionContext,
-      });
-      if (!prop.silent) actionContext.addLog({
-        name: 'Attribute damage',
-        value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
-        ` ${value}`,
-        inline: true,
-      });
-    });
-  } else {
-    if (!prop.silent) actionContext.addLog({
-      name: 'Attribute damage',
-      value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
-      ` ${value}`,
-      inline: true,
-    });
-  }
-
-  return applyChildren(node, actionContext);
-}
-
-function applyChildren(node, actionContext){
-  applyNodeTriggers(node, 'after', actionContext);
-  node.children.forEach(child => applyProperty(child, actionContext));
-}

app/imports/api/engine/actions/applyPropertyByType/applyBranch.js

@@ -1,80 +0,0 @@
-import applyProperty from '../applyProperty.js';
-import recalculateCalculation from './shared/recalculateCalculation.js';
-import rollDice from '/imports/parser/rollDice.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyBranch(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const applyChildren = function(){
-    applyNodeTriggers(node, 'after', actionContext);
-    node.children.forEach(child => applyProperty(child, actionContext));
-  };
-  const scope = actionContext.scope;
-  const targets = actionContext.targets;
-  const prop = node.node;
-  switch(prop.branchType){
-    case 'if':
-      recalculateCalculation(prop.condition, actionContext);
-      if (prop.condition?.value) applyChildren();
-      break;
-    case 'index':
-      if (node.children.length){
-        recalculateCalculation(prop.condition, actionContext);
-        if (!isFinite(prop.condition?.value)) {
-          actionContext.addLog({
-            name: 'Branch Error',
-            value: 'Index did not resolve into a valid number'
-          });
-          break;
-        }
-        let index = Math.floor(prop.condition?.value);
-        if (index < 1) index = 1;
-        if (index > node.children.length) index = node.children.length;
-        applyNodeTriggers(node, 'after', actionContext);
-        applyProperty(node.children[index - 1], actionContext);
-      }
-      break;
-    case 'hit':
-      if (scope['$attackHit']?.value){
-        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On hit**'});
-        applyChildren();
-      }
-      break;
-    case 'miss':
-      if (scope['$attackMiss']?.value){
-        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On miss**'});
-        applyChildren();
-      }
-      break;
-    case 'failedSave':
-      if (scope['$saveFailed']?.value){
-        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On failed save**'});
-        applyChildren();
-      }
-      break;
-    case 'successfulSave':
-      if (scope['$saveSucceeded']?.value){
-        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On save**',});
-        applyChildren();
-      }
-      break;
-    case 'random':
-      if (node.children.length){
-        let index = rollDice(1, node.children.length)[0] - 1;
-        applyNodeTriggers(node, 'after', actionContext);
-        applyProperty(node.children[index], actionContext);
-      }
-      break;
-    case 'eachTarget':
-      if (targets.length) {
-        targets.forEach(target => {
-          applyNodeTriggers(node, 'after', actionContext);
-          actionContext.targets = [target]
-          node.children.forEach(child => applyProperty(child, actionContext));
-        });
-      } else {
-        applyChildren();
-      }
-      break;
-  }
-}

app/imports/api/engine/actions/applyPropertyByType/applyBuff.js

@@ -1,171 +0,0 @@
-import {
-	setLineageOfDocs,
-	renewDocIds
-} from '/imports/api/parenting/parenting.js';
-import {setDocToLastOrder} from '/imports/api/parenting/order.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import computedSchemas from '/imports/api/properties/computedPropertySchemasIndex.js';
-import applyFnToKey from '/imports/api/engine/computation/utility/applyFnToKey.js';
-import { get } from 'lodash';
-import resolve, { map, toString } from '/imports/parser/resolve.js';
-import symbol from '/imports/parser/parseTree/symbol.js';
-import logErrors from './shared/logErrors.js';
-import { insertCreatureLog } from '/imports/api/creature/log/CreatureLogs.js';
-import cyrb53 from '/imports/api/engine/computation/utility/cyrb53.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import INLINE_CALCULATION_REGEX from '/imports/constants/INLINE_CALCULTION_REGEX.js';
-
-export default function applyBuff(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-  let buffTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
-
-  // Then copy the decendants of the buff to the targets
-  let propList = [prop];
-  function addChildrenToPropList(children, { skipCrystalize } = {}){
-    children.forEach(child => {
-      if (skipCrystalize) child.node._skipCrystalize = true;
-      propList.push(child.node);
-      // recursively add the child's children, but don't crystalize nested buffs
-      addChildrenToPropList(child.children, {
-        skipCrystalize: skipCrystalize || child.node.type === 'buff'
-      });
-    });
-  }
-  addChildrenToPropList(node.children);
-  if (!prop.skipCrystalization) {
-    crystalizeVariables({propList, actionContext});
-  }
-
-  let oldParent = {
-    id: prop.parent.id,
-    collection: prop.parent.collection,
-  };
-  buffTargets.forEach(target => {
-    // Apply the buff
-    copyNodeListToTarget(propList, target, oldParent);
-
-    //Log the buff
-    if ((prop.name || prop.description?.value) && !prop.silent){
-      if (target._id === actionContext.creature._id){
-        // Targeting self
-        actionContext.addLog({
-          name: prop.name,
-          value: prop.description?.value,
-        });
-      } else {
-        // Targeting other
-        insertCreatureLog.call({
-          log: {
-            creatureId: target._id,
-            content: [{
-              name: prop.name,
-              value: prop.description?.value,
-            }],
-          }
-        });
-      }
-    }
-  });
-  applyNodeTriggers(node, 'after', actionContext);
-
-  // Don't apply the children of the buff, they get copied to the target instead
-}
-
-function copyNodeListToTarget(propList, target, oldParent){
-  let ancestry = [{collection: 'creatures', id: target._id}];
-  setLineageOfDocs({
-    docArray: propList,
-    newAncestry: ancestry,
-    oldParent,
-  });
-  renewDocIds({
-    docArray: propList,
-  });
-  setDocToLastOrder({
-    collection: CreatureProperties,
-    doc: propList[0],
-  });
-  CreatureProperties.batchInsert(propList);
-}
-
-/**
- * Replaces all variables with their resolved values
- * except variables of the form `$target.thing.total` become `thing.total`
- */
-function crystalizeVariables({propList, actionContext}){
-  propList.forEach(prop => {
-    if (prop._skipCrystalize) {
-      delete prop._skipCrystalize;
-      return;
-    }
-    // Iterate through all the calculations and crystalize them
-    computedSchemas[prop.type].computedFields().forEach( calcKey => {
-      applyFnToKey(prop, calcKey, (prop, key) => {
-        const calcObj = get(prop, key);
-        if (!calcObj?.parseNode) return;
-        calcObj.parseNode = map(calcObj.parseNode, node => {
-          // Skip nodes that aren't symbols or accessors
-          if (
-            node.parseType !== 'accessor' && node.parseType !== 'symbol'
-          ) return node;
-          // Handle variables
-          if (node.name === '$target'){
-            // strip $target
-            if (node.parseType === 'accessor'){
-              node.name = node.path.shift();
-              if (!node.path.length){
-                return symbol.create({name: node.name})
-              }
-            } else {
-              // Can't strip symbols
-              actionContext.addLog({
-                name: 'Error',
-                value: 'Variable `$target` should not be used without a property: $target.property',
-              });
-            }
-            return node;
-          } else {
-            // Resolve all other variables
-            const {result, context} = resolve('reduce', node, actionContext.scope);
-            logErrors(context.errors, actionContext);
-            return result;
-          }
-        });
-        calcObj.calculation = toString(calcObj.parseNode);
-        calcObj.hash = cyrb53(calcObj.calculation);
-      });
-    });
-    // For each key in the schema
-    computedSchemas[prop.type].inlineCalculationFields().forEach( calcKey => {
-      // That ends in .inlineCalculations
-      applyFnToKey(prop, calcKey, (prop, key) => {
-        const inlineCalcObj = get(prop, key);
-        if (!inlineCalcObj) return;
-
-        // If there is no text, skip
-        if (!inlineCalcObj.text){
-          return;
-        }
-
-        // Replace all the existing calculations
-        let index = -1;
-        inlineCalcObj.text = inlineCalcObj.text.replace(INLINE_CALCULATION_REGEX, () => {
-          index += 1;
-          return `{${inlineCalcObj.inlineCalculations[index].calculation}}`;
-        });
-
-        // Set the value to the uncomputed string
-        inlineCalcObj.value = inlineCalcObj.text;
-
-        // Write a new hash
-        const inlineCalcHash = cyrb53(inlineCalcObj.text);
-        if (inlineCalcHash === inlineCalcObj.hash) {
-          // Skip if nothing changed
-          return;
-        }
-        inlineCalcObj.hash = inlineCalcHash;
-      });
-    });
-  });
-}

app/imports/api/engine/actions/applyPropertyByType/applyBuffRemover.js

@@ -1,101 +0,0 @@
-import { findLast, difference, intersection, filter } from 'lodash';
-import applyProperty from '../applyProperty.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import { getProperyAncestors, getPropertiesOfType } from '/imports/api/engine/loadCreatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { softRemove } from '/imports/api/parenting/softRemove.js';
-import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
-
-export default function applyBuffRemover(node, actionContext) {
-  // Apply triggers
-  applyNodeTriggers(node, 'before', actionContext);
-
-  const prop = node.node;
-
-  // Log Name
-  if (prop.name && !prop.silent){
-    actionContext.addLog({ name: prop.name });
-  }
-
-  // Remove buffs
-  if (prop.targetParentBuff) {
-    // Remove nearest ancestor buff
-    const ancestors = getProperyAncestors(actionContext.creature._id, prop._id);
-    const nearestBuff = findLast(ancestors, ancestor => ancestor.type === 'buff');
-    if (!nearestBuff) {
-      actionContext.addLog({
-        name: 'Error',
-        value: 'Buff remover does not have a parent buff to remove',
-      });
-      return;
-    }
-    removeBuff(nearestBuff, actionContext, prop);
-  } else {
-    // Get all the buffs targeted by tags
-    const allBuffs = getPropertiesOfType(actionContext.creature._id, 'buff');
-    const targetedBuffs = filter(allBuffs, buff => {
-      if (buff.inactive) return false;
-      if (buffRemoverMatchTags(prop, buff)) return true;
-    });
-    // Remove the buffs
-    if (prop.removeAll) {
-      // Remove all matching buffs
-      targetedBuffs.forEach(buff => {
-        removeBuff(buff, actionContext, prop);
-      });
-    } else {
-      // Sort in reverse order
-      targetedBuffs.sort((a, b) => b.order - a.order);
-      // Remove the one with the highest order
-      const buff = targetedBuffs[0];
-      if (buff) {
-        removeBuff(buff, actionContext, prop);
-      }
-    }
-  }
-
-  // Apply triggers
-  applyNodeTriggers(node, 'after', actionContext);
-  // Apply children
-  node.children.forEach(child => applyProperty(child, actionContext));
-}
-
-function removeBuff(buff, actionContext, prop) {
-  if (!prop.silent) actionContext.addLog({
-    name: 'Removed',
-    value: `${buff.name || 'Buff'}`
-  });
-  softRemove({ _id: buff._id, collection: CreatureProperties });
-}
-
-function buffRemoverMatchTags(buffRemover, prop) {
-  let matched = false;
-  const propTags = getEffectivePropTags(prop);
-  // Check the target tags
-  if (
-    !buffRemover.targetTags?.length ||
-    difference(buffRemover.targetTags, propTags).length === 0
-  ) {
-    matched = true;
-  }
-  // Check the extra tags
-  buffRemover.extraTags?.forEach(extra => {
-    if (extra.operation === 'OR') {
-      if (matched) return;
-      if (
-        !extra.tags.length ||
-        difference(extra.tags, propTags).length === 0
-      ) {
-        matched = true;
-      }
-    } else if (extra.operation === 'NOT') {
-      if (
-        extra.tags.length &&
-        intersection(extra.tags, propTags)
-      ) {
-        return false;
-      }
-    }
-  });
-  return matched;
-}

app/imports/api/engine/actions/applyPropertyByType/applyDamage.js

@@ -1,241 +0,0 @@
-import { some, intersection, difference, remove } from 'lodash';
-import applyProperty from '../applyProperty.js';
-import {insertCreatureLog} from '/imports/api/creature/log/CreatureLogs.js';
-import resolve, { Context, toString } from '/imports/parser/resolve.js';
-import logErrors from './shared/logErrors.js';
-import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import {
-  getPropertiesOfType
-} from '/imports/api/engine/loadCreatures.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyDamage(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const applyChildren = function(){
-    applyNodeTriggers(node, 'after', actionContext);
-    node.children.forEach(child => applyProperty(child, actionContext));
-  };
-
-  const prop = node.node;
-  const scope = actionContext.scope;
-
-  // Skip if there is no parse node to work with
-  if (!prop.amount?.parseNode) return;
-
-  // Choose target
-  let damageTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
-  // Determine if the hit is critical
-  let criticalHit = scope['$criticalHit']?.value &&
-    prop.damageType !== 'healing' // Can't critically heal
-  ;
-  // Double the damage rolls if the hit is critical
-  let context = new Context({
-    options: {doubleRolls: criticalHit},
-  });
-
-  // Gather all the lines we need to log into an array
-  const logValue = [];
-  const logName = prop.damageType === 'healing' ? 'Healing' : 'Damage';
-
-  // roll the dice only and store that string
-  applyEffectsToCalculationParseNode(prop.amount, actionContext.log);
-  const {result: rolled} = resolve('roll', prop.amount.parseNode, scope, context);
-  if (rolled.parseType !== 'constant'){
-    logValue.push(toString(rolled));
-  }
-  logErrors(context.errors, actionContext);
-
-  // Reset the errors so we don't log the same errors twice
-  context.errors = [];
-
-  // Resolve the roll to a final value
-  const {result: reduced} = resolve('reduce', rolled, scope, context);
-  logErrors(context.errors, actionContext);
-
-  // Store the result
-  if (reduced.parseType === 'constant'){
-    prop.amount.value = reduced.value;
-  } else if (reduced.parseType === 'error'){
-    prop.amount.value = null;
-  } else {
-    prop.amount.value = toString(reduced);
-  }
-  let damage = +reduced.value;
-
-  // If we didn't end up with a constant of finite amount, give up
-  if (reduced?.parseType !== 'constant' || !isFinite(reduced.value)){
-    return applyChildren();
-  }
-
-  // Round the damage to a whole number
-  damage = Math.floor(damage);
-
-  // Convert extra damage into the stored type
-  if (prop.damageType === 'extra' && scope['$lastDamageType']) {
-    prop.damageType = scope['$lastDamageType'];
-  }
-  // Store current damage type
-  if (prop.damageType !== 'healing') {
-    scope['$lastDamageType'] = prop.damageType;
-  }
-
-  // Memoise the damage suffix for the log
-  let suffix = (criticalHit ? ' critical ' : ' ') +
-    prop.damageType +
-    (prop.damageType !== 'healing' ? ' damage ': '');
-
-  if (damageTargets && damageTargets.length) {
-    // Iterate through all the targets
-    damageTargets.forEach(target => {
-
-      // Apply weaknesses/resistances/immunities
-      damage = applyDamageMultipliers({
-        target,
-        damage,
-        damageProp: prop,
-        logValue
-      });
-
-      actionContext.target = [target];
-      // Deal the damage to the target
-      let damageDealt = dealDamage({
-        target,
-        damageType: prop.damageType,
-        amount: damage,
-        actionContext
-      });
-
-      // Log the damage done
-      if (target._id === actionContext.creature._id){
-        // Target is same as self, log damage as such
-        logValue.push(`**${damageDealt}** ${suffix}  to self`);
-      } else {
-        logValue.push(`Dealt **${damageDealt}** ${suffix} ${target.name && ' to '}${target.name}`);
-        // Log the damage received on that creature's log as well
-        insertCreatureLog.call({
-          log: {
-            creatureId: target._id,
-            content: [{
-              name,
-              value: `Recieved **${damageDealt}** ${suffix}`,
-            }],
-          }
-        });
-      }
-    });
-  } else {
-    // There are no targets, just log the result
-    logValue.push(`**${damage}** ${suffix}`);
-  }
-  if (!prop.silent) actionContext.addLog({
-    name: logName,
-    value: logValue.join('\n'),
-    inline: true,
-  });
-  return applyChildren();
-}
-
-function applyDamageMultipliers({target, damage, damageProp, logValue}){
-  const damageType = damageProp?.damageType;
-  if (!damageType) return damage;
-
-  const multiplier = target?.variables?.[damageType];
-  if (!multiplier) return damage;
-
-  const damageTypeText = damageType == 'healing' ? 'healing': `${damageType} damage`;
-
-  if (
-    multiplier.immunity &&
-    some(multiplier.immunities, multiplierAppliesTo(damageProp))
-  ){
-    logValue.push(`Immune to ${damageTypeText}`);
-    return 0;
-  } else {
-    if (
-      multiplier.resistance &&
-      some(multiplier.resistances, multiplierAppliesTo(damageProp))
-    ){
-      logValue.push(`Resistant to ${damageTypeText}`);
-      damage = Math.floor(damage / 2);
-    }
-    if (
-      multiplier.vulnerability &&
-      some(multiplier.vulnerabilities, multiplierAppliesTo(damageProp))
-    ){
-      logValue.push(`Vulnerable to ${damageTypeText}`);
-      damage = Math.floor(damage * 2);
-    }
-  }
-  return damage;
-}
-
-function multiplierAppliesTo(damageProp){
-  return multiplier => {
-    const hasRequiredTags = difference(
-      multiplier.includeTags, damageProp.tags
-    ).length === 0;
-
-    const hasNoExcludedTags = intersection(
-      multiplier.excludeTags, damageProp.tags
-    ).length === 0;
-
-    return hasRequiredTags && hasNoExcludedTags;
-  }
-}
-
-function dealDamage({target, damageType, amount, actionContext}){
-  // Get all the health bars and do damage to them
-  let healthBars = getPropertiesOfType(target._id, 'attribute');
-
-  // Keep only the healthbars that can take damage/healing
-  remove(healthBars, (bar) =>
-    bar.attributeType !== 'healthBar' ||
-    bar.inactive ||
-    bar.removed ||
-    bar.overridden ||
-    (amount >= 0 && bar.healthBarNoDamage) ||
-    (amount < 0 && bar.healthBarNoHealing)
-  );
-
-  // Sort healthbars by damage/healing order or tree order as a fallback
-  healthBars.sort((a, b) => {
-    let diff;
-    if (amount >= 0) {
-      diff = a.healthBarDamageOrder - b.healthBarDamageOrder;
-    } else {
-      diff = a.healthBarHealingOrder - b.healthBarHealingOrder;
-    }
-    if (Number.isFinite(diff)) {
-      return diff;
-    } else {
-      return a.order - b.order;
-    }
-  });
-
-  // Deal the damage to each healthbar in order until all damage is done
-  const totalDamage = amount;
-  let damageLeft = totalDamage;
-  if (damageType === 'healing') damageLeft = -totalDamage;
-  healthBars.forEach(healthBar => {
-    if (damageLeft === 0) return;
-    // Replace the healthbar by the one in the action context if we can
-    // The damagePropertyWork function bashes the prop with the damage
-    // So we can use the new value in later action properties
-    if (healthBar.variableName) {
-      const targetHealthBar = target.variables[healthBar.variableName];
-      if (targetHealthBar?._id === healthBar._id) {
-        healthBar = targetHealthBar;
-      }
-    }
-    // Do the damage
-    let damageAdded = damagePropertyWork({
-      prop: healthBar,
-      operation: 'increment',
-      value: damageLeft,
-      actionContext
-    });
-    damageLeft -= damageAdded;
-  });
-  return totalDamage;
-}

app/imports/api/engine/actions/applyPropertyByType/applyNote.js

@@ -1,27 +0,0 @@
-import recalculateInlineCalculations from './shared/recalculateInlineCalculations.js';
-import applyProperty from '../applyProperty.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyNote(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-
-  // Log Name, summary
-  let content = { name: prop.name };
-  if (prop.summary?.text){
-    recalculateInlineCalculations(prop.summary, actionContext);
-    content.value = prop.summary.value;
-  }
-  if (content.name || content.value){
-    actionContext.addLog(content);
-  }
-  // Log description
-  if (prop.description?.text){
-    recalculateInlineCalculations(prop.description, actionContext);
-    actionContext.addLog({value: prop.description.value});
-  }
-  // Apply triggers
-  applyNodeTriggers(node, 'after', actionContext);
-  // Apply children
-  node.children.forEach(child => applyProperty(child, actionContext));
-}

app/imports/api/engine/actions/applyPropertyByType/applyRoll.js

@@ -1,61 +0,0 @@
-import applyProperty from '../applyProperty.js';
-import logErrors from './shared/logErrors.js';
-import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
-import resolve, { toString } from '/imports/parser/resolve.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyRoll(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-
-  const applyChildren = function(){
-    applyNodeTriggers(node, 'after', actionContext);
-    node.children.forEach(child => applyProperty(child, actionContext));
-  };
-
-  if (prop.roll?.calculation){
-    const logValue = [];
-
-    // roll the dice only and store that string
-    applyEffectsToCalculationParseNode(prop.roll, actionContext);
-    const {result: rolled, context} = resolve('roll', prop.roll.parseNode, actionContext.scope);
-    if (rolled.parseType !== 'constant'){
-      logValue.push(toString(rolled));
-    }
-    logErrors(context.errors, actionContext);
-
-    // Reset the errors so we don't log the same errors twice
-    context.errors = [];
-
-    // Resolve the roll to a final value
-    const {result: reduced} = resolve('reduce', rolled, actionContext.scope, context);
-    logErrors(context.errors, actionContext);
-
-    // Store the result
-    if (reduced.parseType === 'constant'){
-      prop.roll.value = reduced.value;
-    } else if (reduced.parseType === 'error'){
-      prop.roll.value = null;
-    } else {
-      prop.roll.value = toString(reduced);
-    }
-
-    // If we didn't end up with a constant of finite amount, give up
-    if (reduced?.parseType !== 'constant' || !isFinite(reduced.value)){
-      return applyChildren();
-    }
-    const value = reduced.value;
-
-    actionContext.scope[prop.variableName] = value;
-    logValue.push(`**${value}**`);
-
-    if (!prop.silent){
-      actionContext.addLog({
-        name: prop.name,
-        value: logValue.join('\n'),
-        inline: true,
-      });
-    }
-  }
-  return applyChildren();
-}

app/imports/api/engine/actions/applyPropertyByType/applySavingThrow.js

@@ -1,104 +0,0 @@
-import rollDice from '/imports/parser/rollDice.js';
-import recalculateCalculation from './shared/recalculateCalculation.js';
-import applyProperty from '../applyProperty.js';
-import numberToSignedString from '/imports/ui/utility/numberToSignedString.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applySavingThrow(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-
-  let saveTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
-
-  recalculateCalculation(prop.dc, actionContext);
-
-  const dc = (prop.dc?.value);
-  if (!isFinite(dc)){
-    actionContext.addLog({
-      name: 'Error',
-      value: 'Saving throw requires a DC',
-    });
-    return node.children.forEach(child => applyProperty(child, actionContext));
-  }
-  if (!prop.silent) actionContext.addLog({
-    name: prop.name,
-    value: `DC **${dc}**`,
-    inline: true,
-  });
-  const scope = actionContext.scope;
-
-  // If there are no save targets, apply all children as if the save both
-  // succeeeded and failed
-  if (!saveTargets?.length){
-    scope['$saveFailed'] = {value: true};
-    scope['$saveSucceeded'] = { value: true };
-    applyNodeTriggers(node, 'after', actionContext);
-    return node.children.forEach(child => applyProperty(child, actionContext));
-  }
-
-  // Each target makes the saving throw
-  saveTargets.forEach(target => {
-    delete scope['$saveFailed'];
-    delete scope['$saveSucceeded'];
-    delete scope['$saveDiceRoll'];
-    delete scope['$saveRoll'];
-
-    const applyChildren = function () {
-      applyNodeTriggers(node, 'after', actionContext);
-      actionContext.targets = [target]
-      node.children.forEach(child => applyProperty(child, actionContext));
-    };
-
-    const save = target.variables[prop.stat];
-
-    if (!save){
-      actionContext.addLog({
-        name: 'Saving throw error',
-        value: 'No saving throw found: ' + prop.stat,
-      });
-      return applyChildren();
-    }
-
-    const rollModifierText = numberToSignedString(save.value, true);
-
-    let value, values, resultPrefix;
-    if (save.advantage === 1){
-      const [a, b] = rollDice(2, 20);
-      if (a >= b) {
-        value = a;
-        resultPrefix = `Advantage\n1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
-      } else {
-        value = b;
-        resultPrefix = `Advantage\n1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
-      }
-    } else if (save.advantage === -1){
-      const [a, b] = rollDice(2, 20);
-      if (a <= b) {
-        value = a;
-        resultPrefix = `Disadvantage\n1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
-      } else {
-        value = b;
-        resultPrefix = `Disadvantage\n1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
-      }
-    } else {
-      values = rollDice(1, 20);
-      value = values[0];
-      resultPrefix = `1d20 [ ${value} ] ${rollModifierText}`
-    }
-    scope['$saveDiceRoll'] = {value};
-    const result = value + save.value || 0;
-    scope['$saveRoll'] = {value: result};
-    const saveSuccess = result >= dc;
-    if (saveSuccess){
-      scope['$saveSucceeded'] = {value: true};
-    } else {
-      scope['$saveFailed'] = {value: true};
-    }
-    if (!prop.silent) actionContext.addLog({
-      name: saveSuccess ? 'Successful save' : 'Failed save',
-      value: resultPrefix + '\n**' + result + '**',
-      inline: true,
-    });
-    return applyChildren();
-  });
-}

app/imports/api/engine/actions/applyPropertyByType/applyToggle.js

@@ -1,13 +0,0 @@
-import applyProperty from '../applyProperty.js';
-import recalculateCalculation from './shared/recalculateCalculation.js';
-import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-
-export default function applyToggle(node, actionContext){
-  applyNodeTriggers(node, 'before', actionContext);
-  const prop = node.node;
-  recalculateCalculation(prop.condition, actionContext);
-  if (prop.condition?.value) {
-    applyNodeTriggers(node, 'after', actionContext);
-    return node.children.forEach(child => applyProperty(child, actionContext));
-  }
-}

app/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js

@@ -1,24 +0,0 @@
-import operator from '/imports/parser/parseTree/operator.js';
-import { parse } from '/imports/parser/parser.js';
-import logErrors from './logErrors.js';
-
-export default function applyEffectsToCalculationParseNode(calcObj, actionContext){
-  if (!calcObj.effects) return;
-  calcObj.effects.forEach(effect => {
-    if (effect.operation !== 'add') return;
-    if (!effect.amount) return;
-    if (effect.amount.value === null) return;
-    let effectParseNode;
-    try {
-      effectParseNode = parse(effect.amount.value.toString());
-      calcObj.parseNode = operator.create({
-        left: calcObj.parseNode,
-        right: effectParseNode,
-        operator: '+',
-        fn: 'add'
-      });
-    } catch (e){
-      logErrors([e], actionContext)
-    }
-  });
-}

app/imports/api/engine/actions/applyPropertyByType/shared/logErrors.js

@@ -1,7 +0,0 @@
-export default function logErrors(errors, actionContext){
-  errors?.forEach(error => {
-    if (error.type !== 'info'){
-      actionContext.addLog({name: 'Error', value: error.message});
-    }
-  });
-}

app/imports/api/engine/actions/applyPropertyByType/shared/recalculateCalculation.js

@@ -1,11 +0,0 @@
-import evaluateCalculation from '/imports/api/engine/computation/utility/evaluateCalculation.js';
-import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
-import logErrors from './logErrors.js';
-
-export default function recalculateCalculation(calc, actionContext, context){
-  if (!calc?.parseNode) return;
-  calc._parseLevel = 'reduce';
-  applyEffectsToCalculationParseNode(calc, actionContext.log);
-  evaluateCalculation(calc, actionContext.scope, context);
-  logErrors(calc.errors, actionContext.log);
-}

app/imports/api/engine/actions/applyPropertyByType/shared/recalculateInlineCalculations.js

@@ -1,13 +0,0 @@
-import embedInlineCalculations from '/imports/api/engine/computation/utility/embedInlineCalculations.js';
-import recalculateCalculation from './recalculateCalculation.js'
-
-export default function recalculateInlineCalculations(inlineCalcObj, actionContext){
-  // Skip if there are no calculations
-  if (!inlineCalcObj?.inlineCalculations?.length) return;
-  // Recalculate each calculation with the current scope
-  inlineCalcObj.inlineCalculations.forEach(calc => {
-    recalculateCalculation(calc, actionContext);
-  });
-  // Embed the new calculated values
-  embedInlineCalculations(inlineCalcObj);
-}

app/imports/api/engine/actions/applyTriggers.js

@@ -1,111 +0,0 @@
-import recalculateCalculation from '/imports/api/engine/actions/applyPropertyByType/shared/recalculateCalculation.js';
-import recalculateInlineCalculations from '/imports/api/engine/actions/applyPropertyByType/shared/recalculateInlineCalculations.js';
-import { getPropertyDecendants } from '/imports/api/engine/loadCreatures.js';
-import { nodeArrayToTree } from '/imports/api/parenting/nodesToTree.js';
-import applyProperty from '/imports/api/engine/actions/applyProperty.js';
-import { difference, intersection } from 'lodash';
-import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
-
-export function applyNodeTriggers(node, timing, actionContext) {
-  const prop = node.node;
-  const type = prop.type;
-  const triggers = actionContext.triggers?.doActionProperty?.[type]?.[timing];
-  if (triggers) {
-    triggers.forEach(trigger => {
-      applyTrigger(trigger, prop, actionContext);
-    });
-  }
-}
-
-export function applyTriggers(triggers = [], prop, actionContext) {
-  // Apply the triggers
-  triggers.forEach(trigger => {
-    applyTrigger(trigger, prop, actionContext)
-  });
-}
-
-export function applyTrigger(trigger, prop, actionContext) {
-  // If there is a prop we are applying the trigger from,
-  // don't fire if the tags don't match
-  if (prop && !triggerMatchTags(trigger, prop)) {
-    return;
-  }
-
-  // Prevent trigger from firing if it's inactive
-  if (trigger.inactive) {
-    return;
-  }
-  
-  // Prevent triggers from firing if their condition is false
-  if (trigger.condition?.parseNode) {
-    recalculateCalculation(trigger.condition, actionContext);
-    if (!trigger.condition.value) return;
-  }
-
-  // Prevent triggers from firing themselves in a loop
-  if (trigger.firing) {
-    /*
-    log.content.push({
-      name: trigger.name || 'Trigger',
-      value: 'Trigger can\'t fire itself',
-      inline: true,
-    });
-    */
-    return;
-  }
-  trigger.firing = true;
-
-  // Fire the trigger
-  const content = {
-    name: trigger.name || 'Trigger',
-    value: trigger.description,
-    inline: false,
-  }
-  if (trigger.description?.text){
-    recalculateInlineCalculations(trigger.description, actionContext);
-    content.value = trigger.description.value;
-  }
-  if(!trigger.silent) actionContext.addLog(content);
-
-  // Get all the trigger's properties and apply them
-  const properties = getPropertyDecendants(actionContext.creature._id, trigger._id);
-  properties.sort((a, b) => a.order - b.order);
-  const propertyForest = nodeArrayToTree(properties);
-  propertyForest.forEach(node => {
-    applyProperty(node, actionContext);
-  });
-
-  trigger.firing = false;
-}
-
-function triggerMatchTags(trigger, prop) {
-  let matched = false;
-  const propTags = getEffectivePropTags(prop);
-  // Check the target tags
-  if (
-    !trigger.targetTags?.length ||
-    difference(trigger.targetTags, propTags).length === 0
-  ) {
-    matched = true;
-  }
-  // Check the extra tags
-  trigger.extraTags?.forEach(extra => {
-    if (extra.operation === 'OR') {
-      if (matched) return;
-      if (
-        !extra.tags.length ||
-        difference(extra.tags, propTags).length === 0
-      ) {
-        matched = true;
-      }
-    } else if (extra.operation === 'NOT') {
-      if (
-        extra.tags.length &&
-        intersection(extra.tags, propTags)
-      ) {
-        return false;
-      }
-    }
-  });
-  return matched;
-}

app/imports/api/engine/actions/doAction.js

@@ -1,100 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { nodeArrayToTree } from '/imports/api/parenting/nodesToTree.js';
-import {
-  getProperyAncestors, getPropertyDecendants
-} from '/imports/api/engine/loadCreatures.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import applyProperty from './applyProperty.js';
-import ActionContext from '/imports/api/engine/actions/ActionContext.js';
-
-const doAction = new ValidatedMethod({
-  name: 'creatureProperties.doAction',
-  validate: new SimpleSchema({
-    actionId: SimpleSchema.RegEx.Id,
-    targetIds: {
-      type: Array,
-      defaultValue: [],
-      maxCount: 20,
-      optional: true,
-    },
-    'targetIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    scope: {
-      type: Object,
-      blackbox: true,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({ actionId, targetIds = [], scope }) {
-    // Get action context
-    let action = CreatureProperties.findOne(actionId);
-    const creatureId = action.ancestors[0].id;
-    const actionContext = new ActionContext(creatureId, targetIds, this);
-    
-		// Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-    actionContext.targets.forEach(target => {
-      assertEditPermission(target, this.userId);
-    });
-
-    const ancestors = getProperyAncestors(creatureId, action._id);
-    ancestors.sort((a, b) => a.order - b.order);
-
-    const properties = getPropertyDecendants(creatureId, action._id);
-    properties.push(action);
-    properties.sort((a, b) => a.order - b.order);
-
-    // Do the action
-    doActionWork({properties, ancestors, actionContext, methodScope: scope});
-
-    // Recompute all involved creatures
-    Creatures.update({
-      _id: { $in: [creatureId, ...targetIds] }
-    }, {
-      $set: {dirty: true},
-    });
-  },
-});
-
-export default doAction;
-
-export function doActionWork({
-  properties, ancestors, actionContext, methodScope = {},
-}){
-  // get the docs
-  const ancestorScope = getAncestorScope(ancestors);
-  const propertyForest = nodeArrayToTree(properties);
-  if (propertyForest.length !== 1){
-    throw new Meteor.Error(`The action has ${propertyForest.length} top level properties, expected 1`);
-  }
-
-  // Include the ancestry and method scope in the context scope
-  Object.assign(actionContext.scope, ancestorScope, methodScope);
-
-  // Apply the top level property, it is responsible for applying its children
-  // recursively
-  applyProperty(propertyForest[0], actionContext);
-
-  // Insert the log
-  actionContext.writeLog();
-}
-
-// Assumes ancestors are in tree order already
-function getAncestorScope(ancestors){
-  let scope = {};
-  ancestors.forEach(prop => {
-    scope[`#${prop.type}`] = prop;
-  });
-  return scope;
-}

app/imports/api/engine/actions/doAction.test.js

@@ -1,53 +0,0 @@
-import '/imports/api/simpleSchemaConfig.js';
-//import testTypes from './testTypes/index.js';
-import { doActionWork } from './doAction.js';
-import { CreatureLogSchema } from '/imports/api/creature/log/CreatureLogs.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-
-function cleanProp(prop){
-  let schema = CreatureProperties.simpleSchema(prop);
-  return schema.clean(prop);
-}
-
-function cleanCreature(creature){
-  let schema = Creatures.simpleSchema(creature);
-  return schema.clean(creature);
-}
-
-// Fake ActionContext to test actions with
-const creatureId = 'actionTestCreatureId';
-const creatureName = 'Action Test Creature';
-const testActionContext = {
-  creature: cleanCreature({
-    _id: creatureId,
-  }),
-  log: CreatureLogSchema.clean({
-    creatureId: creatureId,
-    creatureName: creatureName,
-  }),
-  scope: {},
-  addLog(content) {
-    if (content.name || content.value){
-      this.log.content.push(content);
-    }
-  },
-  writeLog: () => { },
-}
-
-const action = cleanProp({
-  type: 'action',
-});
-const actionAncestors = [];
-
-describe('Do Action', function(){
-  it('Does an empty action', function(){
-    doActionWork({
-      properties: [action],
-      ancestors: actionAncestors,
-      actionContext: testActionContext,
-      methodScope: {},
-    });
-  });
-  //testTypes.forEach(test => it(test.text, test.fn));
-});

app/imports/api/engine/actions/doCastSpell.js

@@ -1,125 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import {
-  getProperyAncestors, getPropertyDecendants
-} from '/imports/api/engine/loadCreatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { doActionWork } from '/imports/api/engine/actions/doAction.js';
-import ActionContext from '/imports/api/engine/actions/ActionContext.js';
-
-const doAction = new ValidatedMethod({
-  name: 'creatureProperties.doCastSpell',
-  validate: new SimpleSchema({
-    spellId: SimpleSchema.RegEx.Id,
-    slotId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-      optional: true,
-    },
-    targetIds: {
-      type: Array,
-      defaultValue: [],
-      maxCount: 20,
-      optional: true,
-    },
-    'targetIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    scope: {
-      type: Object,
-      blackbox: true,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({ spellId, slotId, targetIds = [], scope = {} }) {
-		// Get action context
-    let spell = CreatureProperties.findOne(spellId);
-    const creatureId = spell.ancestors[0].id;
-    const actionContext = new ActionContext(creatureId, targetIds, this);
-
-		// Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-    actionContext.targets.forEach(target => {
-      assertEditPermission(target, this.userId);
-    });
-
-    const ancestors = getProperyAncestors(creatureId, spell._id);
-    ancestors.sort((a, b) => a.order - b.order);
-
-    const properties = getPropertyDecendants(creatureId, spell._id);
-    properties.push(spell);
-    properties.sort((a, b) => a.order - b.order);
-
-    // Spend the appropriate slot
-    let slotLevel = spell.level || 0;
-    let slot;
-
-    if (slotId && !spell.castWithoutSpellSlots){
-      slot = CreatureProperties.findOne(slotId);
-      if (!slot){
-        throw new Meteor.Error('No slot',
-          'Slot not found to cast spell');
-      }
-      if (!slot.value){
-        throw new Meteor.Error('No slot',
-          'Slot depleted');
-      }
-      if (slot.attributeType !== 'spellSlot'){
-        throw new Meteor.Error('Not a slot',
-          'The given property is not a valid spell slot');
-      }
-      if (!slot.spellSlotLevel?.value){
-        throw new Meteor.Error('No slot level',
-          'Slot does not have a spell slot level');
-      }
-      if (slot.spellSlotLevel.value < spell.level){
-        throw new Meteor.Error('Slot too small',
-          'Slot is not large enough to cast spell');
-      }
-      slotLevel = slot.spellSlotLevel.value;
-      damagePropertyWork({
-        prop: slot,
-        operation: 'increment',
-        value: 1,
-        actionContext,
-      });
-    }
-
-    // Post the slot level spent to the log
-    if (slot?.spellSlotLevel?.value){
-      actionContext.addLog({
-        name: `Casting using a level ${slotLevel} spell slot`
-      });
-    } else if (slotLevel) {
-      actionContext.addLog({
-        name: `Casting at level ${slotLevel}`
-      });
-    }
-
-    actionContext.scope['slotLevel'] = slotLevel;
-
-    // Do the action
-    doActionWork({
-      properties, ancestors, actionContext, methodScope: scope,
-    });
-
-    // Force the characters involved to recalculate
-    Creatures.update({
-      _id: { $in: [creatureId, ...targetIds] }
-    }, {
-      $set: { dirty: true },
-    });
-  },
-});
-
-export default doAction;

app/imports/api/engine/actions/doCheck.js

@@ -1,108 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import rollDice from '/imports/parser/rollDice.js';
-import numberToSignedString from '/imports/ui/utility/numberToSignedString.js';
-import { applyTriggers } from '/imports/api/engine/actions/applyTriggers.js';
-import ActionContext from '/imports/api/engine/actions/ActionContext.js';
-
-const doCheck = new ValidatedMethod({
-  name: 'creatureProperties.doCheck',
-  validate: new SimpleSchema({
-    propId: SimpleSchema.RegEx.Id,
-    scope: {
-      type: Object,
-      blackbox: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({propId, scope}) {
-    const prop = CreatureProperties.findOne(propId);
-    const creatureId = prop.ancestors[0].id;
-    const actionContext = new ActionContext(creatureId, [creatureId], this);
-    Object.assign(actionContext.scope, scope);
-
-    // Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-
-    // Do the check
-    doCheckWork({prop, actionContext});
-  },
-});
-
-export default doCheck;
-
-export function doCheckWork({prop, actionContext}){
-
-  applyTriggers(actionContext.triggers.check?.before, prop, actionContext);
-  rollCheck(prop, actionContext);
-  applyTriggers(actionContext.triggers.check?.after, prop, actionContext);
-
-  // Insert the log
-  actionContext.writeLog();
-}
-
-function rollCheck(prop, actionContext) {
-  const scope = actionContext.scope;
-  // get the modifier for the roll
-  let rollModifier;
-  let logName = `${prop.name} check`;
-  if (prop.type === 'skill'){
-    rollModifier = prop.value;
-    if (prop.skillType === 'save'){
-      if (prop.name.match(/save/i)){
-        logName = prop.name;
-      } else {
-        logName = prop.name ? `${prop.name} save` : 'Saving Throw';
-      }
-    }
-  } else if (prop.type === 'attribute'){
-    if (prop.attributeType === 'ability'){
-      rollModifier = prop.modifier;
-    } else {
-      rollModifier = prop.value;
-    }
-  } else {
-    throw (`${prop.type} not supported for checks`);
-  }
-
-  const rollModifierText = numberToSignedString(rollModifier, true);
-
-  let value, values, resultPrefix;
-  if (scope['$checkAdvantage'] === 1){
-    logName += ' (Advantage)';
-    const [a, b] = rollDice(2, 20);
-    if (a >= b) {
-      value = a;
-      resultPrefix = `1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText} = `;
-    } else {
-      value = b;
-      resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText} = `;
-    }
-  } else if (scope['$checkAdvantage'] === -1){
-    logName += ' (Disadvantage)';
-    const [a, b] = rollDice(2, 20);
-    if (a <= b) {
-      value = a;
-      resultPrefix = `1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText} = `;
-    } else {
-      value = b;
-      resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText} = `;
-    }
-  } else {
-    values = rollDice(1, 20);
-    value = values[0];
-    resultPrefix = `1d20 [ ${value} ] ${rollModifierText} = `
-  }
-  const result = (value + rollModifier) || 0;
-  actionContext.addLog({
-    name: logName,
-    value: `${resultPrefix} **${result}**`,
-  });
-}

app/imports/api/engine/actions/index.js

@@ -1,2 +0,0 @@
-import './doCastSpell.js';
-import './doCheck.js';

app/imports/api/engine/computation/CreatureComputation.js

@@ -1,40 +0,0 @@
-import { EJSON } from 'meteor/ejson';
-import createGraph from 'ngraph.graph';
-import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
-
-export default class CreatureComputation {
-  constructor(properties, creature, variables){
-    // Set up fields
-    this.originalPropsById =  {};
-    this.propsById =  {};
-    this.propsWithTag = {};
-    this.scope = {};
-    this.props =  properties;
-    this.dependencyGraph = createGraph();
-    this.errors = [];
-    this.creature = creature;
-    this.variables = variables;
-
-    // Store properties for easy access later
-    properties.forEach(prop => {
-      // Store a copy of the unmodified prop
-      // EJSON clone is ~4x faster than lodash cloneDeep for EJSONable objects
-      this.originalPropsById[prop._id] = EJSON.clone(prop);
-      // Store by id
-      this.propsById[prop._id] = prop;
-
-      // Store sets of ids in each tag
-      getEffectivePropTags(prop).forEach(tag => {
-        if (!tag) return;
-        if (this.propsWithTag[tag]) {
-          this.propsWithTag[tag].push(prop._id);
-        } else {
-          this.propsWithTag[tag] = [prop._id];
-        }
-      });
-
-      // Store the prop in the dependency graph
-      this.dependencyGraph.addNode(prop._id, prop);
-    });
-  }
-}

app/imports/api/engine/computation/buildComputation/computeInactiveStatus.js

@@ -1,43 +0,0 @@
-import walkDown from '/imports/api/engine/computation/utility/walkdown.js';
-
-export default function computeInactiveStatus(node){
-  const prop = node.node;
-  if (!isActive(prop)){
-    // Mark prop inactive due to self
-    prop.inactive = true;
-    prop.deactivatedBySelf = true;
-  }
-  if(!childrenActive(prop)){
-    // Mark children as inactive due to ancestor
-    walkDown(node.children, child => {
-      child.node.inactive = true;
-      child.node.deactivatedByAncestor = true;
-    });
-  }
-}
-
-function isActive(prop){
-  if (prop.disabled) return false;
-  switch (prop.type){
-    // Unprepared spells are inactive
-    case 'spell': return !!prop.prepared || !!prop.alwaysPrepared;
-    default: return true;
-  }
-}
-
-function childrenActive(prop){
-  // Children of disabled properties are always inactive
-  if (prop.disabled) return false;
-  switch (prop.type){
-    // Only equipped items have active children
-    case 'item': return !!prop.equipped;
-    // The children of actions, spells, and triggers are always inactive
-    case 'action': return false;
-    case 'spell': return false;
-    case 'trigger': return false;
-    // The children of notes are always inactive
-    case 'note': return false;
-    // Other children are active
-    default: return true;
-  }
-}

app/imports/api/engine/computation/buildComputation/computeSlotQuantityFilled.js

@@ -1,21 +0,0 @@
-/**
- * Only computes `totalFilled`, need to compute `quantityExpected.value`
- * before `spacesLeft` can be computed
- */
-export default function computeSlotQuantityFilled(node, dependencyGraph){
-  let slot = node.node;
-  if (slot.type !== 'propertySlot') return;
-  slot.totalFilled = 0;
-  node.children.forEach(child => {
-    let childProp = child.node;
-    dependencyGraph.addLink(slot._id, childProp._id, 'slotFill');
-    if (
-      childProp.type === 'slotFiller' &&
-      Number.isFinite(childProp.slotQuantityFilled)
-    ){
-      slot.totalFilled += childProp.slotQuantityFilled;
-    } else {
-      slot.totalFilled++;
-    }
-  });
-}

app/imports/api/engine/computation/buildComputation/computeToggleDependencies.js

@@ -1,19 +0,0 @@
-import walkDown from '/imports/api/engine/computation/utility/walkdown.js';
-
-export default function computeToggleDependencies(node, dependencyGraph){
-  const prop = node.node;
-  // Only for toggles that aren't inactive and aren't set to enabled or disabled
-  if (
-    prop.inactive ||
-    prop.type !== 'toggle' ||
-    prop.disabled ||
-    prop.enabled
-  ) return;
-  walkDown(node.children, child => {
-    // Only for children that aren't inactive
-    if (child.node.inactive) return;
-    // The child nodes depend on the toggle condition compuation
-    child.node._computationDetails.toggleAncestors.push(prop);
-    dependencyGraph.addLink(child.node._id, prop._id, 'toggle');
-  });
-}

app/imports/api/engine/computation/buildComputation/linkCalculationDependencies.js

@@ -1,51 +0,0 @@
-import findAncestorByType from '/imports/api/engine/computation/utility/findAncestorByType.js';
-import { traverse } from '/imports/parser/resolve.js';
-
-export default function linkCalculationDependencies(dependencyGraph, prop, {propsById}){
-  prop._computationDetails.calculations.forEach(calcObj => {
-    // Store resolved ancestors
-    const memo = {
-      // ancestors: {} //this gets added if there are resolved ancestors
-    };
-    // Add this calculation to the dependency graph
-    const calcNodeId = `${prop._id}.${calcObj._key}`;
-    dependencyGraph.addNode(calcNodeId, calcObj);
-
-    // Traverse the parsed calculation looking for variable names
-    traverse(calcObj.parseNode, node => {
-      // Skip nodes that aren't symbols or accessors
-      if (node.parseType !== 'symbol' && node.parseType !== 'accessor') return;
-      // Link ancestor references as direct property dependencies
-      if (node.name[0] === '#'){
-        let ancestorProp = getAncestorProp(
-          node.name.slice(1), memo, prop, propsById
-        );
-        if (!ancestorProp) return;
-        // Link the ancestor prop as a direct dependency
-        dependencyGraph.addLink(
-          calcNodeId, ancestorProp._id, 'ancestorReference'
-        );
-      } else {
-        // Link variable name references as variable dependencies
-        dependencyGraph.addLink(
-          calcNodeId, node.name, 'variableReference'
-        );
-      }
-    });
-    // Store the resolved ancestors in this calculation's local scope
-    if (memo.ancestors) {
-      calcObj._localScope = { ...calcObj._localScope, ...memo.ancestors};
-    }
-  });
-}
-
-function getAncestorProp(type, memo, prop, propsById){
-  if (memo.ancestors && memo.ancestors['#' + type]){
-    return memo.ancestors['#' + type];
-  } else {
-    var ancestorProp = findAncestorByType( prop, type, propsById );
-    if (!memo.ancestors) memo.ancestors = {};
-    memo.ancestors['#' + type] = ancestorProp;
-    return ancestorProp;
-  }
-}

app/imports/api/engine/computation/buildComputation/linkInventory.js

@@ -1,62 +0,0 @@
-/**
- * Performs a depth first traversal of the character tree, summing the container
- * and inventory contents on the way up the tree
- */
-export default function linkInventory(forest, dependencyGraph){
-  // The stack of properties to still navigate
-  const stack = [...forest];
-  // The current containers we are inside of
-  const containerStack = [];
-
-  while(stack.length){
-    const top = stack[stack.length - 1];
-    const prop = top.node;
-    if (prop._computationDetails.inventoryChildrenVisited){
-      if (prop.type === 'container') containerStack.pop();
-      stack.pop();
-      handleProp(prop, containerStack, dependencyGraph);
-    } else {
-      // Add all containers to the stack when we first visit them
-      if (prop.type === 'container'){
-        containerStack.push(top.node);
-      }
-      // Push children onto the stack and mark this as children are visited
-      stack.push(...top.children);
-      prop._computationDetails.inventoryChildrenVisited = true;
-    }
-  }
-}
-
-function handleProp(prop, containerStack, dependencyGraph){
-  // Skip props that aren't part of the inventory
-  if (prop.type !== 'item' && prop.type !== 'container') return;
-  // Determine if this property is carried, items are carried by default
-  let carried = prop.type === 'container' ? prop.carried : true;
-
-  // Item-specific links
-  if (prop.type === 'item'){
-    if (prop.attuned){
-      dependencyGraph.addLink('itemsAttuned', prop._id, 'attunedItem');
-    }
-    if (prop.equipped){
-      dependencyGraph.addLink('weightEquipment', prop._id, 'equippedItem');
-      dependencyGraph.addLink('valueEquipment', prop._id, 'equippedItem');
-    }
-  }
-
-  // Get the parent container
-  const container = containerStack[containerStack.length - 1];
-
-  if (container){
-    // The container depends on this prop for its contents data
-    dependencyGraph.addLink(container._id, prop._id, 'containerContents');
-  } else {
-    // There is no parent container, the character totals depend on this prop
-    dependencyGraph.addLink('weightTotal', prop._id, 'inventoryStats');
-    dependencyGraph.addLink('valueTotal', prop._id, 'inventoryStats');
-    if (carried){
-      dependencyGraph.addLink('weightCarried', prop._id, 'inventoryStats');
-      dependencyGraph.addLink('valueCarried', prop._id, 'inventoryStats');
-    }
-  }
-}

app/imports/api/engine/computation/buildComputation/linkTypeDependencies.js

@@ -1,309 +0,0 @@
-import { get, intersection, difference, union } from 'lodash';
-
-const linkDependenciesByType = {
-  action: linkAction,
-  adjustment: linkAdjustment,
-  attribute: linkAttribute,
-  branch: linkBranch,
-  buff: linkBuff,
-  class: linkVariableName,
-  classLevel: linkClassLevel,
-  constant: linkVariableName,
-  damage: linkDamage,
-  damageMultiplier: linkDamageMultiplier,
-  effect: linkEffects,
-  proficiency: linkProficiencies,
-  roll: linkRoll,
-  pointBuy: linkPointBuy,
-  propertySlot: linkSlot,
-  skill: linkSkill,
-  spell: linkAction,
-  spellList: linkSpellList,
-  savingThrow: linkSavingThrow,
-  toggle: linkToggle,
-}
-
-export default function linkTypeDependencies(dependencyGraph, prop, computation){
-  linkDependenciesByType[prop.type]?.(dependencyGraph, prop, computation);
-}
-
-function dependOnCalc({dependencyGraph, prop, key}){
-  let calc = get(prop, key);
-  if (!calc) return;
-  if (calc.type !== '_calculation'){
-    throw `Expected calculation got ${calc.type}`
-  }
-  dependencyGraph.addLink(prop._id, `${prop._id}.${key}`, 'calculation');
-}
-
-function linkAction(dependencyGraph, prop, {propsById}){
-  // The action depends on its attack roll and uses calculations
-  dependOnCalc({dependencyGraph, prop, key: 'attackRoll'});
-  dependOnCalc({dependencyGraph, prop, key: 'uses'});
-
-  // Link the resources the action uses
-  if (!prop.resources) return;
-  // Link items consumed
-  prop.resources.itemsConsumed.forEach((itemConsumed, index) => {
-    if (!itemConsumed.itemId) return;
-    const item = propsById[itemConsumed.itemId];
-    if (!item || item.inactive){
-      // Unlink if the item doesn't exist or is inactive
-      itemConsumed.itemId = undefined;
-      return;
-    }
-    // none of these dependencies are computed, we can use them immediately
-    itemConsumed.available = item.quantity;
-    itemConsumed.itemName = item.name;
-    itemConsumed.itemIcon = item.icon;
-    itemConsumed.itemColor = item.color;
-    dependencyGraph.addLink(prop._id, item._id, 'inventory');
-    // Link the property to its resource quantity calculation
-
-    dependOnCalc({
-      dependencyGraph,
-      prop,
-      key: `resources.itemsConsumed[${index}].quantity`,
-    });
-  });
-  // Link attributes consumed
-  prop.resources.attributesConsumed.forEach((attConsumed, index) => {
-    if (!attConsumed.variableName) return;
-    dependencyGraph.addLink(prop._id, attConsumed.variableName, 'resource');
-    // Link the property to its resource quantity calculation
-    dependOnCalc({
-      dependencyGraph,
-      prop,
-      key: `resources.attributesConsumed[${index}].quantity`,
-    });
-  });
-}
-
-function linkAdjustment(dependencyGraph, prop){
-  // Adjustment depends on its amount
-  dependOnCalc({dependencyGraph, prop, key: 'amount'});
-}
-
-function linkAttribute(dependencyGraph, prop){
-  linkVariableName(dependencyGraph, prop);
-  // Depends on spellSlotLevel
-  dependOnCalc({dependencyGraph, prop, key: 'spellSlotLevel'});
-
-  // Depends on base value
-  dependOnCalc({dependencyGraph, prop, key: 'baseValue'});
-
-  // hit dice depend on constitution
-  if (prop.attributeType === 'hitDice'){
-    dependencyGraph.addLink(prop._id, 'constitution', 'hitDiceConMod');
-  }
-}
-
-function linkBranch(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'condition'});
-}
-
-function linkBuff(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'duration'});
-}
-
-function linkClassLevel(dependencyGraph, prop) {
-  if (prop.inactive) return;
-  // The variableName of the prop depends on the prop
-  if (prop.variableName && prop.level){
-    dependencyGraph.addLink(prop.variableName, prop._id, 'classLevel');
-    // The level variable depends on the class variableName variable
-    let existingLevelLink = dependencyGraph.getLink('level', prop.variableName);
-    if (!existingLevelLink){
-      dependencyGraph.addLink('level', prop.variableName, 'level');
-    }
-  }
-}
-
-function linkDamage(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'amount'});
-}
-
-function linkEffects(dependencyGraph, prop, computation) {
-  // The effect depends on its amount calculation
-  dependOnCalc({ dependencyGraph, prop, key: 'amount' });
-  // Inactive effects aren't going to impact their targeted stats
-  if (prop.inactive) return;
-  // The stats depend on the effect
-  if (prop.inactive) {
-    // Inactive effects apply to no stats
-    return;
-  } else if (prop.targetByTags){
-    getEffectTagTargets(prop, computation).forEach(targetId => {
-      const targetProp = computation.propsById[targetId];
-      if (
-        (targetProp.type === 'attribute' || targetProp.type === 'skill')
-        && targetProp.variableName
-        && !prop.targetField
-      ) {
-        // If the field wasn't specified and we're targeting an attribute or
-        // skill, just treat it like a normal effect on its variable name
-        dependencyGraph.addLink(targetProp.variableName, prop._id, 'effect');
-      } else {
-        // Otherwise target a field on that property
-        const key = prop.targetField || getDefaultCalculationField(targetProp);
-        const calcObj = get(targetProp, key);
-        if (calcObj && calcObj.calculation){
-          dependencyGraph.addLink(`${targetProp._id}.${key}`, prop._id , 'effect');
-        }
-      }
-    });
-  } else {
-    prop.stats.forEach(statName => {
-      if (!statName) return;
-      dependencyGraph.addLink(statName, prop._id, 'effect');
-    });
-  }
-}
-
-// Returns an array of IDs of the properties the effect targets
-function getEffectTagTargets(effect, computation){
-  let targets = getTargetListFromTags(effect.targetTags, computation);
-  let notIds = [];
-  if (effect.extraTags){
-    effect.extraTags.forEach(ex => {
-      if (ex.operation === 'OR') {
-        targets = union(targets, getTargetListFromTags(ex.tags, computation));
-      } else if (ex.operation === 'NOT'){
-        ex.tags.forEach(tag => {
-          const idList = computation.propsWithTag[tag];
-          if (idList) {
-            notIds = union(notIds, computation.propsWithTag[tag]);
-          }
-        });
-      }
-    });
-  }
-  return difference(targets, notIds);
-}
-
-function getTargetListFromTags(tags, computation){
-  const targetTagIdLists = [];
-  if (!tags) return [];
-  tags.forEach(tag => {
-    const idList = computation.propsWithTag[tag] || [];
-    targetTagIdLists.push(idList);
-  });
-  const targets = intersection(...targetTagIdLists);
-  return targets;
-}
-
-function getDefaultCalculationField(prop){
-  switch (prop.type){
-    case 'action': return 'attackRoll';
-    case 'adjustment': return 'amount';
-    case 'attribute': return 'baseValue';
-    case 'branch': return 'condition';
-    case 'buff': return 'duration';
-    case 'class': return null;
-    case 'classLevel': return null;
-    case 'constant': return null;
-    case 'container': return null;
-    case 'damageMultiplier': return null;
-    case 'damage': return 'amount';
-    case 'effect': return 'amount';
-    case 'feature': return null;
-    case 'folder': return null;
-    case 'item': return null;
-    case 'note': return null;
-    case 'proficiency': return null;
-    case 'reference': return null;
-    case 'roll': return 'roll';
-    case 'savingThrow': return 'dc';
-    case 'skill': return 'baseValue';
-    case 'slotFiller': return null;
-    case 'slot': return 'quantityExpected';
-    case 'spellList': return 'attackRollBonus';
-    case 'spell': return null;
-    case 'toggle': return 'condition';
-  }
-}
-
-function linkRoll(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'roll'});
-}
-
-function linkVariableName(dependencyGraph, prop){
-  // The variableName of the prop depends on the prop if the prop is active
-  if (prop.variableName && !prop.inactive){
-    dependencyGraph.addLink(prop.variableName, prop._id, 'definition');
-  }
-}
-
-function linkDamageMultiplier(dependencyGraph, prop) {
-  if (prop.inactive) return;
-  prop.damageTypes.forEach(damageType => {
-    // Remove all non-letter characters from the damage name
-    const damageName = damageType.replace(/[^a-z]/gi, '')
-    dependencyGraph.addLink(damageName, prop._id, prop.type);
-  });
-}
-
-function linkPointBuy(dependencyGraph, prop){
-  dependOnCalc({ dependencyGraph, prop, key: 'min' });
-  dependOnCalc({ dependencyGraph, prop, key: 'max' });
-  dependOnCalc({ dependencyGraph, prop, key: 'cost' });
-  dependOnCalc({ dependencyGraph, prop, key: 'total' });
-  prop.values?.forEach(row => {
-    // Wrap the document in a new object so we don't bash it unintentionally
-    const pointBuyRow = {
-      ...row,
-      type: 'pointBuyRow',
-      tableName: prop.name,
-      tableId: prop._id,
-    }
-    dependencyGraph.addNode(row._id, pointBuyRow);
-    linkVariableName(dependencyGraph, pointBuyRow);
-    dependOnCalc({ dependencyGraph, pointBuyRow, key: 'row.min' });
-    dependOnCalc({ dependencyGraph, pointBuyRow, key: 'row.max' });
-    dependOnCalc({ dependencyGraph, pointBuyRow, key: 'row.cost' });
-  });
-  if (prop.inactive) return;
-}
-
-function linkProficiencies(dependencyGraph, prop){
-  // The stats depend on the proficiency
-  if (prop.inactive) return;
-  prop.stats.forEach(statName => {
-    if (!statName) return;
-    dependencyGraph.addLink(statName, prop._id, prop.type);
-  });
-}
-
-function linkSavingThrow(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'dc'});
-}
-
-function linkSkill(dependencyGraph, prop){
-  // Depends on base value
-  dependOnCalc({ dependencyGraph, prop, key: 'baseValue' });
-  // Link dependents
-  if (prop.inactive) return;
-  linkVariableName(dependencyGraph, prop);
-  // The prop depends on the variable references as the ability
-  if (prop.ability){
-    dependencyGraph.addLink(prop._id, prop.ability, 'skillAbilityScore');
-  }
-  // Skills depend on the creature's proficiencyBonus
-  dependencyGraph.addLink(prop._id, 'proficiencyBonus', 'skillProficiencyBonus');
-}
-
-function linkSlot(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'quantityExpected'});
-  dependOnCalc({dependencyGraph, prop, key: 'slotCondition'});
-}
-
-function linkSpellList(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'maxPrepared'});
-  dependOnCalc({dependencyGraph, prop, key: 'attackRollBonus'});
-  dependOnCalc({dependencyGraph, prop, key: 'dc'});
-}
-
-function linkToggle(dependencyGraph, prop){
-  linkVariableName(dependencyGraph, prop);
-  dependOnCalc({dependencyGraph, prop, key: 'condition'});
-}

app/imports/api/engine/computation/buildComputation/parseCalculationFields.js

@@ -1,105 +0,0 @@
-import INLINE_CALCULATION_REGEX from '/imports/constants/INLINE_CALCULTION_REGEX.js';
-import { prettifyParseError, parse } from '/imports/parser/parser.js';
-import applyFnToKey from '/imports/api/engine/computation/utility/applyFnToKey.js';
-import { get, unset } from 'lodash';
-import errorNode from '/imports/parser/parseTree/error.js';
-import cyrb53 from '/imports/api/engine/computation/utility/cyrb53.js';
-
-export default function parseCalculationFields(prop, schemas){
-  discoverInlineCalculationFields(prop, schemas);
-  parseAllCalculationFields(prop, schemas);
-}
-
-function discoverInlineCalculationFields(prop, schemas){
-  // For each key in the schema
-  schemas[prop.type].inlineCalculationFields().forEach( calcKey => {
-    // That ends in .inlineCalculations
-    applyFnToKey(prop, calcKey, (prop, key) => {
-      const inlineCalcObj = get(prop, key);
-      if (!inlineCalcObj) return;
-      // Store a reference to all the inline calculations
-      prop._computationDetails.inlineCalculations.push(inlineCalcObj);
-      // Extract the calculations and store them on the property
-      let string = inlineCalcObj.text;
-      // If there is no text, delete the whole field
-      if (!string){
-        unset(prop, calcKey);
-        return;
-      }
-
-      // Set the value to the uncomputed string for use in calculations
-      inlineCalcObj.value = string;
-
-      // Has the text, if it matches the existing hash, stop
-      const inlineCalcHash = cyrb53(inlineCalcObj.text);
-      if (inlineCalcHash === inlineCalcObj.hash){
-        return;
-      }
-      inlineCalcObj.hash = inlineCalcHash;
-      inlineCalcObj.inlineCalculations = [];
-
-      // It will be re set including the embedded calculation at the end of
-      // the computation
-      let matches = string.matchAll(INLINE_CALCULATION_REGEX);
-      for (let match of matches){
-        let calculation = match[1];
-        inlineCalcObj.inlineCalculations.push({
-          calculation,
-        });
-      }
-    });
-  });
-}
-
-function parseAllCalculationFields(prop, schemas){
-  // For each computed key in the schema
-  schemas[prop.type].computedFields().forEach( calcKey => {
-    // Determine the level the calculation should compute down to
-    let parseLevel = schemas[prop.type].getDefinition(calcKey).parseLevel || 'reduce';
-
-    // Special case of effects, when targeting by tags compile
-    if (prop.type === 'effect' && prop.targetByTags) parseLevel = 'compile';
-
-    // For all fields matching they keys
-    // supports `keys.$.with.$.arrays`
-    applyFnToKey(prop, calcKey, (prop, key) => {
-      const calcObj = get(prop, key);
-      if (!calcObj) return;
-      // Delete the whole calculation object if the calculation string isn't set
-      if (!calcObj.calculation){
-        unset(prop, calcKey);
-        return;
-      }
-      // Store a reference to all the calculations
-      prop._computationDetails.calculations.push(calcObj);
-      // Store the level to compute down to later
-      calcObj._parseLevel = parseLevel;
-      // Store the key
-      calcObj._key = key;
-      // Set a type
-      calcObj.type = '_calculation';
-      // Parse the calculation
-      parseCalculation(calcObj);
-    });
-  });
-}
-
-function parseCalculation(calcObj){
-  const calcHash = cyrb53(calcObj.calculation);
-  // If the cached parse calculation is equal to the calculation, skip
-  if (calcHash === calcObj.hash){
-    return;
-  }
-  calcObj.hash = calcHash;
-  try {
-    calcObj.parseNode = parse(calcObj.calculation);
-    calcObj.parseError = null;
-  } catch (e) {
-    let error = {
-      type: 'evaluation',
-      message: prettifyParseError(e),
-    };
-    calcObj.parseError = error;
-    calcObj.parseNode = errorNode.create({error});
-  }
-}