UFO 50 Bingo Training Dummy

Finally! It took me a while, but it's finally done now. Thank you so much for your patience, and I hope you'll enjoy what I have cooked up here.

What is this?

The UFO 50 Bingo training buddy is an idea I came up with when I thought about all the people who might want to practice bingo but may not always have access to anyone to practice with. 

This "traning dummy", as I choose to call it, is a simple program that pretends to take part in a match against you. What it does is, during a match, it picks a bingo entry from the card, determines an amount of waiting time to beat it according to average time information given from a JSON file, and once that amount of time is elapsed, claims that card entry and chooses the next entry to try.

NOTE: the JSON file used by the training dummy is NOT the same JSON file you use when setting up a bingo in the regular way. Instead, a special JSON file (examples of which are included with the program) is necessary.  This special JSON contains information such as average/standard deviation time for completion of gift, gold and cherry goals in all games, as well as what types of collectibles can be found in each game, the amount of levels/bosses in each game, and a long list of bingo entries (to fill the bingo cards) specifying what needs to be accomplished for the cell to be claimed. The instructions on how to build and modify the JSON files are contained below in simple terms.

The Downloads page has the source code, example JSONs, and Windows/Linux versions of the dummy.

Also, also! If you have more accurate completion times for certain tasks than the ones given in the example JSON, please let me know so we can make the training dummy more accurate!

How to use

Quick start video:

FILE SELECT SCREEN.

On the first screen, you are prompted to pick a JSON file with which to start the game. The JSON files included in the package can be picked, but you may also want to create your own if you want to change parameters. Once that file is picked, open it, and you should be sent to the second screen.

ADJUSTMENTS SCREEN.

In the adjustments screen, you can define the following parameters:

- Minimum and maximum standard deviations added to the average time, in order to define the amount of time taken to finish a game, goal, or task. Negative values are allowed, in case you want a challenge.  - When the training dummy picks a game or task to complete, it calculates an amount of time based on the average time (as written in the input JSON), plus or minus an certain coefficient times the standard deviation time of the task. In simple terms, the lower the number of standard deviations, the faster the dummy will be, with negative values making the time lower than the given average.

- Percentage of time (as in percentage of the total time to get gold) which the dummy must spend in a game before secondary collectibles are counted as collected.  - In this current version of the training dummy, once that percentage of time is elapsed within the game, they will automatically claim all secondary collectibles in the game. Later versions will allow one to set custom times for each of those per game.  - Secondary collectibles are: eggs, ufos, shops, HP upgrades, foods, drinks

- Percentage of time (as in percentage of the total time to get gold) for the dummy claim a leaderboard position in a game.

  - In the current version, there is no distinction between top 5 and top 3 leaderboard positions. Future versions will allow the player to set a custom percentage for each game, and separate top 5 from top 3.

- Total match time (seconds)  - The total time of the match against the dummy

- Card review time (seconds)  - The time where the player is allowed to view the card before the game begins

- Test Mode  - Allows the player to see exactly what the dummy is trying to do at any given time, and the collectibles it has acquired.

Once you are ready, click "Apply and Start Game" to be taken to the game screen

GAME SCREEN.

Before the game starts, a simple timer should show up at the bottom of the screen, counting down from the number of seconds established for card review.

Once the card review time is over, a small chime will play, and the bingo card will become interactive. The timer in the current version of the dummy is in seconds, rather than a more standard HH:MM:SS format, and it counts downwards.

To claim a bingo entry, simply click it with the left mouse button. The dummy will also be actively trying to claim entries (setting up timers and claiming entries when the timers elapse), and an entry claimed by the dummy cannot be claimed by the player, and vice-versa.

If either the player or the dummy complete a bingo, a jingle will play (victory if the player wins, defeat if the dummy wins) and the program will stop. In order to play again, you must reopen the program (this should also change in a future version).

Available input JSONs

The download list has two input JSONs:

"test_with_fake_games.json": a JSON file with fake games, and short objectives, meant to test out the training dummy if need be, and provide an example of how the keys and entries in the input JSON must look.

