When you edit a value in one of the defenses popovers, it doesn't always correctly update the calculated value. Refreshing will fix it; however, it doesn't always apply the change when you refresh.

Sometimes it's only one field that breaks, other times it's multiple. Once a field 'breaks' it will never start updating again.

I've been investigating this, and it stumps me. It will need more investigation.
@Gissues:{"order":78.57142857142858,"status":"backlog"}

I should be able to mark how many times I've used a given power, if it supports multiple uses.

One complication is what if the multiple uses come from a feat? How do we tell that?

We need the paragon paths from the other database.

This is a data conversion task. All data conversion tasks involve moving data from the old sql databases into the new mongodb one, and are likely to involve custom script work. They will result in no code, and no visual changes to the application, but are required to get data into the new system.

We need to convert from the Mongoose/MongoDB database to the Omega Models DB abstraction layer. Not only is it easier to work with, but it means that we don't have to change again, since it supports multiple database backends.

Class feature power Distract could not be added, nor could send thoughts.

Send thoughts eventually worked...

Add popovers to the dnd character sheet, explaining how the number was calculated.

For example, If you clicked on your REF defense, a popover would show up that would have:

+-------------------/\------------------+
|         1/2LVL   MOD    FEAT          |
|    10 + | 6 | + | 5 | + | 2 | = 23    |
+---------------------------------------+

In some cases, this would also allow you to edit the values (Misc bonuses, and things like that.)

On the DnD4e character sheet page, add the ability to create/edit 'attacks'; basically named die rolls with bonuses pre-calculated for you.

The reason this isn't simply a named die roll is because we want to store the attack and the damage together, in an easy to view manner.

Must include:

• Name
• Attack roll (with an input field for situational bonus/penalty)
• Damage roll (with an input field for situational bonus/penalty)
• Ability to see where your attack/damage bonus came from

Update:

Here's an initial layout for an 'attack':

When user is logged in, they are able to access all characters created by any other user, as well as edit them.

After creating a new character, the user is redirected to the system's character sheet page. We should pop a dialog for new characters, and allow the user to fill in all the 'creation time' information that's required.

Implement a dialog to give the player the ability to level up their character. It will allow editing of:

• Level
• Feats
• Powers
• Paragon Path
• Epic Destiny
• Attributes

It will also provide a reference for what you get at each level, but not force you into that.

Implement a dice parser for rolls, which has support for wildcards, pulling from attributes, etc.

I highly recommend using LordNull's parser:

• https://github.com/lordnull/dicer/blob/master/public/dice.peg
• https://github.com/lordnull/dicer/blob/master/public/dice.parse.js
• https://github.com/lordnull/dicer/blob/master/public/dice.eval.js

From there, it should be easy to implement dice rolling in the rest of the application.

Implement the list on the side of all powers associated with a character. This will need to include:

• Racial Powers
• Powers from Feats
• Powers from Class Features (including sub-features and choices)
• Chosen Powers
• Powers from Equipment.

At least give an error or indication that's what's wrong.

Currently the data model for Race doesn't have a place to enter ability bonuses that are part of the race.

User able to change a defense value once, then it seems the socket connection drops as they are unable to get the calculated value to update. Reload of the page fixes it.

We needs scripts that use mongoexport and mongorestore to dump/load the mongo database. See this for reference.

What we will need is everything in the dnd4e database, except the characters collection. Eventually we'll also need the Savage Worlds database, but not until #23 is complete.

Currently, a very simple export script has been written, and is in the db directory.

Need to implement user, group, and permissions as Mongoose models in order to do the conversion talked about in #4.

As a step towards that, implement a user model, a group model, and a permissions model, and then convert the authentication code to use them instead of sequelize.

We need the Epic Destinies from the other database.

This is a data conversion task. All data conversion tasks involve moving data from the old sql databases into the new mongodb one, and are likely to involve custom script work. They will result in no code, and no visual changes to the application, but are required to get data into the new system.

