#039: Flip Flop - Xs and Os

Release Date: July 1973

Platform: Mainframe (BASIC type-in)

Genre: Puzzle

Developer(s): Michael Kass

Publisher(s): Digital Equipment Corporation

We're continuing in the realm of basic (ha) puzzle games today. Flip Flop, while it's an odd name, turns out to be a fairly straightforward logic puzzle.

History

Flip Flop continues our run in the original publication of David Ahl's 101 BASIC Computer Games. It's not a game of Ahl's own making, instead being submitted by a Michael Kass of New Hyde Park, New York. Unfortunately, I can't precisely identify this Michael Kass; even AI couldn't help me with this one. MobyGames lists him as attending Herricks High School, the major high school servicing the area, but after that the trail goes completely cold. Kass has no other known game credits, either, so nothing to go on from that end, either. There is a well-known computer scientist named Michael Kass, who worked on several Disney-Pixar films, but there simply aren't any tangible connections that can be made. Plus, that Michael Kass looks too young to be Flip Flop's creator.

These illustrations really are something, aren't they?

Flip Flop also received a couple of ports, one by Creative Computing itself for the Commodore PET in 1979, and a second done by the Association of Computer Experimenters for the RCA COSMAC in 1980. That's all the info I've got. I tried scanning the archive of Creative Computing Magazine as well, but found no mention of the game anywhere, despite CC doing their own port of the game. In some sense, I'm not surprised, considering how insignificant this game is in the overall scheme of computing history.

The Game

The nature of the puzzle of Flip Flop is, like the last game I did (Even Wins), hinted at in the game's title; something's getting flipped - fortunately it's not tables. No, the simple objective of Flip Flop is to turn a row of 10 Xs into Os. That's it. Not pulling your leg, that's literally all you have to do.

Here's how you "flip flop."

It's the how you flip the Xs where the puzzle element of the game comes in. Each X corresponds to a number - 10 Xs, 10 numbers. To flip the X, you simply input the corresponding number, and the X will turn into an O - just like a binary switch. However, there is a catch: some numbers don't always flip their corresponding X alone. Some of the numbers will also flip another, random X in the sequence. So 1 might flip itself and 5, or 4 might flip itself and 2; some of the flips are one-way, so 4 might flip 2, but 2 may not necessarily flip 4. It's up to the player to figure out how to make it all work together to flip the whole sequence. If you do happen to get stuck, there's two different ways provided to restart: type 0 to reset the current sequence to all Xs, or type 11 to start over with a new sequence.

An easy game.

On top of that, this isn't a one-and-done game with a single, set puzzle. No, each round the algorithms are randomised; no two rounds are the same. From a replay standpoint, it's great, but it's a double-edged sword. This mechanic also has the nasty side effect of making some rounds significantly harder than others. 101 BASIC Games states that you should be able to get the sequence flipped in 12-15 moves. In some cases, I could get it done in 8-9 moves because the sequence had no tricks. In other cases, the sequence was so confusing that I just gave up and started a new round. It would've been fun if there was a level structure that increased in difficulty more consistently, but we're not really at the point of game design yet where devs figured out that that was probably a good idea. Decimal Darts is really the only game I can think of that actually has a conventional difficulty curve up to this point in time. It's only a matter of time, though.

A not-so-easy game.

There's not a whole lot of sense in doing a play-by-play commentary for Flip Flop. It's not really the kind of game conducive to that style of writing and is probably better discussed within the context of my scores. so that's where we'll head now.

Scores

Time Played: 20 minutes

Difficulty: N/A (Variable)
Since the patterns change each round, the difficulty varies wildly. Some times it's incredibly easy and I win in 8 guesses - other times it seems impossible and I have to start over.

Gameplay: 2/20
If the algorithm wasn't randomised each round, this would get a 1. It's a double-edged sword, though; randomisation ups the replay value, but the rules are so simple that it ends up lacking the depth or interest to make it worth replaying. The randomisation also adds a severely fluctuating difficulty curve which I didn't appreciate.

