/*
Undertricks are only linear when undoubled, so doubled and redoubled values are best stored in arrays. Since that accounts for four of six possible sets of undertrick values, I opted to create arrays for all six. We will see, when we look at down(), why this is useful. The names refer to non-vulnerable (nv) and vulnerable (v) for undoubled (0), doubled (x), and redoubled (xx) states.
*/

/*
While overtricks in undoubled contracts are each worth the same number of points as the trick taken before them, doubled and redoubled overtricks are not linear. Furthermore, the first trick over book in No Trump contracts is worth more than the rest, which is easy enough to code ; however, I chose again to go with arrays. Note that, as suggested earlier, these figures only apply to the tricks that taken in completion of a specified made contract. Overtricks are calculated later.
*/

/*
This final global variable lists all possible results of all possible contracts, from the 1 level to the 7 level. A 7-level contract can go down 13, and a 1-level contract can make six overtricks. The value of this will become clear in the first three functions.
*/

/*
I really like this one. The menu() function is called whenever the level is changed. It abbreviates a couple long addresses to information and defines selection to be equal to "7-(level-0)"; this second point allows it to set the new values and display "=" when it makes the change. Also, since the value attribute of an option element is seen as a text data type, and because there is no texttonum() function in Javascript, subtracting 0 is the only way to force the conversion of a number into the numeric data type without changing it.

The fun part comes next. It defines the text values (what the user sees) of the level menu, drawing its values from the ressulttext array above. By subtracting the level from a series of numbers beginning with 20 (the number of values in the array), it picks the proper text to display for each outcome. If you look at the .html file, you will see that the value for each position in the array remains constant, corresponding to the number of tricks won. Beginning with version (1.4), this is handled by a for() loop (2 lines) rather than individual statements for each option (14 lines).
*/

/*
The parent() function is the parent of the down() and made() functions. It decides which one gets called to calculate a score. It begins by defining five shorthand names for the values in the widget's menus. Once that is done, it asks whether the number of tricks taken (expressed as "result") is less than the number of tricks bid (expressed as "result < ((level-0)+6)"). If so, it calls the down() function, passing the necessary data to it; otherwise, it calls the made() function and passes those data it needs.
*/

/*
This one is pretty simple. It uses a series of conditional statements to check the vulnerability and doubled status of the contract so it can determine which of the undertrick arrays to use. It then writes the proper value to a blank div tag in the .html file via document.getElementById.

The reason for subtracting 5 from the result is simple. First, remember that Javascript arrays begin with element number 0. Now, since the level is the number of tricks above 6 declarer must win, we need to reduce the result (which looks at total tricks taken) by 6. However, since a contract going down by one trick needs to address array element 0, we need to subtract a larger number from the level, hence we subtract 5 from result, instead of subtracting 6.
*/

/*
The made() function first looks at the value of the denomination selection to determine which of the "bidtrick" arrays to use (minor, major or nt), assigning the value to the local "den" variable. It then runs through a check of the doubled status to determine whether to award straight points, double points, or quadruple points for the tricks that apply to the level of the contract. This is the base score for a making contract. Note that once again we need to reduce the value (this time of "level") by one because arrays begin with element 0.

It then determines how many overtricks were taken and computes, based upon the denomination (if undoubled) or the doubled status, what multiplier to apply. The joy here is that 0 overtricks returns the proper result, so it is not necessary to determine first whether or not a made contract included any overtricks. With a little poking about, you can see how the multipliers work.

The next two steps involve determining what bonuses to apply for part score, game, and slam. In duplicate bridge, even a making part score earns a bonus. A slam or grand slam also earns the bonus for the underlying game, so these get calculated separately.

The last component of score is the bonus for making a doubled or redoubled contract, worth 50 and 100 points, respectively. This is unaffected by the level or denomination.

Finally, it adds all five values together and assigns them to that blank div tag we saw mentioned in down().
*/

/*
The remainder of these functions are supplied by, at least in their basic form, Apple. Only two are different enough to deserve much more comment than Apple already provides, however. Zip on down to see why.
*/

/*
This next function is a modification of Apple's standard menu display code. Since I have four menus that just require the basic code, I wanted a way to call the same function for all four instead of using the older method of having four distinct functions.

In order to accomplish this, I added one argument ("text") to the function and used it to pass the information about which menu's information to display, which was the only piece of information that wasn't being passed using "this" in the original version.
*/

/*
First of all, because I chose to use the suit symbols instead of letters, I had to encode the document as UTF-8 (TextWrangler does a nice job of recognizing and managing this). Without that step, the suits would be gibberish. It's all well and good that Apple shows me how I can make these cool menus, but I love that I can also exercise full control of the display because of how it is set up.

Since what the user sees when a menu is not active is being handled by filling a div tag, the same way we did with the score, we have control over every aspect of the displayed text. Suit symbols are smaller than normal characters, so normally "NT" looks disproportionately large. The solution is to specify the positioning, font-family, color, and size for each possible result. This allows the menu to make the most of its space without tripping over symbols that render differently. Note that everything must be specified every time; otherwise, the unchanged parameters will carry over, which could have unintended results.
*/