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"
+  }
+}

.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).
+This is the repo for [DiceCloud](dicecloud.com). The currently deployed version should always be the head of the master branch.
-
-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.

app/.gitignore

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

app/.meteor/packages

@@ -1,53 +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
-random
-dburles:collection-helpers
-reactive-var
-underscore
-momentjs:moment
-dburles:mongo-collection-instances
-accounts-google
-email
-meteorhacks:subs-manager
-chuangbo:marked
-meteor-base
-mobile-experience
-mongo
-session
-tracker
-logging
-reload
-ejson
-check
-standard-minifier-js
-shell-server
-templates:array
-ecmascript
-es5-shim
-reactive-dict
-percolate:synced-cron
-ongoworks:speakingurl
-service-configuration
-dynamic-import
-ddp-rate-limiter
-rate-limit
-mdg:validated-method
-akryum:vue-router2
-static-html
-aldeed:collection2
-aldeed:schema-index
-zer0th:meteor-vuetify-loader
-accounts-patreon
-bozhao:link-accounts
-peerlibrary:reactive-publish
-simple:rest
-simple:rest-method-mixin
-mikowals:batch-insert
-peerlibrary:subscription-data
-seba:minifiers-autoprefixer
-akryum:vue-component
-akryum:vue-sass

app/.meteor/release

@@ -1 +0,0 @@
-METEOR@2.2.1

app/.meteor/versions

@@ -1,129 +0,0 @@
-accounts-base@1.9.0
-accounts-google@1.3.3
-accounts-oauth@1.2.0
-accounts-password@1.7.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
-akryum:vue-sass@0.1.2
-aldeed:collection2@3.4.1
-aldeed:schema-index@3.0.0
-allow-deny@1.1.0
-autoupdate@1.7.0
-babel-compiler@7.6.2
-babel-runtime@1.5.0
-base64@1.0.12
-binary-heap@1.0.11
-blaze-tools@1.1.2
-boilerplate-generator@1.7.1
-bozhao:link-accounts@2.4.0
-caching-compiler@1.2.2
-caching-html-compiler@1.2.1
-callback-hook@1.3.0
-check@1.3.1
-chuangbo:marked@0.3.5_1
-coffeescript@2.4.1
-coffeescript-compiler@2.4.1
-dburles:collection-helpers@1.1.0
-dburles:mongo-collection-instances@0.3.5
-ddp@1.4.0
-ddp-client@2.4.1
-ddp-common@1.4.0
-ddp-rate-limiter@1.0.9
-ddp-server@2.3.3
-deps@1.0.12
-diff-sequence@1.1.1
-dynamic-import@0.6.0
-ecmascript@0.15.1
-ecmascript-runtime@0.7.0
-ecmascript-runtime-client@0.11.1
-ecmascript-runtime-server@0.10.1
-ejson@1.1.1
-email@2.0.0
-es5-shim@4.8.0
-fetch@0.1.1
-geojson-utils@1.0.10
-google-oauth@1.3.0
-hot-code-push@1.0.4
-html-tools@1.1.2
-htmljs@1.1.1
-http@1.4.4
-id-map@1.1.1
-inter-process-messaging@0.1.1
-lai:collection-extensions@0.2.1_1
-launch-screen@1.2.1
-livedata@1.0.18
-localstorage@1.2.0
-logging@1.2.0
-mdg:validated-method@1.2.0
-meteor@1.9.3
-meteor-base@1.4.0
-meteorhacks:subs-manager@1.6.4
-mikowals:batch-insert@1.2.0
-minifier-css@1.5.4
-minifier-js@2.6.1
-minimongo@1.6.2
-mobile-experience@1.1.0
-mobile-status-bar@1.1.0
-modern-browsers@0.1.5
-modules@0.16.0
-modules-runtime@0.12.0
-momentjs:moment@2.29.1
-mongo@1.11.1
-mongo-decimal@0.1.2
-mongo-dev-server@1.1.0
-mongo-id@1.0.8
-npm-bcrypt@0.9.4
-npm-mongo@3.9.0
-oauth@1.3.2
-oauth2@1.3.0
-ongoworks:speakingurl@9.0.0
-ordered-dict@1.1.0
-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.0
-peerlibrary:reactive-publish@0.10.0
-peerlibrary:server-autorun@0.8.0
-peerlibrary:subscription-data@0.8.0
-percolate:synced-cron@1.3.2
-promise@0.11.2
-raix:eventemitter@1.0.0
-random@1.2.0
-rate-limit@1.0.9
-react-fast-refresh@0.1.1
-reactive-dict@1.3.0
-reactive-var@1.0.11
-reload@1.3.1
-retry@1.1.0
-routepolicy@1.1.0
-seba:minifiers-autoprefixer@2.0.1
-service-configuration@1.0.11
-session@1.2.0
-sha@1.0.9
-shell-server@0.5.0
-simple:json-routes@2.1.0
-simple:rest@1.1.1
-simple:rest-method-mixin@1.0.1
-socket-stream-client@0.3.3
-spacebars-compiler@1.3.0
-srp@1.1.0
-standard-minifier-js@2.6.1
-static-html@1.3.2
-templates:array@1.0.3
-templating-tools@1.2.1
-tmeasday:check-npm-versions@1.0.2
-tracker@1.2.0
-typescript@4.2.2
-underscore@1.0.10
-url@1.3.2
-webapp@1.10.1
-webapp-hashing@1.1.0
-zer0th:meteor-vuetify-loader@0.1.30

app/client/index.html

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

app/client/main.js

@@ -1,4 +0,0 @@
-import '/imports/ui/vueSetup.js';
-import '/imports/ui/styles/stylesIndex.js';
-import '/imports/client/config.js';
-import '/imports/client/serviceWorker.js';

app/exampleMeteorSettings.json

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

app/imports/api/creature/actions/applyAction.js

@@ -1,13 +0,0 @@
-import spendResources from '/imports/api/creature/actions/spendResources.js'
-import embedInlineCalculations from '/imports/api/creature/computation/afterComputation/embedInlineCalculations.js';
-
-export default function applyAction({prop, log}){
-  let content = { name: prop.name };
-  if (prop.summary){
-    content.value = embedInlineCalculations(
-      prop.summary, prop.summaryCalculations
-    );
-  }
-  log.content.push(content);
-  spendResources({prop, log});
-}

app/imports/api/creature/actions/applyAdjustment.js

@@ -1,55 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-import damagePropertiesByName from '/imports/api/creature/creatureProperties/methods/damagePropertiesByName.js';
-
-export default function applyAdjustment({
-  prop,
-  creature,
-  targets,
-  actionContext,
-  log
-}){
-  let damageTargets = prop.target === 'self' ? [creature] : targets;
-  let scope = {
-    ...creature.variables,
-    ...actionContext,
-  };
-  var {result, context} = evaluateString({
-    string: prop.amount,
-    scope,
-    fn: 'reduce'
-  });
-  context.errors.forEach(e => {
-    log.content.push({
-      name: 'Attribute damage error',
-      value: e.message || e.toString(),
-    });
-  });
-  if (damageTargets) {
-    damageTargets.forEach(target => {
-      if (prop.target === 'each'){
-        ({result} = evaluateString({
-          string: prop.amount,
-          scope,
-          fn: 'reduce'
-        }));
-      }
-      damagePropertiesByName.call({
-        creatureId: target._id,
-        variableName: prop.stat,
-        operation: prop.operation || 'increment',
-        value: result.value,
-      });
-      log.content.push({
-        name: 'Attribute damage',
-        value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
-        ` ${result.isNumber ? -result.value : result.toString()}`,
-      });
-    });
-  } else {
-    log.content.push({
-      name: 'Attribute damage',
-      value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
-      ` ${result.isNumber ? -result.value : result.toString()}`,
-    });
-  }
-}

app/imports/api/creature/actions/applyAttack.js

@@ -1,22 +0,0 @@
-import roll from '/imports/parser/roll.js';
-
-export default function applyAttack({
-  prop,
-  log,
-  actionContext,
-  creature,
-}){
-  let value = roll(1, 20)[0];
-  actionContext.attackRoll = {value};
-  let criticalHitTarget = creature.variables.criticalHitTarget &&
-    creature.variables.criticalHitTarget.currentValue || 20;
-  let criticalHit = value >= criticalHitTarget;
-  if (criticalHit) actionContext.criticalHit = {value: true};
-  let result = value + prop.rollBonusResult;
-  actionContext.toHit = {value: result};
-
-  log.content.push({
-    name: criticalHit ? 'Critical Hit!' : 'To Hit',
-    value: `1d20 [${value}] + ${prop.rollBonusResult} = ` + result,
-  });
-}

app/imports/api/creature/actions/applyBuff.js

@@ -1,61 +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';
-
-export default function applyBuff({
-  prop,
-  children,
-  creature,
-  targets = [],
-  //actionContext,
-}){
-  let buffTargets = prop.target === 'self' ? [creature] : targets;
-
-  //let scope = {
-  //  ...creature.variables,
-  //  ...actionContext,
-  //};
-
-  // TODO
-  // If the target is not self, walk through all decendants and replace
-  // variables in calculations with their values from the creature scope
-  // If the target is self, replace all the target.x references with just x
-
-  // Then copy the decendants of the buff to the targets
-  prop.applied = true;
-  let propList = [prop];
-  function addChildrenToPropList(children){
-    children.forEach(child => {
-      propList.push(child.node);
-      addChildrenToPropList(child.children);
-    });
-  }
-  addChildrenToPropList(children);
-  let oldParent = {
-    id: prop.parent.id,
-    collection: prop.parent.collection,
-  };
-  buffTargets.forEach(target => {
-    copyNodeListToTarget(propList, target, oldParent);
-  });
-}
-
-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);
-}

app/imports/api/creature/actions/applyDamage.js

