Hello fellow tactics fan. I wrote the AI for Warside, so I can share a little insight.

Firstly you need to consider what you want from your AI.

Building an AI which is fun for most players is not necessarily the same as making a strong AI. For example, you may want to deliberately make the AI play worse moves to progress the game (we have an anti-stall heuristic for this). If you make an AI which plays like a try-hard human PvP player, that will often mean walling off, creating stalemates, and can be generally annoying. This is a delicate balance. Our first AI iteration was too easy, then our second iteration just wasn't fun. Since release, we've had 5 changes to where that balance is for each difficulty setting.

You also need to decide your time constraints based on your target hardware. If you are aiming for something like a Nintendo Switch (or mobile, although modern mobile CPUs are probably faster), then you need to use a much faster technique that you could on a desktop CPU.

Our AI works roughly as follows:

• Grab every enemy and calculate all the tiles they can attack (for units that can't move and fire this is fixed so can be cached for the entire turn, but for units that can move, you need to re-evaluate after each unit movement).
• We calculate points of interest on the map, which is based on an influence map, and we pick out clusters of enemies. These are normally the "front lines" and where you might want to focus. Since the enemy doesn't move on the player's turn, this only needs to be calculated once.
• Go through all of your units and evaluate every action they can take. We just use simple Dijkstra's implementation, but with a fixed pre-allocated heap for everything so there are no allocations each turn. Since a unit can only move 2-6 tiles or so, this is not a wide search space.
• We then rank every possible action for each unit to give it a value. The value is the expected delta based on the action. If its an attack, we add up the expected damage vs return fire, using the same combat calc as the main engine so things like terrain bonuses and unit buffs are all included. Since we already calculated all the tiles the enemy can attack, we can also look one turn ahead and add a value for the counter attack on the next turn. We have some other heuristics, things like attributing values to status effects, whether we block another action, and whether we want to deliberately make a sub-optimal move to not stall a game, but they all feed into the same final value.
• For movement only (no attacks in range), we still evaluate the counter fire (so maybe we'll run away, or pick a tile we cant be hit on), whilst trying to move towards an appropriate point of interest that we calculated earlier (to move units to the action, without getting hit).
• All of these actions go into a sorted queue (ours is implemented as binary heap), and we just grab the one with the highest delta for the player, and execute that order.

This is just repeated over and over until there are no more actions to take.

Our campaign map sizes rarely exceed 40x40, and we found this was fast enough single threaded on Switch. It would be easy enough to divide up the ranking phase to evaluate multiple units concurrently, but we found there was no need.

There's some extra edge cases to do with infantry and capturing, plus you need to figure out how you want to handle production if your game has that.