Programming

# Simulating the way to victory: Bloons TD Battles

Simulations can provide curious insights; in this case a distinct advantage to winning a game. I recently encountered a perfect opportunity to run a simulation on the game “Bloons TD Battles”. There is a “money” aspect and I wanted to know what strategy would be best. Since the rules are quite simple, at least part of them, it shouldn’t be too hard to code.

The full code can be found here. It’s written in C++ using a few C++11 features. I’ve also put it up at ideone for quick experimentation.

### The Game

This tower defense game has a two-player “defensive” mode. You and another player attempt to hold off an onslaught of balloons. The person who lasts longer wins. You can either buy towers (monkeys in this game) or invest the money to increase your income. It’s a somewhat tricky balance: lots of things to buy, four investment plans to choose from.

Each investment plan has an upfront cost and a revenue increase amount: spend money now to gain back more over time. The lowest plan is \$50 for \$2 income: spend \$50 and at each income interval you get an additional \$2. The next plan is \$300 for \$15. At first it looks better: buying 6 of the lower plan would cost the same, but get you less return (\$12 as opposed to \$15). The trick is that you normally don’t have enough money to buy the higher plan and would be forced to wait. During that waiting time you could be compounding more money with the lower plans.

#### The Plans

That was my basic question: is it worth it to wait for the higher plans? This is what I addressed first in my simulation. My initial results seemed a bit off due to a missing variable. Each time a plan is purchased it has a cool-off time before it can be purchased again. Watching the game I noted the numbers and created a `plan` data structure.

 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13``` ```struct plan { //plan acquisition cost int cost; //resulting increase in revenue int increase; //timeout before repeat purchase int regen; }; std::vector plans({ { 50, 2, 4 }, { 300, 15, 13 }, { 1000, 70, 60 }, }); ```

Money in the game is an integral value therefore all monetary values are using `int`. There is also a fourth plan, which costs a lot more, that I’ve omitted. In practice you never have enough money to buy it: I was unable to determine it’s `regen` timeout.

#### Game State

A simulation requires a state. This state is modified on each iteration of the game. Here I use a 1-second interval as it matches the precision needed for this game. My state structure looks like below, plus several member functions to manipulate it.

 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15``` ```struct game_state { // how much money we have now int money; //income on each income interval int income; //total money we had/have int total; //money spent on upgrades int spent; //money invested for income int invested; //block purchase of the plan for regen time std::vector plan_timeout; //total elapsed time int time; ```

A `step` function does the one-step iteration. It adds the income to the money and updates the tracking stats. Additionally it iterates over the `plan_timeout` to model the plan purchase lockout time. My state object thus also models the core mechanics of the game. Often one finds the state as independent data and a separate driver class modifies it. If the rules of the simulation are complex that would be required, but here the rules are simple enough, and static, to be situated in the state class.

### Strategy

With the basic modelling complete a strategy is now required. A strategy models the player’s behaviour in the game. At each step in the simulation the strategy is called and allowed to perform its actions. This is the perfect scenario for polymorphism with inheritance and a virtual function.

 ``` 1 2 3 4 5 6 7 8 9 10 11 12``` ```struct strategy { void step(int spend) { /*common behaviour*/ . . . state->step(); step_impl(); } virtual void step_impl() = 0; }; ```

The approach I’ve taken is to implete a `step` function as well as a virtual `step_impl`. This allows me to implement common behaviour across all strategies in the base class and specialized behaviour in derived classes. I’ve also also chosen to store the state directly in each strategy; the strategy `step` function is responsible for calling `step` on the state. I don’t believe in overdoing the design and this setup is sufficient for this simulation.

#### Baseline Strategy

A couple of basic strategies establish the baseline for our simulation. The first is the `buy_none` strategy which never invests in any plan. It sticks with the starting income level for the duration of the game. The second is `buy_all` which buys every plan it can whenever it can.

Before I show any results I must explain the stats I track first. The `total` money in the game is the total amount of money the player ever had (starting money plus all income). It’s actually not an interesting number. The `spent` money is more interesting. It tracks how much money was actually spent on building defenses — without these you lose quite quickly. In my initial version no money was “spent” though, so this number is just how much money was left over at the end. It is essentially the disposable income, and it is the interesting number.

For the first round the `buy_none` strategy ends up with only 3950 spent, and the `buy_all` has 9060. Clearly investing looks better.

#### Spending

Investment is obviously not the goal of the game. You need to build defense to block those pesky balloons from getting past. This means a strategy that doesn’t consider spending may not be valid. The ideal way to spend the money is not easy to simulate as there are a lot of factors involved. However, I can estimate roughly what the rate of spending must be.

I created a very simple formula of multiplying the elapsed time by a constant factor. At each interval the baseline strategy ensures it has spent at least this much money. If not enough money is available it will check again next interval.

Adjusting the value does change the results. Lower values tend to improve the value of investing. That is of course at the expense of possibly letting balloons through and loosing.

#### Fixed plans and stopping

I added a few other simple strategies that purchase only one particular plan. Here it came out that `buy_all` and `buy_plan_1` looked to be quite comparable in spent money. I realized though that it doesn’t make sense to invest right up to the end of the game: a certain period of time is needed to recoup the investment. I needed a strategy that stopped investing after some point.

This is a modification to all existing strategies. Rather than complicate the hiearchy I just added a `stop_when` variable to the base strategy and introduced a `should_buy_plan` function.

 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13``` ```struct strategy { //stop investing at this time, if -1 then never stop int when; . . . virtual bool should_buy_plan( int i ) { if( stop_invest_when >= 0 && state->time >= stop_invest_when ) { return false; } return state->can_buy_plan(i); } }; ```

When to stop depends highly on how long the game actually lasts. So far my games have been topping out at seven minutes. I run the simulation with a variety of stopping times. Stopping at 240s is roughly ideal for the `buy_all` strategy, and at 300s for the `buy_play_1` strategy. They both have roughly the same spent money. Interesting though is that stopping at 180s for `buy_all` is only 2% less money. Since the game is hectic it is helpful to stop earlier and focus on other things.

### Conclusion

The results are somewhat unfortunate. Investing is clearly meant to play a significant role in the game, but the influence is quite limited. A good strategy is to buy whatever plan you can, whenever you can, and stopping around half-time. Changing many of the constants in the simulation change the total money spent, but the same strategy is usually one of the best. It is also has the great advantage of being very flexible: you are never waiting to accumulate money to invest.

Finding this desired strategy is of course the purpose of the simulation. I also just enjoy writing simulations; they are somewhat different from my typical daily programming tasks.

Categories: Programming

Tagged as: , , ,

### 3 replies »

1. Mike S. says:

Funny, my kids used to play that game and complain about how hard it was. I’m pretty sure they never invested.

It’s interesting how difficult it is to explain to kids the value of economy in a strategy game with a resource facet. When they played Starcraft 2 and asked for help, the most common thing I would say, dozens of times per game, is “buy another worker” (resource harvester).

2. Matthew says: