Data Science 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.