@@ -1,115 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-import dealDamage from '/imports/api/creature/creatureProperties/methods/dealDamage.js';
-import {insertCreatureLog} from '/imports/api/creature/log/CreatureLogs.js';
-import { CompilationContext } from '/imports/parser/parser.js';
-
-export default function applyDamage({
-  prop,
-  creature,
-  targets,
-  actionContext,
-  log,
-}){
-  let damageTargets = prop.target === 'self' ? [creature] : targets;
-  let scope = {
-    ...creature.variables,
-    ...actionContext,
-  };
-  // Add the target's variables to the scope
-  if (targets.length === 1){
-    scope.target = targets[0].variables;
-  }
-  // Determine if the hit is critical
-  let criticalHit = !!(
-    actionContext.criticalHit &&
-    actionContext.criticalHit.value &&
-    prop.damageType !== 'healing' // Can't critically heal
-  );
-  // Double the damage rolls if the hit is critical
-  let context = new CompilationContext({
-    doubleRolls: criticalHit,
-  });
-
-  // Compute the roll the first time, logging any errors
-  var {result} = evaluateString({
-    string: prop.amount,
-    scope,
-    fn: 'reduce',
-    context
-  });
-
-  // If the result is an error bail out now
-  if (result.constructor.name === 'ErrorNode'){
-    log.content.push({
-      name: 'Damage error',
-      value: result.toString(),
-    });
-    return;
-  }
-
-  // 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 => {
-      let name = prop.damageType === 'healing' ? 'Healing' : 'Damage';
-
-      // Reroll the damage if needed
-      if (prop.target === 'each'){
-        ({result, context} = evaluateString({
-          string: prop.amount,
-          scope,
-          fn: 'reduce'
-        }));
-      }
-      // If the result is an error or not a number bail out now
-      if (result.constructor.name === 'ErrorNode' || !result.isNumber){
-        log.content.push({
-          name: 'Damage error',
-          value: result.toString(),
-        });
-        return;
-      }
-
-      // Deal the damage to the target
-      let damageDealt = dealDamage.call({
-        creatureId: target._id,
-        damageType: prop.damageType,
-        amount: result.value,
-      });
-
-      // Log the damage done
-      if (target._id === creature._id){
-        // Target is same as self, log damage as such
-        log.content.push({
-          name,
-          value: damageDealt + suffix + ' to self',
-        });
-      } else {
-        log.content.push({
-          name,
-          value: '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
-    log.content.push({
-      name: prop.damageType === 'healing' ? 'Healing' : 'Damage',
-      value: result.toString() + suffix,
-    });
-  }
-}

app/imports/api/creature/actions/applyProperties.js

@@ -1,82 +0,0 @@
-import applyAction from '/imports/api/creature/actions/applyAction.js';
-import applyAdjustment from '/imports/api/creature/actions/applyAdjustment.js';
-import applyAttack from '/imports/api/creature/actions/applyAttack.js';
-import applyBuff from '/imports/api/creature/actions/applyBuff.js';
-import applyDamage from '/imports/api/creature/actions/applyDamage.js';
-import applyRoll from '/imports/api/creature/actions/applyRoll.js';
-import applyToggle from '/imports/api/creature/actions/applyToggle.js';
-import applySave from '/imports/api/creature/actions/applySave.js';
-
-function applyProperty(options){
-  let prop = options.prop;
-  if (prop.type === 'buff'){
-    // ignore only applied buffs, don't apply them again
-    if (prop.applied === true){
-      return false;
-    }
-  // Only ignore toggles if they wont be computed
-  } else if (prop.type === 'toggle') {
-    if (prop.disabled) return false;
-    if (prop.enabled) return true;
-    if (!prop.condition) return false;
-  // Ignore inactive props of other types
-  } else if (prop.deactivatedBySelf === true){
-    return false;
-  }
-  switch (prop.type){
-    case 'action':
-    case 'spell':
-      applyAction(options);
-      break;
-    case 'attack':
-      applyAction(options);
-      applyAttack(options);
-      break;
-    case 'damage':
-      applyDamage(options);
-      break;
-    case 'adjustment':
-      applyAdjustment(options);
-      break;
-    case 'buff':
-      applyBuff(options);
-      return false;
-    case 'toggle':
-      return applyToggle(options);
-    case 'roll':
-      applyRoll(options);
-      break;
-    case 'savingThrow':
-      return applySave(options);
-  }
-  return true;
-}
-
-function applyPropertyAndWalkChildren({prop, children, targets, ...options}){
-  let shouldKeepWalking = applyProperty({ prop, children, targets, ...options });
-  if (shouldKeepWalking){
-    applyProperties({ forest: children, targets, ...options,});
-  }
-}
-
-export default function applyProperties({ forest, targets, ...options}){
-  forest.forEach(node => {
-    let prop = node.node;
-    options.actionContext[`#${prop.type}`] = prop;
-    let children = node.children;
-    if (shouldSplit(prop) && targets.length){
-      targets.forEach(target => {
-        let targets = [target]
-        applyPropertyAndWalkChildren({ targets, prop, children, ...options});
-      });
-    } else {
-      applyPropertyAndWalkChildren({prop, children, targets, ...options});
-    }
-  });
-}
-
-function shouldSplit(prop){
-  if (prop.target === 'each'){
-    return true;
-  }
-}

app/imports/api/creature/actions/applyRoll.js

@@ -1,25 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-
-export default function applyRoll({
-  prop,
-  creature,
-  actionContext,
-  log,
-}){
-  let scope = {
-    ...creature.variables,
-    ...actionContext,
-  };
-  var {result} = evaluateString({
-    string: prop.roll,
-    scope,
-    fn: 'reduce'
-  });
-  if (result.isNumber){
-    actionContext[prop.variableName] = result.value;
-  }
-  log.content.push({
-    name: prop.name,
-    value: prop.variableName + ' = ' + prop.roll + ' = ' + result.toString(),
-  });
-}

app/imports/api/creature/actions/applySave.js

@@ -1,76 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-import CreaturesProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import roll from '/imports/parser/roll.js';
-
-export default function applySave({
-  prop,
-  creature,
-  actionContext,
-  log,
-}){
-  let scope = {
-    ...creature.variables,
-    ...actionContext,
-  };
-  try {
-    // Calculate the DC
-    var {result} = evaluateString({
-      string: prop.dc,
-      scope,
-      fn: 'reduce'
-    });
-    let dc = result.value;
-    log.content.push({
-      name: prop.name,
-      value: ' DC ' + result.toString(),
-    });
-    if (prop.target === 'self'){
-      let save = CreaturesProperties.findOne({
-        'ancestors.id': creature._id,
-        type: 'skill',
-        skillType: 'save',
-        variableName: prop.stat,
-        removed: {$ne: true},
-        inactive: {$ne: true},
-      });
-      if (!save){
-        log.content.push({
-          name: 'Saving throw error',
-          value: 'No saving throw found: ' + prop.stat,
-        });
-        return;
-      }
-      let value, values, resultPrefix;
-      if (save.advantage === 1){
-        values = roll(2, 20).sort().reverse();
-        value = values[0];
-        resultPrefix = `Advantage: 1d20 [${values[0]},~~${values[1]}~~] + ${save.value} = `
-      } else if (save.advantage === -1){
-        values = roll(2, 20).sort();
-        value = values[0];
-        resultPrefix = `Disadvantage: 1d20 [${values[0]},~~${values[1]}~~] + ${save.value} = `
-      } else {
-        values = roll(1, 20);
-        value = values[0];
-        resultPrefix = `1d20 [${value}] + ${save.value} = `
-      }
-      actionContext.savingThrowRoll = {value};
-      let result = value + save.value;
-      actionContext.savingThrow = {value: result};
-      let saveSuccess = result >= dc;
-      log.content.push({
-        name: 'Save',
-        value: resultPrefix + result + (saveSuccess ? 'Passed' : 'Failed')
-      });
-      return !saveSuccess;
-    } else {
-      // TODO
-      return true;
-    }
-  } catch (e){
-    log.content.push({
-      name: 'Save error',
-      value: e.toString(),
-    });
-  }
-}

app/imports/api/creature/actions/applyToggle.js

@@ -1,33 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-
-export default function applyToggle({
-  prop,
-  creature,
-  actionContext,
-  log,
-}){
-  let scope = {
-    ...creature.variables,
-    ...actionContext,
-  };
-  if (Number.isFinite(+prop.condition)){
-    return !!+prop.condition;
-  }
-  var {result} = evaluateString({
-    string: prop.condition,
-    scope,
-    fn: 'reduce'
-  });
-  if (result.constructor.name === 'ErrorNode') {
-    log.content.push({
-      name: 'Toggle error',
-      value: result.toString(),
-    });
-    return false;
-  }
-  log.content.push({
-    name: prop.name || 'Toggle',
-    value: prop.condition + ' = ' + result.toString(),
-  });
-  return !!result.value;
-}

app/imports/api/creature/actions/castSpellWithSlot.js

@@ -1,92 +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 Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import { doActionWork } from '/imports/api/creature/actions/doAction.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import getAncestorContext from '/imports/api/creature/actions/getAncestorContext.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties';
-
-const castSpellWithSlot = new ValidatedMethod({
-  name: 'creatureProperties.castSpellWithSlot',
-  validate: new SimpleSchema({
-    spellId: SimpleSchema.RegEx.Id,
-    slotId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-      optional: true,
-    },
-    targetId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({spellId, slotId, targetId}) {
-    let spell = CreatureProperties.findOne(spellId);
-		// Check permissions
-    let creature = getRootCreatureAncestor(spell);
-    assertEditPermission(creature, this.userId);
-    let target = undefined;
-    if (targetId) {
-      target = Creatures.findOne(targetId);
-      assertEditPermission(target, this.userId);
-    }
-    let slotLevel = spell.level || 0;
-    if (slotLevel !== 0){
-      let slot = CreatureProperties.findOne(slotId);
-      if (!slot){
-        throw new Meteor.Error('No slot',
-          'Slot not found to cast spell');
-      }
-      if (!slot.currentValue){
-        throw new Meteor.Error('No slot',
-          'Slot depleted');
-      }
-      if (!(slot.spellSlotLevelValue >= spell.level)){
-        throw new Meteor.Error('Slot too small',
-          'Slot is not large enough to cast spell');
-      }
-      slotLevel = slot.spellSlotLevelValue;
-      damagePropertyWork({
-        property: slot,
-        operation: 'increment',
-        value: 1,
-      });
-    }
-    let actionContext = getAncestorContext(spell);
-
-    doActionWork({
-      action: spell,
-      actionContext: {slotLevel, ...actionContext},
-      creature,
-      targets: target ? [target] : [],
-      method: this,
-    });
-
-    // Note these lines only recompute the top-level creature, not the nearest one
-    // The acting creature might have a new item
-    recomputeInventory(creature._id);
-    // The spell might add properties which need to be activated
-    recomputeInactiveProperties(creature._id);
-    recomputeCreatureByDoc(creature);
-
-    if (target){
-      recomputeInventory(target._id);
-      recomputeInactiveProperties(target._id);
-      recomputeCreatureByDoc(target);
-    }
-  },
-});
-
-export default castSpellWithSlot;

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

@@ -1,99 +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 Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { CreatureLogSchema, insertCreatureLogWork } from '/imports/api/creature/log/CreatureLogs.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import nodesToTree from '/imports/api/parenting/nodesToTree.js';
-import applyProperties from '/imports/api/creature/actions/applyProperties.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import getAncestorContext from '/imports/api/creature/actions/getAncestorContext.js';
-
-const doAction = new ValidatedMethod({
-  name: 'creatureProperties.doAction',
-  validate: new SimpleSchema({
-    actionId: SimpleSchema.RegEx.Id,
-    targetIds: {
-      type: Array,
-      defaultValue: [],
-      maxCount: 10,
-      optional: true,
-    },
-    'targetIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({actionId, targetIds = []}) {
-    let action = CreatureProperties.findOne(actionId);
-		// Check permissions
-    let creature = getRootCreatureAncestor(action);
-
-    // Build ancestor context
-    let actionContext = getAncestorContext(action);
-
-    assertEditPermission(creature, this.userId);
-    let targets = [];
-    targetIds.forEach(targetId => {
-      let target = Creatures.findOne(targetId);
-      assertEditPermission(target, this.userId);
-      targets.push(target);
-    });
-		doActionWork({action, creature, targets, actionContext, method: this});
-
-    // The acting creature might have used ammo
-    recomputeInventory(creature._id);
-
-    // The action might add properties which need to be activated
-    recomputeInactiveProperties(creature._id);
-
-    // recompute creatures
-		recomputeCreatureByDoc(creature);
-    targets.forEach(target => {
-      recomputeInactiveProperties(target._id);
-      recomputeCreatureByDoc(target);
-    });
-  },
-});
-
-export function doActionWork({
-  action,
-  creature,
-  targets,
-  actionContext = {},
-  method
-}){
-  // Create the log
-  let log = CreatureLogSchema.clean({
-    creatureId: creature._id,
-    creatureName: creature.name,
-  });
-
-  let decendantForest = nodesToTree({
-    collection: CreatureProperties,
-    ancestorId: action._id,
-  });
-  let startingForest = [{
-    node: action,
-    children: decendantForest,
-  }];
-  applyProperties({
-    forest: startingForest,
-    actionContext,
-    creature,
-    targets,
-    log,
-  });
-  insertCreatureLogWork({log, creature, method});
-}
-
-export default doAction;

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

@@ -1,56 +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 { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import roll from '/imports/parser/roll.js';
-
-const doCheck = new ValidatedMethod({
-  name: 'creature.doCheck',
-  validate: new SimpleSchema({
-    creatureId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-      optional: true,
-    },
-    attributeName: {
-      type: String,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({creatureId, attributeName}) {
-    let creature = Creatures.findOne(creatureId);
-    assertEditPermission(creature, this.userId);
-    let bonus = getAttributeValue({creature, attributeName})
-		return doCheckWork({bonus});
-  },
-});
-
-function getAttributeValue({creature, attributeName}){
-  let att = creature.variables[attributeName];
-  if (!att) throw new Meteor.Error('No such attribute',
-    `This creature does not have a ${attributeName} property`);
-  let bonus = att.attributeType === 'ability'? att.modifier : att.value;
-  return bonus || 0;
-}
-
-export function doCheckWork({bonus, advantage = 0}){
-  let rolls = roll(2,20);
-  let chosenRoll;
-  if (advantage === 1){
-    chosenRoll = Math.max.apply(rolls);
-  } else if (advantage === -1){
-    chosenRoll = Math.min.apply(rolls);
-  } else {
-    chosenRoll = rolls[0];
-  }
-  let result = chosenRoll + bonus;
-  return {rolls, bonus, chosenRoll, result};
-}
-
-export default doCheck;

app/imports/api/creature/actions/getAncestorContext.js

@@ -1,15 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-
-export default function getAncestorContext(prop){
-  // Build ancestor context
-  const actionContext = {};
-  let ancestorIds = prop.ancestors.map(ref => ref.id);
-  CreatureProperties.find({
-    _id: {$in: ancestorIds}
-  }, {
-    sort: {order: 1},
-  }).forEach(ancestor => {
-    actionContext[`#${ancestor.type}`] = ancestor;
-  });
-  return actionContext;
-}

app/imports/api/creature/actions/spendResources.js

@@ -1,93 +0,0 @@
-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';
-
-export default function spendResources({prop, log}){
-  // Check Uses
-  if (prop.usesUsed >= prop.usesResult){
-    throw new Meteor.Error('Insufficient Uses',
-      'This prop has no uses left');
-  }
-  // Resources
-  if (prop.insufficientResources){
-    throw new Meteor.Error('Insufficient Resources',
-      'This creature doesn\'t have sufficient resources to perform this prop');
-  }
-  // Items
-  let itemQuantityAdjustments = [];
-  let spendLog = [];
-  let gainLog = [];
-  prop.resources.itemsConsumed.forEach(itemConsumed => {
-    if (!itemConsumed.itemId){
-      throw new Meteor.Error('Ammo not selected',
-        'No ammo was selected for this prop');
-    }
-    let item = CreatureProperties.findOne(itemConsumed.itemId);
-    if (!item || item.ancestors[0].id !== prop.ancestors[0].id){
-      throw new Meteor.Error('Ammo not found',
-        'The prop\'s ammo was not found on the creature');
-    }
-    if (!item.equipped){
-      throw new Meteor.Error('Ammo not equipped',
-        'The selected ammo is not equipped');
-    }
-    if (!itemConsumed.quantity) return;
-    itemQuantityAdjustments.push({
-      property: item,
-      operation: 'increment',
-      value: itemConsumed.quantity,
-    });
-    let logName = item.name;
-    if (itemConsumed.quantity > 1 || itemConsumed.quantity < -1){
-      logName = item.plural || logName;
-    }
-    if (itemConsumed.quantity > 0){
-      spendLog.push(logName + ': ' + itemConsumed.quantity);
-    } else if (itemConsumed.quantity < 0){
-      gainLog.push(logName + ': ' + -itemConsumed.quantity);
-    }
-  });
-  // 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.usesResult){
-    CreatureProperties.update(prop._id, {
-      $inc: {usesUsed: 1}
-    }, {
-      selector: prop
-    });
-    log.content.push({
-      name: 'Uses left',
-      value: prop.usesResult - (prop.usesUsed || 0) - 1,
-    });
-  }
-
-  // Damage stats
-  prop.resources.attributesConsumed.forEach(attConsumed => {
-    if (!attConsumed.quantity) return;
-    let stat = CreatureProperties.findOne(attConsumed.statId);
-    damagePropertyWork({
-      property: stat,
-      operation: 'increment',
-      value: attConsumed.quantity,
-    });
-    if (attConsumed.quantity > 0){
-      spendLog.push(stat.name + ': ' + attConsumed.quantity);
-    } else if (attConsumed.quantity < 0){
-      gainLog.push(stat.name + ': ' + -attConsumed.quantity);
-    }
-  });
-
-  // Log all the spending
-  if (gainLog.length) log.content.push({
-    name: 'Gained',
-    value: gainLog.join('\n'),
-  });
-  if (spendLog.length) log.content.push({
-    name: 'Spent',
-    value: spendLog.join('\n'),
-  });
-}

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

@@ -1,57 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-
-// Archived creatures is an immutable collection of creatures that are no longer
-// in use and can be safely archived by the mongoDB hosting service.
-// It keeps the working datasets like creatureProperties much smaller
-// than they would otherwise be.
-let ArchivedCreatures = new Mongo.Collection('archivedCreatures');
-
-// We use blackbox objects for everything:
-// - saves time checking every object against a schema
-// - doesn't accidentaly create indices defined in subschemas
-// - The objects we are archiving have already been checked against their
-//   own schemas
-let ArchivedCreatureSchema = new SimpleSchema({
-  owner: {
-		type: String,
-		regEx: SimpleSchema.RegEx.Id,
-    // The primary index on this collection
-		index: 1,
-	},
-  archiveDate: {
-    type: Date,
-    // Indexed so the archiving system can archive documents when they
-    // get to a certain age
-    index: 1,
-  },
-	creature: {
-    type: Object,
-    blackbox: true,
-  },
-  properties: {
-    type: Array,
-  },
-  'properties.$': {
-    type: Object,
-    blackbox: true,
-  },
-  experiences: {
-    type: Array,
-  },
-  'experiences.$': {
-    type: Object,
-    blackbox: true,
-  },
-  logs: {
-    type: Array,
-  },
-  'logs.$': {
-    type: Object,
-    blackbox: true,
-  },
-});
-
-ArchivedCreatures.attachSchema(ArchivedCreatureSchema);
-
-import '/imports/api/creature/archive/methods/index.js';
-export default ArchivedCreatures;

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

@@ -1,66 +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 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 ArchivedCreatures from '/imports/api/creature/archive/ArchivedCreatures.js';
-
-function archiveCreature(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 = {
-    owner: creature.owner,
-    archiveDate: new Date(),
-    creature,
-    properties,
-    experiences,
-    logs,
-  };
-
-  // Insert it
-  let id = ArchivedCreatures.insert(archiveCreature);
-
-  // Remove the original creature
-  removeCreatureWork(creatureId);
-
-  return id;
-}
-
-const archiveCreatures = new ValidatedMethod({
-  name: 'Creatures.methods.archiveCreatures',
-  validate: new SimpleSchema({
-    creatureIds: {
-      type: Array,
-      max: 10,
-    },
-    'creatureIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 1,
-    timeInterval: 5000,
-  },
-  run({creatureIds}) {
-    for (let id of creatureIds){
-      assertOwnership(id, this.userId)
-    }
-    let archivedIds = [];
-    for (let id of creatureIds){
-      let archivedId = archiveCreature(id);
-      archivedIds.push(archivedId);
-    }
-    return archivedIds;
-  },
-});
-
-export default archiveCreatures;

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

@@ -1,2 +0,0 @@
-import '/imports/api/creature/archive/methods/archiveCreatures.js';
-import '/imports/api/creature/archive/methods/restoreCreatures.js';

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

@@ -1,77 +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/sharing/sharingPermissions.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 ArchivedCreatures from '/imports/api/creature/archive/ArchivedCreatures.js';
-import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature.js';
-
-function restoreCreature(archiveId){
-  // Get the archive
-  const archivedCreature = ArchivedCreatures.findOne(archiveId);
-
-  // Insert the creature sub documents
-  // They still have their original _id's
-  Creatures.insert(archivedCreature.creature);
-  try {
-    // Add all the properties
-    if (archivedCreature.properties && archivedCreature.properties.length){
-      CreatureProperties.batchInsert(archivedCreature.properties);
-    }
-    if (archivedCreature.experiences && archivedCreature.experiences.length){
-      Experiences.batchInsert(archivedCreature.experiences);
-    }
-    if (archivedCreature.logs && archivedCreature.logs.length){
-      CreatureLogs.batchInsert(archivedCreature.logs);
-    }
-    // Remove the archived creature
-    ArchivedCreatures.remove(archiveId);
-  } catch (e) {
-    // If the above fails, delete the inserted creature
-    removeCreatureWork(archivedCreature.creature._id);
-    throw e;
-  }
-
-  // Do not recompute. The creature was in a computed and ordered state when
-  // we archived it, just restore everything as-is
-
-  return archivedCreature.creature._id;
-}
-
-const restoreCreatures = new ValidatedMethod({
-  name: 'Creatures.methods.restoreCreatures',
-  validate: new SimpleSchema({
-    archiveIds: {
-      type: Array,
-      max: 10,
-    },
-    'archiveIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 1,
-    timeInterval: 5000,
-  },
-  run({archiveIds}) {
-    for (let id of archiveIds){
-      let archivedCreature = ArchivedCreatures.findOne(id, {
-        fields: {owner: 1}
-      });
-      assertOwnership(archivedCreature, this.userId)
-    }
-    let creatureIds = [];
-    for (let id of archiveIds){
-      let creatureId = restoreCreature(id);
-      creatureIds.push(creatureId);
-    }
-    return creatureIds;
-  },
-});
-
-export default restoreCreatures;

app/imports/api/creature/computation/afterComputation/embedInlineCalculations.js

@@ -1,11 +0,0 @@
-import INLINE_CALCULATION_REGEX from '/imports/constants/INLINE_CALCULTION_REGEX.js';
-
-export default function embedInlineCalculations(string, calculations){
-  if (!string) return '';
-  if (!calculations) return string;
-  let index = 0;
-  return string.replace(INLINE_CALCULATION_REGEX, substring => {
-    let comp = calculations && calculations[index++];
-    return (comp && 'result' in comp) ? comp.result : substring;
-  });
-}

app/imports/api/creature/computation/afterComputation/evaluateString.js

@@ -1,67 +0,0 @@
-import { parse, CompilationContext } from '/imports/parser/parser.js';
-import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
-import SymbolNode from '/imports/parser/parseTree/SymbolNode.js';
-import ErrorNode from '/imports/parser/parseTree/ErrorNode.js';
-
-//TODO replace constants with their parsed node
-
-export default function evaluateString({string, scope, fn = 'compile', context}){
-  if (!context){
-    context = new CompilationContext({});
-  }
-  if (!string){
-    context.storeError('No string provided');
-    return {result: {value: string}, context};
-  }
-
-  if (!scope) context.storeError('No scope provided');
-
-  // Parse the string using mathjs
-  let node;
-  try {
-    node = parse(string);
-  } catch (e) {
-    context.storeError(e);
-    return {result: {value: string}, context};
-  }
-  node = replaceConstants({calc: node, context, scope});
-  let result = node[fn](scope, context);
-  return {result, context};
-}
-
-// Replace constants in the calc with the right ParseNodes
-function replaceConstants({calc, context, scope}){
-  let constFailed = [];
-  calc = calc.replaceNodes(node => {
-    if (!(node instanceof SymbolNode)) return;
-    let constant = scope[node.name];
-    // replace constants that aren't overridden by stats or disabled by a toggle
-    if (constant && constant.type === 'constant'){
-      // Fail if the constant has errors
-      if (constant.errors && constant.errors.length){
-        constFailed.push(node.name);
-        return;
-      }
-      let parsedConstantNode;
-      try {
-        parsedConstantNode = parse(constant.calculation);
-      } catch(e){
-        constFailed.push(node.name);
-        return;
-      }
-      if (!parsedConstantNode) constFailed.push(node.name);
-      return parsedConstantNode;
-    }
-  });
-  constFailed.forEach(name => {
-    context.storeError({
-      type: 'error',
-      message: `${name} is a constant property with parsing errors`
-    });
-  });
-  let failed = !!constFailed.length;
-  if (failed){
-    calc = new ErrorNode({error: 'Failed to replace constants'});
-  }
-  return calc;
-}

app/imports/api/creature/computation/creatureComputation.test.js

@@ -1,97 +0,0 @@
-import {computeCreature} from "./recomputeCreature.js";
-import assert from "assert";
-
-const makeEffect = function(operation, value){
-  let effect = {computed: false, result: 0, operation}
-  if (_.isFinite(value)){
-    effect.value = +value;
-  } else {
-    effect.calculation = value;
-  }
-  return effect;
-}
-
-describe('computeCreature', function () {
-  it('computes an aritrary creature', function () {
-    let char = {
-      atts: {
-        attribute1: {
-          computed: false,
-          busyComputing: false,
-          type: "attribute",
-          attributeType: "ability",
-          result: 0,
-          mod: 0, // The resulting modifier if this is an ability
-          base: 0,
-          add: 0,
-          mul: 1,
-          min: Number.NEGATIVE_INFINITY,
-          max: Number.POSITIVE_INFINITY,
-          effects: [
-            makeEffect("base", 10),
-            makeEffect("add", 5),
-            makeEffect("mul", 2),
-          ],
-        },
-        attribute2: {
-          computed: false,
-          busyComputing: false,
-          type: "attribute",
-          result: 0,
-          mod: 0, // The resulting modifier if this is an ability
-          base: 0,
-          add: 0,
-          mul: 1,
-          min: Number.NEGATIVE_INFINITY,
-          max: Number.POSITIVE_INFINITY,
-          effects: [
-            makeEffect("base", "attribute1"),
-            makeEffect("max", 2),
-          ],
-        },
-      },
-      skills: {
-        skill1: {
-          computed: false,
-          busyComputing: false,
-          type: "skill",
-          ability: "attribute1",
-          result: 0,
-          proficiency: 0,
-          add: 0,
-          mul: 1,
-          min: Number.NEGATIVE_INFINITY,
-          max: Number.POSITIVE_INFINITY,
-          advantage: 0,
-          disadvantage: 0,
-          passiveAdd: 0,
-          fail: 0,
-          conditional: 0,
-          effects: [],
-          proficiencies: [],
-        },
-      },
-      dms: {
-        dm1: {
-          computed: false,
-          busyComputing: false,
-          type: "damageMultiplier",
-          result: 0,
-          immunityCount: 0,
-          ressistanceCount: 0,
-          vulnerabilityCount: 0,
-          effects: [],
-        }
-      },
-      classes: {
-        Barbarian: {
-          level: 5,
-        },
-      },
-      level: 5,
-    };
-    char = computeCreature(char);
-    console.log(char);
-    assert(true);
-  });
-});

app/imports/api/creature/computation/engine/ComputationMemo.js

@@ -1,289 +0,0 @@
-import { includes, cloneDeep } from 'lodash';
-import findAncestorByType from '/imports/api/creature/computation/engine/findAncestorByType.js';
-
-// The computation memo is an in-memory data structure used only during the
-// computation process
-export default class ComputationMemo {
-  constructor(props, creature){
-    this.statsByVariableName = {};
-    this.constantsByVariableName = {};
-    this.constantsById = {};
-    this.extraStatsByVariableName = {};
-    this.statsById = {};
-    this.originalPropsById = {};
-    this.propsById = {};
-    this.skillsByAbility = {};
-    this.unassignedEffects = [];
-    this.classLevelsById = {};
-    this.classes = {};
-    this.togglesById = {};
-    this.toggleIds = new Set();
-    // Equipped items that might be used as ammo
-    this.equipmentById = {};
-    // Properties that have calculations, but don't impact other properties
-    this.endStepPropsById = {};
-    // First note all the ids of all the toggles
-    props.forEach((prop) => {
-      if (
-        prop.type === 'toggle'
-      ) {
-        this.toggleIds.add(prop._id);
-      }
-    });
-    props.filter((prop) => {
-      if (
-        prop.type === 'toggle'
-      ) {
-        this.addToggle(prop);
-      } else {
-        return true;
-      }
-    }).filter((prop) => {
-      if (
-        prop.type === 'attribute' ||
-        prop.type === 'skill'
-      ) {
-        // Add all the stats
-        this.addStat(prop);
-      } else if (
-        prop.type === 'item'
-      ) {
-        this.addEquipment(prop);
-      } else {
-        return true;
-      }
-    }).forEach((prop) => {
-      // Now add everything else
-      if (prop.type === 'effect'){
-        this.addEffect(prop);
-      } else if (prop.type === 'proficiency') {
-        this.addProficiency(prop);
-      } else if (prop.type === 'classLevel'){
-        this.addClassLevel(prop);
-      } else if (prop.type === 'constant'){
-        this.addConstant(prop);
-      } else {
-        this.addEndStepProp(prop);
-      }
-    });
-    for (let name in creature.denormalizedStats){
-      if (!this.statsByVariableName[name]){
-        this.statsByVariableName[name] = {
-          variableName: name,
-          value: creature.denormalizedStats[name],
-          computationDetails: propDetailsByType.denormalizedStat(),
-        }
-      }
-    }
-  }
-  addConstant(prop){
-    prop = this.registerProperty(prop);
-    this.constantsById[prop._id] = prop;
-  }
-  registerProperty(prop){
-    this.originalPropsById[prop._id] = cloneDeep(prop);
-    this.propsById[prop._id] = prop;
-    prop.dependencies = [];
-    prop.computationDetails = propDetails(prop);
-    prop.ancestors.forEach(ancestor => {
-      if (this.toggleIds.has(ancestor.id)){
-        prop.computationDetails.toggleAncestors.push(ancestor.id);
-      }
-    });
-    return prop;
-  }
-  addToggle(prop){
-    prop = this.registerProperty(prop);
-    this.togglesById[prop._id] = prop;
-  }
-  addClassLevel(prop){
-    prop = this.registerProperty(prop);
-    this.classLevelsById[prop._id] = prop;
-  }
-  addStat(prop){
-    let variableName = prop.variableName;
-    if (!variableName) return;
-    let existingStat = this.statsByVariableName[variableName];
-    prop = this.registerProperty(prop);
-    if (existingStat){
-      existingStat.computationDetails.idsOfSameName.push(prop._id);
-    } else {
-      this.statsById[prop._id] = prop;
-      this.statsByVariableName[variableName] = prop;
-      if (
-        prop.type === 'skill' &&
-        isSkillCheck(prop) &&
-        prop.ability
-      ){
-        this.addSkillToAbility(prop, prop.ability)
-      }
-    }
-  }
-  addSkillToAbility(prop, ability){
-    if (!this.skillsByAbility[ability]){
-      this.skillsByAbility[ability] = [];
-    }
-    this.skillsByAbility[ability].push(prop);
-  }
-  addEffect(prop){
-    prop = this.registerProperty(prop);
-    let targets = this.getEffectTargets(prop);
-    targets.forEach(target => {
-      if (target.computationDetails && target.computationDetails.effects){
-        target.computationDetails.effects.push(prop);
-      }
-    });
-    if (!targets.size){
-      this.unassignedEffects.push(prop);
-    }
-  }
-  getEffectTargets(prop){
-    let targets = new Set();
-    if (!prop.stats) return targets;
-    prop.stats.forEach((statName) => {
-      let target;
-      if (statName[0] === '#'){
-        target = findAncestorByType({
-          type: statName.slice(1),
-          prop,
-          memo: this
-        });
-      } else {
-        target = this.statsByVariableName[statName];
-      }
-      if (!target) return;
-      targets.add(target);
-      if (isSkillOperation(prop) && isAbility(target)){
-        let extras = this.skillsByAbility[statName] || [];
-        extras.forEach(ex =>{
-          // Only pass on ability effects to skills and checks
-          if (ex.skillType === 'skill' || ex.skillType === 'check'){
-            targets.add(ex)
-          }
-        });
-      }
-    });
-    return targets;
-  }
-  addProficiency(prop){
-    prop = this.registerProperty(prop);
-    let targets = this.getProficiencyTargets(prop);
-    targets.forEach(target => {
-      if(target.computationDetails.proficiencies){
-        target.computationDetails.proficiencies.push(prop);
-      }
-    });
-  }
-  getProficiencyTargets(prop){
-    let targets = new Set();
-    if (!prop.stats) return targets;
-    prop.stats.forEach(statName => {
-      let target = this.statsByVariableName[statName];
-      if (!target) return;
-      targets.add(target);
-      if (isAbility(target)) {
-        let extras = this.skillsByAbility[statName] || [];
-        extras.forEach(ex =>{
-          // Only pass on ability proficiencies to skills and checks
-          if (ex.skillType === 'skill' || ex.skillType === 'check'){
-            targets.add(ex)
-          }
-        });
-      }
-    });
-    return targets;
-  }
-  addEquipment(prop){
-    prop = this.registerProperty(prop);
-    this.equipmentById[prop._id] = prop;
-  }
-  addEndStepProp(prop){
-    prop = this.registerProperty(prop);
-    this.endStepPropsById[prop._id] = prop;
-  }
-}
-
-function isAbility(prop){
-  return prop.type === 'attribute' &&
-  prop.attributeType === 'ability'
-}
-
-function isSkillCheck(prop){
-  return includes(['skill', 'check', 'save', 'utility'], prop.skillType);
-}
-
-const skillOperations = [
-  'advantage',
-  'disadvantage',
-  'passiveAdd',
-  'fail',
-  'conditional',
-  'rollBonus',
-];
-
-function isSkillOperation(prop){
-  return skillOperations.includes(prop.operation);
-}
-
-function propDetails(prop){
-  return propDetailsByType[prop.type] && propDetailsByType[prop.type]() ||
-    propDetailsByType.default();
-}
-
-const propDetailsByType = {
-  default(){
-    return {
-      toggleAncestors: [],
-    };
-  },
-  toggle(){
-    return {
-      computed: false,
-      busyComputing: false,
-      toggleAncestors: [],
-    };
-  },
-  attribute(){
-    return {
-      computed: false,
-      busyComputing: false,
-      effects: [],
-      proficiencies: [],
-      toggleAncestors: [],
-      idsOfSameName: [],
-    };
-  },
-  skill(){
-    return {
-      computed: false,
-      busyComputing: false,
-      effects: [],
-      proficiencies: [],
-      toggleAncestors: [],
-      idsOfSameName: [],
-    };
-  },
-  effect(){
-    return {
-      computed: false,
-      busyComputing: false,
-      toggleAncestors: [],
-    };
-  },
-  classLevel(){
-    return {
-      computed: true,
-      toggleAncestors: [],
-    };
-  },
-  proficiency(){
-    return {
-      toggleAncestors: [],
-    };
-  },
-  denormalizedStat(){
-    return {
-      toggleAncestors: [],
-    };
-  }
-}

app/imports/api/creature/computation/engine/EffectAggregator.js

@@ -1,78 +0,0 @@
-export default class EffectAggregator{
-  constructor(){
-    this.base = undefined;
-    this.add = 0;
-    this.mul = 1;
-    this.min = Number.NEGATIVE_INFINITY;
-    this.max = Number.POSITIVE_INFINITY;
-    this.advantage = 0;
-    this.disadvantage = 0;
-    this.passiveAdd = undefined;
-    this.fail = 0;
-    this.set = undefined;
-    this.conditional = [];
-    this.rollBonus = [];
-    this.hasNoEffects = true;
-  }
-  addEffect(effect){
-    let result = effect.result;
-    if (this.hasNoEffects) this.hasNoEffects = false;
-    switch(effect.operation){
-      case 'base':
-        // Take the largest base value
-        if (Number.isFinite(result)){
-          if(Number.isFinite(this.base)){
-            this.base = Math.max(this.base, result);
-          } else {
-            this.base = result;
-          }
-        }
-        break;
-      case 'add':
-        // Add all adds together
-        this.add += result;
-        break;
-      case 'mul':
-        // Multiply the muls together
-        this.mul *= result;
-        break;
-      case 'min':
-        // Take the largest min value
-        this.min = result > this.min ? result : this.min;
-        break;
-      case 'max':
-        // Take the smallest max value
-        this.max = result < this.max ? result : this.max;
-        break;
-      case 'set':
-        // Take the highest set value
-        this.set = this.set === undefined || result > this.set ? result : this.set;
-        break;
-      case 'advantage':
-        // Sum number of advantages
-        this.advantage++;
-        break;
-      case 'disadvantage':
-        // Sum number of disadvantages
-        this.disadvantage++;
-        break;
-      case 'passiveAdd':
-        // Add all passive adds together
-        if (this.passiveAdd === undefined) this.passiveAdd = 0;
-        this.passiveAdd += result;
-        break;
-      case 'fail':
-        // Sum number of fails
-        this.fail++;
-        break;
-      case 'conditional':
-        // Store array of conditionals
-        this.conditional.push(result);
-        break;
-      case 'rollBonus':
-        // Store array of roll bonuses
-        this.rollBonus.push(result);
-        break;
-    }
-  }
-}

app/imports/api/creature/computation/engine/applyToggles.js

@@ -1,25 +0,0 @@
-import computeToggle from '/imports/api/creature/computation/engine/computeToggle.js';
-import { union } from 'lodash';
-
-export default function applyToggles(prop, memo){
-  // If it used to be inactive delete those fields
-  if (prop.inactive) prop.inactive = undefined;
-  if (prop.deactivatedByAncestor) prop.deactivatedByAncestor = undefined;
-  if (prop.deactivatedByToggle) prop.deactivatedByToggle = undefined;
-  // Iterate through the toggle ancestors from oldest to nearest
-  prop.computationDetails.toggleAncestors.forEach(toggleId => {
-    let toggle = memo.togglesById[toggleId];
-    computeToggle(toggle, memo);
-    prop.dependencies = union(
-      prop.dependencies,
-      [toggle._id],
-      toggle.dependencies,
-    );
-    // Deactivate if the toggle is false
-    if (!toggle.toggleResult){
-      prop.inactive = true;
-      prop.deactivatedByAncestor = true;
-      prop.deactivatedByToggle = true;
-    }
-  });
-}

app/imports/api/creature/computation/engine/combineStat.js

@@ -1,197 +0,0 @@
-import computeStat from '/imports/api/creature/computation/engine/computeStat.js';
-import computeProficiency from '/imports/api/creature/computation/engine/computeProficiency.js';
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import stripFloatingPointOddities from '/imports/ui/utility/stripFloatingPointOddities.js';
-import { union } from 'lodash';
-
-export default function combineStat(stat, aggregator, memo){
-  if (stat.type === 'attribute'){
-    combineAttribute(stat, aggregator, memo);
-  } else if (stat.type === 'skill'){
-    combineSkill(stat, aggregator, memo);
-  } else if (stat.type === 'damageMultiplier'){
-    combineDamageMultiplier(stat, memo);
-  }
-}
-
-function getAggregatorResult(stat, aggregator){
-  let base;
-  if (!Number.isFinite(aggregator.base)){
-    base = stat.baseValue || 0;
-  } else if (!Number.isFinite(stat.baseValue)){
-    base = aggregator.base || 0;
-  } else {
-    base = Math.max(aggregator.base, stat.baseValue);
-  }
-  let result = (base + aggregator.add) * aggregator.mul;
-  if (result < aggregator.min) {
-    result = aggregator.min;
-  }
-  if (result > aggregator.max) {
-    result = aggregator.max;
-  }
-  if (aggregator.set !== undefined) {
-    result = aggregator.set;
-  }
-  if (!stat.decimal && Number.isFinite(result)){
-    result = Math.floor(result);
-  } else if (Number.isFinite(result)){
-    result = stripFloatingPointOddities(result);
-  }
-  return result;
-}
-
-function combineAttribute(stat, aggregator, memo){
-  stat.value = getAggregatorResult(stat, aggregator);
-  if (stat.attributeType === 'spellSlot'){
-    let {
-      result,
-      context,
-      dependencies
-    } = evaluateCalculation({
-      string: stat.spellSlotLevelCalculation,
-      memo,
-      prop: stat,
-    });
-    stat.spellSlotLevelValue = result.value;
-    stat.spellSlotLevelErrors = context.errors;
-    stat.dependencies = union(stat.dependencies, dependencies);
-  }
-  stat.currentValue = stat.value - (stat.damage || 0);
-  // Ability scores get modifiers
-  if (stat.attributeType === 'ability') {
-    stat.modifier = Math.floor((stat.currentValue - 10) / 2);
-  } else {
-    stat.modifier = undefined;
-  }
-  // Hit dice get constitution modifiers
-  stat.constitutionMod = undefined;
-  if (stat.attributeType === 'hitDice') {
-    let conStat = memo.statsByVariableName['constitution'];
-    if (conStat && 'modifier' in conStat){
-      stat.constitutionMod = conStat.modifier;
-      stat.dependencies = union(
-        stat.dependencies,
-        [conStat._id],
-        conStat.dependencies,
-      );
-    }
-  }
-  // Stats that have no effects can be hidden based on a sheet setting
-  stat.hide = aggregator.hasNoEffects &&
-    stat.baseValue === undefined ||
-    undefined
-}
-
-function combineSkill(stat, aggregator, memo){
-  // Skills are based on some ability Modifier
-  let ability = stat.ability && memo.statsByVariableName[stat.ability]
-  if (stat.ability && ability){
-    computeStat(ability, memo);
-    stat.abilityMod = ability.modifier;
-    stat.dependencies = union(
-      stat.dependencies,
-      [ability._id],
-      ability.dependencies,
-    );
-  } else {
-    stat.abilityMod = 0;
-  }
-  // Combine all the child proficiencies
-  stat.proficiency = 0;
-  for (let i in stat.computationDetails.proficiencies){
-    let prof = stat.computationDetails.proficiencies[i];
-    computeProficiency(prof, memo);
-    if (
-      !prof.deactivatedByToggle &&
-      prof.value > stat.proficiency
-    ){
-      stat.proficiency = prof.value;
-      stat.dependencies = union(
-        stat.dependencies,
-        [prof._id],
-        prof.dependencies,
-      );
-    }
-  }
-  // Get the character's proficiency bonus to apply
-  let profBonusStat = memo.statsByVariableName['proficiencyBonus'];
-  let profBonus = profBonusStat && profBonusStat.value;
-
-  if (profBonusStat){
-    stat.dependencies = union(
-      stat.dependencies,
-      [profBonusStat._id],
-      profBonusStat.dependencies,
-    );
-  }
-
-  if (typeof profBonus !== 'number' && memo.statsByVariableName['level']){
-    let levelProp = memo.statsByVariableName['level'];
-    let level = levelProp.value;
-    profBonus = Math.ceil(level / 4) + 1;
-    if (levelProp._id){
-      stat.dependencies = union(stat.dependencies, [levelProp._id]);
-    }
-    if (levelProp.dependencies){
-      stat.dependencies = union(stat.dependencies, levelProp.dependencies);
-    }
-  }
-
-  // Multiply the proficiency bonus by the actual proficiency
-  if(stat.proficiency === 0.49){
-    // Round down proficiency bonus in the special case
-    profBonus = Math.floor(profBonus * 0.5);
-  } else {
-    profBonus = Math.ceil(profBonus * stat.proficiency);
-  }
-
-  // Combine everything to get the final result
-  let base = aggregator.base || 0;
-  let result = (base + stat.abilityMod + profBonus + aggregator.add) * aggregator.mul;
-  if (result < aggregator.min) result = aggregator.min;
-  if (result > aggregator.max) result = aggregator.max;
-  if (aggregator.set !== undefined) {
-    result = aggregator.set;
-  }
-  if (Number.isFinite(result)){
-    result = Math.floor(result);
-  }
-  stat.value = result;
-  // Advantage/disadvantage
-  if (aggregator.advantage && !aggregator.disadvantage){
-    stat.advantage = 1;
-  } else if (aggregator.disadvantage && !aggregator.advantage){
-    stat.advantage = -1;
-  } else {
-    stat.advantage = 0;
-  }
-  // Passive bonus
-  stat.passiveBonus = aggregator.passiveAdd;
-  // conditional benefits
-  stat.conditionalBenefits = aggregator.conditional;
-  // Roll bonuses
-  stat.rollBonus = aggregator.rollBonus;
-  // Forced to fail
-  stat.fail = aggregator.fail;
-  // Rollbonus
-  stat.rollBonuses = aggregator.rollBonus;
-  // Hide
-  stat.hide = aggregator.hasNoEffects &&
-    stat.baseValue === undefined &&
-    stat.proficiency == 0 ||
-    undefined;
-}
-
-function combineDamageMultiplier(stat){
-  if (stat.immunityCount) return 0;
-  let result;
-  if (stat.ressistanceCount && !stat.vulnerabilityCount){
-    result = 0.5;
-  }  else if (!stat.ressistanceCount && stat.vulnerabilityCount){
-    result = 2;
-  } else {
-    result = 1;
-  }
-  stat.value = result;
-}

app/imports/api/creature/computation/engine/computeConstant.js

@@ -1,12 +0,0 @@
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-
-export default function computeConstant(constant, memo){
-  // Apply any toggles
-  applyToggles(constant, memo);
-  if (constant.deactivatedByToggle) return;
-  if (
-    !memo.constantsByVariableName[constant.variableName]
-  ){
-    memo.constantsByVariableName[constant.variableName] = constant
-  }
-}

app/imports/api/creature/computation/engine/computeEffect.js

@@ -1,55 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-import { union } from 'lodash';
-
-export default function computeEffect(effect, memo){
-  if (effect.computationDetails.computed) return;
-  if (effect.computationDetails.busyComputing){
-    // Trying to compute this effect again while it is already computing.
-    // We must be in a dependency loop.
-    effect.computationDetails.computed = true;
-    effect.result = NaN;
-    effect.computationDetails.busyComputing = false;
-    effect.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', effect);
-    return;
-  }
-  // Before doing any work, mark this effect as busy
-  effect.computationDetails.busyComputing = true;
-
-  // Apply any toggles
-  applyToggles(effect, memo);
-
-  // Determine result of effect calculation
-  delete effect.errors;
-  if (!effect.calculation){
-    if(effect.operation === 'add' || effect.operation === 'base'){
-      effect.result = 0;
-    } else {
-      delete effect.result
-    }
-  } else if (Number.isFinite(+effect.calculation)){
-    effect.result = +effect.calculation;
-  } else if(effect.operation === 'conditional' || effect.operation === 'rollBonus'){
-    effect.result = effect.calculation;
-  } else if(_.contains(['advantage', 'disadvantage', 'fail'], effect.operation)){
-    effect.result = 1;
-  } else {
-    let {
-      result,
-      context,
-      dependencies,
-    } = evaluateCalculation({
-      string: effect.calculation,
-      prop: effect,
-      memo
-    });
-    effect.result = result.value;
-    effect.dependencies = union(effect.dependencies, dependencies);
-    if (context.errors.length){
-      effect.errors = context.errors;
-    }
-  }
-  effect.computationDetails.computed = true;
-  effect.computationDetails.busyComputing = false;
-}

app/imports/api/creature/computation/engine/computeEndStepProperty.js

@@ -1,129 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-import { union } from 'lodash';
-
-export default function computeEndStepProperty(prop, memo){
-  applyToggles(prop, memo);
-
-  switch (prop.type){
-    case 'action':
-    case 'spell':
-      computeAction(prop, memo);
-      break;
-    case 'adjustment':
-    case 'damage':
-      computePropertyField(prop, memo, 'amount', 'compile');
-      break;
-    case 'attack':
-      computeAction(prop, memo);
-      computePropertyField(prop, memo, 'rollBonus');
-      break;
-    case 'savingThrow':
-      computePropertyField(prop, memo, 'dc');
-      break;
-    case 'spellList':
-      computePropertyField(prop, memo, 'maxPrepared');
-      computePropertyField(prop, memo, 'attackRollBonus');
-      computePropertyField(prop, memo, 'dc');
-      break;
-    case 'propertySlot':
-      computePropertyField(prop, memo, 'quantityExpected');
-      computePropertyField(prop, memo, 'slotCondition');
-      break;
-    case 'roll':
-      computePropertyField(prop, memo, 'roll', 'compile');
-      break;
-  }
-}
-
-function computeAction(prop, memo){
-  // Uses
-  let {
-    result,
-    context,
-    dependencies,
-  } = evaluateCalculation({ string: prop.uses, prop, memo});
-  prop.usesResult = result.value;
-  prop.dependencies = union(prop.dependencies, dependencies);
-  if (context.errors.length){
-    prop.usesErrors = context.errors;
-  } else {
-    delete prop.usesErrors;
-  }
-  prop.insufficientResources = undefined;
-  if (prop.usesUsed >= prop.usesResult){
-    prop.insufficientResources = true;
-  }
-  if (!prop.resources) return;
-  // Attributes consumed
-  prop.resources.attributesConsumed.forEach((attConsumed, i) => {
-    if (attConsumed.variableName){
-      let stat = memo.statsByVariableName[attConsumed.variableName];
-      prop.resources.attributesConsumed[i].statId = stat && stat._id;
-      prop.resources.attributesConsumed[i].statName = stat && stat.name;
-      let available = stat && stat.currentValue || 0;
-      prop.resources.attributesConsumed[i].available = available;
-      if (available < attConsumed.quantity){
-        prop.insufficientResources = true;
-      }
-      if (stat){
-        prop.dependencies = union(
-          prop.dependencies,
-          [stat._id],
-          stat.dependencies
-        );
-      }
-    }
-  });
-  // Items consumed
-  prop.resources.itemsConsumed.forEach((itemConsumed, i) => {
-    let item = itemConsumed.itemId ?
-      memo.equipmentById[itemConsumed.itemId] :
-      undefined;
-    let available = item ? item.quantity : 0;
-    prop.resources.itemsConsumed[i].available = available;
-    if (!item || available < itemConsumed.quantity){
-      prop.insufficientResources = true;
-    }
-    if (item){
-      prop.resources.itemsConsumed[i].itemId = item._id;
-      let name = item.name;
-      if (item.quantity !== 1 && item.plural){
-        name = item.plural;
-      }
-      if (name) prop.resources.itemsConsumed[i].itemName = name;
-      if (item.icon) prop.resources.itemsConsumed[i].itemIcon = item.icon;
-      if (item.color) prop.resources.itemsConsumed[i].itemColor = item.color;
-      prop.dependencies = union(
-        prop.dependencies,
-        [item._id],
-        item.dependencies
-      );
-    } else {
-      delete prop.resources.itemsConsumed[i].itemId;
-      delete prop.resources.itemsConsumed[i].itemName;
-      delete prop.resources.itemsConsumed[i].itemIcon;
-      delete prop.resources.itemsConsumed[i].itemColor;
-    }
-  });
-}
-
-function computePropertyField(prop, memo, fieldName, fn){
-  let {
-    result,
-    context,
-    dependencies,
-  } = evaluateCalculation({string: prop[fieldName], prop, memo, fn});
-  if (result instanceof ConstantNode){
-    prop[`${fieldName}Result`] = result.value;
-  } else {
-    prop[`${fieldName}Result`] = result.toString();
-  }
-  prop.dependencies = union(prop.dependencies, dependencies);
-  if (context.errors.length){
-    prop[`${fieldName}Errors`] = context.errors;
-  } else {
-    delete prop[`${fieldName}Errors`];
-  }
-}

app/imports/api/creature/computation/engine/computeInlineCalculations.js

@@ -1,40 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import INLINE_CALCULATION_REGEX from '/imports/constants/INLINE_CALCULTION_REGEX.js';
-import ErrorNode from '/imports/parser/parseTree/ErrorNode.js';
-import { union } from 'lodash';
-
-export default function computeInlineCalculations(prop, memo){
-  if (prop.summary){
-    computeInlineCalcsForField(prop, memo, 'summary');
-  }
-  if (prop.description){
-    computeInlineCalcsForField(prop, memo, 'description');
-  }
-}
-
-function computeInlineCalcsForField(prop, memo, field){
-  let string = prop[field];
-  let inlineComputations = [];
-  let matches = string.matchAll(INLINE_CALCULATION_REGEX);
-  for (let match of matches){
-    let calculation = match[1];
-    let {
-      result,
-      context,
-      dependencies,
-    } = evaluateCalculation({string: calculation, prop, memo, fn: 'compile'});
-    if (result instanceof ErrorNode){
-      result = '`Calculation Error`';
-    }
-    let computation = {
-      calculation,
-      result: result && result.toString(),
-    };
-    if (context.errors.length){
-      computation.errors = context.errors;
-    }
-    inlineComputations.push(computation);
-    prop.dependencies = union(prop.dependencies, dependencies);
-  }
-  prop[`${field}Calculations`] = inlineComputations;
-}

app/imports/api/creature/computation/engine/computeLevels.js

@@ -1,66 +0,0 @@
-import { forOwn, has, union } from 'lodash';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-
-export default function computeLevels(memo){
-  computeClassLevels(memo);
-  computeTotalLevel(memo);
-}
-
-function computeClassLevels(memo){
-  forOwn(memo.classLevelsById, classLevel => {
-    applyToggles(classLevel, memo);
-    //  class levels are mutually dependent
-    classLevel.dependencies = union(
-      classLevel.dependencies,
-      Object.keys(memo.classLevelsById)
-    );
-    if (classLevel.deactivatedByToggle) return;
-    let name = classLevel.variableName;
-    let stat = memo.statsByVariableName[name];
-    if (!stat){
-      memo.statsByVariableName[name] = classLevel;
-      memo.classes[name] = classLevel;
-    } else if (!has(stat, 'level')){
-      // Stat is overriden by an attribute
-      return;
-    } else if (stat.level < classLevel.level) {
-      memo.statsByVariableName[name] = classLevel;
-      memo.classes[name] = classLevel;
-    }
-  });
-}
-
-function computeTotalLevel(memo){
-  let currentLevel = memo.statsByVariableName['level'];
-  if (!currentLevel || currentLevel.deactivatedByToggle){
-    currentLevel = {
-      value: 0,
-      dependencies: [],
-      computationDetails: {
-        builtIn: true,
-        computed: true,
-      }
-    };
-    memo.statsByVariableName['level'] = currentLevel;
-  }
-  // bail out if overriden by an attribute
-  if (!currentLevel.computationDetails.builtIn) return;
-  let level = 0;
-  for (let name in memo.classes){
-    let cls = memo.classes[name];
-    level += cls.level || 0;
-    if (cls._id){
-      currentLevel.dependencies = union(
-        currentLevel.dependencies,
-        [cls._id]
-      )
-    }
-    if (cls.dependencies){
-      currentLevel.dependencies = union(
-        currentLevel.dependencies,
-        cls.dependencies,
-      )
-    }
-  }
-  currentLevel.value = level;
-}

app/imports/api/creature/computation/engine/computeMemo.js

@@ -1,37 +0,0 @@
-import { each, forOwn } from 'lodash';
-import computeLevels from '/imports/api/creature/computation/engine/computeLevels.js';
-import computeStat from '/imports/api/creature/computation/engine/computeStat.js';
-import computeEffect from '/imports/api/creature/computation/engine/computeEffect.js';
-import computeToggle from '/imports/api/creature/computation/engine/computeToggle.js';
-import computeEndStepProperty from '/imports/api/creature/computation/engine/computeEndStepProperty.js';
-import computeInlineCalculations from '/imports/api/creature/computation/engine/computeInlineCalculations.js';
-import computeConstant from '/imports/api/creature/computation/engine/computeConstant.js';
-
-export default function computeMemo(memo){
-  // Compute level
-  computeLevels(memo);
-  // Compute all constants that could be used
-  forOwn(memo.constantsById, constant => {
-    computeConstant (constant, memo);
-  });
-  // Compute all stats, even if they are overriden
-  forOwn(memo.statsById, stat => {
-    computeStat (stat, memo);
-  });
-  // Compute effects which didn't end up targeting a stat
-  each(memo.unassignedEffects, effect => {
-    computeEffect(effect, memo);
-  });
-  // Compute toggles which didn't already get computed by dependencies
-  forOwn(memo.togglesById, toggle => {
-    computeToggle(toggle, memo);
-  });
-  // Compute end step properties
-  forOwn(memo.endStepPropsById, prop => {
-    computeEndStepProperty(prop, memo);
-  });
-  // Compute inline calculations
-  forOwn(memo.propsById, prop => {
-    computeInlineCalculations(prop, memo);
-  });
-}

app/imports/api/creature/computation/engine/computeProficiency.js

@@ -1,23 +0,0 @@
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-
-export default function computeEffect(proficiency, memo){
-  if (proficiency.computationDetails.computed) return;
-  if (proficiency.computationDetails.busyComputing){
-    // Trying to compute this proficiency again while it is already computing.
-    // We must be in a dependency loop.
-    proficiency.computationDetails.computed = true;
-    proficiency.result = NaN;
-    proficiency.computationDetails.busyComputing = false;
-    proficiency.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', proficiency);
-    return;
-  }
-  // Before doing any work, mark this proficiency as busy
-  proficiency.computationDetails.busyComputing = true;
-
-  // Apply any toggles
-  applyToggles(proficiency, memo);
-
-  proficiency.computationDetails.computed = true;
-  proficiency.computationDetails.busyComputing = false;
-}

app/imports/api/creature/computation/engine/computeStat.js

@@ -1,162 +0,0 @@
-import combineStat from '/imports/api/creature/computation/engine/combineStat.js';
-import computeEffect from '/imports/api/creature/computation/engine/computeEffect.js';
-import EffectAggregator from '/imports/api/creature/computation/engine/EffectAggregator.js';
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-import { each, union, without } from 'lodash';
-
-export default function computeStat(stat, memo){
-  // If the stat is already computed, skip it
-  if (stat.computationDetails.computed) return;
-  if (stat.computationDetails.busyComputing){
-    // Trying to compute this stat again while it is already computing.
-    // We must be in a dependency loop.
-    stat.computationDetails.computed = true;
-    stat.value = NaN;
-    stat.computationDetails.busyComputing = false;
-    stat.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', stat);
-    return;
-  }
-  // Before doing any work, mark this stat as busy
-  stat.computationDetails.busyComputing = true;
-
-  let effects = stat.computationDetails.effects || [];
-  let proficiencies = stat.computationDetails.proficiencies || [];
-
-  // Get references to all the stats that share the variable name
-  let sameNameStats
-
-  if (stat.computationDetails.idsOfSameName){
-    sameNameStats = stat.computationDetails.idsOfSameName.map(
-      id => memo.propsById[id]
-    );
-  } else {
-    sameNameStats = [];
-  }
-
-  let allStats = [stat, ...sameNameStats];
-
-  // Decide which stat is the last active stat
-  // The last active stat is considered the cannonical stat
-  let lastActiveStat;
-  allStats.forEach(candidateStat => {
-    applyToggles(candidateStat, memo);
-    if (!candidateStat.inactive) lastActiveStat = candidateStat;
-    candidateStat.overridden = undefined;
-  });
-  if (!lastActiveStat){
-    delete memo.statsByVariableName[stat.variableName];
-    return;
-  }
-  // Make sure the active stat has all the effects and proficiencies
-  lastActiveStat.computationDetails.effects = effects;
-  lastActiveStat.computationDetails.proficiencies = proficiencies;
-
-  // Update the memo's stat with the chosen stat
-  memo.statsByVariableName[stat.variableName] = lastActiveStat;
-
-  // Recreate list of the non-cannonical stats
-  sameNameStats = without(allStats, lastActiveStat);
-
-  sameNameStats.forEach(statInstance => {
-    // Mark the non-cannonical stats as overridden
-    statInstance.overridden = true;
-
-    // Apply the cannonical damage
-    statInstance.damage = lastActiveStat.damage;
-  });
-
-  let baseDependencies = [];
-  allStats.forEach(statInstance => {
-    // Add this stat and its deps to the dependencies
-    baseDependencies = union(
-      baseDependencies,
-      [statInstance._id],
-      statInstance.dependencies,
-    );
-
-    // Apply all the base proficiencies
-    if (statInstance.baseProficiency && !statInstance.inactive){
-      proficiencies.push({
-        value: statInstance.baseProficiency,
-        stats: [statInstance.variableName],
-        type: 'proficiency',
-        dependencies: statInstance.overridden ?
-          union(statInstance.dependencies, [statInstance._id]) :
-          [],
-        computationDetails: {
-          computed: true,
-        }
-      });
-    }
-
-    // Compute each active stat's baseValue calculation and apply it
-    if (!statInstance.inactive) {
-      delete statInstance.baseValueErrors;
-      let {
-        result,
-        context,
-        dependencies
-      } = evaluateCalculation({
-        string: statInstance.baseValueCalculation,
-        prop: statInstance,
-        memo
-      });
-      result.value = +result.value;
-      if (!isNaN(result.value)){
-        statInstance.baseValue = result.value;
-      } else {
-        statInstance.baseValue = undefined;
-      }
-      statInstance.dependencies = union(statInstance.dependencies, dependencies);
-      if (context.errors.length){
-        statInstance.baseValueErrors = context.errors;
-      }
-      // Apply all the base values
-      if (Number.isFinite(statInstance.baseValue)){
-        effects.push({
-          operation: 'base',
-          calculation: statInstance.baseValueCalculation,
-          result: statInstance.baseValue,
-          stats: [statInstance.variableName],
-          dependencies: statInstance.overridden ?
-          union(statInstance.dependencies, [statInstance._id]) :
-          [],
-          computationDetails: {
-            computed: true,
-          },
-        });
-      }
-    }
-  });
-
-  // Compute and aggregate all the effects
-  let aggregator = new EffectAggregator();
-  let effectDeps = [];
-  each(effects, (effect) => {
-    // Compute
-    computeEffect(effect, memo);
-    if (effect.deactivatedByToggle) return;
-
-    // dependencies
-    if (effect._id) effectDeps = union(effectDeps, [effect._id]);
-    effectDeps = union(effectDeps, effect.dependencies);
-
-    // Add computed effect to aggregator
-    aggregator.addEffect(effect);
-  });
-
-  // Combine the effects into the stats
-  allStats.forEach(statInstance => {
-    // Conglomerate all the effects to compute the final stat values
-    combineStat(statInstance, aggregator, memo);
-    // Mark the stats as computed
-    statInstance.computationDetails.computed = true;
-    statInstance.computationDetails.busyComputing = false;
-    // Only the active stat instance depeneds on the effects
-    if (!statInstance.overridden){
-      statInstance.dependencies = union(statInstance.dependencies, effectDeps);
-    }
-  });
-}

app/imports/api/creature/computation/engine/computeToggle.js

@@ -1,55 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-import { union } from 'lodash';
-
-export default function computeToggle(toggle, memo){
-  if (toggle.computationDetails.computed) return;
-  if (toggle.computationDetails.busyComputing){
-    // Trying to compute this effect again while it is already computing.
-    // We must be in a dependency loop.
-    toggle.computationDetails.computed = true;
-    toggle.result = false;
-    toggle.computationDetails.busyComputing = false;
-    toggle.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', toggle);
-    return;
-  }
-  // Before doing any work, mark this toggle as busy
-  toggle.computationDetails.busyComputing = true;
-
-  // Apply any parent toggles
-  applyToggles(toggle, memo);
-
-  // Do work
-  delete toggle.errors;
-  if (toggle.enabled){
-    toggle.toggleResult = true;
-  } else if (toggle.disabled){
-    toggle.toggleResult = false;
-  } else if (!toggle.condition){
-    toggle.toggleResult = false;
-  } else if (Number.isFinite(+toggle.condition)){
-    toggle.toggleResult = !!+toggle.condition;
-  } else {
-    let {
-      result,
-      context,
-      dependencies,
-    } = evaluateCalculation({string: toggle.condition, prop: toggle, memo});
-    toggle.toggleResult = !!result.value;
-    toggle.dependencies = union(
-      toggle.dependencies,
-      dependencies,
-    );
-    if (context.errors.length){
-      toggle.errors = context.errors;
-    }
-  }
-  if (!toggle.toggleResult){
-    toggle.inactive = true;
-    toggle.deactivatedBySelf = true;
-    toggle.deactivatedByToggle = true;
-  }
-  toggle.computationDetails.computed = true;
-  toggle.computationDetails.busyComputing = false;
-}

app/imports/api/creature/computation/engine/evaluateCalculation.js

@@ -1,137 +0,0 @@
-import computeStat from '/imports/api/creature/computation/engine/computeStat.js';
-import { prettifyParseError, parse, CompilationContext } from '/imports/parser/parser.js';
-import SymbolNode from '/imports/parser/parseTree/SymbolNode.js';
-import AccessorNode from '/imports/parser/parseTree/AccessorNode.js';
-import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
-import ErrorNode from '/imports/parser/parseTree/ErrorNode.js';
-import findAncestorByType from '/imports/api/creature/computation/engine/findAncestorByType.js';
-import { union } from 'lodash';
-
-/* Convert a calculation into a constant output and errors*/
-export default function evaluateCalculation({
-  string,
-  prop,
-  memo,
-  fn = 'reduce',
-}){
-  let dependencies = [];
-  let context = new CompilationContext();
-  if (!string) return {
-    result: new ConstantNode({value: string, type: 'string'}),
-    context,
-    dependencies,
-  };
-  if (typeof string !== 'string'){
-    string = string.toString();
-  }
-  // Parse the string
-  let calc;
-  try {
-    calc = parse(string);
-  } catch (e) {
-    let error = prettifyParseError(e);
-    return {
-      result: new ErrorNode({context, error}),
-      context,
-      dependencies,
-    };
-  }
-
-  // Replace constants with their parsed constant
-  let replaceResults = replaceConstants({
-    calc, memo, prop, dependencies, context
-  });
-  dependencies = replaceResults.dependencies;
-  calc = replaceResults.calc;
-  if (replaceResults.failed){
-    return {
-      result: new ConstantNode({value: string, type: 'string'}),
-      context,
-      dependencies,
-    };
-  }
-
-  // Ensure all symbol nodes are defined and computed
-  dependencies = computeSymbols({calc, memo, prop, dependencies})
-
-  // Evaluate
-  let result = calc[fn](memo.statsByVariableName, context);
-  return {result, context, dependencies};
-}
-
-// Replace constants in the calc with the right ParseNodes
-function replaceConstants({calc, memo, prop, dependencies, context}){
-  let constFailed = [];
-  calc = calc.replaceNodes(node => {
-    if (!(node instanceof SymbolNode)) return;
-    let stat, constant;
-    if (node.name[0] !== '#'){
-      stat = memo.statsByVariableName[node.name]
-      constant = memo.constantsByVariableName[node.name];
-    } else if (node.name === '#constant'){
-      constant = findAncestorByType({type: 'constant', prop, memo});
-    }
-    // replace constants that aren't overridden by stats or disabled by a toggle
-    if (constant && !constant.deactivatedByToggle && !stat){
-      dependencies = union(dependencies, [
-        constant._id,
-        ...constant.dependencies
-      ]);
-      // Fail if the constant has errors
-      if (constant.errors && constant.errors.length){
-        constFailed.push(node.name);
-        return;
-      }
-      let parsedConstantNode;
-      try {
-        parsedConstantNode = parse(constant.calculation);
-      } catch(e){
-        constFailed.push(node.name);
-        return;
-      }
-      if (!parsedConstantNode) constFailed.push(node.name);
-      return parsedConstantNode;
-    }
-  });
-  constFailed.forEach(name => {
-    context.storeError({
-      type: 'error',
-      message: `${name} is a constant property with parsing errors`
-    });
-  });
-  let failed = !!constFailed.length;
-  if (failed){
-    calc = new ErrorNode({error: 'Failed to replace constants'});
-  }
-  return { failed, dependencies, calc };
-}
-
-  // Ensure all symbol nodes are defined and computed
-function computeSymbols({calc, memo, prop, dependencies}){
-  calc.traverse(node => {
-    if (node instanceof SymbolNode || node instanceof AccessorNode){
-      let stat;
-      // References up the tree start with #
-      if (node.name[0] === '#'){
-        stat = findAncestorByType({type: node.name.slice(1), prop, memo});
-        memo.statsByVariableName[node.name] = stat;
-      } else {
-        stat = memo.statsByVariableName[node.name];
-      }
-      if (stat && stat.computationDetails && !stat.computationDetails.computed){
-        computeStat(stat, memo);
-      }
-      if (stat){
-        if (stat.dependencies){
-          dependencies = union(dependencies, [
-            stat._id || node.name,
-            ...stat.dependencies
-          ]);
-        } else {
-          dependencies = union(dependencies, [stat._id || node.name]);
-        }
-      }
-    }
-  });
-  return dependencies;
-}

app/imports/api/creature/computation/engine/findAncestorByType.js

@@ -1,10 +0,0 @@
-export default function findAncestorByType({type, prop, memo}){
-  if (!prop || !prop.ancestors) return;
-  let ancestor;
-  for (let i = prop.ancestors.length - 1; i >= 0; i--){
-    ancestor = memo.propsById[prop.ancestors[i].id];
-    if (ancestor && ancestor.type === type){
-      return ancestor;
-    }
-  }
-}

app/imports/api/creature/computation/engine/getComputationProperties.js

@@ -1,24 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-
-export default function getComputationProperties(creatureId){
-  // Find all the relevant properties
-  return CreatureProperties.find({
-    'ancestors.id': creatureId,
-    removed: {$ne: true},
-    $or: [
-      // All active properties
-      {inactive: {$ne: true}},
-      // Unless they were deactivated because of a toggle
-      {deactivatedByToggle: true},
-    ]
-  }, {
-    // Filter out fields never used by calculations
-    fields: {
-      icon: 0,
-    },
-    // Obey tree order
-    sort: {
-      order: 1,
-    }
-  }).fetch();
-}

app/imports/api/creature/computation/engine/getDependentProperties.js

@@ -1,51 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { union } from 'lodash';
-
-export default function getDependentProperties({
-  creatureId,
-  propertyIds,
-  propertiesDependedAponIds,
- }){
-  // find ids of all dependant toggles that have conditions, even if inactive
-  let toggleIds = CreatureProperties.find({
-    'ancestors.id': creatureId,
-    type: 'toggle',
-    removed: {$ne: true},
-    condition: { $exists: true },
-    dependencies: {$in: propertyIds},
-  }, {
-    fields: {_id: 1},
-  }).map(t => t._id);
-  // Find all the dependant properties
-  let props = CreatureProperties.find({
-    'ancestors.id': creatureId,
-    removed: {$ne: true},
-    dependencies: {$in: propertyIds},
-    $or: [
-      // All active properties
-      {inactive: {$ne: true}},
-      // All active and inactive toggles with conditions
-      // Same as {$in: toggleIds}, but should be slightly faster
-      {type: 'toggle', condition: { $exists: true }},
-      // All decendents of the above toggles
-      {'ancestors.id': {$in: toggleIds}},
-    ]
-  }, { fields: {_id: 1, dependencies: 1} }).fetch();
-  // Add all the properties that changing props depend on, but haven't yet been
-  // included to make an array of every property we need
-  let allConnectedPropIds = [...propertyIds, ...propertiesDependedAponIds];
-  props.forEach(prop => {
-    allConnectedPropIds = union(
-      allConnectedPropIds,
-      prop.dependencies,
-      [prop._id]);
-  });
-  // Add on all the properties and the objects they depend apon
-  return CreatureProperties.find({
-    _id: {$in: allConnectedPropIds}
-  }, {
-    // Ignore fields not used in computations
-    fields: {icon: 0},
-    sort: {order: 1},
-  }).fetch();
-}

app/imports/api/creature/computation/engine/writeAlteredProperties.js

@@ -1,118 +0,0 @@
-import { Meteor } from 'meteor/meteor'
-import { isEqual, forOwn } from 'lodash';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import propertySchemasIndex from '/imports/api/properties/computedOnlyPropertySchemasIndex.js';
-
-export default function writeAlteredProperties(memo){
-  let bulkWriteOperations = [];
-  // Loop through all properties on the memo
-  forOwn(memo.propsById, changed => {
-    let schema = propertySchemasIndex[changed.type];
-    if (!schema){
-      console.warn('No schema for ' + changed.type);
-      return;
-    }
-    let id = changed._id;
-    let op = undefined;
-    let original = memo.originalPropsById[id];
-    let keys = [
-      'dependencies',
-      'inactive',
-      'deactivatedBySelf',
-      'deactivatedByAncestor',
-      'deactivatedByToggle',
-      'damage',
-      ...schema.objectKeys(),
-    ];
-    op = addChangedKeysToOp(op, keys, original, changed);
-    if (op){
-      bulkWriteOperations.push(op);
-    }
-  });
-  writePropertiesSequentially(bulkWriteOperations);
-}
-
-function addChangedKeysToOp(op, keys, original, changed) {
-  // Loop through all keys that can be changed by computation
-  // and compile an operation that sets all those keys
-  for (let key of keys){
-    if (!isEqual(original[key], changed[key])){
-      if (!op) op = newOperation(original._id, changed.type);
-      let value = changed[key];
-      if (value === undefined){
-        // Unset values that become undefined
-        addUnsetOp(op, key);
-      } else {
-        // Set values that changed to something else
-        addSetOp(op, key, value);
-      }
-    }
-  }
-  return op;
-}
-
-function newOperation(_id, type){
-  let newOp = {
-    updateOne: {
-      filter: {_id},
-      update: {},
-    }
-  };
-  if (Meteor.isClient){
-    newOp.type = type;
-  }
-  return newOp;
-}
-
-function addSetOp(op, key, value){
-  if (op.updateOne.update.$set){
-    op.updateOne.update.$set[key] = value;
-  } else {
-    op.updateOne.update.$set = {[key]: value};
-  }
-}
-
-function addUnsetOp(op, key){
-  if (op.updateOne.update.$unset){
-    op.updateOne.update.$unset[key] = 1;
-  } else {
-    op.updateOne.update.$unset = {[key]: 1};
-  }
-}
-
-// We use this instead of bulkWriteProperties because it functions with latency
-// compensation without needing to roll back changes, which causes multiple
-// expensive redraws of the character sheet
-function writePropertiesSequentially(bulkWriteOps){
-  bulkWriteOps.forEach(op => {
-    let updateOneOrMany = op.updateOne || op.updateMany;
-    CreatureProperties.update(updateOneOrMany.filter, updateOneOrMany.update, {
-      // The bulk code is bypassing validation, so do the same here
-      // selector: {type: op.type} // include this if bypass is off
-      bypassCollection2: true,
-    });
-  });
-}
-
-// This is more efficient on the database, but significantly less efficient
-// in the UI because of incompatibility with latency compensation. If the
-// duplicate redraws can be fixed, this is a strictly better way of processing
-// writes
-function bulkWriteProperties(bulkWriteOps){
-  if (!bulkWriteOps.length) return;
-  // bulkWrite is only available on the server
-  if (Meteor.isServer){
-    CreatureProperties.rawCollection().bulkWrite(
-      bulkWriteOps,
-      {ordered : false},
-      function(e){
-        if (e) {
-          console.error('Bulk write failed: ');
-          console.error(e);
-        }
-      }
-    );
-  } else {
-    writePropertiesSequentially(bulkWriteOps);
-  }
-}

app/imports/api/creature/computation/engine/writeCreatureVariables.js

@@ -1,59 +0,0 @@
-import { pick, forOwn } from 'lodash';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import VERSION from '/imports/constants/VERSION.js';
-
-export default function writeCreatureVariables(memo, creatureId, fullRecompute = true) {
-  const fields = [
-    'ability',
-    'abilityMod',
-    'advantage',
-    'attributeType',
-    'baseProficiency',
-    'baseValue',
-    'calculation',
-    'conditionalBenefits',
-    'currentValue',
-    'damage',
-    'decimal',
-    'fail',
-    'level',
-    'modifier',
-    'name',
-    'passiveBonus',
-    'proficiency',
-    'reset',
-    'resetMultiplier',
-    'rollBonuses',
-    'skillType',
-    'spellSlotLevelValue',
-    'type',
-    'value',
-  ];
-
-  if (fullRecompute){
-    memo.creatureVariables = {};
-    forOwn(memo.statsByVariableName, (stat, variableName) => {
-      // Don't save context variables
-      if (variableName[0] === '#') return;
-      let condensedStat = pick(stat, fields);
-      memo.creatureVariables[variableName] = condensedStat;
-    });
-    forOwn(memo.constantsByVariableName, (stat, variableName) => {
-      let condensedStat = pick(stat, fields);
-      if (!memo.creatureVariables[variableName]){
-        memo.creatureVariables[variableName] = condensedStat;
-      }
-    });
-    Creatures.update(creatureId, {$set: {
-      variables: memo.creatureVariables,
-      computeVersion: VERSION,
-    }});
-  } else {
-    let $set = {};
-    forOwn(memo.statsByVariableName, (stat, variableName) => {
-      let condensedStat = pick(stat, fields);
-      $set[`variables.${variableName}`] = condensedStat;
-    });
-    Creatures.update(creatureId, {$set});
-  }
-}

app/imports/api/creature/computation/methods/recomputeCreature.js

@@ -1,120 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import ComputationMemo from '/imports/api/creature/computation/engine/ComputationMemo.js';
-import getComputationProperties from '/imports/api/creature/computation/engine/getComputationProperties.js';
-import computeMemo from '/imports/api/creature/computation/engine/computeMemo.js';
-import writeAlteredProperties from '/imports/api/creature/computation/engine/writeAlteredProperties.js';
-import writeCreatureVariables from '/imports/api/creature/computation/engine/writeCreatureVariables.js';
-import { recomputeDamageMultipliersById } from '/imports/api/creature/denormalise/recomputeDamageMultipliers.js';
-import recomputeSlotFullness from '/imports/api/creature/denormalise/recomputeSlotFullness.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import getDependentProperties from '/imports/api/creature/computation/engine/getDependentProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-
-export const recomputeCreature = new ValidatedMethod({
-
-  name: 'creatures.recomputeCreature',
-
-  validate: new SimpleSchema({
-    charId: { type: String }
-  }).validator(),
-
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-
-  run({charId}) {
-    let creature = Creatures.findOne(charId);
-    // Permission
-    assertEditPermission(creature, this.userId);
-    // Work, call this direcly if you are already in a method that has checked
-    // for permission to edit a given character
-    recomputeCreatureById(charId);
-  },
-
-});
-
-export function recomputeCreatureById(creatureId){
-  let creature = Creatures.findOne(creatureId);
-  recomputeCreatureByDoc(creature);
-}
-
-/**
- * This function is the heart of DiceCloud. It recomputes a creature's stats,
- * distilling down effects and proficiencies into the final stats that make up
- * a creature.
- *
- * Essentially this is a depth first tree traversal algorithm that computes
- * stats' dependencies before computing stats themselves, while detecting
- * dependency loops.
- *
- * At the moment it makes no effort to limit recomputation to just what was
- * changed.
- *
- * Attempting to implement dependency management to limit recomputation to just
- * change affected stats should only happen as a last resort, when this function
- * can no longer be performed more efficiently, and server resources can not be
- * expanded to meet demand.
- *
- * A brief overview:
- * - Fetch the stats of the creature and add them to
- *   an object for quick lookup
- * - Fetch the effects and proficiencies which apply to each stat and store them with the stat
- * - Fetch the class levels and store them as well
- * - Mark each stat and effect as uncomputed
- * - Iterate over each stat in order and compute it
- *   - If the stat is already computed, skip it
- *   - If the stat is busy being computed, we are in a dependency loop, make it NaN and mark computed
- *   - Mark the stat as busy computing
- *   - Iterate over each effect which applies to the attribute
- *     - If the effect is not computed compute it
- *       - If the effect relies on another attribute, get its computed value
- *       - Recurse if that attribute is uncomputed
- *     - apply the effect to the attribute
- *   - Conglomerate all the effects to compute the final stat values
- *   - Mark the stat as computed
- * - Write the computed results back to the database
- */
-export function recomputeCreatureByDoc(creature){
-  const creatureId = creature._id;
-  let props = getComputationProperties(creatureId);
-  let computationMemo = new ComputationMemo(props, creature);
-  computeMemo(computationMemo);
-  writeAlteredProperties(computationMemo);
-  writeCreatureVariables(computationMemo, creatureId);
-  recomputeDamageMultipliersById(creatureId);
-  recomputeSlotFullness(creatureId);
-  return computationMemo;
-}
-
-export function recomputePropertyDependencies(property){
-  let creature = getRootCreatureAncestor(property);
-  recomputeCreatureByDependencies({
-    creature,
-    propertyIds: [property._id],
-    propertiesDependedAponIds: property.dependencies,
-  });
-}
-
-export function recomputeCreatureByDependencies({
-  creature,
-  propertyIds,
-  propertiesDependedAponIds
-}){
-  let props = getDependentProperties({
-    creatureId: creature._id,
-    propertyIds,
-    propertiesDependedAponIds,
-  });
-  let computationMemo = new ComputationMemo(props, creature);
-  computeMemo(computationMemo);
-  writeAlteredProperties(computationMemo);
-  writeCreatureVariables(computationMemo, creature._id, false)
-  recomputeInactiveProperties(creature._id);
-  return computationMemo;
-}

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,100 +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({
-	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,
-  },
-  // 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,
-  },
-  // 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,
-  },
-  // Denormalised flag if this property was made inactive because of its own
-  // state
-  deactivatedBySelf: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-  },
-  // 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,
-  },
-  // Denormalised list of all properties or creatures this property depends on
-  dependencies: {
-    type: Array,
-    defaultValue: [],
-    index: 1,
-  },
-  'dependencies.$': {
-    type: String,
-  },
-});
-
-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}
-	});
-}
-
-import '/imports/api/creature/creatureProperties/methods/index.js';
-import '/imports/api/creature/actions/doAction.js';
-import '/imports/api/creature/actions/castSpellWithSlot.js';
-
-export default CreatureProperties;
-export {
-	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,69 +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';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.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});
-
-    // Changing quantity does not change dependencies, but recomputing the
-    // inventory changes many deps at once, so recompute fully
-    recomputeCreatureByDoc(rootCreature);
-    recomputeInventory(rootCreature._id);
-  },
-});
-
-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}
-    }, {
-      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}
-    }, {
-      selector: property
-    });
-  }
-}
-
-export default adjustQuantity;

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

@@ -1,57 +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 Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { recomputePropertyDependencies } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-
-const damagePropertiesByName = new ValidatedMethod({
-  name: 'CreatureProperties.damagePropertiesByName',
-  validate: new SimpleSchema({
-    creatureId: SimpleSchema.RegEx.Id,
-    variableName: {
-      type: String,
-    },
-    operation: {
-      type: String,
-      allowedValues: ['set', 'increment']
-    },
-    value: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 20,
-    timeInterval: 5000,
-  },
-  run({creatureId, variableName, operation, value}) {
-		// Check permissions
-    let creature = Creatures.findOne(creatureId, {
-      fields: {
-        damageMultipliers: 1,
-        owner: 1,
-        readers: 1,
-        writers: 1,
-      },
-    });
-    assertEditPermission(creature, this.userId);
-    let lastProperty;
-    CreatureProperties.find({
-      'ancestors.id': creatureId,
-      variableName,
-      removed: {$ne: false},
-      inactive: {$ne: true},
-    }).forEach(property => {
-      // Check if property can take damage
-      let schema = CreatureProperties.simpleSchema(property);
-      if (!schema.allowsKey('damage')) return;
-      // Damage the property
-      damagePropertyWork({property, operation, value});
-      lastProperty = property;
-    });
-    if (lastProperty) recomputePropertyDependencies(lastProperty);
-  }
-});
-
-export default damagePropertiesByName;

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

@@ -1,80 +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';
-import { recomputePropertyDependencies } from '/imports/api/creature/computation/methods/recomputeCreature.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}) {
-    // Check permissions
-		let property = CreatureProperties.findOne(_id);
-    if (!property) throw new Meteor.Error(
-      'Damage property failed', 'Property doesn\'t exist'
-    );
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-		// Check if property can take damage
-		let schema = CreatureProperties.simpleSchema(property);
-		if (!schema.allowsKey('damage')){
-			throw new Meteor.Error(
-				'Damage property failed',
-				`Property of type "${property.type}" can't be damaged`
-			);
-		}
-		let result = damagePropertyWork({property, operation, value});
-    // Dependencies can't be changed through damage, only recompute deps
-    recomputePropertyDependencies(property);
-    return result;
-  },
-});
-
-export function damagePropertyWork({property, operation, value}){
-  if (operation === 'set'){
-    let currentValue = property.value;
-    // Set represents what we want the value to be after damage
-    // So we need the actual damage to get to that value
-    let damage = currentValue - value;
-    // Damage can't exceed total value
-    if (damage > currentValue) damage = currentValue;
-    // Damage must be positive
-    if (damage < 0) damage = 0;
-    CreatureProperties.update(property._id, {
-      $set: {damage}
-    }, {
-      selector: property
-    });
-    return currentValue - damage;
-  } else if (operation === 'increment'){
-    let currentValue = property.value - (property.damage || 0);
-    let currentDamage = property.damage;
-    let increment = value;
-    // Can't increase damage above the remaining value
-    if (increment > currentValue) increment = currentValue;
-    // Can't decrease damage below zero
-    if (-increment > currentDamage) increment = -currentDamage;
-    CreatureProperties.update(property._id, {
-      $inc: {damage: increment}
-    }, {
-      selector: property
-    });
-    return increment;
-  }
-}
-
-export default damageProperty;

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

@@ -1,73 +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 Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { recomputeCreatureByDependencies } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-
-const dealDamage = new ValidatedMethod({
-  name: 'creatureProperties.dealDamage',
-  validate: new SimpleSchema({
-    creatureId: SimpleSchema.RegEx.Id,
-    damageType: {
-      type: String,
-    },
-    amount: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 20,
-    timeInterval: 5000,
-  },
-  run({creatureId, damageType, amount}) {
-    // permissions
-    let creature = Creatures.findOne(creatureId, {
-      fields: {
-        damageMultipliers: 1,
-        owner: 1,
-        readers: 1,
-        writers: 1,
-      },
-    });
-    assertEditPermission(creature, this.userId);
-
-    // Get all the health bars and do damage to them
-    let healthBars = CreatureProperties.find({
-      'ancestors.id': creatureId,
-      type: 'attribute',
-      attributeType:'healthBar',
-      removed: {$ne: true},
-      inactive: {$ne: true},
-    }, {
-      sort: {order: -1},
-    });
-    let multiplier = creature.damageMultipliers[damageType];
-    if (multiplier === undefined) multiplier = 1;
-    let totalDamage = Math.floor(amount * multiplier);
-    let damageLeft = totalDamage;
-    if (damageType === 'healing') damageLeft = -totalDamage;
-    let propertyIds = [];
-    let propertiesDependedAponIds = [];
-    healthBars.forEach(healthBar => {
-      if (damageLeft === 0) return;
-      let damageAdded = damagePropertyWork({
-        property: healthBar,
-        operation: 'increment',
-        value: damageLeft,
-      });
-      damageLeft -= damageAdded;
-      propertyIds.push(healthBar._id);
-      propertiesDependedAponIds.push(...healthBar.dependencies);
-    });
-    recomputeCreatureByDependencies({
-      creature,
-      propertyIds,
-      propertiesDependedAponIds,
-    });
-    return totalDamage;
-  },
-});
-
-export default dealDamage;

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

@@ -1,105 +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 recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.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;
-
-    // Insert the properties
-		CreatureProperties.batchInsert([property, ...nodes]);
-
-    // Tree structure changed by inserts, reorder the tree
-    reorderDocs({
-      collection: CreatureProperties,
-      ancestorId: property.ancestors[0].id,
-    });
-
-    // Inserting the active status of the property needs to be denormalised
-    recomputeInactiveProperties(creature._id);
-
-    // Recompute the inventory
-    recomputeInventory(creature._id);
-
-    // Inserting a creature property invalidates dependencies: full recompute
-    recomputeCreatureByDoc(creature);
-
-    return propertyId;
-  },
-});
-
-export default duplicateProperty;

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

