Python on Blood Bowl Scholarly blogs

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.

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.