Currently, there's no way for a user to upload a portrait for their character when they create one.

This should have the ability to upload files, and give the user a nice bit of feedback about the upload.

While working on adding a character, the user us unable to get armor to update. Reloading the page brought an error stating the character could not be found. Logged out, then back in, and character was not in the list.

Character's name: Zehir. Id: 7sNSX6eqNGmDdNB2

This caused an unexpected loss of work.

On the Powers/Feats/Equipment tabs, there's two buttons: Expand and Collapse. These should expand or collapse the currently shown tab's items (ex: powers).

The toughness feat adds 5, 10, or 15 hitpoints, depending on character tier. We need a way of recording that this has been taken, somehow, even if it's just a feat bonus used when calculating hitpoints....

If the section text starts with a newline, that new line is stripped. This can make some undesirable formatting, particularly for augment powers or other powers with a section that has subsections.

Example:

Augment 1
Hit: As above , but you push the target a number of squares
equal to your Charisma modifier. In addition, .until the end of your next turn, if you or any of your allies pulls, pushes, or slides the target, the forced movement increases by 1 square.

Becomes:

Augment 1 Hit: As above , but you push the target a number of squares
equal to your Charisma modifier. In addition, .until the end of your next turn, if you or any of your allies pulls, pushes, or slides the target, the forced movement increases by 1 square.

Currently Class Features are shown as Feats, with no indication they aren't. Instead, we need to use a heading in that list, and display both separately:

  +-------+
 /  Feats  \ 
+--------------------------+
|   Class Features         |
|  ------------------      |
|  Some Feature            |
|  Another Feature         |
|  etc...                  |
|                          |
|   Feats                  |
|  -------                 |
|  Some Feat               |
|  Another Feat            |
|  etc...                  |
+--------------------------+

The data models we end up working with are so complex, doing things with SQL simply isn't possible Sequelize is alright, but has sever big downsides. Mongoose, on the other hand, is more straightforward, and while not perfect, is much cleaner to work with.

Currently DnD4e uses mongoose, to great effect.

We need to implement an equipment system.

This is a placeholder till I design the system.
@Gissues:{"order":85.71428571428572,"status":"backlog"}

If the project is converted to using less instead of css, then we can take advantage of the mixins provided by bootstrap, write our own mixins, and make our css classes much more semantic, instead of complicated looking.

Check out this blog post for the rational: http://ruby.bvision.com/blog/please-stop-embedding-bootstrap-classes-in-your-html

When the last conversion was done, many/most of the classes converted did not get the powers granted by the features added to the features themselves. These powers need to be added back on the class features.

This is a data conversion task. All data conversion tasks involve moving data from the old sql databases into the new mongodb one, and are likely to involve custom script work. They will result in no code, and no visual changes to the application, but are required to get data into the new system.

Reflex incorrectly calculated for character sNlgxzDY4P42cWCc.

Create an editable directive that toggled contenteditable on the element. It would also bind the contents to a model. It should work like this:

<h1 editable="title">Page Title</h1>

(This would bind the contents of the h1 to the title model.)

When the element was clicked, it would bring up a floating toolbar that had various editing tools (like a wysiwyg editor), a commit/save button and a revert/cancel button. This toolbar should float above the element, and only be about 20 - 30px high. It's tools would be determined by the type of editable this was. In order to hint that, we need a second directive that requires the first, and sets the type. It should work like this:

<h1 editable="title" type="text">Page Title</h1>

The types supported should be:

• text (default; a wysiwyg text editor)
• choice (only gives a few possible choices)
• integer (provides validation that it's an integer?)
• popup (instead of an editor, shows an entire form, in a popup would use css classes to determine direction (i.e. "popup-left", "popup-right")

Currently we're using a die parser that was written with RPGKeeper in mind. However, it turns out that we want to know more from a roll than we currently get.

With that in mind, this is a proposal for our "perfect" die parser.

Syntax

The intention is to keep the current syntax, with minor additions:

Example:

3d6 + [ wisdomMod ] + 3(4w10 + [ halfLevel ] + 2) - 2

The only addition is that of the parenthesis and multiplier. Here's what we'd like the output of the parser to look like, for that:

{
    rolls: [
        {
            mult: 1,
            die: {
                sides: 6,
                mult: 3,
                bonuses: [],
                wild: false
            }
        },
        {
            mult: 3,
            die: {
                sides: 10,
                mult: 4,
                bonuses: [6, 2],
                wild: true
            }
        }
    ],
    bonuses: [3, -2]
}

This output should give us enough to do any analysis on the rolls we want, plus easily write code to perform the roll.

It should be noted that in the output, the variables are resolved. This may not be possible, in which case, they would simply be functions that take a context, and in order to get the correct output, we would need to run through a simple transform that replaces them.

When making a new Savage Worlds character, it blows up because the app totally expects to have found a savage worlds character related to the base character. Since on new characters those don't exist, we need to make a new one instead.

SavageWorlds contains the last bit of sequelize code; it needs to be converted to mongoose/mongodb.

Currently, powers are ordered At-Will, Daily, Encounter. It should be At-Will, Encounter, Daily.

It would be very useful if we informed players what the ability bonus from the race they chose was when they were assigning their ability scores.

We could automatically add them, if we store the information correctly.

The project structure is a little messy; it could stand to be cleaned up a bit. Currently, we have the following:

├── client
├── db
├── lib
├── systems
│   ├── dnd4e
│   ├── dnd4e_simp
├── templates
└── vendor

What I would like to change to, is this:

├── client
│   └── vendor
├── server
│   ├── db
│   ├── lib
│   └── templates
└── systems
    ├── dnd4e
    └── dnd4e_simp

I feel this is just cleaner, and more expected.

We need a simple upstart job written for rpgkeeper; it should use grunt watch instead of simply using npm start, as then I can update the application without having to restart it.

Powers need to be converted from the old rpgkeeper's db dump, to the new one's.

This is a data conversion task. All data conversion tasks involve moving data from the old sql databases into the new mongodb one, and are likely to involve custom script work. They will result in no code, and no visual changes to the application, but are required to get data into the new system.

When you delete a character, the base character is removed, however the system is never informed, and therefore never removes the system character.

Calculations need to be performed client side; not server-side. Currently, there are several fields which get their value from properties in the db-layer; this needs to change to client-side calculations.

We probably need a separate controller for the character; this shouldn't be hard to implement.

This should address, or otherwise help #43 and #44.

Currently, the character sheet layout is terrible on small screens, and also just plain doesn't look that good.

We need to get off of showdown; it's slow, and has buggy gfm support (and its table support is broken.)

I suggest we switch to marked, which I've used server-side and it just works.

This may help with #46.

We need to convert the feats from the old data.

This is a data conversion task. All data conversion tasks involve moving data from the old sql databases into the new mongodb one, and are likely to involve custom script work. They will result in no code, and no visual changes to the application, but are required to get data into the new system.

We need to actually populate the language field when we get a list of characters. Once that's done, then you can then display the language in the new char dialog.

Error Text:
Encountered an error while updating system specific character: TypeError: Cannot use 'in' operator to search for '_id' in Fey Pact

Class selected: Warlock
Race selected: Changeling

We are being informed when the base character is deleted, but we are not currently removing it from mongo. This should be a very simple fix.

Currently systems are trying to us the base angular application, but this causes issues with loading modules, controllers, etc. Instead, convert to sub-applications.

This should greatly clean up the code.

The current dnd4e system has been supplanted by dnd4e_simp. It needs to be removed; and we need to rename dnd4e_simp to just dnd4e.

I should be able to mark a power as used. This should propagate to the database. If a power allows more than one use; then I should be able to mark multiple uses.