From 61478149ed92d293b4e11f08f3844ebb3c625adb Mon Sep 17 00:00:00 2001 From: Bastiaan Veelo Date: Sun, 16 Jan 2022 13:47:43 +0100 Subject: [PATCH] Add D version of War (94). --- 94_War/d/.gitignore | 2 + 94_War/d/README.md | 125 ++++++++++++++++++++++++++++++++++++++++++++ 94_War/d/war.d | 80 ++++++++++++++++++++++++++++ 3 files changed, 207 insertions(+) create mode 100644 94_War/d/.gitignore create mode 100644 94_War/d/README.md create mode 100644 94_War/d/war.d diff --git a/94_War/d/.gitignore b/94_War/d/.gitignore new file mode 100644 index 00000000..d969f6b2 --- /dev/null +++ b/94_War/d/.gitignore @@ -0,0 +1,2 @@ +*.exe +*.obj diff --git a/94_War/d/README.md b/94_War/d/README.md new file mode 100644 index 00000000..2bc48a12 --- /dev/null +++ b/94_War/d/README.md @@ -0,0 +1,125 @@ +Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html) + +Converted to [D](https://dlang.org/) by [Bastiaan Veelo](https://github.com/veelo). + +## Running the code + +Assuming the reference [dmd](https://dlang.org/download.html#dmd) compiler: +```shell +dmd -preview=dip1000 -run war.d +``` + +[Other compilers](https://dlang.org/download.html) also exist. + +## Specialties explained + +This game code contains some specialties that you might want to know more about. Here goes. + +### Suits + +Most modern consoles are capable of displaying more than just ASCII, and so I have chosen to display the actual ♠, ♥, ♦ +and ♣ instead of substituting them by letters like the BASIC original did. Only the Windows console needs a nudge in +the right direction with these instructions: +```d +SetConsoleOutputCP(CP_UTF8); // Set code page +SetConsoleOutputCP(GetACP); // Restore the default +``` +Instead of cluttering the `main()` function with these lesser important details, we can move them into a +[module constructor and module destructor](https://dlang.org/spec/module.html#staticorder), which run before and after +`main()` respectively. And because order of declaration is irrelevant in a D module, we can push those all the way +down to the bottom of the file. This is of course only necessary on Windows (and won't even work anywhere else) so +we'll need to wrap this in a `version (Windows)` conditional code block: +```d +version (Windows) +{ + import core.sys.windows.windows; + + shared static this() @trusted + { + SetConsoleOutputCP(CP_UTF8); + } + + shared static ~this() @trusted + { + SetConsoleOutputCP(GetACP); + } +} +``` +Although it doesn't matter much in this single-threaded program, the `shared` attribute makes that these +constructors/destructors are run once per program invocation; non-shared module constructors and module destructors are +run for every thread. The `@trusted` annotation is necessary because these are system API calls; The compiler cannot +check these for memory-safety, and so we must indicate that we have reviewed the safety manually. + +### Uniform Function Call Syntax + +In case you wonder why this line works: +```d +if ("Do you want instructions?".yes) + // ... +``` +then it is because this is equivalent to +```d +if (yes("Do you want instructions?")) + // ... +``` +where `yes()` is a Boolean function that is defined below `main()`. This is made possible by the language feature that +is called [uniform function call syntax (UFCS)](https://dlang.org/spec/function.html#pseudo-member). UFCS works by +passing what is in front of the dot as the first parameter to the function, and it was invented to make it possible to +call free functions on objects as if they were member functions. UFCS can also be used to obtain a more natural order +of function calls, such as this line inside `yes()`: +```d +return trustedReadln.strip.toLower.startsWith("y"); +``` +which reads easier than the equivalent +```d +return startsWith(toLower(strip(trustedReadln())), "y"); +``` + +### Type a lot or not? + +It would have been straight forward to define the `cards` array explicitly like so: +```d +const cards = ["2♠", "2♥", "2♦", "2♣", "3♠", "3♥", "3♦", "3♣", + "4♠", "4♥", "4♦", "4♣", "5♠", "5♥", "5♦", "5♣", + "6♠", "6♥", "6♦", "6♣", "7♠", "7♥", "7♦", "7♣", + "8♠", "8♥", "8♦", "8♣", "9♠", "9♥", "9♦", "9♣", + "10♠", "10♥", "10♦", "10♣", "J♥", "J♦", "J♣", "J♣", + "Q♠", "Q♥", "Q♦", "Q♣", "K♠", "K♥", "K♦", "K♣", + "A♠", "A♥", "A♦", "A♣"]; +``` +but that's tedious, difficult to spot errors in (*can you?*) and looks like something a computer can automate. Indeed +it can: +```d +static const cards = cartesianProduct(["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"], + ["♠", "♥", "♦", "♣"]).map!(a => a.expand.only.join).array; +``` +The function [`cartesianProduct`](https://dlang.org/phobos/std_algorithm_setops.html#cartesianProduct) takes two +ranges, like the horizontal and vertical headers of a spreadsheet, and fills the table with the combinations that form +the coordinates of the cells. But the output of that function is in the form of an array of +[`Tuple`](https://dlang.org/phobos/std_typecons.html#Tuple)s, which looks like `[Tuple!(string, string)("2", "♠"), +Tuple!(string, string)("2", "♥"), ... etc]`. [`map`](https://dlang.org/phobos/std_algorithm_iteration.html#map) +comes to the rescue, converting each Tuple to a string, by calling +[`expand`](https://dlang.org/phobos/std_typecons.html#.Tuple.expand), then +[`only`](https://dlang.org/phobos/std_range.html#only) and then [`join`](https://dlang.org/phobos/std_array.html#join) +on them. The result is a lazily evaluated range of strings. Finally, +[`array`](https://dlang.org/phobos/std_array.html#array) turns the range into a random access array. The `static` +attribute makes that all this is performed at compile-time, so the result is exactly the same as the manually entered +data, but without the typo's. + +### Shuffle the cards or not? + +The original BASIC code works with a constant array of cards, ordered by increasing numerical value, and indexing it +with indices that have been shuffled. This is efficient because in comparing who wins, the indices can be compared +directly, since a higher index correlates to a card with a higher numerical value (when divided by the number of suits, +4). Some of the other reimplementations in other languages have been written in a lesser efficient way by shuffling the +array of cards itself. This then requires the use of a lookup table or searching for equality in an auxiliary array +when comparing cards. + +I find the original more elegant, so that's what you see here: +```d +const indices = iota(0, cards.length).array.randomShuffle; +``` +[`iota`](https://dlang.org/phobos/std_range.html#iota) produces a range of integers, in this case starting at 0 and +increasing up to the number of cards in the deck (exclusive). [`array`](https://dlang.org/phobos/std_array.html#array) +turns the range into an array, so that [`randomShuffle`](https://dlang.org/phobos/std_random.html#randomShuffle) can +do its work. diff --git a/94_War/d/war.d b/94_War/d/war.d new file mode 100644 index 00000000..d5a453fa --- /dev/null +++ b/94_War/d/war.d @@ -0,0 +1,80 @@ +@safe: // Make @safe the default for this file, enforcing memory-safety. +import std; + +void main() +{ + enum width = 50; + writeln(center("War", width)); + writeln(center("(After Creative Computing Morristown, New Jersey)\n\n", width)); + writeln(wrap("This is the card game of war. Each card is given by suit-# " ~ + "as 7♠ for seven of spades. ", width)); + + if ("Do you want instructions?".yes) + writeln("\n", wrap("The computer gives you and it a 'card'. The higher card " ~ + "(numerically) wins. The game ends when you choose not to " ~ + "continue or when you have finished the pack.\n", width)); + + static const cards = cartesianProduct(["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"], + ["♠", "♥", "♦", "♣"]).map!(a => a.expand.only.join).array; + const indices = iota(0, cards.length).array.randomShuffle; + int yourScore = 0, compScore = 0, i = 0; + while (i < indices.length) + { + size_t your = indices[i++], comp = indices[i++]; + writeln("\nYou: ", cards[your].leftJustify(9), "Computer: ", cards[comp]); + your /= 4; comp /= 4; + if (your == comp) + writeln("Tie. No score change."); + else if (your < comp) + writeln("The computer wins!!! You have ", yourScore, + " and the computer has ", ++compScore, "."); + else + writeln("You win. You have ", ++yourScore, + " and the computer has ", compScore, "."); + if (i == indices.length) + writeln("\nWe have run out of cards. Final score: You: ", yourScore, + ", the computer: ", compScore, "."); + else if (!"Do you want to continue?".yes) + break; + } + writeln("\nThanks for playing. It was fun."); +} + +/// Returns whether question was answered positively. +bool yes(string question) +{ + writef!"%s "(question); + try + return trustedReadln.strip.toLower.startsWith("y"); + catch (Exception) // readln throws on I/O and Unicode errors, which we handle here. + return false; +} + +/** An @trusted wrapper around readln. +* +* This is the only function that formally requires manual review for memory-safety. +* [Arguably readln should be safe already](https://forum.dlang.org/post/rab398$1up$1@digitalmars.com) +* which would remove the need to have any @trusted code in this program. +*/ +string trustedReadln() @trusted +{ + return readln; +} + +version (Windows) +{ + // Make the Windows console do a better job at printing UTF-8 strings, + // and restore the default upon termination. + + import core.sys.windows.windows; + + shared static this() @trusted + { + SetConsoleOutputCP(CP_UTF8); + } + + shared static ~this() @trusted + { + SetConsoleOutputCP(GetACP); + } +}