The other way the game could've gone about the replay vs. depth problem is by upping the complexity of the algorithm, but make the puzzles more static. The numbers could flip up to 4 other numbers, for example, but the algorithm is set. Or, add difficulty levels; the easiest being 1-2 numbers change, then 3-4, then 5-6 for a hardest difficulty. That way, replay value is added from having more challenging levels, and depth is added through the levels gradually increasing the complexity of the puzzle. I know this is a 1973 game, and game devs didn't think like that yet, but a man can dream.

Controls: 5/10
As adequate as can be for a text-based game.

Visual: 1/10
The formatting is quite poor on this game. I would've liked to have seen more line breaks, as it feels very cluttered and is hard to read.

Functionality: 5/5
No issues found.

Accessibility: 3/5
Fairly standard for text-based games.

Fun Factor: 1/20
I didn't particularly enjoy this puzzle. Too simple, and too much variability. Not conducive to replayability, and I lost interest in it pretty quickly.

Overall, the scores don't make for great reading here: a final score of 17, earning a spot at the tippy-top of the F tier. These little throwaway games aren't really enthusing anybody these days. I wish I could get through them more quickly, but the current pace of life doesn't allow for that. Next week's game promises to be a little more interesting, at least.

#038x: Even Wins - Cybernetic Version

Release Date: July 1973

Platform: Mainframe (BASIC type-in)

Genre: Puzzle (Nim Variant)

Developer(s): Eric Peters

Publisher(s): Digital Equipment Corporation

Trust me, it sounds way cooler than it actually is.

History

This little side quest is a follow-up from last week's Even Wins article. As I stated there, 101 BASIC Computer Games has two versions of Even Wins. The one from last week's article is the original, which uses a conventional AI. This one, which is called EVEN1 and Game of Even Wins by the two versions of the book respectively, does something a little different with its AI: it learns.

This version of the game was written in-house at DEC by Eric Peters, who also developed the Lunar Lander variant, Rocket. MobyGames dubs his version of Even Wins the "Cybernetic Version" (I think based off of the game's description in-book), uses a different AI pattern that begins only knowing the basic rules of Even Wins, and progressively learns how to play the game better over successive rounds.

A quick refresher on Even Wins.

The whole idea of "machine learning" in this sense isn't new to the blog; we've previously seen this form of AI learning in a couple of previous programs. Animal is likely the most notable, although is different in the sense that the player was the one teaching the computer different questions and animals, instead of with games like Awari and this version of Even Wins, where the computer learns by itself. Animal, as a side, happens to be one of my most-read articles, though I honestly don't know why - it's not even a game. This is supposed to be a gaming blog!

The Game

Anyway, I said this was going to be a short one, so let's get into it.

Look familiar?

First of all, the game is almost entirely re-written from the original, and has significant differences as a result. Visually, the game presents the objects as chips instead of marbles. Mechanically is where the majority of changes are, however.

No longer is the pile of objects set at 27 - it's now a random, odd number. The game code suggests that a pile size of a single chip could be generated (there is failsafe code in place for this occurrence); in practice it tended to be between 7 - 21 chips.

The player does not have the choice of going first or second anymore. Instead, the computer always goes first. I find this a curious choice, with first being the advantaged position. However, it makes sense in the idea that it showcases how the AI begins squandering its advantaged position, but progressively learns the game and gets to the point where it can rarely be beaten.

Bro is pretty stupid.

On the note of the AI, it does indeed start out woefully bad at the game. It makes some truly bizarre and illogical choices, and continues in that pattern from quite some time. Sometimes it will completely blow a winning position, like being at 5, myself taking 1 chip, being on an even number, and it'll just take the whole pile like it's giving up.

...but he does get better. Eventually.

Eventually, it does start to get good, and did start taking game off me. However, I seemed to have found a flaw in its algorithm, as there was a particular strategy that it just couldn't figure out. I would force the pile, if I was on an even number, to 9 chips remaining. From there, the AI would always take 3 chips, putting me in a position I would always win from. It never learned how to beat this strategy - I must have beaten it 10 times in a row at least.

Closing Thoughts

No scores for Even Wins: Cybernetic Edition. For one, I think it's somewhat redundant as it's functionally the same game as the source. It's more of a showcase of AI programming, which is inherently interesting to me and worthwhile not skipping over just because of "redundancy." Every game matters.