rpitv / scoreboard Goto Github PK

There have been several errors during live productions because the wrong sport is configured. Need to build a mechanism for keeping track of sport configuration data (clock settings, strings - manup/powerplay/whatever it's called, and anything else we might think of)

For example, open up two scoreboard tabs. Set (e.g.) a delayed penalty in one. Set (e.g.) empty net in the second one. It goes nuts! This is because these actions fire off two PUT requests in rapid succession. In the second tab, the first PUT request fails with a conflict, but meanwhile the second one has already been initiated, and the data serial number has now been incremented by two (resulting in the server accepting it).

Basically, we need to check that the server dataSerial is <= the client dataSerial before incrementing the client dataSerial and doing a PUT request. If it is not, then we may not even try to increment the dataSerial, because we are already in an invalid state.

It might be a thing in the RTD feed. Check a dump and see if it's in there.

By using the team status field for empty net status, the empty net hooks in the penalty logic no longer work. This is a situation that happens more often than one would think, so this should be fixed.

Having one input for text is limiting to what can be done, especially with the 'announce' functionality. 'Announce' is difficult to use because the current UI configuration doesn't properly allow for message queueing as originally intended. 'Announce' also needs to work very quickly (e.g., after a goal scored), and the current UI is to clunky to allow it. Future templates may also allow both a 'status' and an 'announce' to be displayed simultaneously.

On the 'announce' side of things, I propose creating a front end queue on top of the back end 'announce' queue that would allow the user to organize a series of announcements, then send them to be displayed, rather than the current race to type in the next announcement before the current announcement fades away. This opens up the UI to better feedback as to which announce status is currently up, repeating announcements, and pausing announcements among other potential improvements.

Currently, it's impossible to reconfigure scoreboard synchronization without editing scoreboard_server.rb. This needs to change.

The play clock "display" and "clear" buttons do not function as intended. This is because the event handler calls a function postStatus(), which no longer exists (was renamed in commit 931bfad).

The parser captures the data correctly, but it doesn't go into the scoreboard.

Now that we have RTD sync and know the ball position at all times, we should have a button to calculate the distance of a field goal attempt and show something like "45 yard FG attempt".

There is no front-end indication of successful sync. The various sync toggles will indicate whether sync is on or off, but when on, there is no confirmation of actual synchronization. There are obviously limitations based on what each hardware sync device is capable of, but I believe there should be enough information from each to determine sync status.

During a normal production, this likely wouldn't be an issue because the scoreboard is being watched by enough eyes to identify an issue, but for smaller crew productions, especially single cams, the sync failure may go unnoticed for periods of time, if there is no apparent 'error.'

Unfortunately, this may not be the easiest thing in the world to implement in the current design.

The play clock (possibly down and distance as well) should automatically disappear when play starts. It should be possible to detect this in most cases by observing when the play clock increases. (While play is pending, the play clock is likely to increase only in very rare circumstances - e.g. a penalty or timeout situation.)

This could be used to switch the clock to FINAL and hide any penalties, for example.

When the scoreboard is under a minute and switches to tenths of a second, the fixed-width numerals are shaky. It seems to shake on the ".1," but 1s when the scoreboard is counting by second (rather than by tenth of a second) don't pose an issue.

While investigating #41 I discovered we have a bit of a consistency issue with function names. Some functions are "active voice" (verb-noun - e.g. postGlobalStatus, putGameState) while others are "passive voice" (noun-verb - e.g. fieldGoalDisplay, ddDisplay). Some don't even have a verb (e.g. ytgCustom) Since it's rare in English for the object of a verb to come before the verb, I would recommend that we change these to the verb-noun style (e.g. "displayFieldGoalAttempt", "displayDownDistance") or add a verb if needed (e.g. setCustomYtg).

If we tackle this soon we should do it in a branch and test thoroughly because making changes like this could break all kinds of things.

If there is a penalty on both teams, and I give one of them an empty net, it says power play. This is a 5 on 4, but not a power play.

Maybe say something like Empty Net - M on N, while highlighting the team with the empty net.

prevents mixups with score sync data

In current version; period and time is submitted as one package. Would be useful if you could do them independently so 1) you only have to edit one thing and 2) you don't accidentally screw the other one up.
Also useful in sports that don't require time, but require period (e.g., baseball)

The ability to change the remaining time of a penalty (one already created) would allow easier correction of errors. It is currently too difficult to properly correct a penalty if it wasn't set correctly within the stoppage window.

e.g. a team is on the power play and I put in a status, the status goes up but the team on the PP remains highlighted. This looks bad. Should probably be fixed in the template.

This is useful for title generation outside of the scoreboard system.

The current penalty queue system isn't very flexible. First, it can't adapt easily to changing game rules, such as the number of penalties being served at once. Also, it doesn't really play nice with the format used by the RTD sync feed. Using a single queue for all penalties could eliminate some of these issues, but might introduce new ones.

In refactoring this, I'd like to avoid putting timers into the team state if possible. Perhaps individual penalties should have a time-assessed field, instead of that being a property of the queue. It's pretty easy to back out a time assessed from the RTD feed, so that might be the way to go.

