A highly-extensible python-based AI framework for digital fantasy-football board-games. FFAI is still under development and is planned to be heavily updated.

Please cite us if you use FFAI in your publications.

@inproceedings{justesen2018blood,
  title={Blood Bowl: The Next Board Game Challenge for AI},
  author={Justesen, Niels and Risi, Sebastian and Togelius, Julian},
  booktitle={FDG 2018, 1st Workshop on Tabletop Games},
  year={2018}
}

• Rule implementation of the Living Rulebook 5 with the following limitations:
  • Only skills for the Human and Orc teams have been implemented and tested
  • No big guys
  • No league or tournament play
  • No star player points or level up
  • No inducements
  • No timers; Players have unlimited time each turn
• A web interface supporting:
  • Hot-seat
  • Online play
  • Spectators
  • Human vs. bot
• An AI interface that allows you to implement and test your own bots
  • Path finding utilities
  • Examples to get started
• Implementation of the Open AI Gym interface, that allows you to train machine learning algorithms
• Custom pitches (we call these arenas). FFAI comes with arenas of four different sizes.
• Rule configurations are possible from a configuration file, including:
  • Arena (which .txt file to load describing the arena)
  • Ruleset (which .xml file to load containing rules for rosters etc.)
  • Setup restrictions
  • Number of turns
  • Kick-off table enabled/disabled
  • Which scatter dice to use
  • ...
• Premade formations to ease the setup phase. Custom made formations can easily be implemented.
• Games can be saved and loaded

• More documentation
• AI tournament module
• Support for dungeon arenas
• Support for all skills and teams in LRB6
• League mode
• Integration with OBBLM

Make sure python 3.6 or newer is installed, together with pip.

pip install git+https://github.com/njustesen/ffai

python examples/server_example.py

Go to: http://127.0.0.1:5000/

The main page lists active games. For each active game you can click on a team to play it. If a team is disabled it is controlled by a bot and cannot be selected. Click hot-seat to play human vs. human on the same machine.

To make you own bot you must implement the Agent class and its three methods: new_game, act, and end_game which are called by the framework. The act method must return an instance of the Action class.

Take a look at our bot_example.py.

Be aware, that you shouldn't modify instances that comes from the framework such as Square instances as these are shared with the GameState instance in FFAI. In future releases, we plan to release an AI tournament module that will clone the instances before they are handed to the bots. For now, this is up to the user to do.

FFAI implements the Open AI Gym interace for easy integration of machine learning algorithms.

Take a look at our gym_example.py.

Observations are split in three parts:

1. 'board': two-dimensional feature leayers
2. 'state': a vector of normalized values (e.g. turn number, half, scores etc.) describing the game state
3. 'procedure' a one-hot vector describing which of 18 procedures the game is in. The game engine is structered as a stack of procedures. The top-most procedure in the stack is active.

The default feature layers in obs['board'] are:

0. OccupiedLayer()
1. OwnPlayerLayer()
2. OppPlayerLayer()
3. OwnTackleZoneLayer()
4. OppTackleZoneLayer()
5. UpLayer()
6. UsedLayer()
7. AvailablePlayerLayer()
8. AvailablePositionLayer()
9. RollProbabilityLayer()
10. BlockDiceLayer()
11. ActivePlayerLayer()
12. TargetPlayerLayer()
13. MALayer()
14. STLayer()
15. AGLayer()
16. AVLayer()
17. MovemenLeftLayer()
18. BallLayer()
19. OwnHalfLayer()
20. OwnTouchdownLayer()
21. OppTouchdownLayer()
22. SkillLayer(Skill.BLOCK)
23. SkillLayer(Skill.DODGE)
24. SkillLayer(Skill.SURE_HANDS)
25. SkillLayer(Skill.PASS)

Custom layers can be implemented like this:

from ffai.ai import FeatureLayer
class MyCustomLayer(FeatureLayer):

    def produce(self, game):
        out = np.zeros((game.arena.height, game.arena.width))
        for y in range(len(game.state.pitch.board)):
            for x in range(len(game.state.pitch.board[0])):
                player = game.state.pitch.board[y][x]
                out[y][x] = 1.0 if player is not None and player.role.cost > 80000 else 0.0
        return out

    def name(self):
        return "expensive players"

and added to the environment's feature layers:

env.layers.append(MyCustomLayer())

To visualize the feature layers, use the feature_layers option when calling render:

env.render(feature_layers=True)

The 44 default normalized values in obs['state'] are:

0. 'half'
1. 'round'
2. 'is sweltering heat'
3. 'is very sunny'
4. 'is nice'
5. 'is pouring rain'
6. 'is blizzard'
7. 'is own turn'
8. 'is kicking first half'
9. 'is kicking this drive'
10. 'own reserves'
11. 'own kods'
12. 'own casualites'
13. 'opp reserves'
14. 'opp kods'
15. 'opp casualties'
16. 'own score'
17. 'own turns'
18. 'own starting rerolls'
19. 'own rerolls left'
20. 'own ass coaches'
21. 'own cheerleaders'
22. 'own bribes'
23. 'own babes'
24. 'own apothecary available'
25. 'own reroll available'
26. 'own fame'
27. 'opp score'
28. 'opp turns'
29. 'opp starting rerolls'
30. 'opp rerolls left'
31. 'opp ass coaches'
32. 'opp cheerleaders'
33. 'opp bribes'
34. 'opp babes'
35. 'opp apothecary available'
36. 'opp reroll available'
37. 'opp fame'
38. 'is blitz available'
39. 'is pass available'
40. 'is handoff available'
41. 'is foul available'
42. 'is blitz'
43. 'is quick snap'
44. 'is move action'
45. 'is block action'
46. 'is blitz action'
47. 'is pass action'
48. 'is handoff action'
49. 'is foul action'

The 19 procedures represented in the one-hot vector obs['procedure'] are:

1. StartGame
2. CoinTossFlip
3. CoinTossKickReceive
4. Setup
5. PlaceBall
6. HighKick
7. Touchback
8. Turn
9. PlayerAction
10. Block
11. Push
12. FollowUp
13. Apothecary
14. PassAction
15. Catch
16. Interception
17. GFI
18. Dodge
19. Pickup

Actions consists of 31 action types. Some action types, denoted by also requires an x and y-coordinate.

0. ActionType.START_GAME
1. ActionType.HEADS
2. ActionType.TAILS
3. ActionType.KICK
4. ActionType.RECEIVE
5. ActionType.END_PLAYER_TURN
6. ActionType.USE_REROLL
7. ActionType.DONT_USE_REROLL
8. ActionType.END_TURN
9. ActionType.STAND_UP
10. ActionType.SELECT_ATTACKER_DOWN
11. ActionType.SELECT_BOTH_DOWN
12. ActionType.SELECT_PUSH
13. ActionType.SELECT_DEFENDER_STUMBLES
14. ActionType.SELECT_DEFENDER_DOWN
15. ActionType.SELECT_NONE
16. ActionType.PLACE_PLAYER (Only used during high-kick)
17. ActionType.PLACE_BALL
18. ActionType.PUSH
19. ActionType.FOLLOW_UP
20. ActionType.INTERCEPTION
21. ActionType.SELECT_PLAYER
22. ActionType.MOVE
23. ActionType.BLOCK
24. ActionType.PASS
25. ActionType.FOUL
26. ActionType.HANDOFF
27. ActionType.SETUP_FORMATION_WEDGE
28. ActionType.SETUP_FORMATION_LINE
29. ActionType.SETUP_FORMATION_SPREAD
30. ActionType.SETUP_FORMATION_ZONE

Actions are instantiated and used like this:

action = {
    'action-type': 26,
    'x': 8,
    'y': 6
}
obs, reward, done, info = env.step(action)

The default reward function only rewards for a win, draw or loss 1/0/-1. However, the info object returned by the step function contains useful information for reward shaping:

'cas_inflicted': {int},
'opp_cas_inflicted': {int},
'touchdowns': {int},
'opp_touchdowns': {int},
'half': {int},
'round': {int}

These values are commulative, such that 'cas_inflicted' referes to the total number of casualties inflicted by the team.

FFAI comes with four environments with various difficulty:

• FFAI-v1: 11 players on a 26x15 pitch (traditional size)
• FFAI-v1-7: 7 players on a 20x11 pitch
• FFAI-v1-5: 5 players on a 16x8 pitch
• FFAI-v1-3: 3 players on a 12x5 pitch

This is how the FFAI-v1-3 environment looks:

FFAI is not affiliated with or endorsed by any company and/or trademark. FFAI is an open research framework and the authors have no commercial interests in this project. The web interface in FFAI currently uses a small set of icons from the Fantasy Football Client. These icons are not included in the license of FFAI. If you are the author of these icons and don't want us to use them in this project, please contact us at njustesen at gmail dot com, and we will replace them ASAP.

Do you want implement a bot for FFAI or perhaps help us test, develop, and/or organize AI competitions? Join our Discord server using this link: FFAI Discord Server.