AI ship design scripting workshop 1. Crew and life support.

The AI desings each ship in the Script_AI_DesignCreation.txt file. Scrolling down it you find an area that looks like this:

// b. Add Life Support (Multiple)
set comp_id := Sys_Get_Component_With_Name(sys_long_Player_ID, AI_COMPONENT_LIFE_SUPPORT)
if (comp_id > 0) then
set comp_enh_id := Sys_Get_Best_Comp_Enh_For_Component(sys_long_Player_ID, design_id, comp_id)
set num_to_add := Get_Number_Of_Components_To_Add(design_id, AI_GEN_COMP_TYPE_LIFE_SUPPORT)
call Add_Components_To_Vehicle_Design(design_id, comp_id, comp_enh_id, SHIP_SECTION_INNER_HULL, num_to_add, FALSE)
else
set bool_continue_design := FALSE
endif

// c. Add Crew Quarters (Multiple)
set comp_id := Sys_Get_Component_With_Name(sys_long_Player_ID, AI_COMPONENT_CREW_QUARTERS)
if (comp_id > 0) then
set comp_enh_id := Sys_Get_Best_Comp_Enh_For_Component(sys_long_Player_ID, design_id, comp_id)
set num_to_add := Get_Number_Of_Components_To_Add(design_id, AI_GEN_COMP_TYPE_CREW_QUARTERS)
call Add_Components_To_Vehicle_Design(design_id, comp_id, comp_enh_id, SHIP_SECTION_INNER_HULL, num_to_add, FALSE)
else
set bool_continue_design := FALSE
endif

This is where the AI adds life support and crew quarters to the design it is creating. Looking at this, you can start to make some sense of it. set comp_id lets the AI know what componenet we are working with. set num_to_add calls a separate script named Get_Number_Of_Components_To_Add. call Add_Components_To_Vehicle_Design tells the AI to add these components to this design.

Since we care about how many of these it is adding, we should look up Get_Number_Of_Components_To_Add. Fortunatly, it is here in the same file.

In it, you can see an area that looks like this:

case (comp_type)
AI_GEN_COMP_TYPE_LIFE_SUPPORT:
return lst_AI_Vehicle_Sizes_Num_Life_Support.Get(index)
AI_GEN_COMP_TYPE_CREW_QUARTERS:
return lst_AI_Vehicle_Sizes_Num_Crew_Quarters.Get(index)
AI_GEN_COMP_TYPE_ENGINE:
return lst_AI_Vehicle_Sizes_Num_Engines.Get(index)
AI_GEN_COMP_TYPE_SMALL_ENGINE:
return lst_AI_Vehicle_Sizes_Num_Engines.Get(index)
AI_GEN_COMP_TYPE_GROUND_MOVEMENT:
return lst_AI_Vehicle_Sizes_Num_Engines.Get(index)
endcase

This means that for each of these cases, look up the associated variable, and return it to whatever called it.