@@ -1,58 +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 { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.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},
-    }, {
-			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,
-    });
-
-    recomputeInactiveProperties(creature._id);
-    recomputeInventory(creature._id);
-    recomputeCreatureByDoc(creature);
-  },
-});
-
-export default equipItem;

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,44 +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,
-      }]
-    });
-  }
-  let tagsOr = [];
-  let tagsNor = [];
-  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'){
-        tagsNor.push({tags: {$all: extra.tags}});
-      }
-    });
-  }
-  if (tagsOr.length){
-    filter.$and.push({$or: tagsOr});
-  }
-  if (tagsNor.length){
-    filter.$and.push({$nor: tagsNor});
-  }
-  if (!filter.$and.length){
-    delete filter.$and;
-  }
-  return filter;
-}

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

@@ -1,14 +0,0 @@
-import '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
-import '/imports/api/creature/creatureProperties/methods/damagePropertiesByName.js';
-import '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import '/imports/api/creature/creatureProperties/methods/dealDamage.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';

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

@@ -1,156 +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 recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.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;
-  let _id = CreatureProperties.insert(property);
-  // Tree structure changed by insert, reorder the tree
-  reorderDocs({
-    collection: CreatureProperties,
-    ancestorId: creature._id,
-  });
-  // Inserting the active status of the property needs to be denormalised
-  recomputeInactiveProperties(creature._id);
-
-  // Recompute the inventory if it has changed
-  if (property.type === 'item' || property.type === 'container'){
-    recomputeInventory(creature._id);
-  }
-  // Inserting a creature property invalidates dependencies: full recompute
-  recomputeCreatureByDoc(creature);
-  return _id;
-}
-
-export default insertProperty;
-export { insertPropertyAsChildOfTag };

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

@@ -1,250 +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 recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.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 recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.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,
-    });
-
-    // The library properties need to denormalise which of them are inactive
-    recomputeInactiveProperties(rootCreature._id);
-    // Some of the library properties may be items or containers
-    recomputeInventory(rootCreature._id);
-		// Inserting a creature property invalidates dependencies: full recompute
-    recomputeCreatureByDoc(rootCreature);
-		// 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, nodeId);
-
-  // 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;
-  }
-
-  // Insert the creature properties
-  CreatureProperties.batchInsert(nodes);
-  return node;
-}
-
-
-function storeLibraryNodeReferences(nodes){
-  nodes.forEach(node => {
-    node.libraryNodeId = node._id;
-  });
-}
-
-// 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 => {
-
-    // We have already visited this ref and replaced it
-    if (visitedRefs.has(node._id)) return false;
-
-    // Already replaced an ancestor node
-    for (let i; i < node.ancestors.length; i++){
-      if (visitedRefs.has(node.ancestors[i].id)) return false;
-    }
-
-    // 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,
-		});
-
-    // Remove all the looped references and descendents from the new nodes
-    // We can't rely on the reify recursion to do this, since the IDs are
-    // getting renewed before it is called
-    addedNodes = addedNodes.filter(node => {
-      // Exclude removed referenced
-      if (visitedRefs.has(node._id)) return false;
-
-      // Exclude descendants of removed references
-      for (let i; i < node.ancestors.length; i++){
-        if (visitedRefs.has(node.ancestors[i].id)) return false;
-      }
-      return true;
-    });
-
-    // TODO: Force the referencedNode to take the old id of the reference
-    // such that the reference's children can be kept
-
-    // Give the new referenced sub-tree new ids
-    renewDocIds({
-      docArray: addedNodes,
-    });
-
-    // 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,36 +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 { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.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}},
-		}, {
-			selector: {type: property.type},
-			getAutoValues: false,
-		});
-
-    // TODO figure out if this method can change deps or not
-    recomputeCreatureByDoc(rootCreature);
-    // recomputePropertyDependencies(property);
-	}
-});
-
-export default pullFromProperty;

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

