def submem(key1, key2): # type: (str, str) -> JSMap[Any, Any] """ :rtype: jstools.js_set_map.JSMap """ v = volatile() if not v.has(key1): v.set(key1, new_map([(key2, new_map())])) elif not v.get(key1).has(key2): v.get(key1).set(key2, new_map()) return v.get(key1).get(key2)
def visit_room_graph(center_room: str, max_distance: int, visitor: Callable[[str], bool]): """ Visits each room from the center room outwards by calling the visitor function. Will end exploring from a given room if visitor returns false - but will continue to explore other paths until all paths end with visitor returning false. """ visited = new_map() def visit_with_neighbors(room_name: str, time_left_now: int): already_visited_here = False if visited.has(room_name): already_visited_here = True last_time_left = visited.get(room_name) if last_time_left < 0 or last_time_left >= time_left_now: return visited.set(room_name, time_left_now) if not already_visited_here: continuing = visitor(room_name) if not continuing: visited.set(room_name, -1) return time_left_after_this_room = time_left_now - 50 if time_left_after_this_room > 0: exits = Game.map.describeExits(room_name) for room_key in _.shuffle(Object.keys(exits)): next_room = exits[room_key] visit_with_neighbors(next_room, time_left_after_this_room) visit_with_neighbors(center_room, max_distance)
def volatile(): # type: () -> JSMap[str, Any] global _tick_stored_for global _volatile_memory if _volatile_memory is None or _tick_stored_for < Game.time: _tick_stored_for = Game.time _volatile_memory = new_map() return _volatile_memory
def mem(key): # type: (str) -> JSMap[Any, Any] """ :rtype: jstools.js_set_map.JSMap """ v = volatile() if not v.has(key): v.set(key, new_map()) return v.get(key)
def _deserialize_data(data: str) -> StoredRoom: # NOTE: this cache is only ever reset as a last resort, in normal operation the server should reset the global # before this is reached. global _cached_data, _cache_created if Game.time - _cache_created > 1000: _cached_data = new_map() _cache_created = Game.time deserialized = _cached_data.get(data) if deserialized: return deserialized deserialized = StoredRoom.decode(data) _cached_data.set(data, deserialized) return deserialized
def note_stage3_creep(self, creep, squad_id): # type: (RoleBase, Union[Flag, str]) -> None """ :type creep: creeps.base.RoleBase :type squad_id: str """ if not self._stage3_registered_for_squad_id: self._stage3_registered_for_squad_id = new_map() members = self._stage3_registered_for_squad_id.get(squad_id) if not members: members = [] self._stage3_registered_for_squad_id.set(squad_id, members) members.push(creep)
def note_stage0_creep(self, creep, target): # type: (RoleBase, Union[Flag, Location]) -> None """ :type creep: creeps.base.RoleBase :type target: Flag | position_management.locations.Location """ if self._stage0_registered_for_target is undefined: self._stage0_registered_for_target = new_map() registered_so_far_tuple = self._stage0_registered_for_target.get( target.name) if not registered_so_far_tuple: registered_so_far_tuple = (target, []) self._stage0_registered_for_target.set(target.name, registered_so_far_tuple) registered_so_far_tuple[1].append(creep)
def boost_or_depot(self, creep): # type: (RoleBase) -> None """ :type creep: creeps.base.RoleBase """ if not self.can_boost(creep): creep.go_to_depot() return if self._boost_registered is undefined: self._boost_registered = new_map() specialty = creep.findSpecialty() specialty_list = self._boost_registered.get(specialty) if not specialty_list: specialty_list = [] self._boost_registered.set(specialty, specialty_list) specialty_list.append(creep)
def usage_map_of(room_name): # type: (str) -> JSMap[int, int] """ :type room_name: str :rtype: jstools.js_set_map.JSMap """ map_of_values = new_map() gmem = _get_mem() if room_name not in gmem: return map_of_values for data_string in gmem[room_name]: points = data_string[data_string.codePointAt(0):] for i in range(0, len(points)): xy = points.codePointAt(i) if map_of_values.has(xy): map_of_values.set(xy, map_of_values.get(xy) + 1) else: map_of_values.set(xy, 1) return map_of_values
def refresh_flag_caches(): # type: () -> None global _last_flag_len, _last_checked_flag_len, _cache_refresh_time, \ _room_name_to_flag_type_to_flags, _flag_type_to_flags, _flag_color_to_flag_secondary_color_to_flags game_flag_names = Object.keys(Game.flags) _cache_refresh_time = Game.time + _REFRESH_EVERY _last_flag_len = len(game_flag_names) _room_name_to_flag_type_to_flags = new_map() _flag_type_to_flags = new_map() _flag_color_to_flag_secondary_color_to_flags = new_map() possible_flag_mains = _.values(main_to_flag_primary) for flag_name in game_flag_names: flag = Game.flags[flag_name] if possible_flag_mains.includes(flag.color): if _flag_color_to_flag_secondary_color_to_flags.has(flag.color): flag_secondary_to_flags = _flag_color_to_flag_secondary_color_to_flags.get( flag.color) else: flag_secondary_to_flags = new_map() _flag_color_to_flag_secondary_color_to_flags.set( flag.color, flag_secondary_to_flags) if flag_secondary_to_flags.has(flag.secondaryColor): flag_secondary_to_flags.get(flag.secondaryColor).push(flag) else: flag_secondary_to_flags.set(flag.secondaryColor, [flag]) if flag_secondary_to_flags.has(_ALL_OF_PRIMARY): flag_secondary_to_flags.get(_ALL_OF_PRIMARY).push(flag) else: flag_secondary_to_flags.set(_ALL_OF_PRIMARY, [flag]) if _room_name_to_color_to_secondary_to_flags.has( flag.pos.roomName): in_room_color_to_secondary_to_flags = _room_name_to_color_to_secondary_to_flags.get( flag.pos.roomName) else: in_room_color_to_secondary_to_flags = new_map() _room_name_to_color_to_secondary_to_flags.set( flag.pos.roomName, in_room_color_to_secondary_to_flags) if in_room_color_to_secondary_to_flags.has(flag.color): in_room_flag_secondary_to_flags = in_room_color_to_secondary_to_flags.get( flag.color) else: in_room_flag_secondary_to_flags = new_map() in_room_color_to_secondary_to_flags.set( flag.color, in_room_flag_secondary_to_flags) if in_room_flag_secondary_to_flags.has(flag.secondaryColor): in_room_flag_secondary_to_flags.get( flag.secondaryColor).push(flag) else: in_room_flag_secondary_to_flags.set(flag.secondaryColor, [flag]) if in_room_flag_secondary_to_flags.has(_ALL_OF_PRIMARY): in_room_flag_secondary_to_flags.get(_ALL_OF_PRIMARY).push(flag) else: in_room_flag_secondary_to_flags.set(_ALL_OF_PRIMARY, [flag]) if _flag_type_to_flags.has(flag.hint): _flag_type_to_flags.get(flag.hint).push(flag) else: _flag_type_to_flags.set(flag.hint, [flag]) if _room_name_to_flag_type_to_flags.has(flag.pos.roomName): in_room_flag_type_to_flags = _room_name_to_flag_type_to_flags.get( flag.pos.roomName) else: in_room_flag_type_to_flags = new_map() _room_name_to_flag_type_to_flags.set(flag.pos.roomName, in_room_flag_type_to_flags) if in_room_flag_type_to_flags.has(flag.hint): in_room_flag_type_to_flags.get(flag.hint).push(flag) else: in_room_flag_type_to_flags.set(flag.hint, [flag])
sub_type) for sub_type in Object.keys(flag_sub_to_structure_type): structure_type_to_flag_sub[flag_sub_to_structure_type[sub_type]] = int( sub_type) define_reverse_maps() _REFRESH_EVERY = 50 _last_flag_len = 0 _last_checked_flag_len = 0 _cache_refresh_time = 0 _flag_type_to_flags = new_map() # type: JSMap[int, List[Flag]] _flag_color_to_flag_secondary_color_to_flags = new_map( ) # type: JSMap[int, JSMap[int, List[Flag]]] _room_name_to_flag_type_to_flags = new_map( ) # type: JSMap[str, JSMap[int, List[Flag]]] _room_name_to_color_to_secondary_to_flags = new_map( ) # type: JSMap[str, JSMap[int, JSMap[int, List[Flag]]]] _ALL_OF_PRIMARY = '__all__' def refresh_flag_caches(): # type: () -> None global _last_flag_len, _last_checked_flag_len, _cache_refresh_time, \ _room_name_to_flag_type_to_flags, _flag_type_to_flags, _flag_color_to_flag_secondary_color_to_flags
if TYPE_CHECKING: from empire.hive import HiveMind from jstools.js_set_map import JSMap, JSSet __pragma__('noalias', 'name') __pragma__('noalias', 'undefined') __pragma__('noalias', 'Infinity') __pragma__('noalias', 'keys') __pragma__('noalias', 'get') __pragma__('noalias', 'set') __pragma__('noalias', 'type') __pragma__('noalias', 'update') __pragma__('noalias', 'values') _cache_created = Game.time _cached_data = new_map() # type: JSMap[str, StoredRoom] _metadata_segment = 14 _portal_data_segment = 14 _segments_to_use = [5, 6, 7, 8, 9, 10, 11, 12, 13, 14] _room_data_segments = [5, 6, 7, 8, 9, 10] _old_room_data_segments = [11, 12, 13] _segments_cache = new_map() # type: JSMap[int, _Memory] _segments_last_retrieved = new_map() # type: JSMap[int, int] _modified_segments = new_set() # type: JSSet[int] _segment_change_reasons = new_map() # type: JSMap[int, List[str]] def initial_modification_check(): # TODO: periodic check which balances segments which have too much data stored in them, and runs