Why use `AbilityId.TERRANBUILDDROP_SUPPLYDEPOTDROP` as the addon_place ability value?

[yorhaha]

https://github.com/BurnySc2/python-sc2/blob/a747fc6b461d0303c6357650199ec642cd293828/sc2/bot_ai.py#L721C31-L721C62

Should it be changed to:

if addon_place:
    # Filter remaining positions if addon can be placed
    res = await self.client._query_building_placement_fast(
        # AbilityId.TERRANBUILDDROP_SUPPLYDEPOTDROP,
        building,
        [p.offset((2.5, -0.5)) for p in possible],
    )
    possible = [p for r, p in zip(res, possible) if r]

[raspersc2]

Because this logic is checking if building can fit an addon if the user passed in addon_place = True for the calculated possible_positions for building.

AbilityId.TERRANBUILDDROP_SUPPLYDEPOTDROP is used because that's a 2x2 structure, the same building size as addons

[yorhaha]

But I frequently encountered the issue of "Can't find placement location" while developing the bot with addon_place=True . So I consulted Gemini, and here's what it said:

---

Alright, let's analyze this code. When addon_place=True, this function often fails to find a location, and the issue likely lies in the part that checks the space for addon buildings.

Core Problem Analysis

The root cause is in this line:

res = await self.client._query_building_placement_fast(  
    AbilityId.TERRANBUILDDROP_SUPPLYDEPOTDROP,  
    [p.offset((2.5, -0.5)) for p in possible],  
)  

Here, AbilityId.TERRANBUILDDROP_SUPPLYDEPOTDROP is used to check whether the 2x2 space for the addon is available. This AbilityId corresponds to the Orbital Command's Supply Depot drop ability.

This leads to several issues:

1. Incorrect AbilityId: The intention of this check is to determine, "Can a 2x2 structure be built here?"—not, "Can an Orbital Command drop a Supply Depot here?" Using this specific AbilityId may cause the query to fail due to unmet conditions (e.g., you might not have an Orbital Command, or the game engine might consider this query invalid in the given context), even if the space itself is empty and buildable.

2. Not Generic: The purpose of checking the addon space is to ensure there’s a free 2x2 area. The most generic way is to simulate placing a standard 2x2 structure, such as an SCV-built Supply Depot. TERRANBUILDDROP_SUPPLYDEPOTDROP is clearly not a generic check.

3. Inconsistent with Other Code: Note this part at the beginning of the function:

   if await self.can_place_single(building, near) and (  
       not addon_place or await self.can_place_single(UnitTypeId.SUPPLYDEPOT, near.offset((2.5, -0.5)))  
   ):  

   Here, when checking the addon position, it correctly uses can_place_single(UnitTypeId.SUPPLYDEPOT, ...). This suggests the original author knew the correct approach—using the UnitTypeId of a Supply Depot—but made a mistake in the loop.

How to Fix

You should replace the hardcoded, incorrect AbilityId with the correct AbilityId for SCV-built Supply Depots.

The safest way is to fetch this ID from game_data, just like how the building parameter is handled at the start of the function.

Proposed Fix:

For efficiency, you can retrieve the Supply Depot’s build ability ID before entering the loop and reuse it inside.

Here’s the corrected code:

import random  
from sc2.ids.unit_typeid import UnitTypeId  
from sc2.ids.ability_id import AbilityId  
from sc2.position import Point2  

# ... (class definition)  

    async def find_placement(  
        self,  
        building: UnitTypeId | AbilityId,  
        near: Point2,  
        max_distance: int = 20,  
        random_alternative: bool = True,  
        placement_step: int = 2,  
        addon_place: bool = False,  
    ) -> Point2 | None:  
        """Finds a placement location for building.  

        Example::  

            if self.townhalls:  
                cc = self.townhalls[0]  
                depot_position = await self.find_placement(UnitTypeId.SUPPLYDEPOT, near=cc)  

        :param building:  
        :param near:  
        :param max_distance:  
        :param random_alternative:  
        :param placement_step:  
        :param addon_place:"""  

        assert isinstance(building, (AbilityId, UnitTypeId))  
        assert isinstance(near, Point2), f"{near} is not a Point2 object"  

        if isinstance(building, UnitTypeId):  
            building_ability = self.game_data.units[building.value].creation_ability.id  
        else:  
            building_ability = building  

        # 【First Fix】: If addon space checking is needed, fetch the Supply Depot's build AbilityId beforehand.  
        # This is a standard 2x2 structure, perfect for checking addon space.  
        addon_check_ability = None  
        if addon_place:  
            addon_check_ability = self.game_data.units[UnitTypeId.SUPPLYDEPOT.value].creation_ability.id  

        # Check the 'near' point itself  
        if await self.can_place_single(building_ability, near):  
            if not addon_place or await self.can_place_single(addon_check_ability, near.offset((2.5, -0.5))):  
                return near  

        if max_distance == 0:  
            return None  

        # Search in a square spiral  
        for distance in range(placement_step, max_distance, placement_step):  
            possible_positions = [  
                Point2(p).offset(near).to2  
                for p in (  
                    [(dx, -distance) for dx in range(-distance, distance + 1, placement_step)]  
                    + [(dx, distance) for dx in range(-distance, distance + 1, placement_step)]  
                    + [(-distance, dy) for dy in range(-distance, distance + 1, placement_step)]  
                    + [(distance, dy) for dy in range(-distance, distance + 1, placement_step)]  
                )  
            ]  

            # Filter positions where the main building can be placed  
            res = await self.client._query_building_placement_fast(building_ability, possible_positions)  
            possible = [p for r, p in zip(res, possible_positions) if r]  

            if not possible:  
                continue  

            if addon_place:  
                # 【Second Fix】: Use the correct AbilityId to check addon space  
                res = await self.client._query_building_placement_fast(  
                    addon_check_ability,  # <-- Correct ID  
                    [p.offset((2.5, -0.5)) for p in possible],  
                )  
                possible = [p for r, p in zip(res, possible) if r]  

            if not possible:  
                continue  

            if random_alternative:  
                return random.choice(possible)  
            return min(possible, key=lambda p: p.distance_to_point2(near))  

        return None  

---

Later, I experimented with the code it provided and found that the frequency of the aforementioned issue decreased significantly. What do you think of the explanation and code it gave?

[BurnySc2]

It seems during a refactor in 1ec2d72 I changed the AbilityId to query the can_place to be faster (by using _query_building_placement_fast), because this find_placement function is rather slow in general.

I guess this mishap happened by using autocomplete resulting in the wrong AbilityId. The current AbilityId (Supply Drop) expects a target unit instead of a position anyway. I tested it a bit and it seems the function was not working as expected.

Can you verify that the changes in the PR #225 work as expected for you?
I have added small instructions on how to try it out (using the battlecruiser example which requires tech lab on the starport).

Obviously the AI doesn't quite understand (yet) how it works internally.