@@ -1,53 +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 { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.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},
-		}, {
-			selector: {type: property.type},
-		});
-
-    // TODO figure out if this method can change deps or not
-    recomputeCreatureByDoc(rootCreature);
-    // recomputePropertyDependencies(property);
-	}
-});
-
-export default pushToProperty;

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

@@ -1,40 +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';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.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});
-
-    // Items and containers might be restored
-    recomputeInventory(rootCreature._id);
-    // Parents active status may have changed while it was deleted
-    recomputeInactiveProperties(rootCreature._id);
-    // Changes dependency tree by restoring children
-    recomputeCreatureByDoc(rootCreature);
-	}
-});
-
-export default restoreProperty;

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

@@ -1,52 +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';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.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}
-    }, {
-      selector: action,
-    });
-
-    // Changing the linked item does change the dependency tree
-    // TODO: We can predict exactly which deps will be affected instead of
-    //       recomputing the entire creature
-    recomputeCreatureByDoc(rootCreature);
-  },
-});
-
-export default selectAmmoItem;

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

@@ -1,37 +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';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.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});
-
-    // Potentially changes items and containers
-    recomputeInventory(rootCreature._id);
-    // Changes dependency tree by removing children
-    recomputeCreatureByDoc(rootCreature);
-	}
-});
-
-export default softRemoveProperty;

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

@@ -1,67 +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 { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.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}};
-    } else {
-      modifier = {$set: {[pathString]: value}};
-    }
-		CreatureProperties.update(_id, modifier, {
-			selector: {type: property.type},
-		});
-
-    // Some updates might cause other properties to become inactive
-    if ([
-      'applied', 'equipped', 'prepared', 'alwaysPrepared', 'disabled'
-    ].includes(path[0])){
-      recomputeInactiveProperties(rootCreature._id);
-    }
-
-    if (property.type === 'item' || property.type === 'container'){
-      // Potentially changes items and containers
-      recomputeInventory(rootCreature._id);
-    }
-    // Updating a property is likely to change dependencies, do a full recompute
-    // denormalised stats might change, so fetch the creature again
-    recomputeCreatureById(rootCreature._id);
-  },
-});
-
-export default updateCreatureProperty;

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

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

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

@@ -1,180 +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,
-  },
-  // 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,
-  },
-	// 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,
-  },
-  // Inventory
-	'denormalizedStats.weightTotal': {
-		type: Number,
-		defaultValue: 0,
-	},
-  'denormalizedStats.weightEquipment': {
-		type: Number,
-		defaultValue: 0,
-	},
-  'denormalizedStats.weightCarried': {
-		type: Number,
-		defaultValue: 0,
-	},
-  'denormalizedStats.valueTotal': {
-		type: Number,
-		defaultValue: 0,
-	},
-  'denormalizedStats.valueEquipment': {
-		type: Number,
-		defaultValue: 0,
-	},
-  'denormalizedStats.valueCarried': {
-		type: Number,
-		defaultValue: 0,
-	},
-  'denormalizedStats.itemsAttuned': {
-		type: Number,
-		defaultValue: 0,
-	},
-  // 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: {}
-	},
-
-  // 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);
-
-
-import '/imports/api/creature/creatures/methods/index.js';
-
-export default Creatures;
-export { CreatureSchema };

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: 'Choose a starting point for your character, this will define the basic setup of your character sheet. Without a base, your sheet will be empty.',
-      slotTags: ['base'],
-      tags: [],
-      quantityExpected: 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/index.js

