• Ship movement is mostly unchanged; ships pretty much just move towards the closest enemy. However, they now calculate a desired engagement range and stop once they are within that range. This means that ships armed with longer ranged weapons such as missiles or fighters will tend to hang back a bit instead of rushing into close range. Ships attacking with lasers will try to get closer than in vanilla.
• The AI will now assign priority to potential targets in range based on how dangerous they are versus the amount of shields and armour they have. This especially helps the AI when assigning missile targets, since I found it used to be pretty exploitable by throwing some expendable craft ahead of your fleet.
• PD weapons preferentially attack missiles and fightercraft. Most PD weapons just go for the nearest enemy missile, but anti-missiles make an attempt to prioritize.
• Interceptors choose whether to attack missile/bombers or ships by comparing the priority of friendly ships vs the priority of other potential targets. They also take into account how much damage they would deal to an enemy ship vs the damage dealt by the incoming missiles.
• In most cases the priority of a ship is calculated using the amount of damage it can dish out vs the amount of "useless" damage that needs to be chewed through before damaging systems (and thus affecting the combat power of the target). Adjustments are made for a variety of factors, such as hit chance (handles cloaked ships nicely), beam attentuation, etc. Currently the AI doesn't understand shield piercing or armour piercing, so it doesn't take those into account yet. Weapon mods that affect range or fire rate are accounted for by the AI.
• Priorities are dynamic so the AI does a decent job at ignoring crippled ships when there's bigger fish to fry, while concentrating fire on already damaged ships. It's only updated once each turn right now, but I'd like to improve that - just need to figure out a way to do it so that only relevant priorities are updated outside of the once-per-turn recalculation. done.

• Fixed a bug where if stand_off_and_bombard got tripped to true for one side, it would affect both sides and never untrip. I can't be sure if this did affect vanilla since I'm working with modded code, but even in the vanilla lua files I couldn't figure out where stand_off_and_bombard is supposed to be reset.
• Modified stand_off_and_bombard slightly to encourage picket ships to move forwards, providing a bit more of a PD screen.

• AI now considers bombers that have not yet launched when deciding what to do with interceptors
• stand off behaviour is limited to the first 30 turns and the AI attempts a cease-fire after 50 turns.

• Carriers now try to move in closer, and targets that are within 1 turn range are treated with much higher priority for fighters/bombers.
• Missiles that are already targeted by interceptors have reduced priority when choosing targets for the next weapon or interceptor
• Interceptors/strike fighters treat missiles/bombers that are farther away with lower priority.
• Major tweaks to the priority calculation used when targeting fightercraft with weapons. Fightercraft now have an inherent priority that reflects the fact that unlike missiles, destroying a fightercraft is like destroying a weapon system, it reduces the offensive capability of the opposing fleet. This priority is calculated much like that of ships, in order to ensure they are mutually comparable. It's based on the damage dealt by the fighter/bomber group vs it's health.
• Shield regeneration now matters more when considering how vulnerable a potential target is.
• Now any non-PD weapon that can target missiles/bombers may choose to do so.

• The AI now considers reserving direct-fire PD for missiles/craft not yet launched if the PD weapon's own ship is within strike range of the missile launcher/craft carrier. Should help the AI deal with energy torpedoes aka plasma launchers.
• AI now considers hit chance when deciding to attack missiles/craft with direct fire weapons.
• Reduced "stand off and bombard" turn limit to 20, cease fire turn limit to 40.
• Interceptors now consider the distance to hostile carriers/launchers when deciding to reserve, while also considering that the hostile missiles/bombers will likely be closer once launched.
• Interceptors now check if they can reach their target in time before it reaches it's target, when considering to intercept in-flight craft.
• Prevents interceptors and PD from all reserving for the same target. They are now aware if other weapons are reserving for the same launcher, and will consider other options.
• Fixed a vanilla bug that was preventing the AI from using assault shuttles/transporters against non-immobilized ships.
• Added threat assessment for ships equipped with boarding modules/shuttles/transporters. Might need tweaking, though it rightly considers military transports very high priority, given their ability to take ships out of combat in a single turn.

• AI now considers reserving PD for enemy assault shuttles. Though I haven't seen PD be particularly effective at destroying them yet.
• Improved the boarder threat assesment. Now based on an estimation of crew damage that would be dealt by a capture attempt. Boarders still tend to be high priority, but it's not as extreme as before.
• The decision to capture vs raid is now based on the estimated crew damage vs the remaining crew of the target ship.

• AI attempts to account for enemy ship movement when determining if it is at risk from assault shuttles or missiles/crafts when reserving PD.
• Removed the simplified algorithm for PD allocation. It's been around since the very first version of the mod, and now that the AI is better able to weigh hostile missiles/crafts against ships I don't think it's needed anymore. Removing it does seem to improve the AI's handling of ships that are equipped entirely with PD weapons, or missile fleets that have run out of missiles.
• Fixed a stalemate bug that occurred when all crafts and all non-PD weapons on all ships have been destroyed.

• Direct fire weapons now also consider the amount of missiles currently launched at a ship when deciding to target it
• Defence value calculation now includes the amount of useless system health (bulkheads, etc) that might soak up system damage
• Combat boarders now use boarding priority to pick the ship they move towards (note that all ships still only ever pick the best of the closest 3 when deciding what to move to).
• Planets are now always considered lowest priority when deciding what to move towards, unless if they are already in weapons range.
• When deciding to attack missiles/craft or reserve PD for unlaunched missiles/craft, the amount of damage the weapon does vs the amount of damage the missile/craft group does has more weight (It's now calculated as missile damage/weapon damage squared).

• For the last item above, now only the individual missile/craft/weapon damage is squared, since the count of missiles/craft can be unreliable. For example if there are multiple craft groups near each other, or multiple launchers on the same ship, the AI only sees each one individually. So now the multiplier is = [ (# of missiles/craft)*(individual missile/craft damage)^2 ]/[ (# of weapons)*(individual weapon damage)^2 ]

• The AI now always moves ships with boarding modules/assault shuttles/transporters last.
• The AI attempts to estimate the survival rate of it's missiles vs PD and overcommits missiles to targets accordingly, instead of using a hardcoded overcommit multiplier.
• The AI will not enter "stand off and bombard" mode if it's estimated missile/bomber survival rate is less than 25%.

• Overhaul of how missiles and fightercraft adjust their targeting priorities based on the distance to potential targets, now takes advantage of the AI's ability to assess the amount of hostile PD.
• Ships armed with missile weapons now adjust their desired engagement range based on the AI's hostile PD assessment.

• A small change that seems to significantly improve how effective the AI is at using PD: Ships that have interception warnings are moved by the AI last, after boarding ships.

• The AI now decides when to retreat ships based on an estimate of the total combat power of all allied ships vs the combat power of all hostile ships
• Unarmed (or disarmed) ships that are not severely damaged now only retreat if the AI thinks it is outnumbered 2:1 now 1.5:1. This means that the AI can now attack defended planets without all the transports running away at the beginning of combat. Unarmed/disarmed ships that are severely damaged always attempt to retreat.
• Armed ships that are severely damaged may retreat only if the AI thinks it is stronger than it's opponent and if removing those ships will not swing the balance of power.
• When the AI orders a general retreat (such as when either the player or strategic AI chooses autoretreat), the AI will attempt to retreat all ships at the same time. This means that if there are any ship types that take multiple turns to retreat, other ships will continue to move forwards and fight to cover them.
• The AI may also decide to order a general retreat if it thinks it is outmatched between 3:1 to 5:1, depending on a couple of factors: the presence of a friendly planet, and the proportion of its combat power that comes from immobilized ships and starbases.
• When retreating, ships that can cloak attempt to do so.

• The AI can now make ships move or face towards missiles/fightercraft that it wants to shoot at with fixed weapons.
• Made carriers even more cautious about launching fighters when heavy PD is present. Now they will not launch fighters at targets that are outside of point blank range in the most extreme case.
• Fixed an oversight that was causing the AI to overestimate the combat power of carriers.
• The AI now factors in the speed of missiles/torpedoes/fightercraft when evaluating weapons, since it does affect how easily those objects are shot down.
• Improved the damage assessment calculation used to decide when a ship retreats.
• Made sure space harpies and ancient super-dreadnoughts don't retreat.
• Fixed fightercraft and missile launchers underestimating the distance to their targets.
• The AI can now move ships and attack with them later after other ships have moved and attacked. It tries to move its tougher ships first, while attacking with its more powerful ships.
• Many tweaks and fixes.

• Bugfixes.

• The AI now factors in armour and shield piercing effects when calculating the priority of potential targets.

• Bugfixes

harpy eagle wrote:Plus a few tweaks related to fightercraft and a hack to ensure that turn_counter gets reset at the end of combat. I'm guessing there's a way to add values to the environment that close_and_attack_turn executes in, but I wasn't able to figure it out.

sven wrote:It looks like your turn_counter is basically just replicating functionality that can already be accessed through the (obscure and entirely undocumented) global helper function current_side_nturns()

sven wrote:Re: inserting variables into the tactical combat execution environment; AI execution environments are a bit overly fancy, read the comment at the top of @AIContext.lua for a rundown. But, for all the fanciness, there's not currently a clean way to do what I think you're asking about: namely, creating and updating additional per-side state that would persist over the lifetime of the battle.

sven wrote:The reason for that, more or less, is that battles can be loaded and saved, so any permanent state would need to be put somewhere that gets loaded and saved as well. The logical place for tactical ai persistent variables is probably "all_attacks", more specifically, fetching the current attack.battle via local attack = all_attacks[get_attack_id()], and then sticking per-side ai data somewhere inside attack.battle. (Hacks like this are already used to power the 'retreat_all' ai hint.)

sven wrote:That said, using attack.battle is also really something of a kludge; as that data supports game io, but not attack action rollbacks. The *best* solution here would probably be to expose a custom battle-state variable that could act as a sortof AI notepad. That's a change that would require a little fiddling with the C++ side of the engine, but it wouldn't really be that big a deal to setup. Um, basically, if you think tactical ai state is a thing you want to really experiment seriously with, you should let me know, so I can write some helpers that really support the feature "properly".

harpy eagle wrote: I see, I was hoping there might be a way. I'm pretty new to lua and am still getting a handle on the ways you can manipulate scope in the language. So If I create a table at the beginning of the do_ai_turns() function, to be used as a kind of scratch space, there's no way to get it into close_and_attack_turn() when it executes? I have to admit I don't understand what is going on in the control flow between do_ai_turns() -> tactical_ai_call() -> close_and_attack_turn().

function tactical_ai_call(f,...)
 	return SCOPE_call("temp AI State", { }, 
            "calling AI", _ENV, f, ... )
end

   local my_temp_data = { turn_counter=i }
   SCOPE_call("temp AI State",  my_temp_data,  "calling AI", AIContext, AI.close_and_attack_turn )

harpy eagle wrote:what led to the turn_counter thing in the first place is that the stand_off_and_bombard behaviour can eat into the 30 turns that gets allotted to each side before the battle ends in a draw. While the draw won't happen as long as stand_off_and_bombard is true, each stand off turn is still counted, so it can happen that the AI gets far less than 30 turns of "real" combat once it runs out of missiles.

		if(i > 200*Battle.num_sides() )
			sprint("max number of ai turn repetitions reached.")
			break
		end

harpy eagle wrote:The decision problem of whether or not a battle is making sufficient progress to be worth continuing to process is kind of a thorny one anyways, and I'm not sure if I really want to take a deep dive into that (e.g. what if the stand off side has only a few fighters left, not enough to overcome shield regen, while the immobile side has no PD?). I may end up just reverting the turn_counter stuff and focusing on something else instead.

harpy eagle wrote:I guess I've evolved up to the setmetatable() level of lua now. This also helped avoid some duplicated priority calculations and supported the above missile addition.

• Revert turn counter, try to replace it with something simple that doesn't require data to persist across turns, or just revert it altogether.
• Take advantage of __index to do some coffee improvements
• Experiment with considering the amount of PD possessed by the opposing fleets when deciding how many missiles to allocate to a target.
• Experiment with taking into account bombers/missiles not yet launched when allocating interceptors. This might be useful since interceptors are usually committed for a few turns, and throwing them against ships can be a waste

• AI now considers bombers that have not yet launched when deciding what to do with interceptors
• Reverted turn counter changes, instead stand off behaviour is limited to the first 30 turns and the AI attempts a cease-fire after 50 turns.
• Some bugfixes, code cleanup