Blood Bowl Scholarly blogs

Throw Teammate Flowchart for BB2025

Mon, 16 Mar 2026 00:00:00 +0000

Blood Bowl Third Season (aka BB2025) is here!

In this post, I present the updated version of my favorite Throw Teammate (TTM) Flowchart. A quick Facebook search reveals that there are several, dare I say, many flowcharts for TTM out there. For BB2016 there was even one on the NAF website. For BB2020 there are several, for example one by Mike Davies posted on Facebook.

But my personal favorite is the flowchart made by the Red Magician for BB2020, presented in a blog post on his own website. I found it a few years ago where it is was discussed in a Reddit post.

I like it because for me it has the right balance between compressing some things (such as the Throwing player either being an Ogre, Troll or Tree), but being comprehensive in other things, such as what happens when a thrown player bounces off another player on the field. Also I like the layout, having a large font size and designed to cram everything on a single A4 page that can be printed and laminated. As a result it might come a across a bit messy, we can’t have it all.

With the new edition, I contacted the mysterious Red Magician (who replied promptly!) and obtained the source file (a Google Drawing) and his permission to update and share the flowchart. I converted the Google Drawing into a SVG file with embedded fonts that can be edited with Inkscape, an Open Source vector graphics editor, and exported to PDF.

So what’s new? I used as a reference a recent BB2025 version, as reviewed and discussed in a Reddit post from last december. It appears to be somewhat verified by rules lawyers and others from the community.

Changes to TTM involve the outcomes of the Throw, i.e. no more terrible or successful throw, now we have “subpar throw”. I also added in the effects of new skills such as Bullseye and Lethal Flight, and gave the buffed Swoop skill a more prominent position, as it is likely to become standard on Goblin teams.

Without further ado, here it is:

Let me know if you spot any mistakes.

Download section

The updated Throw Teammate Flowchart for BB2025 can be downloaded here and the SVG source is available here if you want to tinker with it in Inkscape (I used version 1.2).

Update August 5 2026: Fixed an error with Bullseye. Thanks to David Goodey for spotting the error!

Note, the text could only be exported as paths (i.e. vector shapes, curse you Google!), the SVG is now a mix of editable text and vector shapes. Be warned!

Welsh Nationals BB2025 roster analysis

Fri, 13 Feb 2026 00:00:00 +0000

Blood Bowl Third Season (aka BB2025) is here!

In this post, I look at tournament roster data from Tourplay, in particular The Welsh Nationals 2026. This was the first big high stakes UK tournament using Third Season (BB2025) rules, with around 100 coaches (98 to be exact) competing for six games of third season Blood Bowl.

A lot of flat tiering tourneys are currently happening, i.e. REVA Bowl (REVA17), Dutch Open 2026 and Waterbowl 2026.

According to the organizers (https://bloodbowlwales.co.uk/tournament/welsh-national-championships-2026-results/),

Flat tiering was used throughout the tournament to help gauge how teams perform under the updated ruleset and to give valuable insight into balance, roster choices and skill effectiveness going forward.

And:

For full standings, match results and stats, check out the Tourplay page: https://tourplay.net/en/blood-bowl/welsh-national-championship-2026

The details of the ruleset

The ruleset was indeed as flat as a ruleset can be, without any race specific rules or exceptions whatsever.

Team building:
Coaches will have 1,150k gold and 7 skill points (SP) with which to build their teams. 
Gold can be spent on players, sideline staff, and inducements.

Inducements can be anything from the core rulebook, excluding Wizards, Mercenaries, Star Players, and Prayers to Nuffle.

Each team will get a free Mascot, the Sheepy Reroll!

Skill points grant a player one additional skill at the following costs:
Primary Skill: 1 SP
Secondary skill: 2 SP, one per team max

There is a limit of 4 repeats for each Elite skill (Block, Dodge, Guard, Mighty Blow). 
This does not include starting skills already present on a team.
No player can receive more than one additional skill. (i.e. no stacking)

High Elves may use the Team of Legend rules
Slann are not permitted

So how did that work out? Lets have a look at the rosters!

Skewed race distribution

The distribution of races was very skewed, with 75% of the rosters coming from only 9 races. Flat tiering likely contributed to this pattern. Hopefully this and other flat tiered tournaments will inform tiering systems so that future tournaments have a more diverse showing of the 30 races available.

The top 10 races at the Welsh Nationals come as no surprise after our previous blog post, it largely reflects the general patterns in race popularity at NAF tournaments.

We will now have a look at the top 11 most popular races (OWA up to Dark Elf), plus Tomb Kings because I want to play them soon. With this selection of races, we have the full top 20 coaches covered, except for Underworld Denizens. A roster book containing all 98 rosters is available as well.

1. Old World Alliance (OWA) rosters

Not only was OWA most popular, it was also most effective, with first and second place going to OWA teams.

What do the rosters look like? I boxed the top four OWA teams.

So what do these four rosters have in common:

All builds have three rerolls, most by utilizing a leader skill on either a human thrower or a dwarf runner.
They all favor a treeman over an ogre, with Guard or Pro.
Mighty blow on the human blitzer, which gives the strong tackle / mighty blow combo.
Block on the S3 catcher
Guard on the dwarf blitzer and troll slayer

2. Necromantic Horror rosters

Necro gets everything at 1150 + 7SP, so no surprises here. 3 rerolls, all positionals, Four guard, three block was the most common build and also the build that came in highest (6th place, by coach camelchops).

Only variation is some coaches putting block on flesh golems.

3. Wood Elves rosters

Here the choice is bringing a tree or not. Best scoring coaches all brought a tree. Comparing with my last roster analysis three years ago done on EB2023 ruleset rosters, we see that the classic top Wood Elf roster is:

giving war dancers tackle and strip ball,
a tree,
3 rerolls (either with or without leader caddy) and
putting dodge and/or wrestle on the linemen.

It appears this has not changed in Third Season.

What is new that the two catchers get skills, sidestep and block. Perhaps because block (and sidestep indirectly) offers a bit more protection for the catchers when only two can be fielded?

4. Shambling Undead rosters

Top performing coaches went for two builds:

three rerolls and 14 players,
or four rerolls with 13 players.

Skill wise: Either guard mummy or spending two SP for a block mummy. Guard and mighty blow wights. Block Ghouls.

5. Skaven rosters

To my surprise, NO variation in team player composition. All coaches went for roger, two gutters, two blitzers, one thrower and 7 linerats. For a total of 13 players. Leader on the thrower.

The top coach went for a really interesting build, putting break tackle on both (S3) blitzers, giving these a +1 on their dodges, making these pieces more similar to a gutter runner.

6. Amazon rosters

For amazon quite some variation, with either zero, one or two throwers, but the top performers both went for the standard roster:

3 rerolls
No throwers
two blitzers, one block / one wrestle,
two blockers, one had the two guard build, the other the block/guard build.
Complemented with either 9 + keg or 10 linewomen and maxed on the elite skill block.

7. Chaos Dwarf Rosters

The chaos Dwarves were popular, but did not perform too well at the Welsh Nationals tournament. So I refrained from singling out a particular build or roster, and we just have a look at the variation here. And there is plenty of that. Either with or without mino, with or without stabba’s, with or without flamesmiths.

8. Lizardmen rosters

Lizardmen are also interesting to have a look at. They were a popular choice, and at least one coach made into a shared fourth place on Match Points (WDL 4/1/1) so they did perform as well.

With Block as an Elite skill maxed at 4, and Saurusses gaining Juggernaut, giving one saurus Frenzy is the obvious choice, creating a semi reliable frenzy blitz piece. Rounded of with 2 rr, a Guard kroxigor, and a tackle Saurus.

9. Orc Rosters

Orcs took third place, so let’s have a look at that roster. New in Third Season is Orc linemen having strength access on a primary.

The top performing Orc coach went for:

3 rerolls,
Troll,
goblin,
all positionals
5 linemen, of which two guard.

With respect to skill choice, both block and guard are popular:

Block on the big uns, that come with mighty blow standard,
two guard blitzers that now come with block and break tackle.

10. Nurgle rosters

As with Chaos Dwarves, no Nurgle roster ended up in the top 20, so no highlighting of particular builds, we just have a look at roster variation.

There were a lot of similarities in the rosters:

3 rerolls
Full positionals: rotspawn, 4 bloaters and two pestigors, with either 5 (+ keg) or 6 rotters for a roster of 12 or 13 players

Skill wise, a lot of block and guard.

One coach went for the new Monstrous Mouth mutation skill, that allows players to " Chomp" other players on a 3+. A “Chomped” player cannot move while being chomped. Curious how effective this new skill will turn out to be!

11. Dark elf rosters

A dark Elf roster took fourth place, which is interesting, because Dark Elves are generally considered to have taken a nerf with the loss of two blitzers.
So what rosters do we have?

First off all, it is noteworthy that no coach took any Runners. Not even as a leader caddy, their traditional use at tourneys.

In contrast, two out of three rosters took two Assassins. Let’s compare the two positionals:

They have equal stat lines, except for passing (3+ vs 4+), similar cost (80 vs 90K) but differ greatly in their skills, and skill access (with Assassins not having primary access to general skills).

The Runner comes with two skills, Dump-off and Punt. Punt is a new skill that allows for a completely new action where a player (that is in possession of the ball) can kick the ball D6 squares down the field (after which it needs to be secured again). I doubt whether such an uncontrolled action (both direction and distance are random) would often be useful. (Update 24/8/26: I missed that this does not cause a turnover, might be more useful than I thought )

An Assassin comes with three skills: Hit and Run, Stab (which make a nice combo, stabbing and then escaping to safety after the deed), and Shadowing that now always succeeds on a 4+.

My preliminary conclusion is that its a clear win for the assassin here.

Back to the top roster: That roster went for full positionals except the runners, 6 linemen for a team of 12 players, and 3 rr. No apothecary.

From the Tourplay data, we can see that the assassins made more than half of the touchdowns. This might be related to the Hit and Run skill, as the free movement after a block or stab action helps break through a line of defense.

Finally, a surprising choice is having Kick on the roster. Not something I have seen before on tournament Dark Elf rosters, curious about the motivation for doing so.

Bonus: Tomb Kings rosters

Finally, we also have a look at Tomb Kings, because this will be my next league team, and up and coming coach Blitzy chose Tomb Kings for this tournament. Blitzy is a Blood Bowl phenomenon who won three Blood Bowl tournaments last year, including Thrudball 2025, with Chaos Dwarf and Nurgle, so he must obviously know what is good :)

No surprises there:

all positionals,
6 skellies for a roster of 12 players,
3 rr

Regarding skill choice: a 50/50 mix of Mighty Blow and Guard for the tomb guardians, a guard blitzer and a tackle blitzer, topped off with a block thrower.

To conclude

A rosterbook containing all 98 rosters was made with the R package bbrosterplots and is available as a PDF here.

Third Season race popularity

Sat, 24 Jan 2026 00:00:00 +0000

Blood Bowl Third Season (aka BB2025) is here!

In this post, I look at tournament data from Tourplay and NAF to check what teams are popular in BB2025.

A new edition of Blood Bowl

So what does BB2025 bring? A completely new team (Bretonnian), and lots of (small) changes, while keeping the core of the game intact. The NAF already documented (and sometimes clarified) a long list of changes. At the time of writing, 214 issues have been identified! They made a great summary of the most important changes and clarifications.

For a nice overview of changes per team / roster, check out the website of nazgob at https://2025.nazgob.co.uk/teams

The first tournaments using BB2025 rules

Currently there are two main data sources with BB2025 games: The NAF database and Tourplay. The nice thing about Tourplay is that it contains the actual rosters as well. Here we only look at team choice, in a later blog post we zoom in on the actual rosters. As the Tourplay data underlying this post was scraped end of december 2025, we are looking at really the first few weeks of BB2025 tournament play. The data largely consist of small scale local tournaments, with 10-20 coaches, several of which were not NAF approved. The biggest tournament was a UK tournament called “Yorkshire’mas Bowl II” , which was NAF registered, and used tiering.

Here is an overview of the included tournaments.

Popular team picks

So without further ado, the most popular races!

So in the first few weeks of BB2025, surprisingly Necromantic Horror was most popular. This could represent the risk-averse coaches playing it safe, as it already was a strong and popular team, and this team was virtually unchanged, with only small improvements, remaining a top pick.

After that we have Shambling Undead , that did have significant changes, losing two Ghouls, their Blitzers gaining tackle, and zombies getting Eye gouge.

Then we have Lizardmen, that did not see changes in positionals, but with Saurusses gaining juggernaut, and the team hit by the elite skill cap of max four of each (no more 6x block on all saurus), they’l likely play different enough to explain their initial popularity.

On to Imperial Nobility, that got an overall boost in BB2025: Although bodyguards lost one movement, the teams cost is reduced, and they have various skill improvements (blitzers gaining pro, throwers gaining a new skill “give and go” as well as pro).

Then comes Skaven that took a blow by losing two gutter runners, but were compensated by Blitzers gaining strip ball and an extra movement, and the remaining two gutter runners gaining stab.

Always popular, we have Orcs, that also saw big changes: losing two blitzers and two big ‘uns, and blitzers gaining Break tackle and the big ‘uns gaining Mighty blow.

(In the NAF data below, Orcs are now second most popular, only surpassed by OWA.)

OWA’s surge in popularity is also visible in the Tourplay data of the first few weeks. They have all sorts of improvements: gaining strong skills like Block and Tackle, losing Animosity, becoming cheaper overall, benefitting from the strength increase of the Human catcher, it is no surprise that everybody who like winning is looking at OWA.

Then we have Wood Elf, that, although technically losing two catchers, already had a viable tournament roster in BB2020 with only two catchers. They benefit from cost reductions, catchers gaining sprint and improved passing across the board.

Completing the top 10, we have Nurgle, Goblin and Bretonnian. Both Nurgle and Goblins are improved in various ways, and Bretonnian are of course brand new (although at first sight do not seem very strong).

The NAF database after two months of BB2025: patterns largely confirmed

A few more weeks down the road, we can check the NAF database (10x more data roughly), and see how it compares. Comparing the top 10 most popular races in both datasets, we find that 8 of the 10 races are the same. Only Lizardmen has dropped substantially lower, and Humans make their appearance in the top 10.

Humans at first sight took a blow with losing two blitzers, but benefit from the strength increase of Catchers and the blitzers gaining Tackle.

Patterns we see are likely to change as tournaments move to new tiering systems, converge on how to deal with elite skills etc. For now we have a first taste of the impact of BB2025, and it sure shakes things up.

Visualizing Blood Bowl Gnome roster development during League play

Tue, 29 Apr 2025 00:00:00 +0000

This blog post uses the fumbbl_replays Python package. To install the fumbbl_replays python package, follow the instructions at the fumbbl_replays Github repository.

This analysis focuses on team development in League play. Last season I played Gnomes in our local league (B.I.G. league in Hilversum, Netherlands), and was curious how to best develop the team.

So I did some data analysis. On FUMBBL, a “meta competition” is organized called Black Box Trophy (BBT). In the Black Box Trophy, teams start off with 1M gold, and play 15 matches against random opponents in the Black box division. It uses the rule book team development rules (earning SPP, leveling up players etc). When the meta-event ends (currently after 4 months), the best performing coaches are declared winner.

This appears to be a high stakes competitive BB League environment, perfect to learn what choices pro players make to optimally develop their teams.

I decided to look at the top performing Gnome teams from the last three BBT seasons.

For this analysis, the starting point is the team_id. This is part of the url of the team on FUMBBL: https://fumbbl.com/p/team?id=1177218

These teams and their coaches stood out based on their win rates:

BBT 11: “We do gnomes” by coach Elyod (10/2/3 WDL) (https://fumbbl.com/t/1177218)
BBT 11: “You’ve been tricked” by coach Heymaiya (8/3/4 WDL) (https://fumbbl.com/t/1175080)
BBT 12: “Lawn Bullies” by coach Candlejack (10/4/1 WDL) (https://fumbbl.com/t/1193897)
BBT 13: “Gnom Gnom” by coach Norn (9/5/1 WDL) (https://fumbbl.com/t/1211512)
BBT 13: “Vengeance Most fowl” by coach Heymaiya (10/1/4 WDL) (https://fumbbl.com/t/1210291)

I wrote a function fetch_team_development_data(team_id) to fetch the rosters from the first 15 replays for each team. We can then plot this data to track the team development using the function make_team_development_plot().

import fumbbl_replays as fb

team_ids = [1177218, 1175080, 1193897, 1211512, 1210291]

for team_id in team_ids:
    res = fb.fetch_team_development_data(team_id)
    fb.make_team_development_plot(res)

...............

...............

...............

.............

...............

What can we learn from how these Gnome teams developed?

What starting roster is used? How are the SPP spent? What player builds do we see?

Starting roster

The Gnome roster including skill access and player cost can be found at the Blood Bowl Tactics website. As a starting roster, all five rosters start with 6 linemen and all positionals, for 14 players. Variation is in number of rerolls (Three or four), and having an Apothecary (yes or no).

Foxes

Foxes are the stars of the team, collecting SPP by scoring TDs. +MA is by far the most popular. Sure feet is also an option, to save on rerolls for the GFIs.

Treemen

Treemen skill up quickly by all those 3-die block casualties and the occassional superb TTM. Guard is favorite. Less common options are +MA, Pro and Defensive. Candlejack managed to get a second skill on both after 12 and 14 games, +MA and Block.

Defensive was a surprise for me. It turns off Guard during the opponents turn. It makes it more difficult for opponents to bring in enough assists to knock down the tree. This is strong when the trees form part of the cage formation, in combination with Beastmasters closeby that come with Guard.

Linemen

For linemen, we see mostly saving up (MVP, TTM TDs?) for Dodge. There is one lineman with a second skill, diving tackle, to serve as a marking player. Overall, it appears difficult to skill up linemen, since they do not live long enough. Of the 6 linemen in the starting roster, without Dodge only 1 or 2 survive after 15 games.

Illusionists

Same as the line gnomes, lifespan issues. After they gain Dodge protection, Leader for an extra reroll. Coach Elyod randomed pass skills, possibly in search of a cheap leader skill.

Beastmasters

Beastmasters have higher AV than the rest of the gnomes, but are more often where the action is, using their guard to assist in blocks, or protecting the ball carrier. So as with the other gnomes, they want Dodge first for more protection. After that Sidestep.

I had great fun painting up and playing Gnomes, so give em a try!

Want more BB Gnome stuff? check out the Gnome Counties Discord server. Enjoy the company of over one hundred Gnome coaches discussing and sharing all things Gnomey!

Introducing the fumbbl_replays Python package for Blood Bowl

Thu, 25 Jul 2024 00:00:00 +0000

The fumbbl_replays package is a Python utility package for the board game Blood Bowl. It allows users to plot board positions, either from scratch, or from existing (FUMBBL) game logs. In addition, it has some functionality to analyze FUMBBL game logs.

On the FUMBBL website, a lot of high quality replay data is available as well as an API to conveniently fetch the data. In addition, the API provides up to date roster information. To do useful analyses (aka nufflytics) in Python with this data, we need a utility package / library. In R, a similar package exists to work with BB2 replays https://github.com/nufflytics/nufflytics. For BB3 replay files, work is ongoing to process them, with a proof-of-concept example C# Github repo available.

We also need a standard way to describe Blood Bowl games in a compact way, that is both human and machine readable. In chess, there is the Portable Game Notation (PGN). PGN has become the de facto standard of describing Chess games. For Blood Bowl, already in 2002 some work has been done towards this end. David Morgan-Mar developed a notation for the purpose of sharing Blood Bowl game logs over the internet. https://www.dangermouse.net/games/bloodbowl/rules.html

If we could converge on a standard Fantasy Football Game Notation (FFGN), it would serve many purposes, e.g.:

It would allow us to interchange data between software
it would help to train AI engines.

So the package is being developed with this end goal in mind. As Blood Bowl is a much complexer game than Chess, and I am an amateur programmer, we need some intermediate goals that bring us closer to the end goal. Thus, I started with plotting (new or extracted) board positions using a short hand notation for board pieces (players) and codifying player moves. While developing the package, I benefited greatly from discussions and feedback on the Bot bowl discord forum.

`1`	`%pip install -e . --quiet`

Plotting Blood Bowl board positions

If we want to describe (codify) a Blood Bowl board state, we need to describe the pieces (what type of player is it, what extra skills does it have), the location of the pieces as well as the “state” of the pieces. Player state in Blood Bowl can be either standing, prone, or stunned, and can be in various special states such as “Bone head”, “Rooted”, “Hypnotized” etc. (A full game state also contains additional information on rerolls, players on the bench etc. This is not yet implemented)

Let’s start with the location of the pieces. A grid reference system is needed. The game board of Blood Bowl has dimensions 15 x 26. It has cognitive benefit to use numbers for one dimension, and letters for the other dimensions. Fancy word: alphanumeric. Chess over the centuries has had various notations, and this notation is the one that became universally accepted. [https://en.wikipedia.org/wiki/Algebraic_notation_(chess)] The only choice left for us is then, which axis should have letters, and which axis should have the numbers.

A strong argument was made on the BotBowl discord that distance to the end zone is very important in BB. By using numbers for the long axis, we can easily deduce that a Gutter Runner at position c15 is in scoring position: It needs 11 movement to score a touchdown at c26. This notation is also used by Cow Daddy Gaming in his “What´s the play” puzzles.

I wrote a function show_boardpos() that displays the name of all the board positions.

1
2
3

import fumbbl_replays as fb

fb.show_boardpos(rotation = 'H')

Now we need a way to describe the playing pieces, and visualize them. In chess it is easy, there are only six different ones. In Blood Bowl, there are roughly 200 different playing pieces (30 teams, times 5 positionals, plus 50+ star players). Here the concept of a roster can help us out. I wrote a function fetch_roster() that fetches rosters from FUMBBL and displays the positions. It also contains links to icons that can represent the piece on the board.

Take for example the High Elf roster.

1
2

roster = fb.fetch_roster("High Elf")
roster

	positionId	positionName	skillArray	shorthand	icon_path	race
0	39330	Lineman	[]	L	https://fumbbl.com/i/585638.png	High Elf
1	39331	Thrower	[Cloud Burster, Pass, Safe Pass]	T	https://fumbbl.com/i/436284.png	High Elf
2	39332	Catcher	[Catch]	C	https://fumbbl.com/i/585639.png	High Elf
3	39333	Blitzer	[Block]	Z	https://fumbbl.com/i/436286.png	High Elf

It has four different pieces or “positionals”. It turns out that FUMBBL has already solved our problem of denoting them, introducing a shorthand text reference. So if we want to describe some action involving a High Elf Catcher, and there are four of them on the board, we could denote them by C1, C2, C3 and C4. This is compact, and has meaning within the context of the High Elf roster.

If we combine the descriptions of the pieces, and their location, we have enough to describe for example an initial setup formation before kick-off.

1
2

my_setup = ['setup', ['L1: g13', 'L2: h13', 'L3: i13', 'Z1: c11', 'Z2: m11', 'T1: h6', 'L4: e11', 
                      'L5: k11', 'C1: l10', 'C2: d10', 'L6: h11']]

I wrote a function create_position() that combines the roster and the setup annotation to create an object that contains all the information to make a nice plot of the board state. The function print_position() prints a nicely formatted summary of the position. As default, a position is created for the home team, denoted as “teamHome”.

1
2

positions = fb.create_position(roster, my_setup)
fb.print_position(positions)

	home_away	race	short_name	positionName	boardpos	PlayerState
5	teamHome	High Elf	T1	Thrower	h6	Standing
9	teamHome	High Elf	C2	Catcher	d10	Standing
8	teamHome	High Elf	C1	Catcher	l10	Standing
3	teamHome	High Elf	Z1	Blitzer	c11	Standing
6	teamHome	High Elf	L4	Lineman	e11	Standing
10	teamHome	High Elf	L6	Lineman	h11	Standing
7	teamHome	High Elf	L5	Lineman	k11	Standing
4	teamHome	High Elf	Z2	Blitzer	m11	Standing
0	teamHome	High Elf	L1	Lineman	g13	Standing
1	teamHome	High Elf	L2	Lineman	h13	Standing
2	teamHome	High Elf	L3	Lineman	i13	Standing

Let’s suppose that the High Elf team is playing against a Gnome team. Let’s also fetch a Gnome roster and create a board position on the other half of the pitch. As we already have a home team, we refer to this team as “teamAway”.

1
2

roster = fb.fetch_roster("Gnome")
roster

	positionId	positionName	skillArray	shorthand	icon_path	race
0	57706	Altern Forest Treeman	[Mighty Blow (+1), Stand Firm, Strong Arm, Thi...	T	https://fumbbl.com/i/733781.png	Gnome
1	57707	Gnome Beastmaster	[Jump Up, Wrestle, Guard, Stunty]	B	https://fumbbl.com/i/735006.png	Gnome
2	57708	Gnome Illusionist	[Jump Up, Wrestle, Stunty, Trickster]	I	https://fumbbl.com/i/735007.png	Gnome
3	57709	Woodland Fox	[Dodge, Side Step, Stunty, My Ball]	F	https://fumbbl.com/i/735008.png	Gnome
4	57710	Gnome Lineman	[Jump Up, Wrestle, Right Stuff, Stunty]	L	https://fumbbl.com/i/735009.png	Gnome

my_setup = ['setup', ['T2: j14', 'T1: f14', 'F1: h20', 'I1: b14', 'I2: n14', 'L3: e14', 'L6: k14', 
                      'B2: m15', 'B1: c15', 'L4: g15', 'F2: i16']]

positions2 = fb.create_position(roster, my_setup, 'teamAway')

fb.print_position(positions2)

	home_away	race	short_name	positionName	boardpos	PlayerState
3	teamAway	Gnome	I1	Gnome Illusionist	b14	Standing
5	teamAway	Gnome	L3	Gnome Lineman	e14	Standing
1	teamAway	Gnome	T1	Altern Forest Treeman	f14	Standing
0	teamAway	Gnome	T2	Altern Forest Treeman	j14	Standing
6	teamAway	Gnome	L6	Gnome Lineman	k14	Standing
4	teamAway	Gnome	I2	Gnome Illusionist	n14	Standing
8	teamAway	Gnome	B1	Gnome Beastmaster	c15	Standing
9	teamAway	Gnome	L4	Gnome Lineman	g15	Standing
7	teamAway	Gnome	B2	Gnome Beastmaster	m15	Standing
10	teamAway	Gnome	F2	Woodland Fox	i16	Standing
2	teamAway	Gnome	F1	Woodland Fox	h20	Standing

As a final step before plotting, we add both positions together. As both are pandas DataFrames, we use the concat() function from pandas to combine (“concatenate”) them.

1
2
3

import pandas as pd

positions = pd.concat([positions, positions2])

The function create_plot() plots the board position. By default, it plots a horizontal pitch, with the team denoted as “teamHome” in red, and the other team in blue.

`1`	`fb.create_plot(positions)`

The create_plot() function allows us the swap the color of the teams, to change the pitch orientation to vertical, and to add a layer of semi-transparant tacklezones.

`1`	`fb.create_plot(positions, red_team = "teamAway", orientation = 'V', tackle_zones = True)`

The library also support moving single pieces (players). It currently only works for pieces that already exist in a board position. In the plot above, suppose we want to move the Woodland Fox F1 to board position o26:

1
2
3

positions = fb.move_piece(positions, "teamAway", "F1", "o26")

fb.create_plot(positions, red_team = "teamAway")

Each player also has an associated PlayerState. This can either be Standing (the default), HasBall, Prone or Stunned. The function set_piece_state() allows to set this for individual players:

positions = fb.set_piece_state(positions, "teamAway", "F1", "HasBall")
positions = fb.set_piece_state(positions, "teamHome", "T1", "Prone")
positions = fb.set_piece_state(positions, "teamAway", "B1", "Stunned")

fb.create_plot(positions, red_team = "teamAway")

The compact setup description can also describe player states other than standing. / is Prone, X denotes stunned. o denotes a player that has the ball.

The compact description for the Gnome position plotted above can be obtained using get_position():

`1`	`fb.get_position(positions, home_away = 'teamAway')`

['setup', ['T2: j14', 'T1: f14', 'F1: o26o', 'I1: b14', 'I2: n14', 'L3: e14', 'L6: k14', 'B2: m15', 'B1: c15X', 'L4: g15', 'F2: i16']]

Note the notation for Fox F1 with the ball (F1: o26o) and the notation for the stunned Beastmaster B1 (B1: c15X).

As the positions object is a table of players, I added an extra argument to create_plot() to plot a free ball.

`1`	`fb.create_plot(positions, red_team = "teamAway", ballpos = 'e5')`

Star players can also be plotted. For this we need to fetch a separate star player “roster” and add it to the team roster. Lets add Rowana Forestfoot (“RF”) and Rodney Roachbait (“RR”) to the Gnome setup, replacing Gnome linemen L3 and L6.

positions = positions.query('home_away == "teamHome"')

roster = fb.fetch_roster("Gnome")
stars = fb.fetch_stars()
roster = pd.concat([roster, stars])

my_setup = ['setup', ['T2: j14', 'T1: f14', 'F1: o26o', \
                    'I1: b14', 'I2: n14', \
                    'RF1: e14', 'RR1: k14', \
                    'B2: m15', 'B1: c15X', 'L4: g15', 'F2: i16']]

positions2 = fb.create_position(roster, my_setup, 'teamAway')


positions = pd.concat([positions, positions2])

fb.create_plot(positions, red_team = "teamAway", ballpos = 'e5')

Plotting player skills aka “digital loom color bands”

Knowing what extra skills players have is often important in analyzing a given board position (what blocks are possible, can we use the Dodge skill or does the opponent has Tackle etc). In the FUMBBL client there is a function that allows automatic skill marking using text. When playing on tabletop there are various ways to mark / denote what extra skills players have. One popular way is to use colored elastic (“loom”) band. The most common skills have semi-standardized colors associated with them:

Guard is green
Block is blue
Wrestle is white
Dodge is yellow
Leader is purple
Mighty Blow is red
Tackle is orange

At a typical tournament (I checked this for Thrudball 2024) 80% of skills chosen are one of these seven skills. Here I decided to make a digital version of the colored elastic band, plotted below the player icon. If a player has more than one extra skill (“Skill stacking”), the colored bands are stacked on top of each other.

Here I will demonstrate by setting up the board for a Shambling Undead team with a set of 6 skills often chosen at tournaments.

import fumbbl_replays as fb
roster = fb.fetch_roster("Shambling Undead")

my_setup = ['setup', ['Z1: g14', 'Z2: h14', 'Z3: i14', 
                      'W1: e16', 'W2: k16', 'G1: h16', 'G2: h17', 
                      'M1: c16', 'M2: m16', 'Z4: b17', 'Z5: n17']]

positions = fb.create_position(roster, my_setup)

fb.add_skill_to_player(positions, "M1", "Guard")
fb.add_skill_to_player(positions, "M2", "Guard")
fb.add_skill_to_player(positions, "G1", "Block")
fb.add_skill_to_player(positions, "G2", "Block")
fb.add_skill_to_player(positions, "W1", "Tackle")
fb.add_skill_to_player(positions, "W1", "Mighty Blow")

fb.create_plot(positions, red_team = "teamAway", orientation = 'H', skill_bands = True)

It is also possible to remove a (Gained) skill from a player.

`1`	`fb.remove_skill_from_player(positions, "W1", "Tackle")`

1
2
3

(positions
 .filter(['short_name', 'positionName', 'skillArrayRoster', 'learned_skills', 'skill_colors', 'boardpos'])
)

	short_name	positionName	skillArrayRoster	learned_skills	skill_colors	boardpos
0	Z1	Zombie Lineman	[Regeneration]	[]	[]	g14
1	Z2	Zombie Lineman	[Regeneration]	[]	[]	h14
2	Z3	Zombie Lineman	[Regeneration]	[]	[]	i14
3	W1	Wight Blitzer	[Block, Regeneration]	[Mighty Blow]	[red]	e16
4	W2	Wight Blitzer	[Block, Regeneration]	[]	[]	k16
5	G1	Ghoul Runner	[Dodge]	[Block]	[blue]	h16
6	G2	Ghoul Runner	[Dodge]	[Block]	[blue]	h17
7	M1	Mummy	[Mighty Blow (+1), Regeneration]	[Guard]	[lime]	c16
8	M2	Mummy	[Mighty Blow (+1), Regeneration]	[Guard]	[lime]	m16
9	Z4	Zombie Lineman	[Regeneration]	[]	[]	b17
10	Z5	Zombie Lineman	[Regeneration]	[]	[]	n17

Plotting board positions from FUMBBL replays

Up until now, we created board positions from scratch, using rosters from FUMBBL and a simple way to describe a board position.

The package also allows us to plot board positions extracted from FUMBBL replay files. At this moment, only the board position right before kick-off can be plotted. Suppose we want to plot this position for match 4550284.

We first need to fetch the replay data. The fetch_data() function takes the match_id as argument and returns five objects: the match_id, replay_id, a positions object containing the board state right before first kick-off, which team is the receiving_team (i.e. playing offense), and a metadata list (coach names, race names, and match touchdown result).

`1`	`match_id, replay_id, positions, receiving_team, metadata = fb.fetch_data(match_id = 4550284)`

To plot the board state right before kick-off, we can use the create_plot() function in the same way as above. We plot the receiving team in red so we can see which team is playing offense and which team is playing defense.

`1`	`fb.create_plot(positions, red_team = receiving_team)`

1
2

(positions.filter(['race', 'home_away', 'short_name', 'positionName', 'playerName',  'skillArrayRoster', 'learned_skills', 'cost', 'recoveringInjury'])
                    )

	race	home_away	short_name	positionName	playerName	skillArrayRoster	learned_skills	cost	recoveringInjury
0	Gnome	teamHome	T2	Altern Forest Treeman	Caroline Rigol	[Mighty Blow, Stand Firm, Strong Arm, Take Roo...	[+MA]	120000	None
1	Gnome	teamHome	T1	Altern Forest Treeman	Matthew Ir	[Mighty Blow, Stand Firm, Strong Arm, Take Roo...	[Pro]	120000	None
2	Gnome	teamHome	L2	Gnome Lineman	Jaiden Netzigon	[Jump Up, Right Stuff, Stunty, Wrestle]	[]	40000	None
5	Gnome	teamHome	B1	Gnome Beastmaster	Eloise Celorn	[Guard, Jump Up, Stunty, Wrestle]	[]	55000	None
6	Gnome	teamHome	L1	Gnome Lineman	Andre Drumma	[Jump Up, Right Stuff, Stunty, Wrestle]	[]	40000	None
7	Gnome	teamHome	B2	Gnome Beastmaster	Sienna Rime	[Guard, Jump Up, Stunty, Wrestle]	[]	55000	None
8	Gnome	teamHome	L4	Gnome Lineman	Melanie Kayce	[Jump Up, Right Stuff, Stunty, Wrestle]	[]	40000	None
9	Gnome	teamHome	L5	Gnome Lineman	Eliza Elora	[Jump Up, Right Stuff, Stunty, Wrestle]	[]	40000	None
10	Gnome	teamHome	L7	Gnome Lineman	Gabriela Lacspor	[Jump Up, Right Stuff, Stunty, Wrestle]	[]	40000	None
11	Gnome	teamHome	I1	Gnome Illusionist	Brynlee Tror	[Jump Up, Stunty, Trickster, Wrestle]	[]	50000	None
12	Gnome	teamHome	L3	Gnome Lineman	Chase Kavelin	[Jump Up, Right Stuff, Stunty, Wrestle]	[Sneaky Git]	40000	None
14	Shambling Undead	teamAway	Z3	Zombie Lineman	Rylee Dager	[Regeneration]	[]	40000	None
15	Shambling Undead	teamAway	Z2	Zombie Lineman	Molly Harven	[Regeneration]	[]	40000	None
16	Shambling Undead	teamAway	Z1	Zombie Lineman	Asher Meridan	[Regeneration]	[]	40000	None
17	Shambling Undead	teamAway	M1	Mummy	Brooklyn Biel	[Mighty Blow, Regeneration]	[]	125000	None
18	Shambling Undead	teamAway	G1	Ghoul Runner	Noelle Vythethi	[Dodge]	[]	75000	None
19	Shambling Undead	teamAway	Z5	Zombie Lineman	Asher Meegosh	[Regeneration]	[]	40000	None
20	Shambling Undead	teamAway	M2	Mummy	Bailey Fer	[Mighty Blow, Regeneration]	[]	125000	None
21	Shambling Undead	teamAway	Z4	Zombie Lineman	Haley Guilomar	[Regeneration]	[]	40000	None
22	Shambling Undead	teamAway	W1	Wight Blitzer	Corbin Aleemy	[Block, Regeneration]	[]	90000	None
23	Shambling Undead	teamAway	W2	Wight Blitzer	Lucas Mickal	[Block, Regeneration]	[]	90000	None
24	Shambling Undead	teamAway	G2	Ghoul Runner	Ivy Farate	[Dodge]	[]	75000	None

Adjusting this board position by moving players one-by-one works also in the same way as above.

positions = fb.move_piece(positions, "teamAway", "Z1", "b26")
positions = fb.move_piece(positions, "teamAway", "Z2", "o26")

fb.create_plot(positions, red_team = receiving_team)

Suppose we think that this Gnome defensive setup is awesome, and we wish to share this setup with other coaches. Here the compact way to describe a setup using player abbreviations and the alphanumeric grid system comes in handy:

`1`	`fb.get_position(positions, home_away = 'teamHome')`

['setup', ['T2: g13', 'T1: i13', 'L2: h13', 'B1: f10', 'L1: e11', 'B2: j10', 'L4: k11', 'L5: h11', 'L7: i10', 'I1: g10', 'L3: h10']]

However, suppose we think this setup is nice, but it would be even better if the illusionist in row g would instead be a Woodland Fox. We can take the setup (copy-paste), change the setup slightly, and create a new position, with F1: g10. As we now only have a single team, we can rotate the pitch and crop to show only the upper part of it.

roster = fb.fetch_roster("Gnome")

my_setup = ['setup', ['T2: g13', 'T1: i13', 'L2: h13', 'B1: f10', \
                      'L1: e11', 'B2: j10', 'L4: k11', 'L5: h11', \
                        'L7: i10', 'F1: g10', 'L3: h10']]

positions = fb.create_position(roster, my_setup)

fb.create_plot(positions, orientation= "V", crop = "upper")

Working with raw replays directly

It is also possible to work with the raw FUMBBL replay files directly. I made a start with describing the replay file format in doc/fumbbl_replay_file_format.md. We can use fetch_replay() to retrieve a replay in JSON format.

1
2
3

import fumbbl_replays as fb

my_replay = fb.fetch_replay(match_id = 4447439)

JSON consists of key-value pairs. We can for example query the value of the key gameStatus:

`1`	`my_replay['gameStatus']`

'uploaded'

Or query the rosterName:

`1`	`my_replay['game']['teamHome']['roster']['rosterName']`

'Necromantic Horror'

The replay contains both a game log, as well as full roster information on both teams. We can extract the roster information from the replay using the function extract_rosters_from_replay().

import pandas as pd
pd.set_option('display.max_colwidth', None)

df_positions = fb.extract_rosters_from_replay(my_replay)
(df_positions
 .query("home_away == 'teamAway'")
 .filter(['short_name', 'positionName', 'skillArrayRoster', 'learned_skills', 'skill_colors'])
)

	short_name	positionName	skillArrayRoster	learned_skills	skill_colors
14	Tr1	Loren Forest Treeman	[Loner, Mighty Blow, Stand Firm, Strong Arm, Take Root, Thick Skull, Throw Team-Mate]	[]	[]
15	W1	Wardancer	[Block, Dodge, Leap]	[]	[]
16	W2	Wardancer	[Block, Dodge, Leap]	[Strip Ball]	[deeppink]
17	T1	Thrower	[Pass]	[Leader]	[purple]
18	C1	Catcher	[Catch, Dodge]	[]	[]
19	C2	Catcher	[Catch, Dodge]	[]	[]
20	L1	Wood Elf Lineman	[]	[Dodge]	[yellow]
21	L2	Wood Elf Lineman	[]	[Dodge]	[yellow]
22	L3	Wood Elf Lineman	[]	[]	[]
23	L4	Wood Elf Lineman	[]	[Wrestle]	[floralwhite]
24	L5	Wood Elf Lineman	[]	[Wrestle]	[floralwhite]

I wrote a replay parser that parses the gameLog section of a replay and transforms this into a pandas DataFrame object, i.e. a flat 2D table with rows and columns.

df = fb.parse_replay(my_replay)
(df[0:4]
 .filter(['commandNr', 'turnNr', 'turnMode', 'Half', 'modelChangeId', 'modelChangeValue'])
)

	commandNr	turnMode	modelChangeId	modelChangeValue
0	1	startGame	fieldModelAddPlayerMarker	{'playerId': '15440786', 'homeText': 'B', 'awayText': 'B'}
1	1	startGame	fieldModelAddPlayerMarker	{'playerId': '15440787', 'homeText': 'G', 'awayText': 'G'}
2	1	startGame	fieldModelAddPlayerMarker	{'playerId': '15440788', 'homeText': 'G', 'awayText': 'G'}
3	1	startGame	fieldModelAddPlayerMarker	{'playerId': '15440790', 'homeText': 'G', 'awayText': 'G'}

We can use the pandas query() function to select rows based on conditions. This query selects all “fieldModelSetPlayerCoordinate” commands during setup before turn 1.

positions = (df.query('turnNr == 0 & turnMode == "setup" & Half == 1 & \
                     modelChangeId == "fieldModelSetPlayerCoordinate"')
                     .groupby('modelChangeKey')
                     .tail(1))

(positions[0:4]
 .filter(['commandNr', 'turnNr', 'turnMode', 'Half', 'modelChangeId', 'modelChangeValue'])
)

	commandNr	turnMode	Half	modelChangeId	modelChangeValue
77	20	setup	1	fieldModelSetPlayerCoordinate	[12, 6]
79	21	setup	1	fieldModelSetPlayerCoordinate	[12, 7]
81	22	setup	1	fieldModelSetPlayerCoordinate	[12, 8]
84	24	setup	1	fieldModelSetPlayerCoordinate	[10, 4]

As I was interested in defensive setup formations, I wrote a function determine_receiving_team_at_start() that does exactly what you’d expect given its name :)

`1`	`fb.determine_receiving_team_at_start(df)`

'teamAway'

Towards FFGN

Finally, there is a function fumbbl2ffgn() that is very much a work in progress. The idea is to take a FUMBBL game log, and systematically strip away all information that is redundant regarding the actual logging of what happened during the game. A minimal game description would consist of all actions taken, all decisions that were made (i.e. to use the dodge skill) and all dice results. After we have such a description, we can transform it to a compact annotation that is readable both by humans and machines, and is still a complete description of the game, in that the full game can be reproduced. The compact annotation would then be candidate to become the official “Fantasy Football Game Notation”, or FFGN for short.

1
2

my_game_log = fb.fumbbl2ffgn(match_id = 4447439)
len(my_game_log)

This is where it currently stands. A single gamelog is now roughly 1000 lines of text. The table below describes the first turn of a Wood Elf team against Necromantic.

pd.set_option('display.max_colwidth', None)

# Turn 1 for the offensive
(my_game_log
 .query("Half == 1 & turnNr == 1 & commandNr > 88 & commandNr < 211")
 .filter(['modelChangeKey', 'modelChangeValue'])
)

	modelChangeKey	modelChangeValue
29	['T1']	[j17, i17, h17, g17, f17, e17]
30	['C1']	[g17, f17, e18, d17, c17, b17]
31	['L1']	[d14, e13, f13]
32	['L4']	Block roll:['!', '!'] \| block result: ! (POW/PUSH)
33	['L5']	[g12]
34	['L4']	[g13]
35	0	Armour roll: [3, 5] \| Armour of ['L5'] is not broken
36	['Tr1']	Confusion roll: 2 \| ['Tr1'] acts normally
37	['Tr1']	Block roll:['>', '%', ''] \| block result: (POW)
38	['L2']	[i12]
39	['Tr1']	[h13]
40	0	Armour roll: [4, 2] \| Armour of ['L2'] is not broken
41	['L5']	Block roll:['>', '!'] \| block result: ! (POW/PUSH)
42	['L4']	[h12]
43	0	Armour roll: [2, 5] \| Armour of ['L4'] is not broken
44	['L3']	[m16, l16, k16, j16, i16, h16]
45	['L2']	[l15, k15, j15, i15, h15, g15, f15]
46	['C2']	[c15]
47	['W1']	[d16, c16, b16]
48	['W2']	[g18, f18, e18, d18, c18, b18]
49	['W2']	{'reportId': 'pickUpRoll', 'playerId': '['W2']', 'successful': True, 'roll': 4, 'minimumRoll': 2, 'reRolled': False}
50	['W2']	[c18, d18]
51	___	End of Turn

Thrower 1 moves. Catcher 1 moves. Lineman 1 moves. Lineman 4 blocks, chooses pow/push, pows Zombie lineman L5 into square g12, follows up, does not break armor. Treeman does not take root, does a 3D block on Zombie lineman 2, chooses pow into square i12, follows up to square h13, does not break armor. Lineman 5 blocks zombie lineman L4, pows into h12, does not follow up, does not break armor. Then linemen L3, L2, catcher C2 and wardancer W1 all do a move action. Finally Wardancer W2 moves, picks up the ball and moves a bit more. End turn.

This blog post describes the basic functionality of the fumbbl_replays Python package. I have a second blog post coming up with three applications that use the fumbbl_replays package to accomplish some Nufflytics goal.

The Super League: Tournament Blood Bowl online

Thu, 21 Sep 2023 00:00:00 +0000

Yet another Blood Bowl post! If you don’t know about Blood Bowl and/or FUMBBL, See my previous blog posts on Blood Bowl for more background and stats.

This one is to introduce the Super League, where top (and not so top) coaches compete with each other online on FUMBBL. The Super League is a system of interconnected leagues, in a pyramid-like system. This is not uncommon in sports, a well known example is the English Football league system, also called the “football pyramid”. The creator and tireless promotor of this league, the infamous Tripleskull from Denmark, asked me to do some data analysis on the SL, with this blog as a result.

How does it work? Each season coaches play a match against all the other coaches in their division / tier (“single round-robin”). At the end of the season coaches are promoted to a higher division, remain, or are relegated to a lower division, based on how well they did. New coaches have to start in the lowest division and work their way to the top. The highest division is called the “Premier League”, where some of the world’s best Blood Bowl coaches compete for the crown (well ring in fact, designed and 3D printed by Flashman1234).

In a post on Discord, current head admin Storr explains the design of the Super League:

The Super League is designed as a tiered league with a pyramid structure to allow coaches to play against opponents of their own level. This is done intentionally in contrast to the TSD*, where we have completely random divisions each season with a playoff at the end. We do have a rather high number of relegations and promotions to allow everyone to pass rather quickly to the tier they “should” be in, but we need to try to keep the balance between the two. I know it is a bit unfortunate to join now and having to take the long way to the top, but that’s what it is in a tiered league. There will not be a reset in the Super League, as that would be against the very nature and idea of the league. There is, however, the option to make the lower tiers a bit wider, as we don’t follow through with the pyramid structure through all tiers at the moment. The reason for that is that the league grew quite large rather quick, and a decision was made to implement the divisional structure as it is now, possibly because it fit the participant numbers well (i.e. “historical reasons). We will think about expanding the pyramid structure, especially if the league grows even further, as we also don’t want to handle a giant swiss division at the bottom (ask LemonheadWallenstein why), but I won’t make any promises.

(*TackleZone Star Division, another competitive league/tournament on FUMBBL)

At this point we should mention TheFear, who together with TripleSkull started it all, and was sole admin for Season 0 and 1. His historic blog post on FUMBBL introducing the Super League can be found here on FUMBBL.

To illustrate the (somewhat) pyramid-like structure of the SL I made a schematic:

Each rectangular block is a division with 8 coaches, except for the lowest division, which uses a Swiss pairing system (i.e. coaches are initially randomly matched and after that are matched based on their performance so-far). At the time of writing the league is going into its third season, with 188 coaches competing.

A “season 0” Swiss tournament was played to fill the “empty” pyramid with coaches according to their performance in S0. This filled the top half of the pyramid, after that new coaches were divided randomly across the remaining divisions (D3 and D4), hence this season was nicknamed “the season of shortcuts” by Lorebass. In November 2022 Season 1 kicked off. Going into S2 (march 2023) and now S3 (sept 2023), the system is working as intended with coaches moving through the pyramid via promotion and relegation.

Ranking the stars!

So what can be learned from two seasons of Super League competition play? As this is about competition, let’s try and create a ranking over who did best over those two seasons.

{width=100%} Here we use the ranking primarily to summarise / show part of the data. In creating the ranking, I made several choices that can be considered arbitrary, I mention these in parentheses.

The ranking is constructed as follows: Main idea is that competing in the Premier League is valued the most (Arbitrary Decision #1, division level as main score). This puts Strider84 and RolexWL firmly at the top as the only coaches that ended up, and managed to stayed in the Premier League for all three seasons. Here, Strider84 is clearly number one, since he also managed to win the PL (Arbitrary Decision #2, trophies as first tie breaker). Next we have a block of six coaches that played twice in the PL, and once in the league directly below (Championship A/B). Using trophies as a tie breaker puts Purplegoo in third place with two trophies, and Storr in fourth place with one trophy.

How to rank the remaining four coaches? For this I looked at placement within the division, averaged over S1 and S2. This puts Stimme in fifth place, as his average placement was 2. (Arbitrary decision #3, average placement over season disregarding division level as second tie breaker). Finally I cut the list at a threshold of score 12 or less (I award 6 points for playing one season in the PL, 5 points for a single season in the CH etc). This resulted in one Dutch Coach making the list, and that honour goes to Schwifty, who managed to accomplish this playing Nurgle! Respect.

Rising to the top

As all new coaches have to start at the bottom (with Season 1 being an exception where coaches could be randomly placed in D2, halfway in the pyramid), we can change perspective. Let’s have a look at ALL coaches who in the upcoming season (S3) play in the top two divisions and how they got there. The top two divisions are Premier League and Championship A/B, containing 24 coaches:

{ width=100%} In the Premier League, we see two new names: Junior84 and siggi. They rose with lightning speed to the top division, and show what is possible for the rest of us. Good luck up there competing with the best! In the Championship A/B division, we have a group of five coaches that steadfastly marched their way up from Division 2. Here we have a Dutch coach as well, go Edwin!

What teams do successful coaches pick?

Note that the league placing belongs to the coach. Coaches can swap teams (between seasons) and retain their ranking. So what teams did successful coaches pick in Season 2?

In season 2 the World Cup ruleset was used, with one exception: no star players. Now, we already know the World Cup win rates by team, thanks to Mike Davies and his awesome Tableau stats site. Here I show the top 10 teams with the highest win rate at the World Cup:

Top five teams in the WC ruleset are Underworld, Dark Elf, Amazon, Lizardmen and Shambling Undead. Indeed, the same teams did well in the Super League:

{ width=100%}

Here I looked at teams from Coaches that played in the top three divisions in Season 2, and managed to either remain in their league, or that got promoted to a higher league.

Interestingly, two coaches managed to do well with Imperial Nobility, and also low tier teams such as Nurgle, Chaos Chosen and Black Orc has some degree of success. Note that the absence of Old World Alliance in the Super League is likely because its success in the World Cup depended heavily on Star players.

Final remarks

If you’re interested in following along head over to Discord or FUMBBL. If you would like to join you have to wait a few months, Season 4 will likely start in Feb/March 2024. If you’re interested in the data analysis itself, both data and R code are available on my GitHub, the repository fumbbl_super_league is a good place to start.

Visualizing Blood Bowl Tournament rosters

Mon, 27 Feb 2023 00:00:00 +0000

(Photo by Erik Cats)

Yet another Blood Bowl post! This one is to warm up to the upcoming World Cup, analyzing variation in Roster choices by top coaches. For the uninitiated: In my spare time I like to play Blood Bowl, a chess-like board game where two teams play a match of fantasy football. It is set in the Warhammer universe, with teams populated by Orcs, Dwarves, Elves etc. See my previous blog posts on Blood Bowl for more background and stats. To get an estimate of the player base: a popular Blood Bowl channel on Youtube called “Bonehead podcast” currently has some 16K subscribers.

So the cool thing of Blood Bowl is that it has a highly competitive Tournament scene. With the ultimate tournament of course being the World Cup! The previous World Cup was held in 2019 in Dornbirn, Austria, and attracted 1400 coaches. This year the World Cup is hosted by Spain, and at least as many coaches are expected in Alicante to battle it out.

Blood Bowl tournaments typically come with a “Rule pack”. This describes which teams are allowed, how much gold coaches have to buy players, and how much skills can be allotted to players to improve their ball handling, or ability to knock other players down.

It turns out that the World Cup is pretty similar to the Eurobowl ruleset, so we can learn from the Eurobowl rosters to prepare for the World Cup. Bad roster choices will put you at a disadvantage even before the actual game has started. So let’s check out what the pro’s are using!

Online Blood Bowl Tournaments on FUMBBL

Blood Bowl can also be played online. Here we focus on FUMBBL.com, consisting of a Game client (a Java app), linked to a website that performs match making, calculates rankings, provides a forum for discussions etc.

There are many things great with respect to FUMBBL. Here I like to mention three key elements that allow for this post:

Online Blood Bowl tournaments are organized on FUMBBL that use exactly the same rules as large tabletop tournaments such as Eurobowl,
FUMBBL has an API where we can fetch the data we need for roster analysis,
FUMBBL stores full replays of all FUMBBL matches, so we can observe how successful rosters can be played

The 2022 Road to Malta Online NAF tournament

Last November, Eurobowl took place in Malta. To get an impression check this vid on Youtube. A few months before Eurobowl 2022, the Nuffle Amorical Football (NAF) organized an online Tournament “Road to Malta” on FUMBBL to warm up to this event. The Online Tournament used the exact same ruleset as the Eurobowl itself, and the Rulepack for the 2023 World cup is highly similar.

The rulepack for the Road to Malta can be found here.

This blog post’s main goal is to share the analysis results. Check my Github for the technical stuff (R/Python web scraping and visualization of FUMBBL data).

I’ll discuss the most popular races, and leave the rest for the interested reader. I created a PDF rosterbook containing all 29 different races that participated in the tournament. For each race I made a plot (a clustered heatmap) displaying the roster as a colorcoded matrix, where teams that are similar (based on a cost weighted similarity score) are put side by side. To give some information about the performance of the various builds, I added the tournament points scored behind the coach name.

Of course, roster build is only one factor influencing tournament results, with skill being much more important, so we have to keep that in mind. Occasionaly, I’ll compare with the Eurobowl rosters and their performance, for this I use the great Tableau resource compiled by Mike Davies.

Top 10 races in Road To Malta

The Road to Malta tournament featured 46 teams of 4 coaches each, supplying a total of 184 rosters for our analysis. Here we focus on the top 10 most popular teams:

The two most popular teams with 16 rosters each were Underworld Denizens and High Elf.

Underworld Denizens (Tier 2)

We start with Underworld Denizens. Even after the nerf to UW by GW in November 2021 they kept their popularity. And 10 out of 16 rosters include a star player! All rosters pick the full allowance of Blitzer, Thrower, Runner and three clan rats. From the plot below, we see that the Morg plus Troll build was most popular, but that there were various other “Big guy + star player” builds, with the big guy being either a Troll or the Rat Ogre, and the star player being either Varag, Glart, or Kreek.

Surprisingly, there are no Hakflem builds ! This might be due to the additional skill cost, although Morg too had an additional skill cost, leaving only a single skill left, that was unanimously used to gain an extra re-roll by putting the leader skill on the thrower.

{width=150%} The roster with the best performance (by Sandune) was the Varag plus Troll build.

High elf (Tier 4)

UW shared the top spot for most popular team with High Elves. High Elf’s recent popularity is likely related to their low tier placement, for this tournament it was Tier 4. This allowed for 8 primary skills and 1 secondary skill (or 6 primary skills and 2 secondary skills), on a 12 player line up. From the rosters, it appears that there are two roster variants popular. Both variants have the same lineup wrt players (2 blitzers, 3 catcher, 1 thrower). Coaches either choose three rerolls without an apo, or two rerolls with apo. The two-reroll builds all use leader to compensate for the “missing” reroll.

The best performing roster here was by Hartl78, who fielded a Sneaky Git/ Dirty player lineman, a most unelvish thing to do :) For the World cup, High elves moved from Tier 4 to Tier 2, so performance of the team will likely suffer.

{width=100%}

Necromantic Horror (Tier 2)

Necro was in tier 2, allowing for seven primary skills. All rosters went for this skill pack. Skill wise, well, a lot of guard and block! For Necro, there where three variants popular:

One werewolf, 6 zombies, 3 rerolls
Two werewolves, 4 zombies, 2 rerolls
Two werewolves, 3 zombies, 3 rerolls

Performance-wise, no clear differences to be seen.

{width=200%}

Shambling Undead (Tier 1)

The Shambling Undead rosters are all surprisingly similar:

2 mummies with guard,
2 wights (one guard, one tackle or mighty blow),
4 ghoul runners (two with block, 1 wrestle), and
three rerolls.

The only noticable variation is whether to complement that lineup with 5 zombies, 4 zombies plus 1 skeleton, or 3 zombies plus 2 skeletons. Performance wise there is little to guide that last judgement, as all three variants performed similar.

{width=200%}

Dark Elf (Tier 1)

All coaches selected the skill pack with 6 primary skills. Skill wise, there appears to be strong consensus: dodge on the blitzers, block and wrestle on the Witch Elves, and if you pick a runner put leader on it for that extra reroll.

There is some variation in the positional choices, we can distinguish three builds:

No assassins, 1 runner, 4-5 linemen
1 assassin, 1 runner, 3 linemen
2 assassins, no runners, 3 linemen

No clear performance differences between the three builds.

{width=200%}

Chaos Dwarf (Tier 1)

For chaos dwarves, the big question is whether to take a minotaur or not. The teams without minotaur did slightly worse. Without a minotaur, the full set of five hobgoblins can be fielded, as well as an additional reroll and apothecary. Skill wise, we can see that the three rosters with sure hands on a hobgoblin underperformed, suggesting that this skill choice is subtoptimal here. We can see that the most common skill allocation is to put block on the bull centaurs and guard on the dwarf blockers.

Interestingly, the highest scoring build by Liam has an uncommon skill choice, with guard on the bull centaurs and two blockers with Mighty Blow.

{width=200%}

Skaven (Tier 2)

Skaven did very well during the Eurobowl, with three Skaven teams in the top 10 best performing coaches. Two of those coaches also participated in Road to Malta, Olivierdulac and Sokratez (Tank).

First the commonalities: All rosters have the Rat ogre (Block or Juggernaut) and at least three gutter runners, of which one has strip ball. For Skaven I highlighted three variants:

Star player builds without blitzer (Either Kreek or Glart, this leaves 4 skills)
3 reroll builds without Thrower
2 reroll build with thrower (+ leader)

{width=200%}

Lizardmen (Tier 1)

For lizardmen coaches life is simple. 6 saurusses, 5 skinks, krox and an apo. Put block on all saurusses, done. That leaves time to bicker on about bigger questions in life, such a whether or not to swap one regular skink for a Chameleon skink :) Just as with all the previous roster variants, performance wise there is no clear winner. Some coaches swap one to three blocks for other skills such as guard, tackle or wrestle.

{width=200%}

Orc (Tier 1)

Orcs also did very well in Malta, with three teams in the top 10. The orcs show some serious roster variation! Agreed, all rosters take four blitzers with mighty blow and tackle, and four big uns with block and guard, but apart from that we see rosters with and without the Troll, with and without an apo, with and without a Thrower, and with varying amounts of goblins. Interestingly, the most exotic roster, with three goblins, and no thrower, performed best here.

{width=200%}

Wood Elf (Tier 1)

Wood elf coaches always take the treeman, two wardancers, and at least two catchers. Typical skills choices are one wardancer with tackle, and one wardancer with strip ball.

As the wood elf players are expensive, to get at least 2 rerolls requires a lineup with only 11 players. Variation is in the number of catchers (2-4) and taking a thrower, versus taking ordinary linemen. On one end, we see rosters that take all four catchers and a thrower, with only three linemen. At the other end, we see rosters that take only two catchers and a thrower, or three catchers, and take five linemen. This allows for three rerolls or two rerolls and an apothecary.

{width=200%}

Final remarks

For now my curiosity on roster variation has been satisfied, and I really looking forward to playing more and learning the finesses of this great game. The World cup in Alicante will be my first international tournament, hope to see you all there!

Classifying Blood Bowl teams using clustered heatmaps

Tue, 01 Nov 2022 00:00:00 +0000

(Photo by Erik Cats)

“If you graph the numbers of any system, patterns emerge” is one of my favorite movie quotes (from Darren Aronofsky’s cult movie about mathematics $\pi$ (“pi”)). In this post we’ll graph the numbers from the Blood Bowl Fantasy football game, and see what patterns emerge. Blood Bowl is a board game that can be summarized as “fantasy-chess-with-dice”, but this would hardly do the game justice. For example, in chess both players play with the same pieces, but in Blood Bowl, almost 30 different teams (e.g. orcs, elves, etc) are available to choose from, each team with different skills that require different playing styles. In addition, Blood Bowl coaches must assemble and paint their playing pieces themselves, making it a creative hobby as well.

For this blog post, we have a look at similarities and differences between the different Blood Bowl 2020 teams, and see where the newly introduced Black Orc and Khorne teams fit in. Using data analysis, we can cluster teams that have similar (average) match performance statistics and graph the data using heatmaps.

Heatmaps are a graphical representation of the data, with for example darker colors representing higher numbers. This allows patterns to emerge visually, and deviations on the patterns are also easy to spot. (Fun fact: a hundred years ago, people already “shaded matrices” but did not call it a heatmap yet (Wilkinson and Friendly 2009).)

We use match performance data from FUMBBL.com where Blood Bowl 2020 can be played online. For a previous blog post that describes the process of scraping the data see here. I made the match data (currently from August 2020 up to June 2022) publicly available in a Github repository.

Team play style categories

The most common way to classify the 25-30 different Blood Bowl teams is to distinguish four categories:

Bash (e.g. Orcs)
Agile (or Dash) (e.g. Wood Elf)
Hybrid (e.g. Humans)
Stunty (e.g. Halflings)

To formally classify a team we can use the follow decision tree, taking as input the most common roster choices for a team:

Does the team roster have a lot of Stunty players and a few Big Guys with negatrait?
- yes classify as Stunty
- no continue
Does the team roster have 4+ players with Strength skill access but < 4 players with Agility access?
- yes classify as Bash
- no continue
Does the team roster have 4+ players with Agility skill access but < 4 players with Strength access?
- yes classify as Agile / Dash
- no classify as Hybrid

As an example, Shambling Undead are typically played with 2 wights and 2 mummies (4 players with Strength access), but also with four Ghoul runners (4 players with Agility access), so this team is classified as Hybrid.

Main source for this scheme is (Dode 2017), but the bash/dash/hybrid/stunty categorization is widespread, for example at (Breidr 2015), (Amiral 2017) and (Schlice 2018).

It will be interesting to compare the patterns in the data with this categorization. In the next section we’ll discuss the various match statistics available from FUMBBL, but first we need to prep the data.

Read and prep the data

We start with reading in the scraped FUMBBL match data, see my previous blog posts mentioned above for details.

# Load packages
library(tidyverse)
library(ggfortify)
library(ggrepel)

df_mbt <- read.csv(file = "fumbbl_datasets/df_mbt.csv")

race_types <- unique(df_mbt %>% 
                       select(race_name, race_type) %>%
                       filter(race_type != "") %>%
                       arrange(race_type))

This blog post focusses on the Blood Bowl 2020 ruleset, for this we need the “Competitive” division from FUMBBL. (I performed the analysis for the older divisions using the 2016 ruleset as well, the plots can be found at the end of this blog post. )

A blog post from Schlice (Schlice 2018) got me interested in BB team classification using data. In his post, he makes heavy use of functional programming using R’s purrr package. This allows us to write a function and have this function work in parallel on a list of objects, and have it return the results also in list form.

As this was new to me, I decided to adapt his code to process the four divisions simultaneously. To do so, I wrote a function filter_division() that takes the source data and selects only matches from a particular division:

divisions <- c("Competitive", "Blackbox", "Ranked", "Regular_league")

filter_division <- function(div_name){
  df_mbt %>% 
  filter(division_name == div_name) %>%
  filter(race_name != "Treeman") %>%
  filter(race_name != "Simyin")
}

data_tables <- purrr::map(divisions, filter_division)
names(data_tables) <- divisions

data_tables now contains a list of four datasets, one for each division.

Next step is to select the variables we are interested in. Again we use the purrr::map() function to apply our selection function at once to all four datasets:

select_stats <- function(df) {
  df %>% 
  select(race_name, race_type, team_score, away_team_score:away_cas_rip) %>%
  select(-(home_cas_bh:home_cas_rip), -(away_cas_bh:away_cas_rip))
}

data_tables <- map(data_tables, select_stats)

We end up with the following set of variables:

`1`	`data_tables$Competitive %>% colnames()`

##  [1] "race_name"       "race_type"       "team_score"      "away_team_score"
##  [5] "home_comp"       "home_pass"       "home_rush"       "home_block"     
##  [9] "home_foul"       "home_cas"        "away_comp"       "away_pass"      
## [13] "away_rush"       "away_block"      "away_foul"       "away_cas"

A quick summary of the FUMMBL match statistics

The match statistics that are made available by FUMBBL are all related to important events during Blood Bowl gameplay. Of course, teams with similar stats can still be different on some aspect not captured in the data, so we keep that in mind.

The most obvious one is scoring Touchdowns (team_score and away_team_score). As this involves getting the ball in the end zone of the opposing player, stats for actions that contribute to scoring such as passing the ball are also present. There is the number of completed passes (home_comp and away_comp) as well as the net passing distance (with distance towards the opposing endzone counted positive and counted negative for passes in the opposite direction) (home_pass and away_pass). As passing is risky, running the ball into the endzone is the most common way to score. For running with the ball FUMBBL has the rushing statistic. This name was chosen some 20 years ago, and now may lead to confusion as under the BB2020 rules moving extra squares is called “rushing” (previously called “Going-for-it” or GFI).

The rushing statistic is described in a 2004 (!) FUMBBL forum post by SkiJunkie (the author of the predecessor of FUMBBL):

running/passing in the wrong direction counts negative. 
So if you run one step forward then one step back, your net rushing is 0.

Running/passing up and down neither adds nor subtracts. Getting pushed/thrown does not count. 
Only movement made during the players move who has the ball counts.

So, you can end up with negative rushing/passing.

This is great! The rushing statistic captures both ball possession as well as the maximum movement of typical ball handlers in each team. For example, in a Skaven team, the ball is typically handled by Gutter Runners, that have a maximum movement of 9. Compare this to the Dwarf team, where the Dwarf runner only has movement 6.

Finally, we have the statistics related towards taking out opposing players. This involves blocking, leading to blocking casualties, as well as fouling (illegally hitting players that are already down). For blocking, the total number of blocks thrown is tracked (home_block and away_block), for casualties we have the number of players who suffer a casualty (home_cas , away_cas) and for fouling we have the number of fouls performed by each team (home_foul, away_foul). For casualties, we use both the number of casualties inflicted as well as casualties suffered (home_cas and away_cas). The average amount of casualties suffered quantifies the vulnerability of a team, and will likely be related to the average armour value (AV) of a team.

As we are interested in statistics at the team level (not for individual matches), we take the average of all the statistics by team:

divisions <- c("Competitive", "Blackbox", "Ranked", "Regular_league")

df_agg <- data_tables$Competitive %>% 
  group_by(race_name, race_type) %>% 
  summarise(Blocks = mean(home_block), 
            Completions = mean(home_comp),
            Fouls = mean(home_foul),
            Distance_passed = mean(home_pass), 
            Running_w_ball = mean(home_rush), 
            Cas_inflicted = mean(home_cas),
            Cas_suffered = mean(away_cas), 
            Touchdowns = mean(team_score),
            size = n())

## `summarise()` has regrouped the output.
## ℹ Summaries were computed grouped by race_name and race_type.
## ℹ Output is grouped by race_name.
## ℹ Use `summarise(.groups = "drop_last")` to silence this message.
## ℹ Use `summarise(.by = c(race_name, race_type))` for per-operation grouping
##   (`?dplyr::dplyr_by`) instead.

`1`	`dim(df_agg)`

## [1] 28 11

This gives us 11 numbers for 28 different BB2020 teams.

So which teams have similar stats?

Next, we want to compare the different Blood Bowl teams on their match statistics with each other, and see which races have comparable stats.

If we have only one statistic, it is easy: we can just plot the different teams on one axis, the value of the statistic on the other axis, sort them and see which races are closest by.

Lets do that for the number of blocks made:

options(dplyr.summarise.inform = FALSE)

ggplot(df_agg, aes(x = reorder(race_name, Blocks), y = Blocks, size = size, col = race_type)) +
         geom_point() + scale_size_area() + coord_flip() + labs(x = "team name")

The different colors visualize the Team classification described above. We can see that the average number of blocks is already pretty predictive of team type.

But races can be similar if we look at blocks, but dissimilar if we look at e.g. passing. So lets make a few plots with each plot comparing two different metrics (code hidden for readability):

1
2
3

library(patchwork)

(p1 | p2)/(p3 | p4) / (p5 | plot_spacer()) +   plot_layout(guides = 'collect')

## `geom_smooth()` using formula = 'y ~ x'

Looking at the plots, we can see that there are clear patterns here. Some metrics are inherently related: Teams that make more passes during a match also cover more passing distance, that is only logical. But there are also patterns that are related to what makes teams different: teams that make more blocks tend to pass less (because they are less good at it).

Given these patterns, we also see teams that do not conform to the pattern: For example, in the top left plot, the Goblin and Snotling teams tend to make less blocks, but also less passes compared to other teams. And for the top middle plot we see that Halflings are an exception: Given how much they pass, we would expect a higher passing distance. (A quick look at their roster explains this: Halflings have dedicated Catchers (making passing attractive), but also the Stunty trait, making long distance passes more risky, decreasing the average passing distance).

Finally, which teams are similar depends on which plot we look at! Take for example the Black Orc team: Based on fouling and distance passed (Bottom left plot), it is very similar to the four Stunty teams. However, In the plot that combines Fouls and Blocks (lower right), it suddenly becomes unique!

PCA versus clustered heatmaps

So how can we compare the teams on all stats simultaneously? We can try to reduce the number of variables by looking at correlations between variables. For example, we observed a strong (negative) correlation between the number of blocks and the number of passes. We could take these two variables together and map (“project”) each team on a single new “axis” (the straight line in the top left plot). For this a commonly used technique is PCA (“principal component analysis”). The original variables are combined into “principle components” along which the most variation occurs. A nufflytics blog post by Schlice (Schlice 2018) applies this technique to classify the Blood Bowl teams of the online Blood Bowl 2 variant of the game. Another example of this approach is the master thesis project of Tadas Ivanauskas (Ivanauskas 2020).

With PCA, a common approach is to focus on the first two principal components, as these can be visualized on a 2D coordinate system (i.e. a scatter plot). However, a big disadvantage of PCA is that the new dimensions are difficult to interpret, because the original data is transformed and combined, and therefore no longer recognizable. In the above mentioned blog post, this becomes apparent when the author puts in serious effort to understand the first four principal components, see his “diving deeper” follow up post. Because each component is a (different) linear combination of ALL 17 variables (!), interpreting the principal components becomes very difficult. To do so requires a high cognitive load, and it is unclear where the signal ends and noise starts.

An attractive alternative is performing a cluster analysis on the original data, and using the cluster order to directly visualize the data as a heatmap. This technique is called clustered heatmaps, and is widely used in bioinformatics to display patterns in data.

Two of the most popular clustering algorithms are Hierarchical clustering and k-means clustering. For example we can ask the computer to cluster the 28 teams into e.g. 5 clusters using the K-means algorithm. This assigns each team to one of $k = 5$ clusters, with the cluster centers chosen such that teams within a cluster are close by the cluster center and far away from the other cluster centers. However, this forces us to pick the number of clusters, AND it does not provide information on team similarity WITHIN a cluster.

Clustered heatmaps for the win

Hierarchical clustering circumvents both drawbacks as it clusters ALL the observations in such a way that the most similar observations end up next to each other, and thus provide a complete ordering of all observations. All that remains is to plot the data in this order on a colored grid, and BAM the patterns hit us right between the eyes!

The basic functionality to make a heatmap is provided in the R package ggplot2 by the geom_tile() geometric object. Many wrapper functions around geom_tile() exist to make clustered heatmaps, however they all combine the clustering step with the plotting step.

I am currently experimenting with my own wrapper function ggorder_heatmap(), which I turned into an R package called ggoheatmap. See for details the GitHub repository for the ggoheatmap R package. Note that it is unstable, under development, and possible not even a good idea, so do not use it yourself. Instead use pheatmap by Raivo Kolde, available from CRAN, with the official repo here.

1
2

# pak::pak("gsverhoeven/ggoheatmap")
library(ggoheatmap)

varnames <- c("Blocks", "Fouls", "Cas_inflicted",  "Distance_passed", "Completions", "Running_w_ball", "Cas_suffered")
yorder <- data.frame(yorder = 1:length(varnames), variable = varnames)

df_long <- df_agg %>%
  pivot_longer(cols = !c(race_name, race_type, size), names_to = "variable") %>%
  group_by(variable) %>%
  mutate(sd_value = scale(value)) %>%
  left_join(yorder, by = "variable")

df_long <- ggoheatmap::hclust_order(df_long, 
                        xvar = "race_name", 
                        yvar = "variable", 
                        value_var = "value",
                   clust_method = "complete",
                   dist_method = "euclidean")

library(patchwork)

p1 <- ggplot(df_long, aes(x = reorder(race_name, cluster_order), y = 1, fill = race_type)) +
  geom_tile() + 
  coord_flip() + 
  labs(x = "", y = NULL) + 
  scale_y_discrete(labels = NULL, breaks = NULL) 

p2 <- ggorder_heatmap(df_long, 
                xvar = "race_name", 
                yvar = "variable", 
                col_var = "sd_value", 
                order_var = "cluster_order",
                yorder_var ="yorder",
                legend = FALSE,
                label_var = "value", round.digits = 1) + coord_flip() +
  scale_y_discrete(position = "right")

p1 + p2 + 
  plot_layout(widths = c(1, 6), guides = "collect") + 
  plot_annotation(title = 'BB2020 team typology')

And there we have it, our main result.

First, we see that the existing team categorization does a good job, with the different categories showing different patterns in the match statistics. Note that I did not pre-specify the sort order here, it emerged naturally from the match statistics by the hierarchical clustering algorithm. So the quote from the Pi movie was correct (at least for Blood Bowl): we graphed the numbers, and patterns emerged!

What else can we learn from this plot? The difference between Bash and Hybrid appears not so clear cut: for example: Are Norse (the old BB2020 roster, not the new one) and Chaos Chosen bash or hybrid? Agile and Stunty teams on the other hand are very distinct. Underworld Denizens are an interesting edge case: In BB2020, they cluster right in between Goblin and Skaven teams, I ended up classifying them as Agile. Finally, it is apparent that Vampires indeed are a category of their own.

Conclusions

And now for the question we set out to answer: Where do the new Khorne and Black Orc teams fit in?

Khorne are clearly a hybrid team (because of the lack of skills and frenzy reduces base contact and thus blocks). Black Orcs appear to be quite unique, being a combination of Bashy Hybrid and Fouling.

Finally we produce the clustered heatmap for all four divisions:

source("make_heatmap.R")

for(i in 1:length(divisions)){
  print(make_heatmap(data_tables[[divisions[i]]], division_name = divisions[i]))
}

References

Amiral, Taureau. 2017. “Blood Bowl Teams Strength.” Blood Bowl Strategies, November 24. https://bloodbowlstrategies.com/en/relative-strength-of-teams/.

Breidr. 2015. “Cyanide - ‘Bashy’ Race Choice for League Play.” Blood Bowl Tactics Forum. https://bbtactics.com/forum/threads/bashy-race-choice-for-league-play.4961/.

Dode. 2017. “What Is the Bashiest Agility Team After Dark Elves? :: Blood Bowl 2 General Discussions.” https://steamcommunity.com/app/236690/discussions/0/135512931355543270/.

Ivanauskas, Tadas. 2020. BloodBowl 2 race clustering by different playstyles. http://urn.kb.se/resolve?urn=urn:nbn:se:mau:diva-41540.

Schlice. 2018. “Bash/Dash/Hybrid by the Numbers.” February 27. http://www.nufflytics.com/post/bash-dash-hybrid-by-the-numbers/.

Wilkinson, Leland, and Michael Friendly. 2009. “The History of the Cluster Heat Map.” The American Statistician 63 (2): 179–84. https://doi.org/10.1198/tas.2009.0033.

Nufflytics: Analyzing Blood Bowl matches from FUMBBL using Python

Sun, 20 Mar 2022 00:00:00 +0000

This blogpost is about Blood Bowl, a strategic boardgame invented in the late 80’s, that I finally started playing last year. Blood bowl is a game of Fantasy Football, where fantasy team races (think “Orcs”, or “Elves”) are pitted against each other. Interestingly, the various teams (there are over 20 different ones) require different play styles, and not all team races are equally strong. On tournaments, this gives rise to various compensation schemes to make all teams “viable” for competition. There exists a lively tournament scene, with thousands of matches played each year.

The idea of this blog post is to showcase some possible analyses that can be done on the FUMBBL match data I’ve compiled. The idea is to make Blood Bowl data analysis (also know as Nufflytics, a term coined by Blood Bowler “Schlice” in reference to Nuffle, the god of Blood Bowl) easier and more accessible to others. I took inspiration from various sources, detailed at the end of this post. So lets dive in the world of Blood Bowl stats nerdery.

Getting started with the data

Since the previous blog post on FUMBBL data, I decided to make a separate Github repository fumbbl_datasets that contains the Python code to fetch and construct the FUMBBL datasets. You can either download the latest datasets manually, or clone the entire repo to your local drive, depending on your expertise and preferences.

The datasets are available both in CSV and HDF5. CSV would be the format of choice for Excel analysis, whereas the HDF5 format is suitable for scripted languages such as Python or R. Here we use Python, with the libraries Pandas and plotnine for data analysis and visualization. The code below assumes the datasets are locally stored at the location contained in the path_to_datasets variable:

import pandas as pd
import numpy as np
import plotnine as p9

# point this to the location of the HDF5 datasets
path_to_datasets = '../../../../fumbbl_datasets/'

# FUMBBL matches
target = 'datasets/v0.2/df_matches.h5'
df_matches = pd.read_hdf(path_to_datasets + target) 

# FUMBBL matches by team
target = 'datasets/v0.2/df_mbt.h5'
df_mbt = pd.read_hdf(path_to_datasets + target) 

# FUMBBL inducements
target = 'datasets/v0.2/inducements.h5'
inducements = pd.read_hdf(path_to_datasets + target)

What data do we have? Weekly game volumes

Let’s see what we’ve got! The pandas DataFrame df_matches contains records for all matches played on FUMBBL between august 2020 and march 2022.

Since we have a proper datetime type variable for each week (week_date), we can use pandas and plotnine to plot the weekly game volume as a time series.

The introduction of the new Competitive division with BB2020 rules is marked by a vertical red line. I labeled the larger leagues as well a recent tournament I took part in myself.

res = (df_matches
    .loc[(df_matches['week_date'] >= '2020-08-01' ) & (df_matches['week_date'] < '2022-11-25')]
    .groupby(['week_date', 'week_number', 'division_name'])
    .agg(        
        n_games = ('match_id', "count") 
    )
    .reset_index()) # this adds the "group by" variables back as columns of res

(p9.ggplot(data = res, mapping = p9.aes(x = 'week_date', y = 'n_games', color = 'division_name'))
+ p9.geom_point() 
+ p9.geom_line()
+ p9.expand_limits(y=[0,2000])
+ p9.geom_vline(xintercept = '2021-09-01', color = "red")
+ p9.theme(figure_size = (10, 5))
+ p9.ggtitle("Weekly game volume on FUMBBL august 2020 - march 2022"))

<ggplot: (-9223363302253724542)>

To check the dataset, I compared this plot with the plot of weekly game volumes that FUMBBL itself provides at https://fumbbl.com/p/stats. Both plots looked identical at the time of writing, so it seems that we have a complete dataset for the given period.

The effect of starting the new BB2020 Competitive division is clearly visible, with the weekly game volume almost doubling in september 2021. The first online NAF tournament using BB2020 rules is also visible, running for 6 weeks in October / November 2021.

Star player usage on FUMBBL

We can also look at the percentage of matches that involve star players. I used the various plot aesthetics like symbol shape and size to encode the game volume and ruleset (BB2016 or BB2020 based).

divisions = ['Blackbox', 'Competitive', 'Online NAF Tournaments',  'Ranked', 'Regular_league']

res = (df_matches
.query("division_name in @divisions")
.groupby(['division_name', 'league', 'ruleset', 'ruleset_version', 'week_date'])
.agg(
    n_games = ('match_id', 'count'),
    perc_sp = ('has_sp', 'mean')
)
.reset_index()
.sort_values("n_games", ascending=False)
)

(p9.ggplot(data = res.query("n_games > 30"), mapping = p9.aes(x = 'week_date', y = 'perc_sp*100', 
group = 'factor(division_name)', color = 'factor(division_name)'))
    + p9.geom_point(p9.aes(shape = 'factor(ruleset_version)', size = 'n_games')) 
    + p9.expand_limits(y=[0,1])
    + p9.scale_size_area()
    + p9.geom_vline(xintercept = '2021-09-01', color = "red")
    + p9.ggtitle("Star player usage over time, by division/league")
    + p9.theme(figure_size = (10, 6))
    + p9.ylab("% matches with at least one Star Player"))

<ggplot: (-9223363302246313763)>

In above graph, the various online NAF Tournaments are clearly distinguished. Amorical Cup 2020 in summer 2020, Eur’Open Online in Nov/dec 2020, SteelBowl in Feb 2021, and LitBowl in May 2021 were all using BB2016 rules.

Through Googling and using the Wayback Machine, I was able to find the rulepacks of these tournaments. LitBowl featured “big budgets” (up to 1440K) and a requirement of only 10 regular players before inducement, this likely explains the large amount of Star Players in that tournament.

In contrast, in the GBFU tournament, the first online NAF tournament using the BB2020 rules, only some 15% of matches involved at least one star player.

Are coach ratings predictive of match outcomes?

For the main divisions on FUMBBL, ELO style coach ratings are available that are updated after each game. The coach rankings are explained on this help page.

According to the ELO ranking system, a coach rating difference of 40 should result in 85% wins for the higher ranked coach. Coaches of equal rating should have a win rate of 0.5 (with draws weighted at half point).

The range of coach rankings observed for a particular game tells us something about the relationship between skill and luck. If a game is pure luck, we will never observe large differences in coach rating, since the outcome will be determined by a coin flip, independent of coach skill.

On FUMBBL, coach ratings vary roughly between 125 and 175. What do we expect if a coach with a rating of 175 plays a coach of rating 145? Well, the rating difference is 30. According to the formula (assuming equal team strength and equal races), the expected win probability is 1/(1 + 10^0.75) = 85%, and the probability of loss is 15%.

Since our CR we obtained from the FUMBBL match result page is an overall coach rating (i.e. it ignores division), we can simply pool all matches from divisions where coach rating is tracked.

The match data contains a Coach Ranking Difference bin (category) that we can each to calculate the Win/draw/loss percentages for each category.

Let’s see what the actual percentages are:

main_divisions = ['Blackbox', 'Ranked', 'Competitive']

res = (df_matches[df_matches['division_name'].isin(main_divisions)]
    .groupby(['cr_bin', 'team1_win'])
    .agg(        
        n_games = ('cr_bin', "count"),
    )
    .reset_index()) # this adds the group by variable (now index) as a column

# add total games played within each bin
res['n_games_bin'] = res.groupby('cr_bin').n_games.transform('sum')

res['perc'] = res['n_games']/res['n_games_bin']

(p9.ggplot(res, p9.aes(x = 'factor(cr_bin)', y = 'perc', fill = 'factor(team1_win)')) 
    + p9.geom_bar(position = "fill", stat = "identity") 
    + p9.theme(axis_text_x= p9.element_text(rotation=90, hjust=1))
    + p9.ggtitle('probability of win/draw/loss as a function of Coach Rating difference')
)

<ggplot: (-9223363302350291624)>

(Note that I made the bins for large CR differences (greater than 10) wider to get more games per bin.)

From above graphs, we can conclude that the coach ratings work as expected, with large coach rating differences indeed showing high win rates for the higher ranked coach. From this we can infer that a highly skilled coach will win 9 times out of ten agains a below average coach. We call Blood Bowl a Strategy game for a reason!

What about the passing game in BB2020?

With Blood Bowl 2020 also came a large change to passing the ball. Passing is no longer linked to the Agility statistics, but now has its own Passing (PA) stat. Overall, passing became riskier, and high agility teams do not automatically have good passing stats. For example, only a High Elf thrower has a PA of 2+, whereas the rest of the players have a PA of 4+ or higher. On the Dark Elf team, the player with the best PA stat is the runner, with a PA of 3+, without a built in re-roll. So we can expect quite some changes in the number of completions per match. For more detail I refer to a nice post by king_ghidra at Blood Bowl Strategies.

Let’s have a look!

divisions = ['Ranked', 'Blackbox', 'Competitive']

tv_bins = ['1.1M', '1.4M', '1.7M']

res = (df_mbt[df_mbt['division_name'].isin(divisions)]
    .loc[df_mbt['tv_bin'].isin(tv_bins)]
    .query("mirror_match == 0 & has_sp == 0 & tv_bin in @tv_bins & division_name in @divisions")
    .groupby(['division_name', 'ruleset_version', 'week_date', 'tv_bin'])
    .agg(        
        avg_comp = ('home_comp', "mean"),
        avg_pass = ('home_pass', "mean"),
        avg_foul = ('home_foul', "mean"),
        avg_block = ('home_block', "mean"),    
        avg_cas = ('home_cas', "mean"),  
        avg_rcv_cas = ('away_cas', "mean"),
        n_games = ('race_name', "count")
    )
    .sort_values( 'n_games', ascending = False)
    .reset_index()) # this adds the group by variables (now index) as a column

res = res.dropna()

(p9.ggplot(data = res.query('n_games > 10'), 
            mapping = p9.aes(x = 'week_date', y = 'avg_comp', 
                            size = 'n_games', color = 'factor(division_name)', shape = 'factor(tv_bin)'))
    + p9.geom_point()
    + p9.scale_size_area() 
    + p9.geom_vline(xintercept = '2021-09-01', color = "red")    
    + p9.theme(figure_size = (10, 5))
    + p9.ggtitle("average completions per game BB2020 vs BB2016"))

/home/gertjan/venvs/requests_env/lib/python3.6/site-packages/plotnine/scales/scale_shape.py:85: PlotnineWarning: Using shapes for an ordinal variable is not advised.

<ggplot: (-9223363302350371093)>

divisions = ['Ranked', 'Blackbox', 'Competitive']

tv_bins = ['1.1M', '1.4M', '1.7M']

res = (df_mbt[df_mbt['division_name'].isin(divisions)]
    .loc[df_mbt['tv_bin'].isin(tv_bins)]
    .query("mirror_match == 0 & has_sp == 0 & tv_bin in @tv_bins & division_name in @divisions")
    .groupby(['ruleset_version', 'race_name', 'tv_bin'])
    .agg(        
        avg_comp = ('home_comp', "mean"),
        avg_pass = ('home_pass', "mean"),
        avg_foul = ('home_foul', "mean"),
        n_games = ('race_name', "count")
    )
    .sort_values( 'n_games', ascending = False)
    .reset_index()) # this adds the group by variables (now index) as a column

res = res.dropna()

(p9.ggplot(data = res.query('n_games > 10 & tv_bin == "1.1M"'), 
            mapping = p9.aes(y = 'reorder(race_name, avg_comp)', x = 'avg_comp', 
                            size = 'n_games', group = 'factor(ruleset_version)', 
                            color = 'factor(ruleset_version)'))
    + p9.geom_point()
    + p9.scale_size_area() 
    + p9.ggtitle("average completions per game BB2016 vs BB2020 at 1.1M TV"))

<ggplot: (-9223363302350232432)>

Across the board we see a decrease in average completions per match. Note that this is for low team values, at around 1.1M, between 950K and 1250K.

Observations that stand out:

High agility teams such as Elven Union, Wood Elf and Skaven show large drops,
Dark elves show the largest relative drop (more than halving in completions),
High Elves are hardly affected, as well as Humans,
Halflings show a large increase.

And what about fouling in BB2020?

Also for fouling Blood Bowl 2020 brought some changes to the rules. The Sneaky Git skill became better, allowing a player to continue moving after the foul has been committed. The Black Orcs were added as a new team, that show fouling potential: they have access to cheap bribes, the Grab skill to set up a foul, and cheap goblin bruisers to quickly move around the pitch. And there was of course the swarming for the Underworld and Snotling teams, that provides a continuous supply of disposable players to foul with. For more detail I refer to a nice post by king_ghidra at Blood Bowl Strategies.

Let’s see how the stats were affected!

divisions = ['Ranked', 'Blackbox', 'Competitive']

tv_bins = ['1.1M', '1.2M', '1.3M', '1.4M']

res = (df_mbt[df_mbt['division_name'].isin(divisions)]
    .loc[df_mbt['tv_bin2'].isin(tv_bins)]
    .query("mirror_match == 0 & has_sp == 0 & tv_bin2 in @tv_bins & division_name in @divisions")
    .groupby(['ruleset_version', 'race_name', 'tv_bin2'])
    .agg(        
        avg_comp = ('home_comp', "mean"),
        avg_pass = ('home_pass', "mean"),
        avg_foul = ('home_foul', "mean"),
        n_games = ('race_name', "count")
    )
    .sort_values( 'n_games', ascending = False)
    .reset_index()) # this adds the group by variables (now index) as a column

res = res.dropna()

(p9.ggplot(data = res.query('n_games > 10'), 
            mapping = p9.aes(y = 'reorder(race_name, avg_foul)', x = 'avg_foul', 
                            size = 'n_games', color = 'factor(ruleset_version)', 
                            shape = 'factor(tv_bin2)'))
    + p9.geom_point()
    + p9.scale_size_area() 
    + p9.ggtitle("average number of fouls per game BB2016 vs BB2020")
    + p9.ylab(""))

<ggplot: (8734504437775)>

From this plot, we can see that BB2020 indeed shows increased fouling across the board. As expected, the Black Orcs are high up in the fouling charts, and we see large increases in fouling for Underworld, Goblins, Halflings and Snotlings. We can also see that as teams develop, fouling typically increases, possible related to developing a specialized fouling player with the sneaky git skill. For humans access to cheap agile halfling hopefulls with access to sneaky git increased fouling opportunity. In Orc teams goblins can forfill this role.

Competitive division win rates and Malta Eurobowl 2022 tiers

Last but not least, a win rate analysis. In a tournament setting, elaborate tiering systems are in place to compensate for differences in race strength, skills are selected from skill packs, and player casualties are forgotten with each match played with a “resurrected” fresh team. Furthermore, opponents are randomly assigned and must be played. Contrast this with the FUMBBL Competitive division: Here teams start with 1M gold and without any extra skills. Teams must be developed, like in a league, and opponents can be strategically chosen based on which race they play, their coach rating etc.

With all this in mind, I tried the impossible: to compare relative team strength as expected by the tournament tiers, with the observed win rates in the Competitive Division. With the Eurobowl 2022 in Malta coming up, I decided to approximate the conditions of that rulepack. Teams are created using 1.15M gold, as well as roughly 36 SPP worth of skills. This translates to 6 primary skills worth 20K, giving us a total team value of 1270K, say around 1.3M.

To correct for differences in coaching ability, I restricted the match selection for matches where coach ratings are not too different (< 10), and above 150. I excluded matches involving Star players, and mirror matches (I.e. Orcs vs Orcs). To distinguish the relatively small % differences in win rate, we need to have a bandwidth around 1.3M to get sufficient statistics for each team. I included confidence intervals to visualize the statistical uncertainty for the win rates.

# Function for computing confidence intervals
from statsmodels.stats.proportion import proportion_confint   

divisions = ['Competitive']

tv_bins = ['1.2M', '1.3M', '1.4M']

res = (df_mbt[df_mbt['division_name'].isin(divisions)]
    .loc[df_mbt['tv_bin2'].isin(tv_bins)]
    .query('mirror_match == 0 & has_sp == 0 & CR_diff < 10 & coach_CR > 150')
    .groupby(['race_name', 'ruleset_version', 'Malta_2022'])
    .agg(        
        perc_win = ('wins', "mean"),
        n_wins = ('wins', "sum"),
        n_games = ('race_name', "count")
    )
    .query('n_games > 0')
    .reset_index()) # this adds the group by variable (now index) as a column

res['lower_CI'], res['upper_CI'] =  proportion_confint(
                                      count = round(res['n_wins']).astype(int),
                                      nobs = res['n_games'],
                                      alpha = 0.05
                                  )

(p9.ggplot(data = res.query('n_games > 30'), 
            mapping = p9.aes(x = 'reorder(race_name, -Malta_2022)', y = 'perc_win', 
            size = 'n_games', color = 'factor(Malta_2022)'))
    + p9.geom_linerange(p9.aes(ymin = 'lower_CI', ymax = 'upper_CI'), size = 1)
    + p9.geom_point()
    + p9.scale_size_area() 
    + p9.coord_flip()
    + p9.geom_hline(yintercept = 0.5)
    + p9.ggtitle("FUMBBL BB2020 win rates around 1.3M"))

<ggplot: (-9223363302334269892)>

First off, I think the most important lesson here is that it is really difficult to compare win rates across such different settings.

But what info can we squeeze from this plot nevertheless:

It seems that Amazon and Underworld have higher FUMBBL win rates than expected based on their Malta 2022 tier.

For Amazon, this might be due to being able to avoid particular opponents on FUMBBL, such as Dwarves and Chaos Dwarves, with a lot of Tackle.
For Underworld, this is likely related to their improvements in BB2020, leading the charts at NAF tournaments, that resulted in recent rule changes that weakened them with the November 2021 Games Workshop ruling.

What else do we got:

Nurgle has a relatively low win rate compared to other teams with the same tier.
High Elf has a low tier, but shows an above average win rate, and appears to perform well at NAF tournaments. Curious to see how this race will do this year.

Concluding Remarks and acknowledgements

The analyses above hopefully give you some idea what can be with the rich FUMMBL data available.

One last application: The data can also be used to search for matches based on highly particular search criteria: for example, if you are interested in Snotling matches that induce Morg N Thorg and play against a skilled Elf coach. The match_id can then be used to watch the replay on FUMBBL.

Finally, some acknowledgements. While writing this blog, I drew inspiration from several sources:

most notable the FUMBBL website itself that has a wealth of statistics available,
the website of FUMBBL coach Koadah with aggregated FUMBBL stats,
the NAF monthly reports by Mike Davies,
a blog post on team strength by Taureau Amiral ,
the Nufflytics blog by Blood Bowl 2 coach Schlice,
the various technical posts of FUMBBL coach Adam Szieberth who followed a similar approach using Python API and web scraping FUMBBL data.

Construction of a public dataset of Blood Bowl matches played on FUMBBL.com

Thu, 30 Dec 2021 00:00:00 +0000

This blogpost is about Blood Bowl, a boardgame of fantasy football that can also be played online at FUMBBL.com. The goal of this blog post is to use Python API and HTML scraping to fetch online Blood Bowl match outcome data, and to create a publicly available dataset ready for analysis and visualization. In a separate blog post I’ll showcase some analyses on this dataset (also known as Nufflytics in reference to Nuffle, the god of Blood Bowl). The dataset is primarily constructed to analyze rule changes that were introduced on FUMBBL.com last year, and how these affected the relative strengths of the different teams coaches can pick to field against each other.

N.b. an updated version of this post is available as a Jupyter Notebook in a separate Github Repository fumbbl_datasets.

In writing this blog post, I took inspiration from a relatively new development in Open Science, that of the Data paper (Chavan & Penev, 2011). A data paper is a (ideally peer reviewed) publication of a dataset as a stand alone research output. A Data paper can be thought of similar to the “Methods” section of a traditional research article, though with greater detail. A data paper describes the contents of the dataset, the data acquisition process, and includes a discussion of the motivation and considerations regarding experimental design (if applicable). Data papers do not provide any analysis nor results / conclusions. The dataset itself should be online available at a data repository such as Zenodo, Figshare or Dryad.

To give an impression of how this works out in practice, here are two examples: The first data paper, A public data set of spatio-temporal match events in soccer competitions, was published in “Scientific data” with the dataset hosted at Figshare. The second is collected from Twitter: A large-scale COVID-19 Twitter chatter dataset for open scientific research – an international collaboration, with the open dataset published on Zenodo.

*Chavan, V., and Penev, L. (2011). The data paper: a mechanism to incentivize data publishing in biodiversity science. BMC Bioinformatics 12(Suppl. 15):S2. doi:10.1186/1471-2105-12-S15-S2

Software needed to reproduce this blog post

This blogpost is written as a Jupyter notebook containing Python code, and is fully reproducible. The idea is to make Blood Bowl data analysis accessible to others. Using open source tooling reduces the barriers for others to build on other people’s work.

import random
import time

import requests # API library

import numpy as np
import pandas as pd

pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)

Blood Bowl online: FUMBBL

The FUMBBL website (https://fumbbl.com) contains a large amount of data. From coach pages, with their teams, to team rosters, with players, and match histories. It’s all there.

To obtain FUMBBL data, we need to fetch it match by match, team by team. To do so, the site creator Christer Kaivo-oja, from Sweden, has made an API that allows us to easily fetch data. What follows is a short demonstration how the API works, before we fetch the FUMBBL match and team data of the last 12 months.

Behold, the power of Requests

I use the Python Requests library to make the API call over HTTPS and obtain the response from the FUMBLL server. The response is in the JSON format, a light-weight data-interchange format which is both easy to read and write for humans, and easy to parse and generate by computers. So this makes it a natural choice for an API.

Here is an example of what is available at the coach level. The full documentation of the API can be found at (https://fumbbl.com/apidoc/).

1
2
3

response = requests.get("https://fumbbl.com/api/coach/teams/gsverhoeven")
# display the complete JSON object {}
response.json()

{'id': 255851,
 'name': 'gsverhoeven',
 'teams': [{'id': 1003452,
   'coachId': 255851,
   'name': 'Hillywood Hellraisers',
   'rosterId': 50,
   'race': 'Human',
   'teamValue': 1090000,
   'canLfg': 'Yes',
   'isLfg': 'Yes',
   'games': '3',
   'divisionId': 1,
   'division': 'Ranked',
   'leagueId': 0,
   'league': None,
   'status': 'Retired',
   'raceLogos': [{'size': 32, 'logo': 486290},
    {'size': 48, 'logo': 486291},
    {'size': 64, 'logo': 486292},
    {'size': 96, 'logo': 486293},
    {'size': 128, 'logo': 486294},
    {'size': 192, 'logo': 486295}]},
  {'id': 1035833,
   'coachId': 255851,
   'name': 'Pharaoh Munchers',
   'rosterId': 51,
   'race': 'Tomb Kings',
   'teamValue': 960000,
   'canLfg': 'Yes',
   'isLfg': 'No',
   'games': '0',
   'divisionId': 1,
   'division': 'Ranked',
   'leagueId': 0,
   'league': None,
   'status': 'Active',
   'raceLogos': [{'size': 32, 'logo': 486296},
    {'size': 48, 'logo': 486297},
    {'size': 64, 'logo': 486298},
    {'size': 96, 'logo': 486299},
    {'size': 128, 'logo': 486300},
    {'size': 192, 'logo': 486301}]},
  {'id': 1035835,
   'coachId': 255851,
   'name': 'Blackbox Bastards',
   'rosterId': 50,
   'race': 'Human',
   'teamValue': 840000,
   'canLfg': 'No',
   'isLfg': 'No',
   'games': '1',
   'divisionId': 10,
   'division': 'Blackbox',
   'leagueId': 0,
   'league': None,
   'status': 'Retired',
   'raceLogos': [{'size': 32, 'logo': 486290},
    {'size': 48, 'logo': 486291},
    {'size': 64, 'logo': 486292},
    {'size': 96, 'logo': 486293},
    {'size': 128, 'logo': 486294},
    {'size': 192, 'logo': 486295}]},
  {'id': 1036599,
   'coachId': 255851,
   'name': 'Seven cities of Gold',
   'rosterId': 52,
   'race': 'Lizardmen',
   'teamValue': 1000000,
   'canLfg': 'Yes',
   'isLfg': 'No',
   'games': '0',
   'divisionId': 1,
   'division': 'Ranked',
   'leagueId': 0,
   'league': None,
   'status': 'Active',
   'raceLogos': [{'size': 32, 'logo': 486302},
    {'size': 48, 'logo': 486303},
    {'size': 64, 'logo': 486304},
    {'size': 96, 'logo': 486305},
    {'size': 128, 'logo': 486306},
    {'size': 192, 'logo': 486307}]},
  {'id': 1038960,
   'coachId': 255851,
   'name': 'Hillywood Hellraisers 2.0',
   'rosterId': 50,
   'race': 'Human',
   'teamValue': 1110000,
   'canLfg': 'Yes',
   'isLfg': 'Yes',
   'games': '4',
   'divisionId': 1,
   'division': 'Ranked',
   'leagueId': 0,
   'league': None,
   'status': 'Active',
   'raceLogos': [{'size': 32, 'logo': 486290},
    {'size': 48, 'logo': 486291},
    {'size': 64, 'logo': 486292},
    {'size': 96, 'logo': 486293},
    {'size': 128, 'logo': 486294},
    {'size': 192, 'logo': 486295}]},
  {'id': 1050267,
   'coachId': 255851,
   'name': 'Gooische Heidebeukers',
   'rosterId': 4974,
   'race': 'Orc',
   'teamValue': 1330000,
   'canLfg': 'Yes',
   'isLfg': 'Yes',
   'games': '6',
   'divisionId': 5,
   'division': 'League',
   'leagueId': 14883,
   'league': 'Benelux Hate Bowl',
   'status': 'Post Match Sequence',
   'raceLogos': [{'size': 32, 'logo': 486332},
    {'size': 48, 'logo': 486333},
    {'size': 64, 'logo': 486334},
    {'size': 96, 'logo': 486335},
    {'size': 128, 'logo': 486336},
    {'size': 192, 'logo': 486337}]},
  {'id': 1052980,
   'coachId': 255851,
   'name': '[2020] Hillywood Hellraisers',
   'rosterId': 4964,
   'race': 'Human',
   'teamValue': 1000000,
   'canLfg': 'Yes',
   'isLfg': 'No',
   'games': '0',
   'divisionId': 2,
   'division': 'Competitive',
   'leagueId': 0,
   'league': None,
   'status': 'Active',
   'raceLogos': [{'size': 32, 'logo': 486290},
    {'size': 48, 'logo': 486291},
    {'size': 64, 'logo': 486292},
    {'size': 96, 'logo': 486293},
    {'size': 128, 'logo': 486294},
    {'size': 192, 'logo': 486295}]},
  {'id': 1053065,
   'coachId': 255851,
   'name': '[2020] Grrrl power',
   'rosterId': 5141,
   'race': 'Amazon',
   'teamValue': 960000,
   'canLfg': 'Yes',
   'isLfg': 'No',
   'games': '0',
   'divisionId': 2,
   'division': 'Competitive',
   'leagueId': 0,
   'league': None,
   'status': 'Active',
   'raceLogos': [{'size': 32, 'logo': 486194},
    {'size': 48, 'logo': 486192},
    {'size': 64, 'logo': 486195},
    {'size': 96, 'logo': 486191},
    {'size': 128, 'logo': 486193},
    {'size': 192, 'logo': 486190}]},
  {'id': 1060696,
   'coachId': 255851,
   'name': 'Hakflem support team',
   'rosterId': 4978,
   'race': 'Underworld Denizens',
   'teamValue': 730000,
   'canLfg': 'Yes',
   'isLfg': 'No',
   'games': '0',
   'divisionId': 2,
   'division': 'Competitive',
   'leagueId': 0,
   'league': None,
   'status': 'Active',
   'raceLogos': [{'size': 32, 'logo': 603383},
    {'size': 48, 'logo': 603381},
    {'size': 64, 'logo': 603378},
    {'size': 96, 'logo': 603382},
    {'size': 128, 'logo': 603380},
    {'size': 192, 'logo': 603379}]}]}

Parsing JSON data

Let’s have a closer look at the JSON data structure here. We have a list of key-value pairs. Using brackets [] we can choose keys and retrieve their values. Some keys contain simple values, such as name,

`1`	`response.json()['name']`

'gsverhoeven'

but some return as value a new list of key-value pairs, such as teams. Actually this is a “list of “lists of key-value pairs”, since we have a separate list for each team. Even the list of a single team contains new structure, for example under the key raceLogos.

`1`	`response.json()['teams'][2]['raceLogos']`

[{'size': 32, 'logo': 486290},
 {'size': 48, 'logo': 486291},
 {'size': 64, 'logo': 486292},
 {'size': 96, 'logo': 486293},
 {'size': 128, 'logo': 486294},
 {'size': 192, 'logo': 486295}]

`1`	`response.json()['teams'][2]['name']`

'Blackbox Bastards'

What data do we need? And in what shape?

Now we know how the data comes in, we need to think about which variables we want, and how to structure them. The most straightforward level to analyze race strength is to look at match outcomes. At its core, the data consists of matches played by teams, commanded by coaches. Furthermore, we expect race strength to change over time, as new strategies are discovered by the players, or new rules get introduced. So the time dimension is important as well.

So, let’s go with a flat data frame with rows for each match, and columns for the various variables associated with each match. These would include:

Coach ids
Team races
Team ids
Date of the match
Outcome (Touchdowns of both teams)

With this basic structure, we can add as many match related variables in the future, keeping the basic structure (each row is a match) unchanged.

So lets get the match data!

Step 1: API scraping the match data: df_matches

So we are mostly interested in the current ruleset, this is BB2020. This ruleset became available for play on FUMBBL at september 1st 2021, and two months later, already some 5000 games have been played. We also want to compare with the previous ruleset, where we have much more data available. How far do we go back? Let’s go for roughly 12 months of BB2016 ruleset matches, and a few months of BB2020 matches.

The easiest way to collect match data over a particular period of time is to just loop over match_id. The most recent match at the time of writing was 4.347.800, and since roughly 100.000 matches are played each year, we can fiddle about and we find match 4.216.258 played on august 1st, 2020. So that means we need to collect some 130K matches.

VERY IMPORTANT: We do not want to overload the FUMBBL server, so we make only three API requests per second. In this way, the server load is hardly affected and it can continue functioning properly for all the Blood Bowl coaches playing their daily games!

To collect 130K matches, we will need 130000*0.333/3600 = 12 hours.

1
2

# estimated hours fetching data
(4347800-4216257)*0.333/3600

12.16773

df_matches = pd.DataFrame(columns=['match_id', 'match_date', 'match_time',  
    'team1_id', 'team1_coach_id', 'team1_roster_id', 'team1_race_name', 'team1_value',
    'team2_id', 'team2_coach_id', 'team2_roster_id', 'team2_race_name', 'team2_value',
    'team1_score', 'team2_score'])

target = 'data/df_matches_' + time.strftime("%Y%m%d_%H%M%S") + '.h5'
print(target)

end_match = 4347800
begin_match = 4216258
n_matches = end_match - begin_match
full_run = 0
print(n_matches)

if(full_run):
    for i in range(n_matches):
        api_string = "https://fumbbl.com/api/match/get/" + str(end_match - i)
        # wait 0.33 s on average between each API call
        wait_time = (random.uniform(0.5, 1) + 0.25)/3
        time.sleep(wait_time)
        match = requests.get(api_string)
        match = match.json()
        if match: # fix for matches that do not exist
            match_id = match['id']
            match_date = match['date']
            match_time = match['time']
            team1_id = match['team1']['id']
            team2_id = match['team2']['id']
            team1_score = match['team1']['score']
            team2_score = match['team2']['score']  
            team1_roster_id = match['team1']['roster']['id']
            team2_roster_id = match['team2']['roster']['id']            
            team1_coach_id = match['team1']['coach']['id']
            team2_coach_id = match['team2']['coach']['id']
            team1_race_name = match['team1']['roster']['name'] 
            team2_race_name = match['team2']['roster']['name'] 
            team1_value = match['team1']['teamValue']
            team2_value = match['team2']['teamValue']
            #print(match_id)     
            df_matches.loc[i] = [match_id, match_date, match_time, 
                team1_id, team1_coach_id, team1_roster_id, team1_race_name, team1_value,
                team2_id, team2_coach_id, team2_roster_id, team2_race_name, team2_value,
                team1_score, team2_score]
        else:
            # empty data for this match, create empty row
            match_id = int(end_match - i)
            df_matches.loc[i] = [np.NaN, np.NaN, np.NaN, 
            np.NaN,np.NaN,np.NaN,np.NaN,
            np.NaN,np.NaN,np.NaN,np.NaN,
            np.NaN,np.NaN, np.NaN, np.NaN] # try np.repeat([np.NaN], 13, axis=0) next time
            df_matches.loc[i]['match_id'] = int(match_id)
        if i % 100 == 0: 
            # write tmp data as hdf5 file
            print(i, end='')
            print(".", end='')
            df_matches.to_hdf(target, key='df_matches', mode='w')

    # write data as hdf5 file
    df_matches.to_hdf(target, key='df_matches', mode='w')
else:
    # read from hdf5 file
    df_matches = pd.read_hdf('data/df_matches_20211215_212935.h5')

df_matches.shape

data/df_matches_20211230_192705.h5
131542

(131542, 15)

Since we manually filled the pandas DataFrame, most of the columns are now of object datatype. We need to change this to be able to work properly with the data, as well as store it properly. Here I convert each column manually, however I later found out about DataFrame.infer_objects(), that can detect the proper dtype automatically. This I will try next time.

# convert object dtype columns to proper pandas dtypes datetime and numeric
df_matches['match_date'] = pd.to_datetime(df_matches.match_date) # Datetime object
df_matches['match_id'] = pd.to_numeric(df_matches.match_id) 
df_matches['team1_id'] = pd.to_numeric(df_matches.team1_id) 
df_matches['team1_coach_id'] = pd.to_numeric(df_matches.team1_coach_id) 
df_matches['team1_roster_id'] = pd.to_numeric(df_matches.team1_roster_id) 
df_matches['team2_id'] = pd.to_numeric(df_matches.team2_id) 
df_matches['team2_coach_id'] = pd.to_numeric(df_matches.team2_coach_id) 
df_matches['team2_roster_id'] = pd.to_numeric(df_matches.team2_roster_id) 
df_matches['team1_score'] = pd.to_numeric(df_matches.team1_score) 
df_matches['team2_score'] = pd.to_numeric(df_matches.team2_score) 

# calculate match score difference
df_matches['team1_win'] = np.sign(df_matches['team1_score'] - df_matches['team2_score'])
df_matches['team2_win'] = np.sign(df_matches['team2_score'] - df_matches['team1_score'])

# mirror match
df_matches['mirror_match'] = 0
df_matches.loc[df_matches['team1_race_name'] == df_matches['team2_race_name'], 'mirror_match'] = 1

1
2

# 5K mirror matches
df_matches.query('mirror_match == 1').shape

(5081, 18)

1
2
3

# Make BB2020 Khorne team name equal to BB2016 to compare them more easily
df_matches.loc[df_matches['team1_race_name'] == "Khorne", 'team1_race_name'] = 'Daemons of Khorne'
df_matches.loc[df_matches['team2_race_name'] == "Khorne", 'team2_race_name'] = 'Daemons of Khorne'

Dataprep: transforming the team values

In Blood Bowl, teams can develop themselves over the course of multiple matches. The winnings of each match can be spend on buying new, stronger players, or replace the players that ended up getting injured or even killed. In addition, players receive so-called star player points (SPP) for important events, such as scoring, or inflicting a casualty on the opponent. Therefore, a balancing mechanism is needed when a newly created “rookie” team is facing a highly developed opposing team with lots of extra skills and strong players.

Blood Bowl solves this by calculating for both teams their Current team value. The Team value difference for a match determines the amount of gold that the weaker team can use to buy so-called inducements. These inducements are temporary, and can consists of a famous “star player” who joins the team just for this match. Another popular option is to hire a wizard that can be used to turn one of the opposing players into a frog.

It is well known that the win rates of the teams depend on how developed a team is. For example, Amazons are thought to be strongest at low team value, as they already start out with lots of block and dodge skills, whereas a Chaos team start out with almost no skills. So if we compare win rates, we would like take into account the current team value. Now as this can differ between the two teams in a match up, I reasoned that the highest team value is most informative about the average strength level of both teams, because of the inducement mechanism described above.

In the dataset, we have for each match the current team values of both teams as a text string. We transform the text string 1100k into an integer number 1100, so that we can calculated the difference as tv_diff, and pick for each match the maximum team value and store it as tv_match. Finally, we create a team value bin tv_bin to be able to compare win rates for binned groups of matches where races have comparable team strength / team development.

# convert team value 1100k to 1100 integer and and above / below median (= low / high TV)
df_matches['team1_value'] = df_matches['team1_value'].str.replace('k$', '')
df_matches['team1_value'] = df_matches['team1_value'].fillna(0).astype(np.int64)

df_matches['team2_value'] = df_matches['team2_value'].str.replace('k$', '')
df_matches['team2_value'] = df_matches['team2_value'].fillna(0).astype(np.int64)

df_matches['tv_diff'] = np.abs(df_matches['team2_value'] - df_matches['team1_value'])

df_matches['tv_match'] = df_matches[["team1_value", "team2_value"]].max(axis=1)

df_matches['tv_bin'] = pd.cut(df_matches['tv_match'], 
    bins = [0, 950, 1250,1550, 1850, float("inf")], 
    labels=['< 950', '1.1K', '1.4K', '1.7K', '> 1850']
)

Dropping empty matches

Some match_id’s do not have match information attached to them, presumably these matches were not played or some real life event interfered. These match_ids are dropped from the dataset to get rid of the NAs in all the columns.

`1`	`df_matches = df_matches.dropna(subset=['match_date'])`

1
2

# 131K matches
len(df_matches)

Dataprep: getting the dates right

To see time trends, its useful to aggregate the data by week. For this we add week_number for each date, and from this week number, we convert back to a date to get a week_date. This last part is useful for plotting with plotnine, as this treats dates in a special way. We use the ISO definition of week, this has some unexpected behavior near the beginning / end of each year, that we fix manually.

The data starts in week 36 (september) of 2020, and stops halfway week 44 in 2021.

df_matches['week_number'] = df_matches['match_date'].dt.isocalendar().week

# cannot serialize numpy int OR Int64 when writing HDF5 file, so we go for plain int as all NAs are gone now
df_matches['week_number'] = df_matches['week_number'].fillna(0).astype(int)

# add year based on match date (but want it based on match ISO week)
df_matches['year'] = pd.DatetimeIndex(df_matches['match_date']).year

# manual fix year for ISO week 2020-53 (2020 has 53 ISO weeks, including a few days in jan 2021)
df_matches.loc[(df_matches['year'] == 2021) & (df_matches['week_number'] == 53), 'year'] = 2020

df_matches['week_year'] = df_matches['year'].astype(str) + '-' + df_matches['week_number'].astype(str)

df_matches['week_date'] = pd.to_datetime(df_matches['week_year'].astype("string") + '-1', format = "%Y-%U-%w")

# manual fix of week date (grrrr)
df_matches.loc[(df_matches['week_date'] == '2021-01-04') & (df_matches['week_number'] == 53), 'week_date'] = pd.to_datetime('2020-12-31')

Step 2: HTML Scraping the inducements and coach rankings for each match

Next, we collect for all the matches in df_matches the inducements and coach rankings. This information is not available through the API, but is presented on a HTML page at https://fumbbl.com/FUMBBL.php?page=match&id=4350014 summarizing information for in this case match 4350014.

I highly recommend this tutorial for a great introduction to BeautifulSoup.

In addition, to clean up the scraped text, I used the re Python module (Regular expressions), part of the Python standard library to extract the actual inducements from the text string that contains them.

from bs4 import BeautifulSoup
import re

df_inducements = pd.DataFrame(columns=['match_id', 'team1_inducements', 'team2_inducements', 'coach1_ranking', 'coach2_ranking'])

target = 'data/df_inducements_' + time.strftime("%Y%m%d_%H%M%S") + '.h5'
print(target)

end_match = 4347800  
begin_match = 4216257

n_matches = end_match - begin_match

full_run = 0

print(n_matches)

if(full_run):
    for i in range(n_matches):
        match_id = end_match - i
        api_string = "https://fumbbl.com/FUMBBL.php?page=match&id=" + str(match_id)
        # wait 0.33 s on average between each GET call
        wait_time = (random.uniform(0.5, 1) + 0.25)/3
        time.sleep(wait_time)
        response = requests.get(api_string)

        soup = BeautifulSoup(response.content, 'html.parser')

        if soup.find("div", {"class": "matchrecord"}) is not None:
            # match record is available
            inducements = soup.find_all("div", class_="inducements")

            pattern = re.compile(r'\s+Inducements: (.*)\n')

            match = re.match(pattern, inducements[0].get_text())
            if match:
                team1_inducements = match.group(1)
            else:
                team1_inducements = ''

            match = re.match(pattern, inducements[1].get_text())
            if match:
                team2_inducements = match.group(1)
            else:
                team2_inducements = ''

            coach_rankings = soup.find_all("div", class_="coach")

            coach1_ranking = coach_rankings[0].get_text()
            coach2_ranking = coach_rankings[1].get_text()

            df_inducements.loc[i] = [match_id, team1_inducements, team2_inducements, coach1_ranking, coach2_ranking]

        if i % 100 == 0: 
                    # write tmp data as hdf5 file
                    print(i, end='')
                    print(".", end='')
                    df_inducements.to_hdf(target, key='df_inducements', mode='w')

    # write data as hdf5 file
    df_inducements.to_hdf(target, key='df_inducements', mode='w')
else:
    # read from hdf5 file
    
    df_inducements = pd.read_hdf('data/df_inducements_20211215_112148.h5') 


df_inducements.info()

data/df_inducements_20211230_192709.h5
131543
<class 'pandas.core.frame.DataFrame'>
Int64Index: 131509 entries, 0 to 131508
Data columns (total 5 columns):
 #   Column             Non-Null Count   Dtype 
---  ------             --------------   ----- 
 0   match_id           131509 non-null  object
 1   team1_inducements  131509 non-null  object
 2   team2_inducements  131509 non-null  object
 3   coach1_ranking     131509 non-null  object
 4   coach2_ranking     131509 non-null  object
dtypes: object(5)
memory usage: 6.0+ MB

`1`	`df_inducements.query("match_id == 4347799")`

	match_id	team1_inducements	team2_inducements	coach1_ranking	coach2_ranking
1	4347799		1 bloodweiser babe, Mercenary Merc Thrall Line...	CR 154.6 (+0.97) Emerging Star Vini	motay666 Emerging Star CR 151.12 (-0.97)

Dataprep: coach rankings

We want to extract the part CR 152.53 from the scraped coach information field. Just as we matched on Inducements:, we can match on CR and grab the contents directly after that, stopping when we encounter a whitespace.

We first play around a bit and test until we discover the proper Regular Expression to use :-)

#pattern = re.compile(r'\s+Inducements: (.*)\n')
pattern = re.compile(r'.*CR (.*)\s\(.*')

match = re.match(pattern, df_inducements.loc[0, 'coach2_ranking'])

if match is not None:
    print(match.group(1)) # group(0) is the whole string
else:
    print("match is none")

df_inducements.loc[0, 'coach2_ranking']

144.51

'LoxodonP Veteran CR 144.51 (-0.76)'

Got ’m! Now that we have figured it out, we can write the code that extracts the coach rankings:

# Dataprep fix match_id
df_inducements['match_id'] = pd.to_numeric(df_inducements.match_id) 

# Dataprep: add the coach rankings as separate cols
df_inducements['coach1_CR'] = df_inducements['coach1_ranking'].str.extract(r'.*CR (.*)\s\(.*')
df_inducements['coach2_CR'] = df_inducements['coach2_ranking'].str.extract(r'.*CR (.*)\s\(.*')

df_inducements['coach1_CR'] = pd.to_numeric(df_inducements['coach1_CR'])
df_inducements['coach2_CR'] = pd.to_numeric(df_inducements['coach2_CR'])

df_inducements['CR_diff'] = np.abs(df_inducements['coach1_CR'] - df_inducements['coach2_CR'])
df_inducements['CR_diff'] = df_inducements['CR_diff'].astype(float)

df_inducements['cr_diff2'] = df_inducements['coach1_CR'] - df_inducements['coach2_CR']

df_inducements['cr_bin'] = pd.cut(df_inducements['cr_diff2'], bins = [-1*float("inf"), -30, -20, -10, -5, 5, 10, 20, 30, float("inf")], 
 labels=['{-Inf,-30]', '[-30,-20]', '[-20,-10]', '[-10,-5]', '[-5,5]', '[5,10]', '[10,20]', '[20,30]', '[30,Inf]'])

`1`	`df_inducements.dtypes`

match_id                int64
team1_inducements      object
team2_inducements      object
coach1_ranking         object
coach2_ranking         object
coach1_CR             float64
coach2_CR             float64
CR_diff               float64
cr_diff2              float64
cr_bin               category
dtype: object

Dataprep match inducements for each team

The next trick is to use pandas explode() method (similar to separate_rows() in tidyverse R) to give each inducement its own row in the dataset. This creates a dataframe (inducements) similar to df_mbt with each match generating at least two rows.

team1_inducements = df_inducements[['match_id', 'team1_inducements']]
team2_inducements = df_inducements[['match_id', 'team2_inducements']]

# make column names equal
team1_inducements.columns = team2_inducements.columns = ['match_id', 'inducements']

# row bind the two dataframes
inducements = pd.concat([team1_inducements, team2_inducements], ignore_index = True)

# convert comma separated string to list
inducements['inducements'] = inducements['inducements'].str.split(',')

# make each element of the list a separate row
inducements = inducements.explode('inducements')

# strip leading and trailing whitespaces
inducements['inducements'] = inducements['inducements'].str.strip()

# create "star player" label
inducements['star_player'] = 0
inducements.loc[inducements['inducements'].str.contains("Star player"), 'star_player'] = 1

# create "card" label
inducements['special_card'] = 0
inducements.loc[inducements['inducements'].str.contains("Card"), 'special_card'] = 1

Add inducement info to df_matches

Here we add df_inducements to df_matches. This contains each players inducements as a single string, not convenient for analysis.

The inducements dataframe cannot easily be added to df_matches. We can however, extract information from inducements at the match level and add this to df_matches. Here, I show how to add a 1/0 flag has_sp that codes for if a match included any star player.

df_matches = pd.merge(df_matches, df_inducements, on='match_id', how='left')

df_sp = (inducements
            .groupby("match_id")
            .agg(has_sp = ("star_player", "max"))
            .reset_index()
)


df_matches = pd.merge(df_matches, df_sp, on = "match_id", how = "left")

df_matches['match_id'] = pd.to_numeric(df_matches.match_id)

Step 3: Create matches by team DataFrame

When analyzing the data, we also like to have a dataframe df_mbt (df_matches_by_team) that contains, for each match, a separate row for each team participating in that match. This structure is nicely visualized at the Nufflytics blog. Such a dataset is suitable for analysis by team, e.g. win rates. We can extend this further by adding, at the match level, data that is specific for each team - coach pair, such as team value, coach rating etc. For example, we can imagine adding more team level data, such as casualties caused during the match, or team composition at the start of the match etc.

# make two copies, one for each team in the match
team1_data = df_matches[['match_id', 'match_date', 'week_number',	'year',	'week_year', 'week_date', 'team1_id',
    'team1_coach_id', 'team1_race_name', 'team1_value', 'team1_win', 'tv_diff', 'tv_match',
    'tv_bin', 'mirror_match', 'coach1_CR', 'CR_diff', 'has_sp']].copy()

team2_data = df_matches[['match_id', 'match_date', 'week_number',	'year',	'week_year', 'week_date', 'team2_id', 
    'team2_coach_id', 'team2_race_name', 'team2_value', 'team2_win', 'tv_diff', 'tv_match', 
    'tv_bin','mirror_match', 'coach2_CR', 'CR_diff', 'has_sp']].copy()

team1_data.columns = team2_data.columns = ['match_id', 'match_date', 'week_number',	'year',	'week_year', 'week_date', 'team_id', 
    'coach_id', 'race_name', 'team_value', 'wins', 'tv_diff', 'tv_match', 
    'tv_bin', 'mirror_match', 'coach_CR', 'CR_diff', 'has_sp']

# combine both dataframes
df_mbt = pd.concat([team1_data, team2_data])

Adding outcome weights

One way to measure team strength is to calculate a win rate. If we want to calculate win rates, we need to decide how to weigh a draw. In Blood Bowl data analysis, it seems that a 2:1:0 (W / D / L) weighting scheme is most commonly used. So if we want to compare with others, it makes sense to adapt this scheme as well. If we divide these weights by two we get something that, if we average it, we can interpret as a win rate.

This scheme has the advantage that the weighted average win percentage over all matches is always 50%, creating a nice reference point allowing conclusions such as “this and that team has an x percent above average win percentage”.

df_mbt.loc[df_mbt['wins'] == 0, 'wins'] = 0.5
df_mbt.loc[df_mbt['wins'] == -1, 'wins'] = 0

# convert to float
df_mbt['wins'] = df_mbt['wins'].astype(float)

At this point, Lets have a look at our dataset again:

`1`	`df_mbt.query("coach_id == 255851").sort_values('match_date')`

	match_id	match_date	week_number	year	week_year	week_date	team_id	coach_id	race_name	team_value	wins	tv_diff	tv_match	tv_bin	mirror_match	coach_CR	CR_diff
99692	4248074	2020-11-13	46	2020	2020-46	2020-11-16	1003452.0	255851.0	Human	1000	0.0	0	1000	1.1K	0	150.00	0.80
77673	4270093	2021-01-17	2	2021	2021-2	2021-01-11	1003452.0	255851.0	Human	1000	0.0	40	1000	1.1K	1	149.22	3.63
32991	4314794	2021-07-01	26	2021	2021-26	2021-06-28	1003452.0	255851.0	Human	980	0.0	10	990	1.1K	0	147.60	1.37
31599	4316193	2021-07-10	27	2021	2021-27	2021-07-05	1035835.0	255851.0	Human	980	0.0	20	1000	1.1K	0	146.62	9.49
25968	4321824	2021-08-16	33	2021	2021-33	2021-08-16	1038960.0	255851.0	Human	970	0.5	30	1000	1.1K	1	145.93	9.30
23609	4324190	2021-09-01	35	2021	2021-35	2021-08-30	1038960.0	255851.0	Human	1000	0.0	10	1000	1.1K	0	145.90	10.19
21018	4326781	2021-09-13	37	2021	2021-37	2021-09-13	1038960.0	255851.0	Human	1010	1.0	80	1010	1.1K	0	144.24	6.02
12941	4334858	2021-10-11	41	2021	2021-41	2021-10-11	1038960.0	255851.0	Human	1110	0.0	150	1260	1.4K	0	145.22	16.80
10050	4337749	2021-10-22	42	2021	2021-42	2021-10-18	1050267.0	255851.0	Orc	1080	0.0	10	1090	1.1K	0	NaN	NaN
9027	4338772	2021-10-26	43	2021	2021-43	2021-10-25	1050267.0	255851.0	Orc	1040	1.0	50	1040	1.1K	0	NaN	NaN
3783	4344017	2021-11-15	46	2021	2021-46	2021-11-15	1050267.0	255851.0	Orc	1150	0.0	170	1150	1.1K	0	NaN	NaN
1186	4346614	2021-11-25	47	2021	2021-47	2021-11-22	1050267.0	255851.0	Orc	1020	0.5	150	1170	1.1K	0	NaN	NaN

Great! Almost there. There is still something missing though, we need to know, for all the teams in our matches dataset, in what division or league they are playing, and what version of the rules they use. For these we turn to the API again, to fetch more data, now on the team level.

Step 4: Fetch data on team division and ruleset

Let grab for all teams in df_mbt the team division and ruleset.

A limitation of the FUMBBL API is that it shows only the latest version of the teams and leagues data. This hides the fact that leagues have changed their rules since they were first created. For example, the NAF used BB2016 rules up until summer of 2021, and thereafter switched to the new BB2020 ruleset for their latest online tournament. So we have to use our “domain knowledge” here to interpret the data properly.

# make list of all teams that need to be fetched
team_ids = list(df_mbt['team_id'].dropna())

# get unique values by converting to a Python set and back to list
team_ids = list(set(team_ids))

len(team_ids)

So we have to fetch data for 47K different teams.

We use the same approach as above, looping over all team_id ’s and making a separate API call for each team.

IMPORTANT: here too, we limit ourselves to a maximum of 3 API calls per second to avoid overloading the FUMBBL server

df_teams = pd.DataFrame(columns=['team_id', 'division_id', 'division_name',  'league' ,
    'ruleset', 'roster_id', 'race_name',  'games_played'])

target = 'data/df_teams_' + time.strftime("%Y%m%d_%H%M%S") + '.h5'
print(target)

fullrun = 0

if fullrun:
    print('fetching team data for ', len(team_ids), ' teams')
    for t in range(len(team_ids)):    
        api_string = "https://fumbbl.com/api/team/get/" + str(int(team_ids[t]))
        wait_time = (random.uniform(0.5, 1) + 0.25)/3
        time.sleep(wait_time)
        team = requests.get(api_string)
        team = team.json()
        # grab fields
        team_id = team['id']
        division_id = team['divisionId']
        division_name = team['division']
        ruleset = team['ruleset']
        league = team['league']
        roster_id = team['roster']['id']
        race_name = team['roster']['name']
        games_played = team['record']['games']
        # add to dataframe
        df_teams.loc[t] = [team_id, division_id, division_name, league, ruleset, roster_id, race_name, games_played]
        if t % 100 == 0: 
            # write tmp data as hdf5 file
            print(t, end='')
            print(".", end='')
            df_teams.to_hdf(target, key='df_teams', mode='w')
    
    df_teams.to_hdf(target, key='df_teams', mode='w')
else:
    # read from hdf5 file
    df_teams = pd.read_hdf('data/df_teams_20211215_211746.h5')


df_teams['roster_name'] = df_teams['roster_id'].astype(str) + '_' + df_teams['race_name']

df_teams.shape

data/df_teams_20211230_192715.h5

(46831, 9)

Dataprep: Add ruleset_version and division_name

FUMBBL allows coaches to create their own rulesets to play their own leagues and tournaments with. For example, there is a so-called “Secret League” where coaches can play with “Ninja halflings”, “Ethereal” spirits etc. Instead of plain normal regular “Halflings” and “Shambling Undead” :-)

Since we want the team strength for the official rulesets BB2016 and BB2020, we need to distinguish those matches from the matches that are played under different rules.

Lets have look at the various divisions and leagues, which rulesets are used, and which races are played how often. There are a lot of small leagues being played on FUMBBL. We only look at divisions and leagues with a sufficient volume of matches, or otherwise we do not have sufficient statistics for each race.

So I aggregated the data by division, league and ruleset, and filtered on at least 150 different teams that have played at least once last year.

Apart from the main “Divisions” that are part of FUMBBL, there were a few user-run leagues present in this table, so I looked up their names on FUMBBL and what ruleset is used (BB2016, BB2020 or some other variant). This information (contained in an xlsx) is added to the dataset below.

# add ruleset_version and division_name from xlsx
ruleset_division_names = pd.read_excel('data/ruleset_division_names.xlsx',  engine='openpyxl')

df_teams = pd.merge(df_teams, ruleset_division_names, on= ['league', 'ruleset', 'division_id'], how='left')

df_teams['division_name'] = df_teams['new_division_name']

df_teams = df_teams.drop('new_division_name', 1)

df_teams['division_id'] = pd.to_numeric(df_teams.division_id) 
df_teams['roster_id'] = pd.to_numeric(df_teams.roster_id) 
df_teams['team_id'] = pd.to_numeric(df_teams.team_id) 
df_teams['games_played'] = pd.to_numeric(df_teams.games_played) 

df_teams['league'] = pd.to_numeric(df_teams.league) 
df_teams['ruleset'] = pd.to_numeric(df_teams.ruleset)

(df_teams
    .groupby(['ruleset', 'league', 'division_id', 'division_name',  'ruleset_version'], dropna=False)
    .agg( n_teams = ('ruleset', 'count')
    )
    .sort_values('n_teams', ascending = False)
    .query('n_teams > 150')['n_teams']
    .reset_index()
)

	ruleset	league	division_id	division_name	ruleset_version	n_teams
0	1	0	10	Blackbox	bb2016	10439
1	1	0	1	Ranked	bb2016	7944
2	4	0	2	Competitive	bb2020	6532
3	6	0	5	Regular_league	bb2016	5942
4	303	10263	5	Secret League	bb2016	2554
5	2228	9298	5	NAF	mixed	1466
6	2	0	3	Stunty Leeg	bb2016	607
7	2198	14708	5	SL BB2020	bb2020	452
8	888	11676	5	LegaGladio	mixed	345
9	4	14713	5	Test Open League BB2020	bb2020	296
10	1049	12026	5	NAF 7s	bb2016	196
11	432	10455	5	CIBBL	bb2016	189

Dataprep: Merging the match data with the team data

For each match in the df_mbt DataFrame we can now add the team-level information from df_teams.

As both datasets contain ‘race_name’, we drop one of them.

`1`	`df_mbt = pd.merge(df_mbt, df_teams.drop('race_name', 1), on='team_id', how='left')`

df_matches = pd.merge(df_matches, df_teams.drop(['race_name', 'roster_id', 'roster_name', 'games_played'], 1), left_on='team1_id', right_on = 'team_id', how='left')

df_matches['team1_id'] = pd.to_numeric(df_matches.team1_id) 
df_matches = df_matches.drop('team_id', 1)

Step 5: adding team tiers

According to this article from the NAF from 2017, already since 2010 efforts were made to balance things out a bit between the different team strengths. For example, the weaker teams get more gold to spend on players, or get more so-called “Star player points” to spend on skilling players up. According to the NAF, traditionally team tiering consists of three groups, with Tier 1 being the strongest teams, and tier 3 the weakest teams. The GW BB2020 rule book also contains three tier groups, that are similar to the NAF tiers: except for Humans and Old World Alliance. And in november 2021, Games Workshop published an update of the three tier groups, now with High Elves moving from tier 2 to tier 1, and Old World Alliance moving back to tier 2.

This is most naturally added to the df_mbt dataframe, as it can differ for each team in a match.

1
2
3

race_tiers = pd.read_excel('data/race_tiers_mapping.xlsx',  engine='openpyxl')
race_tiers = race_tiers[ ['race_name', 'bb2020_tier', 'naf_tier', 'bb2020_nov21_tier']]
race_tiers = race_tiers.dropna()

1
2

# add bb2020 tiers
df_mbt = pd.merge(df_mbt, race_tiers, on='race_name', how='left')

Save all prepped datasets as HDF5 files

target = 'data/df_inducements_final.h5'
df_inducements.to_hdf(target, key='df_inducements', mode='w', format = 't', complevel = 9)

target = 'data/inducements_final.h5'
inducements.to_hdf(target, key='inducements', mode='w', format = 't',  complevel = 9)

1
2
3

target = 'data/df_matches_final.h5'

df_matches.to_hdf(target, key='df_matches', mode='w', format = 't',  complevel = 9)

1
2
3

target = 'data/df_mbt_final.h5'

df_mbt.to_hdf(target, key='df_mbt', mode='w', format = 't',  complevel = 9)

Choosing a license for the public dataset

An important part of making data publicly available is being explicit about what is allowed if people want to use the dataset. However, before we do so, we have to check if we are actually allowed to publish the data. This is explained nicely in a blogpost by Elizabeth Wickes.

Since our data will come from the FUMBBL.com website, we check the Privacy policy where all users, including myself have agreed on when signing up. It contains this part which is specific to the unauthenticated API, which we use to fetch the data, as well as additional public match data, such as which inducements are used in a match, and the Coach rankings of the playing coaches that were current when the match was played.

Content you provide through the website
All the information you provide through the website is processed by FUMBBL. This includes things such as forum posts, private message posts, blog entries, team and player names and biographies and news comments. Data provided this way is visible by other people on the website and in most cases public even to individuals without accounts (not including private messages), and as such are considered of public interest. If direct personal information is posted in public view, you can contact moderators to resolve this. Match records are also considered content in this context, and is also considered of public interest. This data is collected as the primary purpose of the website and it is of course entirely up to you how much of this is provided to FUMBBL. 

Third party sharing
Some of the public data is available through a public (*i.e. unauthenticated*) API, which shares some of the information provided by FUMBBL users in a way suitable for third-party websites and services to process.

The data available through the unauthenticated API is considered non-personal as it only reflects information that is public by its nature on the website. The authenticated API will only show information connected to the authenticated account.

I conclude that since the match data is already considered public content, there is no harm in collecting this public data in a structured dataset and placing this data in a public repository. The final step is then to decide what others are allowed to do with this data. In practice, this means choosing a license under which to release the dataset. I decided to choose a CC0 license: this places the data in the public domain, and people can use the dataset as they wish. Citing or mentioning the source of the data would still be appreciated of course.