@@ -1,4 +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';

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

@@ -1,70 +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 CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { getUserTier } from '/imports/api/users/patreon/tiers.js';
-import defaultCharacterProperties from '/imports/api/creature/creatures/defaultCharacterProperties.js';
-import insertPropertyFromLibraryNode from '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
-
-const insertCreature = new ValidatedMethod({
-
-  name: 'creatures.insertCreature',
-
-  validate: null,
-
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-
-  run() {
-    if (!this.userId) {
-      throw new Meteor.Error('Creatures.methods.insert.denied',
-      'You need to be logged in to insert a creature');
-    }
-    let tier = getUserTier(this.userId);
-
-    let currentCharacterCount = Creatures.find({
-      owner: this.userId,
-    }, {
-      fields: {_id: 1},
-    }).count();
-
-    if (
-      tier.characterSlots !== -1 &&
-      currentCharacterCount >= tier.characterSlots
-    ){
-      throw new Meteor.Error('Creatures.methods.insert.denied',
-      `You are already at your limit of ${tier.characterSlots} characters`)
-    }
-
-		// Create the creature document
-    let creatureId = Creatures.insert({
-			owner: this.userId,
-		});
-
-    // Insert the default properties
-    // Not batchInsert because we want the properties cleaned by the schema
-    let baseId;
-    defaultCharacterProperties(creatureId).forEach(prop => {
-      let id = CreatureProperties.insert(prop);
-      if (prop.name === 'Ruleset'){
-        baseId = id;
-      }
-    });
-
-    if (Meteor.isServer){
-      // Insert the 5e ruleset as the default base
-      insertPropertyFromLibraryNode.call({
-        nodeIds: ['iHbhfcg3AL5isSWbw'],
-        parentRef: {id: baseId, collection: 'creatureProperties'},
-        order: 0.5,
-      });
-    }
-
-		return creatureId;
-  },
-});
-
-export default insertCreature;

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

@@ -1,41 +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 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){
-  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,116 +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 CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-
-const restCreature = new ValidatedMethod({
-  name: 'creature.methods.longRest',
-  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}) {
-    let creature = Creatures.findOne(creatureId, {
-      fields: {
-        owner: 1,
-        writers: 1,
-        settings: 1,
-      }
-    }) ;
-    // Need edit permissions
-    assertEditPermission(creature, this.userId);
-
-    // 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}
-    }, {
-      selector: {type: 'attribute'},
-      multi: true,
-    });
-    // Update all action-like properties' usesUsed
-    filter.type = {$in: [
-      'action',
-      'attack',
-      'spell'
-    ]};
-    CreatureProperties.update(filter, {
-      $set: {usesUsed: 0}
-    }, {
-      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,
-          value: 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.value || 0), 0);
-      let resetMultiplier = 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}
-        }, {
-          selector: {type: 'attribute'},
-        });
-      });
-    }
-    recomputeCreatureById(creatureId);
-  },
-});
-
-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/denormalise/recomputeDamageMultipliers.js

@@ -1,78 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import { assertEditPermission } 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';
-
-export const recomputeDamageMultipliers = new ValidatedMethod({
-
-  name: 'creatures.recomputeDamageMultipliers',
-
-  validate: new SimpleSchema({
-    creatureId: { type: String }
-  }).validator(),
-
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-
-  run({creatureId}) {
-    // Permission
-    assertEditPermission(creatureId, this.userId);
-    // Work, call this direcly if you are already in a method that has checked
-    // for permission to edit a given character
-    recomputeDamageMultipliersById(creatureId);
-  },
-
-});
-
-export function recomputeDamageMultipliersById(creatureId){
-  if (!creatureId) throw 'Creature ID is required';
-  let props = CreatureProperties.find({
-    'ancestors.id': creatureId,
-    type: 'damageMultiplier',
-    removed: {$ne: true},
-    inactive: {$ne: true},
-  }, {
-    sort: {order: 1}
-  });
-
-  // Count of how many weakness, resistances and immunities each damage type has
-  let multipliersByName = {};
-  props.forEach(dm => {
-    dm.damageTypes.forEach(damageType => {
-      if (!multipliersByName[damageType]){
-        multipliersByName[damageType] = {
-          weaknesses: 0,
-          resistances: 0,
-          immunities: 0,
-        };
-      }
-      if (dm.value === 0){
-        multipliersByName[damageType].immunities++;
-      } else if (dm.value === 0.5){
-        multipliersByName[damageType].resistances++;
-      } else if (dm.value === 2){
-        multipliersByName[damageType].weaknesses++;
-      }
-    });
-  });
-  // Make an Object with keys of all the damage types that have a resulting
-  // immunity, weakness, or resistance
-  let damageMultipliers = {};
-  for (let damageType in multipliersByName){
-    let multiplier = multipliersByName[damageType];
-    if (multiplier.immunities){
-      damageMultipliers[damageType] = 0;
-    } else if (multiplier.resistances && !multiplier.weaknesses){
-      damageMultipliers[damageType] = 0.5;
-    } else if (multiplier.weaknesses && !multiplier.resistances){
-      damageMultipliers[damageType] = 2;
-    }
-  }
-  // Store the Object on the creature document
-  Creatures.update(creatureId, {$set: {damageMultipliers}});
-}

app/imports/api/creature/denormalise/recomputeInactiveProperties.js

@@ -1,75 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-
-export default function recomputeInactiveProperties(ancestorId){
-  let disabledFilter = {
-    'ancestors.id': ancestorId,
-    $or: [
-      {disabled: true}, // Everything can be disabled
-      {type: 'buff', applied: false}, // Buffs can be applied
-      {type: 'item', equipped: {$ne: true}},
-      {type: 'spell', prepared: {$ne: true}, alwaysPrepared: {$ne: true}},
-    ],
-  };
-  let disabledIds = CreatureProperties.find(disabledFilter, {
-    fields: {_id: 1},
-  }).map(prop => prop._id);
-
-  // Deactivate relevant properties
-  // Inactive properties
-  CreatureProperties.update({
-    'ancestors.id': ancestorId,
-    '_id': {$in: disabledIds},
-    $or: [
-      {inactive: {$ne: true}},
-      {deactivatedBySelf: {$ne: true}},
-      {deactivatedByAncestor: true},
-    ],
-  }, {
-    $set: {
-      inactive: true,
-      deactivatedBySelf: true,
-    },
-    $unset: {deactivatedByAncestor: 1},
-  }, {
-    multi: true,
-    selector: {type: 'any'},
-  });
-  // Decendants of inactive properties
-  CreatureProperties.update({
-    'ancestors.id': {$eq: ancestorId, $in: disabledIds},
-    $or: [
-      {inactive: {$ne: true}},
-      {deactivatedByAncestor: {$ne: true}},
-    ],
-  }, {
-    $set: {
-      inactive: true,
-      deactivatedByAncestor: true,
-    },
-  }, {
-    multi: true,
-    selector: {type: 'any'},
-  });
-
-  // Remove inactive from all the properties that are inactive but shouldn't be
-  CreatureProperties.update({
-    'ancestors.id': {$eq: ancestorId, $nin: disabledIds},
-    '_id': {$nin: disabledIds},
-    // if it was a toggle responsible, we leave it alone
-    deactivatedByToggle: {$ne: true},
-    $or: [
-      {inactive: true},
-      {deactivatedByAncestor: true},
-      {deactivatedBySelf: true}
-    ],
-  }, {
-    $unset: {
-      inactive: 1,
-      deactivatedByAncestor: 1,
-      deactivatedBySelf: 1,
-    },
-  }, {
-    multi: true,
-    selector: {type: 'any'},
-  });
-}

app/imports/api/creature/denormalise/recomputeInventory.js

@@ -1,111 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import nodesToTree from '/imports/api/parenting/nodesToTree.js';
-
-export default function recomputeInventory(creatureId){
-  let inventoryForest = nodesToTree({
-    collection: CreatureProperties,
-    ancestorId: creatureId,
-    filter: {
-      type: {$in: ['container', 'item']},
-    },
-    deactivatedByAncestor: {$ne: true},
-  });
-  let containersToWrite = [];
-  let data =  getChildrenInventoryData(inventoryForest, containersToWrite);
-  containersToWrite.forEach(container => {
-    CreatureProperties.update(container._id, {$set: {
-      contentsWeight: container.contentsWeight,
-      contentsValue: container.contentsValue,
-    }}, {selector: {type: 'container'}});
-  });
-  Creatures.update(creatureId, {$set: {
-    'denormalizedStats.weightTotal': data.weightTotal,
-    'denormalizedStats.weightEquipment': data.weightEquipment,
-    'denormalizedStats.weightCarried': data.weightCarried,
-    'denormalizedStats.valueTotal': data.valueTotal,
-    'denormalizedStats.valueEquipment': data.valueEquipment,
-    'denormalizedStats.valueCarried': data.valueCarried,
-    'denormalizedStats.itemsAttuned': data.itemsAttuned,
-  }});
-  return data;
-}
-
-function getChildrenInventoryData(forest, containersToWrite){
-  let data = {
-    weightTotal: 0,
-    weightEquipment: 0,
-    weightCarried: 0,
-    valueTotal: 0,
-    valueEquipment: 0,
-    valueCarried: 0,
-    itemsAttuned: 0,
-  }
-  forest.forEach(tree => {
-    let treeData = getInventoryData(tree, containersToWrite);
-    for (let key in data){
-      data[key] += treeData[key] || 0;
-    }
-  });
-  return data;
-}
-
-function getInventoryData(tree, containersToWrite){
-  let data = {
-    weightTotal: 0,
-    weightEquipment: 0,
-    weightCarried: 0,
-    valueTotal: 0,
-    valueEquipment: 0,
-    valueCarried: 0,
-    itemsAttuned: 0,
-  }
-  let childData = getChildrenInventoryData(tree.children, containersToWrite);
-  let node = tree.node;
-  if (node.type === 'container'){
-    data.weightTotal += node.weight || 0;
-    data.valueTotal += node.value || 0;
-    data.weightCarried += node.weight || 0;
-    data.valueCarried += node.value || 0;
-    storeContentsData(node, childData, containersToWrite);
-  } else if (node.type === 'item'){
-    data.weightTotal += (node.weight * node.quantity) || 0;
-    data.valueTotal += (node.value * node.quantity) || 0;
-    data.weightCarried += (node.weight * node.quantity) || 0;
-    data.valueCarried += (node.value * node.quantity) || 0;
-    if (node.equipped){
-      data.weightEquipment += (node.weight * node.quantity) || 0;
-      data.valueEquipment += (node.value * node.quantity) || 0;
-    }
-    if (node.attuned){
-      data.itemsAttuned += 1;
-    }
-  }
-  for (let key in data){
-    data[key] += childData[key];
-  }
-  if (node.contentsWeightless){
-    data.weightCarried = node.weight;
-  }
-  if (node.carried === false){
-    data.weightCarried = 0;
-    data.valueCarried = 0;
-  }
-  return data
-}
-
-function storeContentsData(node, childData, containersToWrite){
-  let newContentsWeight = childData.weightCarried
-  if (node.contentsWeight !== newContentsWeight){
-    node.contentsWeight = newContentsWeight;
-    node.contentsWeightChanged = true;
-  }
-  let newContentsValue = childData.valueCarried;
-  if (node.contentsValue !== newContentsValue){
-    node.contentsValue = newContentsValue;
-    node.contentsValueChanged = true;
-  }
-  if (node.contentsWeightChanged || node.contentsValueChanged){
-    containersToWrite.push(node);
-  }
-}

app/imports/api/creature/denormalise/recomputeSlotFullness.js

@@ -1,43 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-// n + 1 database queries + n potential updates for n slots. Could be sped up.
-export default function recomputeSlotFullness(ancestorId){
-  CreatureProperties.find({
-    'ancestors.id': ancestorId,
-    type: 'propertySlot',
-  }).forEach(slot => {
-    let children = CreatureProperties.find({
-      'parent.id': slot._id,
-      removed: {$ne: true},
-    }, {
-      fields: {
-        slotQuantityFilled: 1,
-        type: 1
-      }
-    }).fetch();
-    let totalFilled = 0;
-    children.forEach(child => {
-      if (child.type === 'slotFiller'){
-        totalFilled += child.slotQuantityFilled;
-      } else {
-        totalFilled++;
-      }
-    });
-    let spaceLeft;
-    let expected = slot.quantityExpectedResult;
-    if (typeof expected !== 'number'){
-      expected = 1;
-    }
-    if (expected === 0){
-      spaceLeft = null;
-    } else {
-      spaceLeft = expected - totalFilled;
-    }
-    if (slot.totalFilled !== totalFilled || slot.spaceLeft !== spaceLeft){
-      CreatureProperties.update(slot._id, {
-        $set: {totalFilled, spaceLeft},
-      }, {
-        selector: {type: 'propertySlot'}
-      });
-    }
-  });
-}

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

@@ -1,183 +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 { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.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}){
-  assertEditPermission(creatureId, userId);
-  if (experience.xp){
-    Creatures.update(creatureId, {$inc: {
-      'denormalizedStats.xp': experience.xp
-    }});
-  }
-  if (experience.levels) {
-    Creatures.update(creatureId, {$inc: {
-      'denormalizedStats.milestoneLevels': experience.levels
-    }});
-  }
-  experience.creatureId = creatureId;
-  let id = Experiences.insert(experience);
-  recomputeCreatureById(creatureId);
-  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 => {
-      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
-      }});
-    }
-    if (experience.levels) {
-      Creatures.update(creatureId, {$inc: {
-        'denormalizedStats.milestoneLevels': -experience.levels
-      }});
-    }
-    experience.creatureId = creatureId;
-    let numRemoved = Experiences.remove(experienceId);
-    recomputeCreatureById(creatureId);
-    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
-    }});
-    recomputeCreatureById(creatureId);
-  },
-});
-
-export default Experiences;
-export { ExperienceSchema, insertExperience, 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,212 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import Creatures from '/imports/api/creature/creatures/Creatures.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,
-  CompilationContext,
-  prettifyParseError
-} from '/imports/parser/parser.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}]};
-  }
-  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: {
-      variables: 1,
-      readers: 1,
-      writers: 1,
-      owner: 1,
-      'settings.discordWebhook': 1,
-      name: 1,
-      avatarPicture: 1,
-    }});
-    assertEditPermission(creature, this.userId);
-    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 rollContext = new CompilationContext();
-      let compiled = parsedResult.compile(creature.variables, rollContext);
-      let compiledString = compiled.toString();
-      if (!equalIgnoringWhitespace(compiledString, roll)) logContent.push({
-        value: roll
-      });
-      logContent.push({
-        value: compiledString
-      });
-      let rolled = compiled.roll(creature.variables, rollContext);
-      let rolledString = rolled.toString();
-      if (rolledString !== compiledString) logContent.push({
-        value: rolled.toString()
-      });
-      let result = rolled.reduce(creature.variables, rollContext);
-      let resultString = result.toString();
-      if (resultString !== rolledString) logContent.push({
-        value: resultString
-      });
-    } catch (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};

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

@@ -1,46 +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,
-  },
-  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;