def __init__(
self, raw_game_data: Any, raw_game_info: Any, raw_observation: Any
) -> None:
"""
Set up variables for use within Creeper.
Args:
raw_game_data (Any): self.game_data from main instance
raw_game_info (Any): self.game_info from main instance
raw_observation (Any): self.game_state from main instance
Returns:
None
"""
self.bot = BotAI()
game_data = GameData(raw_game_data.data)
game_info = GameInfo(raw_game_info.game_info)
game_state = GameState(raw_observation)
self.bot._initialize_variables()
self.bot._prepare_start(
client=None, player_id=1, game_info=game_info, game_data=game_data
)
self.bot._prepare_step(state=game_state, proto_game_info=raw_game_info)
self.pathing = PathManager(raw_game_data, raw_game_info, raw_observation)
self.pf = PathFind(self.pathing.map_grid)
def generate_redirect_abilities_dict(data: dict):
ability_data = data["Ability"]
unit_data = data["Unit"]
upgrade_data = data["Upgrade"]
# Load pickled game data files
path = os.path.dirname(__file__)
pickled_files_folder_path = os.path.join(path, "test", "pickle_data")
pickled_files = os.listdir(pickled_files_folder_path)
random_pickled_file = next(f for f in pickled_files if f.endswith(".xz"))
with lzma.open(
os.path.join(pickled_files_folder_path, random_pickled_file),
"rb") as f:
raw_game_data, raw_game_info, raw_observation = pickle.load(f)
game_data = GameData(raw_game_data.data)
all_redirect_abilities: Dict[AbilityId, AbilityId] = OrderedDict2()
entry: dict
for entry in ability_data:
ability_id_value: int = entry["id"]
try:
ability_id: AbilityId = AbilityId(ability_id_value)
except Exception as e:
print(f"Error with ability id value {ability_id_value}")
continue
generic_redirect_ability_value: int = game_data.abilities[
ability_id_value]._proto.remaps_to_ability_id
if generic_redirect_ability_value:
# Might be 0 if it has no redirect ability
all_redirect_abilities[ability_id] = AbilityId(
generic_redirect_ability_value)
return all_redirect_abilities
def generate_redirect_abilities_dict(data: dict):
ability_data = data["Ability"]
unit_data = data["Unit"]
upgrade_data = data["Upgrade"]
# Load pickled game data files
pickled_file_path = Path(
__file__).parent / "test" / "pickle_data" / "AcropolisLE.xz"
assert pickled_file_path.is_file(
), f"Could not find pickled data file {pickled_file_path}"
logger.info(f"Loading pickled game data file {pickled_file_path}")
with lzma.open(pickled_file_path.absolute(), "rb") as f:
raw_game_data, raw_game_info, raw_observation = pickle.load(f)
game_data = GameData(raw_game_data.data)
all_redirect_abilities: Dict[AbilityId, AbilityId] = OrderedDict2()
entry: dict
for entry in ability_data:
ability_id_value: int = entry["id"]
try:
ability_id: AbilityId = AbilityId(ability_id_value)
except Exception as e:
logger.info(f"Error with ability id value {ability_id_value}")
continue
generic_redirect_ability_value: int = game_data.abilities[
ability_id_value]._proto.remaps_to_ability_id
if generic_redirect_ability_value:
# Might be 0 if it has no redirect ability
all_redirect_abilities[ability_id] = AbilityId(
generic_redirect_ability_value)
return all_redirect_abilities
async def get_game_data(self) -> GameData:
result = await self._execute(data=sc_pb.RequestData(ability_id=True,
unit_type_id=True,
upgrade_id=True,
buff_id=True,
effect_id=True))
return GameData(result.data)
def import_bot_instance(
raw_game_data: Response,
raw_game_info: Response,
raw_observation: ResponseObservation,
) -> BotAI:
"""
import_bot_instance DocString
"""
bot = BotAI()
game_data = GameData(raw_game_data.data)
game_info = GameInfo(raw_game_info.game_info)
game_state = GameState(raw_observation)
# noinspection PyProtectedMember
bot._initialize_variables()
# noinspection PyProtectedMember
bot._prepare_start(client=None,
player_id=1,
game_info=game_info,
game_data=game_data)
# noinspection PyProtectedMember
bot._prepare_first_step()
# noinspection PyProtectedMember
bot._prepare_step(state=game_state, proto_game_info=raw_game_info)
# noinspection PyProtectedMember
bot._find_expansion_locations()
return bot
def __init__(
self, raw_game_data: Any, raw_game_info: Any, raw_observation: Any
) -> None:
"""
Set up variables for use within PathMangager.
Args:
raw_game_data (Any): self.game_data from main instance
raw_game_info (Any): self.game_info from main instance
raw_observation (Any): self.game_state from main instance
Returns:
None
"""
self.bot = BotAI()
game_data = GameData(raw_game_data.data)
game_info = GameInfo(raw_game_info.game_info)
game_state = GameState(raw_observation)
self.bot._initialize_variables()
self.bot._prepare_start(
client=None, player_id=1, game_info=game_info, game_data=game_data
)
self.bot._prepare_step(state=game_state, proto_game_info=raw_game_info)
map_name = game_info.map_name
self.pathing_dict: Dict[int, PathDict] = {}
map_width = game_info.map_size.width
map_height = game_info.map_size.height
raw_grid = np.zeros((map_width, map_height))
for x in range(map_width):
for y in range(map_height):
pos = Point2((x, y))
raw_grid[x][y] = game_info.pathing_grid[pos]
self.map_grid = np.rot90(raw_grid.astype(int))
np.save(f"map_grids/{map_name}_grid", self.map_grid)
self.pf = PathFind(self.map_grid)
def get_map_specific_bot(map_path: Path) -> BotAI:
assert map_path in MAPS
with lzma.open(str(map_path.absolute()), "rb") as f:
raw_game_data, raw_game_info, raw_observation = pickle.load(f)
# Build fresh bot object, and load the pickle'd data into the bot object
bot = BotAI()
game_data = GameData(raw_game_data.data)
game_info = GameInfo(raw_game_info.game_info)
game_state = GameState(raw_observation)
bot._initialize_variables()
bot._prepare_start(client=None, player_id=1, game_info=game_info, game_data=game_data)
bot._prepare_step(state=game_state, proto_game_info=raw_game_info)
return bot
def generate_unit_alias_dict(data: dict):
ability_data = data["Ability"]
unit_data = data["Unit"]
upgrade_data = data["Upgrade"]
# Load pickled game data files from one of the test files
pickled_file_path = Path(
__file__).parent / "test" / "pickle_data" / "AcropolisLE.xz"
assert pickled_file_path.is_file(
), f"Could not find pickled data file {pickled_file_path}"
logger.info(f"Loading pickled game data file {pickled_file_path}")
with lzma.open(pickled_file_path.absolute(), "rb") as f:
raw_game_data, raw_game_info, raw_observation = pickle.load(f)
game_data = GameData(raw_game_data.data)
all_unit_aliases: Dict[UnitTypeId, UnitTypeId] = OrderedDict2()
all_tech_aliases: Dict[UnitTypeId, Set[UnitTypeId]] = OrderedDict2()
entry: dict
for entry in unit_data:
unit_type_value = entry["id"]
unit_type = UnitTypeId(entry["id"])
current_unit_tech_aliases: Set[UnitTypeId] = OrderedSet2()
assert (
unit_type_value in game_data.units
), f"Unit {unit_type} not listed in game_data.units - perhaps pickled file {pickled_file_path} is outdated?"
unit_alias: int = game_data.units[unit_type_value]._proto.unit_alias
if unit_alias:
# Might be 0 if it has no alias
unit_alias_unit_type_id = UnitTypeId(unit_alias)
all_unit_aliases[unit_type] = unit_alias_unit_type_id
tech_aliases: List[int] = game_data.units[
unit_type_value]._proto.tech_alias
for tech_alias in tech_aliases:
# Might be 0 if it has no alias
unit_alias_unit_type_id = UnitTypeId(tech_alias)
current_unit_tech_aliases.add(unit_alias_unit_type_id)
if current_unit_tech_aliases:
all_tech_aliases[unit_type] = current_unit_tech_aliases
return all_unit_aliases, all_tech_aliases
def generate_unit_alias_dict(data: dict):
ability_data = data["Ability"]
unit_data = data["Unit"]
upgrade_data = data["Upgrade"]
# Load pickled game data files from one of the test files
path = os.path.dirname(__file__)
pickled_files_folder_path = os.path.join(path, "test", "pickle_data")
pickled_files = os.listdir(pickled_files_folder_path)
random_pickled_file = next(f for f in pickled_files if f.endswith(".xz"))
with lzma.open(
os.path.join(pickled_files_folder_path, random_pickled_file),
"rb") as f:
raw_game_data, raw_game_info, raw_observation = pickle.load(f)
game_data = GameData(raw_game_data.data)
all_unit_aliases: Dict[UnitTypeId, UnitTypeId] = OrderedDict2()
all_tech_aliases: Dict[UnitTypeId, Set[UnitTypeId]] = OrderedDict2()
entry: dict
for entry in unit_data:
unit_type_value = entry["id"]
unit_type = UnitTypeId(entry["id"])
current_unit_tech_aliases: Set[UnitTypeId] = OrderedSet2()
assert unit_type_value in game_data.units, f"Unit {unit_type} not listed in game_data.units"
unit_alias: int = game_data.units[unit_type_value]._proto.unit_alias
if unit_alias:
# Might be 0 if it has no alias
unit_alias_unit_type_id = UnitTypeId(unit_alias)
all_unit_aliases[unit_type] = unit_alias_unit_type_id
tech_aliases: List[int] = game_data.units[
unit_type_value]._proto.tech_alias
for tech_alias in tech_aliases:
# Might be 0 if it has no alias
unit_alias_unit_type_id = UnitTypeId(tech_alias)
current_unit_tech_aliases.add(unit_alias_unit_type_id)
if current_unit_tech_aliases:
all_tech_aliases[unit_type] = current_unit_tech_aliases
return all_unit_aliases, all_tech_aliases
async def store_data_to_file(self, file_path: str):
# Grab all raw data from observation
raw_game_data = await self._client._execute(
data=sc_pb.RequestData(ability_id=True, unit_type_id=True, upgrade_id=True, buff_id=True, effect_id=True)
)
raw_game_info = await self._client._execute(game_info=sc_pb.RequestGameInfo())
raw_observation = self.state.response_observation
# To test if this data is convertable in the first place
game_data = GameData(raw_game_data.data)
game_info = GameInfo(raw_game_info.game_info)
game_state = GameState(raw_observation)
os.makedirs(os.path.dirname(file_path), exist_ok=True)
with lzma.open(file_path, "wb") as f:
pickle.dump([raw_game_data, raw_game_info, raw_observation], f)
def get_map_specific_bots() -> Iterable[BotAI]:
folder = os.path.dirname(__file__)
subfolder_name = "pickle_data"
pickle_folder_path = os.path.join(folder, subfolder_name)
files = os.listdir(pickle_folder_path)
for file in (f for f in files if f.endswith(".xz")):
with lzma.open(os.path.join(folder, subfolder_name, file), "rb") as f:
raw_game_data, raw_game_info, raw_observation = pickle.load(f)
# Build fresh bot object, and load the pickle'd data into the bot object
bot = BotAI()
game_data = GameData(raw_game_data.data)
game_info = GameInfo(raw_game_info.game_info)
game_state = GameState(raw_observation)
bot._initialize_variables()
bot._prepare_start(client=None, player_id=1, game_info=game_info, game_data=game_data)
bot._prepare_step(state=game_state, proto_game_info=raw_game_info)
yield bot
async def on_start_async(self):
raw_game_data = await self._client._execute(
data=sc_pb.RequestData(ability_id=True, unit_type_id=True, upgrade_id=True, buff_id=True, effect_id=True)
)
raw_game_info = await self._client._execute(game_info=sc_pb.RequestGameInfo())
raw_observation = self.state.response_observation
# To test if this data is convertable in the first place
game_data = GameData(raw_game_data.data)
game_info = GameInfo(raw_game_info.game_info)
game_state = GameState(raw_observation)
print(f"Saving file to {self.map_name}.xz")
file_path = self.get_pickle_file_path()
os.makedirs(os.path.dirname(file_path), exist_ok=True)
with lzma.open(file_path, "wb") as f:
pickle.dump([raw_game_data, raw_game_info, raw_observation], f)
await self._client.leave()