It may be worth calculating tenths of a second between the last RTD time message and either now or the most recent "stop" message to allow penalty timers to be precise to the nearest tenth.

Occasionally, scoreboard data feeds do not provide data to within 1/10 second during the last minute of play. This is a problem, because the on-screen scoreboard always displays the tenths even if they are not counting. Interpolating from the clock feed might be possible but will be a lot of work and might result in glitches if the scoreboard doesn't give us a run/stop flag. Adding an option to just disable the display should work well and be easy to implement.

This data is in the RTD feed, so we should grab it and use it.

Corresponds directly to rpitv/rpits#93.

Basically just abstracting out what we have now to be the 'default' template and providing a way to choose between them. I don't see this being as important for scoreboard as it would be for titles, but it could be useful for both programs.

click display with clock, then hit neutral flag to see the play clock disappear during the fade

For example, the value in the score text box is 0 and autosync sets score to 3. If the possession button is then clicked, it goes back to zero if that is the value in the text box.

It's currently a mess.

Instead of being hard-coded, this needs to come from the sport data. The way it works now results in persistent screw-ups in productions, especially at the beginning of hockey season.

Instead of pulling from multiple URLs when updating, a single JSON file would allow for everything to be easily tied to the success/failure of pulling it.

In football, if the ball is turned over in the last 10 yards of the field, the down/distance logic considers the resulting first down to be "First and Goal". This is incorrect.

A possibly related issue: possession does not appear to be getting synced from the Daktronics feed.

Without knowing this data, it's impossible to detect the end of the game. Thus, this blocks fixing #27.

Include sport in the saved data stream so that a sport doesn't need to be selected each time the UI is loaded.

Add a better indication of which sport is selected (currently only shown in page title)

Commit 6490477 causes 'empty net' to respond differently when toggled and is not switched off when all other statuses are cleared.

Sometimes the scoreboard doesn't know what sport is being scored. This leads to awkward situations where we have power play timers up with no descriptive phrase, but a big blank space where it should be.

I pushed the clear penalties button and a dialog box came up. Pushing the button did nothing. Afterwards, the clear penalties button disappeared completely. WTF??

If the user enters data into a field, but does not click out of the field; shortcuts do not work and can result in undesirable characters be entered into the scoreboard. A 10-15 second timer to auto-blur the field should resolve this.

I feel that the addition of keyboard shortcuts (if possible) would allow for quicker and more accurate scoreboard operation. A quick example could be using space bar to bring up and down the scoreboard (similar to the graphics implementation).

Teams have preset, toggle-able statuses. If a timeout is called for a team, 'Timeout' is toggled and it is shown as the team status. If, during that timeout, a flag is thrown on the team taking a timeout, 'Flag' is toggled and is shown as the team status. When the infraction is resolved and 'Flag' is unchecked, the front-end looks for the next status (if there is one), which in this case is 'Timeout,' and 'Timeout' is once again shown as the team status.

Go back to 'Timeout' being checked, followed by 'Flag' being checked. If the user uses the custom status field to announce the (e.g., holding) penalty, 'Holding' becomes the team status. The issues occur when trying to clear the custom status only.

Issues:

• Pressing the 'Clear' button to erase a custom team status also clears preset statuses
• Manually deleting (backspacing, etc.) a custom team status, leaves the preset statuses ('Timeout' and 'Flag' in this case) as checked, however, no status is shown for the team, creating UI confusion.

Possible Solutions:

• When the custom status is changed to '' (blank), all team statuses are unchecked (probably not desired)
• Add a second 'Clear' button for only the custom status which will properly trigger the next team status to display (likely to create confusion with multiple 'Clear' buttons)
• Entering a custom team status creates a temporary new toggle-able button with that status. When unchecked, the button disappears and the front-end reacts as it normally would with the toggling of a preset status button.

(Empty Net is not affected by this because it uses different code to calculate team strength for man-up/powerplay)

We need a button that just brings up the FLAG text without highlighting either team. This existed at one point but is now broken.

This is an issue that appeared before and was fixed by @asquared but unintentionally reverted somewhere along the line.

When the graphics program is started the scoreboard defaults to "up." This can lead to undesired results (as seen in curling). Default should be down, not last state, because scoreboard may lose sync feed or display other undesired content when restarted.

If the up or down buttons are clicked while a transition is already in progress, the transition is interrupted and starts again from the beginning. This is problematic, because it is easy to click the button twice by accident.

Sometimes, the scoreboard console sends a different type of down/distance data than what we can currently parse. This may happen when the "BALL ON" button is used instead of "+1 DOWN" and "YARDS TO GO"

Right now, it's not easy to tell when the play clock is relevant. Let's add it to the UI so we know exactly when to hit the button to show it.

This is because the various status buttons are implemented as checkboxes. After clicking a status the checkbox becomes in focus and the spacebar press will toggle the checkbox.

This could be fixed by either removing the binding on checkboxes or by forcing the box to lose focus after it is toggled.

If there was a power play while in hockey mode, switch to football. At this point you can't get rid of the power play, without switching back to hockey mode.

When changing sports, it should automatically get rid of things that can't happen.

If not in football, the dot next to team (possession) shouldn't be a thing.
If not in hockey, power play should not be a thing.