So, we set num_to_add := Get_Number_Of_Components_To_Add(design_id, AI_GEN_COMP_TYPE_CREW_QUARTERS). This looks in Get_Number_Of_Components_To_Add passing it the design_id (the ship we are designing) and the componenet we are looking for (AI_GEN_COMP_TYPE_CREW_QUARTERS). Get_Number_Of_Components_To_Add hunts through its case list (we won't go over the mechanics here) until it finds AI_GEN_COMP_TYPE_CREW_QUARTERS.

This case says to return lst_AI_Vehicle_Sizes_Num_Crew_Quarters.Get(index). Index can be thought of the ship class for now, and is determined off of the design_id. This variable is defined in the previous example as 1. So, it returns the number 1 in to num_to_add, which is then used by Add_Components_To_Vehicle_Design(design_id, comp_id, comp_enh_id, SHIP_SECTION_INNER_HULL, num_to_add, FALSE) to determine how many to add to the design.

Okay, so we know in rough terms how the AI knows how many components to add. Here is where the fun begins...

We want the AI to add a number of Crew Quarters and Life Support components based on the actual requirements of the design, and to adjust the ammount it adds based on the components' ability to meet those requirements (each component adds more points as its level goes up).

So...the AI first needs to know how many points it is going to require. This is the easiest change. Go in to Script_AI_GlobalSettings.txt, and start changing the number values in the lst_AI_Vehicle_Sizes_Num_Life_Support and lst_AI_Vehicle_Sizes_Num_Crew_Quarters lines. These values need to match what is required on the actual vehicle design, so Frigate becomes 50 each, while Organic Light Cruiser becomes 100 each. You can look these values up in the VehicleSizes.txt file in the SE5\Data directory.

Now, our frigate looks like:

call lst_AI_Vehicle_Sizes_Name.add(AI_VEHICLE_SIZE_FRIGATE)
call lst_AI_Vehicle_Sizes_AI_Size_Class.add(AI_VEHICLE_SIZE_CLASS_SHIP)
call lst_AI_Vehicle_Sizes_Num_Life_Support.add(50)
call lst_AI_Vehicle_Sizes_Num_Crew_Quarters.add(50)
call lst_AI_Vehicle_Sizes_Num_Engines.add(12)

Of course, this means that the AI will add 50 life support COMPONENTS and 50 crew quarters COMPONENTS. Not QUITE what we want here.

Next, we tell the AI how to determine how many it actually needs...

So, the AI now knows how much it needs. Unfortunatly, it doesn't really understand that, and so is going to add a LOT more than it needs. We need the AI to be smarter about this.

Head back in to your Script_AI_DesignCreation.txt file, and go back down to where it says something like:

// b. Add Life Support (Multiple)
set comp_id := Sys_Get_Component_With_Name(sys_long_Player_ID, AI_COMPONENT_LIFE_SUPPORT)
if (comp_id > 0) then...

I'm going to add it here, because I'm basically lazy. You could add it to the Get_Number_Of_Components_To_Add function if you wished, and that might make for cleaner code.

We will deal with Life Support first.

There is no way, that I know of, to look at the level of component the AI has. We just can't ask it "what is the highest level of X component you have". We CAN, however, ask it what its tech levels are. Since component level is directly related to tech levels, this is the next best thing.

By the way, I will be adding a bunch of variabls here. You need to declare new variables in each function you add them to (unless they are global, but that's not important for this example). Here are the variables I'm adding:

tech_id: long
tech_level: long
comp_level: long
comp_capacity: long
cap_requirement: long

I'll explain each of these as we go.

First, I add:

set tech_id := Sys_Get_Tech_ID(AI_TECH_AREA_MEDICAL_TREATMENT)
This gets us the tech_id (an internal number the AI uses) of the Medical Treatment tech, which governs Life Support (amung other things).

Now:
set tech_level := Sys_Get_Empire_Research_Tech_Level(sys_long_Player_ID, tech_id)
This tells us what level the current player (sys_long_Player_ID) has in a given tech (tech_id) as defined right above here.

Next:
set comp_level := Sys_Min_Long(tech_level, 6)
This tells us what level the component in question is. Literally, it says comp_level is set to tech_level (determined above) or the number 6, whichever is LESS. This is important, because Medical Treatment tech goes beyond level 6, but the Life Support component does not. So, if Medical Treatment is more than six, this lets the game "top out" the level of the Life Support component AT 6.

Next:

set comp_capacity := 100 + ((comp_level - 1) * 20)
This tells us the capacity for the component we are figuring out. This formula is taken directly from the Components.txt file, under the Life Support component. In that file it looks like this: 100 + (([%Level%] - 1) * 20)

Now, the AI knows what capacity its Life Support components have, based on the level of its life support components. Next comes determining how many we need. I use the following line:
set cap_requirement := Get_Number_Of_Components_To_Add(design_id, AI_GEN_COMP_TYPE_LIFE_SUPPORT)
in place of:
set num_to_add := Get_Number_Of_Components_To_Add(design_id, AI_GEN_COMP_TYPE_LIFE_SUPPORT)
as the Get_Number_Of_Components_To_Add function now just tells us the ammount of Life Support required, not the number of components (it's 50 for the frigate now).
Finally I use:
set num_to_add := Sys_Trunc((cap_requirement / comp_capacity) + 0.99)
To determine how many we need. This reads as: num_to_add is set to cap_requirement (how much we need) divided by comp_capacity (how much each component provides), plus 0.99, and then truncated.

Sys_Trunc cuts off all numbers after the decimal place, so 1.436246 becomes 1. However, if our component capacity is more than we require (100 life support, with frigate only needing 50) this creates a problem. The number added becomes 100 / 50, or 0.5, truncated to 0. So, we add 0.99 before we truncate (this is the equivilant of saying "round your result up". 0.5 becomes 1.49, which is then truncated to 1. This is important, because if the ship requires 1.436246 components, that means it needs MORE THAN ONE to fill its requirements. So, adding 0.99 makes this 2.426246, which is truncated to 2, which makes minimum requirements.

The final result of our work in Script_AI_DesignCreation.txt changes this:

// b. Add Life Support (Multiple)
set comp_id := Sys_Get_Component_With_Name(sys_long_Player_ID, AI_COMPONENT_LIFE_SUPPORT)
if (comp_id > 0) then
set comp_enh_id := Sys_Get_Best_Comp_Enh_For_Component(sys_long_Player_ID, design_id, comp_id)
set num_to_add := Get_Number_Of_Components_To_Add(design_id, AI_GEN_COMP_TYPE_LIFE_SUPPORT)
call Add_Components_To_Vehicle_Design(design_id, comp_id, comp_enh_id, SHIP_SECTION_INNER_HULL, num_to_add, FALSE)
else
set bool_continue_design := FALSE
endif

To this:

// b. Add Life Support (Multiple)
set comp_id := Sys_Get_Component_With_Name(sys_long_Player_ID, AI_COMPONENT_LIFE_SUPPORT)
if (comp_id > 0) then
set tech_id := Sys_Get_Tech_ID(AI_TECH_AREA_MEDICAL_TREATMENT)
set tech_level := Sys_Get_Empire_Research_Tech_Level(sys_long_Player_ID, tech_id)
set comp_level := Sys_Min_Long(tech_level, 6)
set comp_capacity := 100 + ((comp_level - 1) * 20)
set cap_requirement := Get_Number_Of_Components_To_Add(design_id, AI_GEN_COMP_TYPE_LIFE_SUPPORT)
set num_to_add := Sys_Trunc((cap_requirement / comp_capacity) + 0.99)
set comp_enh_id := Sys_Get_Best_Comp_Enh_For_Component(sys_long_Player_ID, design_id, comp_id)
call Add_Components_To_Vehicle_Design(design_id, comp_id, comp_enh_id, SHIP_SECTION_INNER_HULL, num_to_add, FALSE)
else
set bool_continue_design := FALSE
endif

This same method can be applied to Crew Quarters to achieve the same result. Just make sure you look up the right tech_id (AI_TECH_AREA_PSYCHOLOGY), you limit your component levels correctly (Sys_Min_Long(tech_level, 10)) and you use the correct formula from the Components.txt file (50 + ((comp_level - 1) * 50)).

Using the trick to look up a tech level, and then calculating the ability of a component based off of that level, can be used in several ways. I encourage you to experiment with it. For instance, I use it in a script for medical ships, to make them check their ability to cure a plague, before going off and attempting to cure it.

Good luck, and I hope this helped.

What you gather is correct. The stock AI wastes a lot of space on crew and life support late in the game.

Other things I've done, for instance, is specify that some races use Master Computers instead of Bridge/Crew/Life Support. Stock AI makes NO use of Master Computers at all, making the Computer Virus component effectivly pointless vs the AI.

I broke it down the way I did, to make it easier to "see" how the code works, and to make it a bit more flexible for me (though the actual code I used is a bit more efficient and in a different function). This way, I can more easily define new crew and life support requirements, expand or contract tech levels, etc.

I use different requirements for crew and life support than the stock game, and have expanded the life support componenet to all 49 levels of medical treatment with a different progression per level. I am also planning to expand crew quarters with the use of a new tech tree.

Boy, but that would make all our lives just that much easier.

Here is what I did:

(BTW, I am at work, so I don't have my script in front of me to check, so this is a rough outline).

First, I added a global variable as to whether the AI uses Master Computers or not.

I set that AI to TRUE for the specific races that I want to use the Master Computer. I did this so that there is some difference between the feel of the races. Some use Automated ships, some use live crew. Knowing your enemy lets you decide between Toxic Injectors or Computer Viruses. I could also make whether each race uses the MC random at AI start, but for now its just set.

Then, I did a simple if then statement at the beginning of required components. Basically:

set comp_id := Master_Computer
If bool_Race_Uses_Master_Computer and (comp_id > 0) then
---Add the master computer component
else
---Add the Bridge/Life Support/Crew Quarters
endif

As for your second question, I don't think its possible to check for design errors. The game will not allow for the creation of the design if it violates the rules (AI cannot make ships without a Bridge or MC, for instance) but the scripting doesn't check for the presence or absence of those errors.

There is a minister called Enemy Analysis. Browsing throug the script files, you will find one dealing with Enemy Analysis. This script file is essentially empty. Theroetically this is where the AI functions to analyze enemy ship designs, tech, defenses, politics, Intel, general behaviour, etc would be located. These scripts, in turn, would be tied back in to the design, intel, politics, and construction scripts, creating a feedback loop between analysis, adaptation, and implementation.

Perhaps this is something that will be done in a patch some day, or perhaps this is an area where modders will have to contribute. Right now, I've got a LOT of fish to fry within the current scripting. I'm not even going to approach this section of the AI for a long time, if ever.

Makes a note to go by the Wiki and figure out how to post in it...