"real_games_real_bingo_tasks_naive_times.json": a JSON file containing all of the real UFO 50 games, most of the real bingo objectives the community created, but the completion times of tasks and games are pulled straight out of my arse (I'm sorry!).  The times are (hopefully) not TOO far off the IRL completion times, so this example JSON can be used for practicing just fine, provided you adjust the parameters to your liking in the adjustments screen. You can also, naturally, change the completion times of tasks in case you think the times are too unrealistic.

"real_games_real_bingo_tasks_naive_times_SRL_ENABLED.json": same as above, but with the extra information necessary to generate BingoSync-like balanced cards.

For a quick start with UFO 50 bingo practice, pick the third file. If you want to test the dummy, or make modifications to the code on your own, I recommend you pick the first file. The second file is pretty much a relic from the past now, unless you really want completely unbalanced cards.

Source code downloads

The training dummy is made with Godot 3, a free and open-source game making engine. The Godot source files are available for download in case you'd like to modify the bingo dummy to your needs and desires, and can be opened without the need for passwords or anything like that.

Input JSON configuration

Quick tutorial video:

This section explains the structure of the training dummy's JSON input file in a bit of detail, in case you'd like to create your own JSON or modify an existing one. If anything is still confusing, do not hesitate to crack open the example JSONs, or ask me about it in the Discord.

In the current version of the input JSON, there are three main entries:

- Game list ("games")

- Bingo entry list ("bingo_entries")

- Games that keep gathering resources while you play other stuff ("continuous_games"), containing only Pilot Quest for a JSON with real UFO 50 games.

- Pre-determined card ("preset_card")

- Flag to use Bingosync-esque SRL generation ("use_srl", boolean)

GAME LIST PARAMETERS

The game list is a list containing dictionary entries in the following format:

{"name" (string): name of the game.

"gift_time" (dictionary): dictionary containing average ("avg") and standard deviation ("stdev") of the time for the dummy to obtain garden gifts.

"gold_time" (dictionary): dictionary containing average ("avg", float) and standard deviation ("stdev", float) of the time for the dummy to obtain the game's gold disk.

"cherry_time" (dictionary): dictionary containing average ("avg", float) and standard deviation ("stdev", float) of the time for the dummy to obtain the game's cherry disk.

"eggs" (boolean): determines whether the game has eggs hidden in it.

"shops" (boolean): determines whether the game has shops in it.

"foods" (boolean): determines whether the game has collectible food.

"drinks" (boolean): determines whether the game has collectible beverages.

"ufos" (boolean): determines whether the game has Campanella easter eggs.

"hp_ups" (boolean): determines whether the game has health upgrades in it.

"bosses" (integer): number of bosses in a gold run of the game.

"extra_bosses_cherry" (integer): number of bosses one only has to face in order to get the cherry (e.g. Velgress would have "bosses" = 0 and "extra_bosses_cherry" = 1).

"leaderboards" (boolean): determines whether the game has leaderboards.

"resets" (boolean): determines whether the game starts over from the start if you leave it or get a game over. (e.g. Ninpek would be true, Mini & Max would be false, and something like Bushido Ball, despite not having permadeath, would also be true because there are no saves and leaving the game results in a reset).

"levels" (integer, optional): determines the number of levels of a game.

"extra_levels_cherry" (integer, optional): determines the number of extra levels to beat in order to get the cherry (e.g. in Velgress and Caramel Caramel). Something like Block Koala should have "extra_levels_cherry" set to the number of levels minus the number of levels necessary to beat.}

BINGO ENTRY LIST PARAMETERS

The Bingo entry list is a list containing dictionary entries in the following format:

{"name" (string): description of the task to be accomplished

"games" (list of integers): the indices (according to the order of the "games" list, 0-indexed) of the games involved in the card. Can be left blank in case it does not require a specific game to be completed. Also leave blank if the time spent in the game should not be computed towards gift/gold/cherry (e.g. if the entry involves terminal codes or doing something that does not advance the goals).

IMPORTANT: since the array of games is 0-indexed, the "normal" UFO 50 number of a game has to be subtracted by 1. For instance, Block Koala is #16, so it must be listed in the "games" list as #15.

"extra_time" (dictionary): the average ("avg", float) and standard deviation ("stdev", float) of "extra time" that the dummy must spend in order to clear this objective (in case the objective is not exclusively dependent on a gift, gold, cherry, collectible or leaderboard)"

"idle_time" (optional, dictionary): the average ("avg", float) and standard deviation ("stdev",float) that the continuous games (Pilot Quest) must be running for it to be possible to get the objective.

"gifts" (list of integers): the indices (according to the order of the "games" list, 0-indexed) of the games the bingo dummy needs to get the garden gift in, in order to finish the task. Can be left blank if no games need garden gifts for this task.

"golds" (list of integers): the indices (according to the order of the "games" list, 0-indexed) of the games the bingo dummy needs to gild in order to finish the task. Can be left blank if no games need to be gilded for this task.

"cherries" (list of integers): the indices (according to the order of the "games" list, 0-indexed) of the games the bingo dummy needs to cherry in order to finish the task. Can be left blank if no games need to be cherried for this task.

"special_type" (string or null): if left as "null", the entry will be treated according to the parameters established above. If it is any of the following: "eggs", "ufos", "golds, "cherries", "gifts", "shops", "leaderboards", "hp_ups", "bosses", "foods", "levels" or "drinks", then the card requires a certain number of the cited collectibles to be acquired. The "games" entry can limit the set of games you can pick from to complete this if necessary (e.g. there is one bingo entry that requires you to beat 3 games among the 16 games listed as "arcade" in the collection).

IF "special_type" is set to "n_bosses" or "n_levels", then 

"special_type_qty" (integer): only used if "special_type" is not null, determines the amount of collectibles that need to be acquired in order to complete the task.

If "n_bosses" or "n_levels" is the value of "special_type", it instead determines the amount of games in which n bosses or n levels need to be beaten (for objectives like "beat one boss in 3 games" or "beat 4 levels in 8 games" or whatever).

"n" (optional, integer): only used if "special_type" is "n_bosses" or "n_levels": the amount of levels or bosses to be beaten in a game.

(EXAMPLE: for the "beat 4 levels in 3 games" card, "special_type" would be "n_levels", "n" would be 4, and "special_type_qty" would be 3)}

Optional Bingo goal properties for SRL card generation:

These HAVE to be present if use_srl is true.

"type1" (string): the first "type" of the goal, same purpose as the first entry in the "types" list of the normal Bingosync JSON (e.g. for "MOONCAT: Find 2 of 3 eggs", it would be "mooncat")

"type2" (string): the second "type" of the goal (for "MOONCAT: Find 2 of 3 eggs", it would be "veryhard").

"tier" (integer between 0 and 24): determines the "tier" of the bingo goal for SRL generation. In the normal Bingosync JSON, this corresponds to the index of the list the bingo goal is on ("MOONCAT: Find 2 of 3 eggs" is in the list of index 19, so its "tier" is 19).

These properties only matter if SRL card generation is enabled, and if it is impossible to create an SRL card with the given information, the dummy will output the following error screen:

When in doubt of what went wrong, do as the message says and yell at me about it.

THE preset_card ENTRY

The preset_card entry is a list of 25 integers, referring to (0-indexed) indices of elements from the bingo entry list. Leave blank if you would like the bingo card to be randomized instead.

Caveats and limitations:

- This training dummy is meant to be used for practice and entertainment. It does not perfectly represent what a player in real life would do, and might not completely follow the UFO 50 bingo rules to the letter. I did what I could to make the dummy's behavior as close to a real player as possible, but some limitations exist, many of which are present to make the dummy's code less convoluted.

- The bingo dummy will occasionally "cheat" by doing things that are not really possible for a real player to do. For instance, the dummy can get the house gift of a game while performing a task that does not imply the house gift. The dummy might also sometimes get an HP upgrade much earlier than actually possible in the game it's playing, and other such things.

These events are caused by certain limitations in the way the training dummy is designed and implemented, and sadly, nothing short of completely rebuilding the dummy from scratch can make them completely disappear.  The dummy is, hopefully, capable of being believable when you don't actually have access to everything it's doing, and only have access to the entries it claimed in the card.

You can, however, mitigate the effect of these fumbles by changing the JSON entries of the tasks to remove some of these possibilities (at the cost of making the task less accurate to real life in some cases), or changing the parameters from the ADJUSTMENTS screen to make such "cheat" moments less impactful in the dummy's overall performance.

- The training dummy, in the current version of the program, only gives up on a task if the player finishes it before the dummy does. Future versions will feature smarter AIs, I hope.

THANKS

Thank you all so much for checking out my bingo dummy! If you have any feedback, feel free to share in the comments down here!

If you appreciate this little program, consider giving a small donation. You don't have to do it, but it would definitely help me out quite a bit, as I'm extremely broke and unemployed (figures, given I had the time to make this thing).