Blood Bowl 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.

Visualizing Blood Bowl Tournament rosters

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

(Photo by Erik Cats)

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

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

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

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

Online Blood Bowl Tournaments on FUMBBL

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

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

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

The 2022 Road to Malta Online NAF tournament

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

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

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

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

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

Top 10 races in Road To Malta

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

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

Underworld Denizens (Tier 2)

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

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

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

High elf (Tier 4)

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

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

{width=100%}

Necromantic Horror (Tier 2)

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

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

Performance-wise, no clear differences to be seen.

{width=200%}

Shambling Undead (Tier 1)

The Shambling Undead rosters are all surprisingly similar:

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

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

{width=200%}

Dark Elf (Tier 1)

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

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

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

No clear performance differences between the three builds.

{width=200%}

Chaos Dwarf (Tier 1)

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

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

{width=200%}

Skaven (Tier 2)

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

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

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

{width=200%}

Lizardmen (Tier 1)

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

{width=200%}

Orc (Tier 1)

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

{width=200%}

Wood Elf (Tier 1)

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

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

{width=200%}

Final remarks

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

Classifying Blood Bowl teams using clustered heatmaps

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

(Photo by Erik Cats)

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

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

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

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

Team play style categories

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

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

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

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

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

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

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

Read and prep the data

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

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

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

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

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

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

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

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

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

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

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

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

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

data_tables <- map(data_tables, select_stats)

We end up with the following set of variables:

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

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

A quick summary of the FUMMBL match statistics

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

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

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

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

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

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

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

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

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

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

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

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

`1`	`dim(df_agg)`

## [1] 28 11

This gives us 11 numbers for 28 different BB2020 teams.

So which teams have similar stats?

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

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

Lets do that for the number of blocks made:

options(dplyr.summarise.inform = FALSE)

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

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

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

1
2
3

library(patchwork)

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

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

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

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

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

PCA versus clustered heatmaps

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

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

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

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

Clustered heatmaps for the win

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

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

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

1
2

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

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

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

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

library(patchwork)

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

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

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

And there we have it, our main result.

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

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

Conclusions

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

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

Finally we produce the clustered heatmap for all four divisions:

source("make_heatmap.R")

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

References

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

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

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

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

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

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

Nufflytics: Analyzing Blood Bowl matches from FUMBBL using Python

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

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

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

Getting started with the data

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

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

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

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

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

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

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

What data do we have? Weekly game volumes

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

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

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

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

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

<ggplot: (-9223363302253724542)>

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

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

Star player usage on FUMBBL

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

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

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

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

<ggplot: (-9223363302246313763)>

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

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

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

Are coach ratings predictive of match outcomes?

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

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

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

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

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

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

Let’s see what the actual percentages are:

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

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

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

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

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

<ggplot: (-9223363302350291624)>

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

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

What about the passing game in BB2020?

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

Let’s have a look!

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

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

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

res = res.dropna()

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

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

<ggplot: (-9223363302350371093)>

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

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

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

res = res.dropna()

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

<ggplot: (-9223363302350232432)>

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

Observations that stand out:

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

And what about fouling in BB2020?

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

Let’s see how the stats were affected!

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

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

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

res = res.dropna()

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

<ggplot: (8734504437775)>

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

Competitive division win rates and Malta Eurobowl 2022 tiers

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

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

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

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

divisions = ['Competitive']

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

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

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

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

<ggplot: (-9223363302334269892)>

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

But what info can we squeeze from this plot nevertheless:

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

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

What else do we got:

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

Concluding Remarks and acknowledgements

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

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

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

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