Please enable JavaScript.

Coggle requires JavaScript to display documents.

Dice Sorting (Current Method (OLD BS) (Scoring 6 dice (comparing each…

- - - - Is it counting every 5 & 1, regardless of whether that # is in a single/triple/etc?
- - - - When a die is clicked and then banked, those dice will be inserted into this new list
    - - A While loop is probably for the best
        
        Take the number value at the first index, then start a new nested loop
        
        This can be any loop type
        
        This one will go from back to front of the list (last to first position)
        
        Since the list is in order, we will start at the end and work forward to find the index of the 'last' occurrence of the same number that is in the first index.
        
        Now, with this index, we know how long a 'chain' of matches exists at the front of the scoring list
        
        Store the 'length' of the match as a variable. Will be handy.
        
        'length'/number of matches = (index of last duplicate)
        aka, finding a match at index 3 should mean there is a triple.
        
        The While-check will start every 'step' of the loop by asking for the condition
        
        Condition: while list size is greater than 0 (because presumably, you can ask that without causing an error)
        
        Use if statments to sort from here
        
        if (number of matches found) == 5.
        if (number of matches found) == 4.
        if (number of matches found) == 3.
        if (number of matches found) == 1.
        
        no need to check for 2 length, as that never counts for score.
        
        Here is also a spot for error checking the user's selection. For instance, selecting a single 4 or a pair of something. Probably, the easiest way to do so is to throw the error to the user and have them restart the selection/scoring.
        
        Ugh, but this would mean that the 'reset' would need to change back to the dices' states before you clicked save. Since my current flow-chart for the save button doesn't include the ability to 'go back', that would have to be added.
        
        Perhaps the best way to do this is literally saving a 'backup-list' of the dice values and their enabled/disabled state. Maybe that means two lists (one for values, one for state).
        
        Examples of detection:
        
        on 'length 1', you then need to check if the value is a 1, or a 5.
        
        for error checking (see below): If neither of those is true, the 'else' will be returning the error for a 'wrong dice' being selected
        
        add the appropriate score
        
        on the check for triples, the score can be calculated by multiplying the dice number value by 100.
        
        when doing this, 1s are not accounted for, but the score for 3 ones is the same as multiplying it, so it works out.
        
        Now that we're done with this segment of matches, remove them from the list
        
        Using the 'length' we have stored, start taking out values from the front of the list
        
        simple loop, whatever type. Loop a number of times equal to the 'length'
        
        each time through the loop, take out index 1 of the list
        
        Remember Karate bot?
        
        While Loop repeats, removing and scoring all values.
      - FIRST: Use existing logic for matches of ALL SIX DICE
        
        Again, this is for only if all 6 dice are selected/'freshly banked'
        
        Do the check and add appropriate score. Then:
        
        If a 6-combo was found, empty the list and move on.
        
        if no combo found, continue as normal to below
      - There doesn't need to be a triple-check for matching 1's.
        
        wtf is that about?
        
        Fuck math
      - FIRST FIRST: Sort the list
      - Farkle checks.
        
        Just run the algorithm to the right for all 'un-banked'/new dice from the roll. If the result for the 'scoring' procedure is zero, then it's a farkle.
        
        Therefore, it migh be good to take the scoring algorithm and have it add to a 'temp-score' value, that can be checked for farkle checks, and separately added to the real score variable for actual scoring
      - All done. Do with the temp-score variable as you will, if that's been implemented. Otherwise, the score is already set.
  - - - Check all dice for if they are selected selected
        
        Use Loop to go through all dice
        
        If selected, is this die also not currently banked, aka, selected before this turn?
        
        If so, append this die's value to the list used for scoring
        
        Then disable/change the 'already banked' variable for the die
        
        If not, move onto the next die
        
        Once all that's done, are all the dice currently selected/disabled/banked?
        
        If yes, then ~Hot dice~
        
        Reset all dice to be enabled and/or un-banked
        
        This may need to happen in the 'Roll' button, since it needs to be done on roll
        
        Alternatively, a variable flag could be used. Boolean 'hotDice' or something similar
        
        Use loop again to check all dice
        
        If no, then allow the next selection and roll as normal
      - Check that at least 1 die was selected before continuing
        
        This is also where a check could be done to see if the farkle has happened.
        
        Farkle checks will likely be identical to the scoring algorithm, but will simply make sure the returned result for all six dice is not zero.
      - (optional backup location for user-error detection. See bright red notes on far right of algorithm section
    - - Dice Variables
        
        'Disabled', or an 'Not-banked-this-turn'/'already banked' variable
        
        On-click function
        
        Forbid de-selection 'by hand' if the die has been banked previously. Use if statement and above-mentioned variable.