Exchange ideas about the simulation approach

[maximiliankir]

The most important part of a football manager game is the simulation engine, as already discussed in #3. I start this discussion to further exchange some ideas about how to compute the outcome of a game and the events, that happen in during the game.

@sturdy-robot brought up some ideas for possible approaches in #3:

• Randomly generate Events from a EventList, based on some probabilities
• Markov Chains
• Agent based simulations
• 2D/3D simulation

My personal opinion is also to start with a simple approach, which can be evolved in the future. But I think that generating random Events from a List of events with a fixed probability is to simple, to get a somehow realistic simulation of a football game.

[maximiliankir]

There is a different possible approach, that has not been mentioned yet. I would call it a top-down approach. First calculate the end result of the game, depending on probabilities (depending on the selected fomations, players, fitness ...). Then step by step calculate more fine-granular events. How and when happend the goals, what move was made before the goal ...

But I think this approach is also very limiting. Because you can not influence the outcome of the game during the game, because the result is already calculated.

So my personal opinion is, that we should start with a simple markov based approach. You have a list of possible events and you have a current state. A event leads from the current state to a different state and the probability of a event depends on the current state.
It is open to discussion, what states and events we need. The probabilities for the events should later be calculated dynamically depending on the used player, the selected tactics ...

[maximiliankir]

I'll try to make a proof of concept implementation, and I will let you know when I have finished it.

[maximiliankir]

I have created a fork of the project and there a branch markov-based, where I started to implement this idea. So if you want to check out how development is going, feel free to have a look. But until now there is not much to see. I just created the basic classes for state and action. And adopted the MatchSimulation and OFM class for that.

I changed my approach slightly, as you can see in the code: I will not go from one state directly to the next state with some probability. But I draw a random action from the current state. And draw then a random outcome of this action (next state). This allows to keep only ball location, team status etc. in the state and implement a duel between to players in an action.

[sturdy-robot]

Cool, thank you for that.

I'll keep an eye out for progress here, we'll be discussing different approaches and how to handle things as we go. I'll see if I can make some progress to some other points that need to be worked on this weekend.

[maximiliankir]

I don't know what you are planning to implement this weekend. But for me it would be nice to have the functions that load the teams and players (with their skill values) from the database files.
That would make it easier for me to test the actions, if I can load some real teams and test the match simulation with that.

[sturdy-robot]

@maximiliankir I'm working on it. I'll need to tweak the database files a bit to include all the necessary info, and I'm also working a bit with the generators to generate some random info instead of the fifa-based files that I got. I'll let you know when that's done.

[maximiliankir]

And in addition we should think about the implementation. I do not think, that it is a good idea to hardcode all the states and events. At the moment the event list and probabilities are hard coded. We should use a generator class, which generates the state machine with the probabilities. And maybe we should also use some kind of description files, which describe the states and the possible events. This keeps the software expendable and improves the code readability.

[sturdy-robot]

It took me a while, but I've completed the work on defining the clubs and working with player and club generation. I'm not sure if you're still willing to help, but I'm going to be focusing on implementing a very simple GUI first, and then I can work with the match simulation and visualize it in real time.

Development pacing should speed up in the next few days. Anyone interested can use this Discussion tab to contact me about the development. I'll set up some issues to work on if that's the case.

[maximiliankir]

Nice to hear from you and great that you're making progress with the project.
I'm still interested in collaborating, because I think this is an intersting project and has some potential. Unfortunately I don't have much time at the moment and probably will not have much time in the near future.
But we can of course use this discussion thread to discuss design choices.
To then setup issues, is a good idea in any case. Maybe I can work from time to time on one or someone else discovers this project and helps.

[sturdy-robot]

It's okay. Whenever you can, you can contact me or submit a pull request if you feel like it.

I'll be working more on this in the next few days, and hopefully we can get an alpha out asap. I feel like if I can get a working prototype out, more people will come to help out, so that's the main focus at this moment.

[tonyemery]

Hello, it's starting to take on a good shape. Having said that, how are you going to manage the aspects linked to the success of the actions by the players. For example, if 2 players are fighting over the ball, how do you calculate which of the 2 will win? The same goes for a defender tackling an attacker or an attacker shooting at goal.

[sturdy-robot]

Well, that's a good question, and it's something I'm still figuring out as I go. I still have some commits to push, but I'm battling a bit with some failing tests and uncompleted code. But my general idea is the following:

Each player has specific attributes, such as passing, dribbling, shooting, crossing, etc.

For each event, I'm picking at least two players on the field: the attacking player (with the ball), and the defending player. For an event like passing, I'm also picking the player that might receive the ball. Passing has a couple of outcomes:

• Pass miss
• Pass succeeds
• Pass intercepts
• Pass is offside

In short, to calculate the probabilities of each of them:

• Pass miss: 100 - probability of pass succeeding (Even if the result of pass succeeds is 99, we need to have at least 1 chance of it failing)
• Pass succeeds: Average of the attacking player's passing and vision attributes (there's also some factor that I'm trying to fit in which is the distance of the pass)
• Pass intercepts: Average of the defending player's positioning and intercept attributes
• Pass is offside: Only happens when the pass is to the offensive positions and after the pass succeeds, and takes into account the team work and positioning attributes of the receiving player.

With the probabilities laid out, I just throw it into the random.choices function to sort out the outcome of the event, and then it spits out the outcome.

There's still a lot to sort out how the outcomes are working for other events. For an event like Shot, there are similar outcomes: Miss, Hit post, Saved, Goal. All of them will take into account the attacking player's attributes and the defending player's attributes. I'm still figuring a few things out and working out the maths underneath, trying to get the best formulas out of this, but that's a lot of trial and error to find the best approach here.

[sturdy-robot]

This is still on the works, so in the current master branch as of commit 1d438ab I'm working on this implementation. Anyone is welcome to contribute with ideas and approaches to the match simulation, I just want to share my thoughts on the implementation, and perhaps describing it gives me a better view on how to continue implementing this.

There are two important classes here:

LiveGame and SimulationEngine.

The LiveGame is the current game and tracks the state of the game. It receives the details of the Fixture (football game), and passes the teams to the SimulationEngine.

The SimulationEngine is where the magic happens, where the events are drawn.

I've selected some events from a list of simplified events in a football match. All of the events derive from a SimulationEvent abstract class, and they're listed as an enum in the EventType enum (I've been working with Rust lately, and working with well-defined types instead of strings are better IMO). These are: Pass, Dribble, Shot, Foul, Free Kick, Corner Kick, Goal Kick and Penalty Kick. I believe Throw-In and other minor events are not so relevant to the match itself, so I'm not concerned with these.

Each event has their own EventOutcomes, which again is just a list of enums for some things that can happen in the game's events. The SimulationEngine tracks the current GameState: the minutes that have passed and the position that the ball is in in the field.

Once an event is drawn from a transition matrix of events that corresponds to the current attacking team's TeamStrategy, the SimulationEngine passes the teams to the Event's calculate_event method. Some events even require their own transition matrix, like passing, crossing or shooting, which they draw from the TeamStrategy's special "Factory" (not officially a class, but works like it).

The events use the Player's attributes to calculate the probabilities of the EventOutcomes. Events can change the current team in possession and alter the current team's stats. The event then returns the new GameState class with a new PitchPosition (if it changed at all).

I'm still figuring out how to fit in the Substitutions in the middle of this, but I have an idea of pausing the current game simulation and doing that out of the current simulation loop, and then restarting the game again from where it left off. Probably I'll need an AI for computer-only games, and for the player's opponents as well, but I don't see that as being too difficult to pull off.

After each iteration of the Event simulation engine, the GameState adds 0.1 minutes to the game's clock, until we reach the end of the current half or the game itself. That can trigger a pause for live player-controlled games.

This is still in early stages but my tests are showing it's a promising approach. A lot of details have to be worked out, and I still need to take care of small details, but progress is here nonetheless.