def set_resources(self, *dict_names): for name in dict_names: rd = load_resource("resource_dicts")[name] for key in rd: file_name = rd[key] self.add_resource(key, file_name)
def load_list_from_resources(database_list, database_resource_name, file_loader, arrange_by_client=False): files = [] for d in database_list: db = resources.load_resource(database_resource_name, d) files.append(file_loader.load_lists_from_database(db, arrange_by_client)) files = sum(files,[]) return files
def add_field(self, d): if type(d) is str: d = load_resource("hud_fields")[d] value_name = d["value_name"] obj = self.target reporter = HudFieldSprite(value_name) get_text = d.get("get_text", False) if type(get_text) is str: get_text = getattr(self, get_text) reporter.set_text_function(get_text) cache_args = d.get("cache") size = d.get("cache_size", 1) if cache_args: args = cache_args else: args = ["cache"] reporter.set_cache_style(size, *args) get_value = d.get("get_value", None) self.model_manager.link_value(value_name, obj, get_value) self.model_manager.link_object(value_name, reporter, "set_cache") self.add_member_row( [self.get_sprite_from_value(value_name + ":"), reporter])
def set_menu(self, file_name): devices = load_resource(file_name)["devices"] self.set_model(devices) options = [] for name in devices: options.append(name) self.set_member_table(options) self.set_header(MenuTools.file_name_to_header(file_name)) for option in self.options: name = option.get_text() cls = devices[name]["class"] on_activate = "" if cls == "button": on_activate = {"name": "on_map_button", "device_name": name} if cls == "dpad": on_activate = {"name": "on_map_dpad", "device_name": name} self.add_option_response(option, on_activate) self.set_options("save_controller")
def set_member_table(self, argument, *sections): if self.table.member_list: self.kill_members() if sections: file_name = argument members = [] for section in sections: d = load_resource(file_name)[section] get_m = getattr(self, "get_members_from_" + section, False) if get_m: plus = get_m(d, file_name) members += plus else: members += self.get_members_from_dict(d) else: if type(argument) is dict: members = self.get_members_from_dict(argument) elif type(argument) is list: members = self.get_members_from_list(argument) else: members = [[self.get_sprite_from_value(argument)]] self.set_members(members)
def set_transitions(self, obj, file_name): cfg = load_resource(file_name) states = list(cfg["state_transitions"].keys()) self.set_states(*states) for state in states: entry = cfg["state_transitions"][state] for transition in list(entry.keys()): args = entry[transition] to_state = args[0] t = {} method_name = transition if transition[0:4] == "not_": method_name = transition[4:] t["logic"] = False t["name"] = transition t["to_index"] = self.get_state_index(to_state) t["buffer"] = "buffer" in args if not method_name == "auto": t["check"] = getattr(obj.controller_interface, method_name) else: t["check"] = "auto" entry[transition] = t self.transitions = cfg["state_transitions"]
def tile(image_name, surface): # PYGAME CHOKE POINT if image_name not in Graphics.PRE_RENDERS: bg_image = load_resource(image_name) sx, sy = SCREEN_SIZE # pre render the tiled background sx *= 2 # to the size of a full screen sy *= 2 pr_surface = pygame.Surface( (sx, sy), pygame.SRCALPHA, 32) w, h = pr_surface.get_size() img_w, img_h = bg_image.get_size() for x in range(0, w + img_w, img_w): for y in range(0, h + img_h, img_h): pr_surface.blit(bg_image, (x, y)) Graphics.PRE_RENDERS[image_name] = pr_surface full_bg = Graphics.PRE_RENDERS[image_name] # return a subsection of the full # # pre rendered background r = surface.get_rect().clip(full_bg.get_rect()) blit_region = full_bg.subsurface(r) surface.blit(blit_region, (0, 0)) return surface
def set_walls(self, *walls): for w in walls: if type(w) is str: w = load_resource("walls")[w] wall = Wall(w["name"], w["origin"], w["end"]) wall.log = self.log self.walls.append(wall)
def play_sound(self, device_names=(), file_name="", key=""): sprite = self.entity if file_name: sound = load_resource(file_name) else: sound = sprite.sounds[key] if ControllerInterface.check_buttons(sprite, *device_names): sound.stop() sound.play()
def load_list_from_resources(database_list, database_resource_name, file_loader, arrange_by_client=False): files = [] for d in database_list: db = resources.load_resource(database_resource_name, d) files.append( file_loader.load_lists_from_database(db, arrange_by_client)) files = sum(files, []) return files
def draw_corners(image_name, surface, corners): corner_image = load_resource(image_name) w, h = surface.get_size() cw, ch = corner_image.get_size() a, b, c, d = BORDER_CORNER_CHOICES locations = {a: (0, 0), b: (w - cw, 0), c: (0, h - ch), d: (w - cw, h - ch)} for corner in corners: surface.blit(ContainerGraphics.get_corner(corner_image, corner), locations[corner])
def set_collisions(self, *systems): for s in systems: if type(s) is str: s = load_resource("collision_systems")[s] s = s.copy() s["group_a"] = self.model[s["group_a"]] b = s.get("group_b") if b: s["group_b"] = self.model[s["group_b"]] self.collision_systems.append( CollisionManager.get_from_dict(s) )
def add_image_layer(self, file_name, position=(0, 0)): image_layer = load_resource(file_name) ImageGraphics.set_colorkey(image_layer) # PYGAME CHOKE POINT scale = self.scale w, h = image_layer.get_size() if scale > 1: w *= scale h *= scale image_layer = pygame.transform.scale(image_layer, (w, h)) x, y = position x *= scale y *= scale self.sprite_sheet.blit(image_layer, (x, y)) self.mirror_sheet = self.mirror_image(self.sprite_sheet)
def get_full_side_image(image_name, orientation): if image_name not in ContainerGraphics.PRE_RENDERS: image = load_resource(image_name) iw, ih = image.get_size() h, v = "hv" size = {h: (iw, SCREEN_SIZE[1]), v: (SCREEN_SIZE[0], iw)}[orientation] pr_surface = pygame.Surface( size, pygame.SRCALPHA, 32) span = {h: range(0, size[1], ih), v: range(0, size[0], iw)}[orientation] for i in span: position = {h: (0, i), v: (i, 0)}[orientation] pr_surface.blit(image, position) ContainerGraphics.PRE_RENDERS[image_name] = pr_surface return ContainerGraphics.PRE_RENDERS[image_name]
def __init__(self, entity, sprite_sheet, scale=1): super(AnimationGraphics, self).__init__(entity) sprite_sheet = load_resource(sprite_sheet) w, h = sprite_sheet.get_size() # PYGAME CHOKE POINT self.scale = scale if scale > 1: w *= scale h *= scale sprite_sheet = pygame.transform.scale(sprite_sheet, (w, h)) self.sprite_sheet = sprite_sheet self.mirror_sheet = self.mirror_image(sprite_sheet) ImageGraphics.set_colorkey(self.sprite_sheet) ImageGraphics.set_colorkey(self.mirror_sheet) self.image_sets = {}
def set_animation(self, d): if type(d) is str: d = load_resource("animation_machines")[d] transition_file = d["state_transitions"] sprite_sheet = d["sprite_sheet"] image_layers = d.get("sprite_sheet_layer", []) if image_layers: image_layers = [image_layers] scale = d.get("scale", 1) self.set_graphics(AnimationGraphics, sprite_sheet, scale) for layer in image_layers: image, x, y = layer position = x, y self.graphics.add_image_layer(image, position) cls = d.get("class") if not cls: self.animation_machine = AnimationMachine(self) else: cls = ANIMATION_CLASS_DICT[cls] self.animation_machine = cls(self) self.animation_machine.set_transitions(self, transition_file) animation_file = d.get("animations") if not animation_file: animation_file = transition_file[:-4] + "_animation.cfg" self.animation_machine.set_animations(animation_file) self.graphics.set_animations(self.animation_machine.animations)
def load_section(file_name, section): return load_resource(file_name)[section]
from classes import MemberTable, CacheList, AverageCache, ChangeCache, Timer from context_manager import init_item from entities import Sprite, ModelManager from graphics import ContainerGraphics, VectorGraphics from resources import load_resource from zs_constants import DIALOG_POSITION from geometry import Vector, Wall BLOCKS = load_resource("blocks") OPTIONS = load_resource("options") EVENTS = load_resource("events") TABLES = load_resource("tables") DIALOG_TABLE = TABLES["dialog"] HUD_FREQUENCY = 12 PRECISION = 3 class GuiMemberTable(MemberTable): def adjust_size(self, size, border_size, buffers): w, h = size border_w, border_h = border_size buff_w, buff_h = buffers body_w, body_h = self.get_minimum_body_size(buffers) full_w, full_h = (body_w + ((border_w + buff_w) * 2), body_h + ((border_h + buff_h) * 2)) if w < full_w: w = full_w if h < full_h:
def set_methods(self, *method_names): methods = load_resource("control_methods") for name in method_names: self.add_method(name, methods[name].copy())
def set_command_inputs(self, *commands): for name in commands: c = load_resource("command_inputs")[name] for controller in self.controllers: controller.add_command_input(name, c)
def set_animations(self, file_name): cfg = load_resource(file_name) self.animations = self.get_animations_from_cfg(cfg) if "hitboxes" in cfg: self.set_hitboxes(cfg)
def make_image(self): image = load_resource(self.file_name) self.set_colorkey(image) return image
def add_resource(self, key, file_name): item = load_resource(file_name) ext = file_name.split(".")[-1] if ext in SOUND_EXT: self.sounds[key] = item
def get_options_from_list(field_list): dict_list = [] for data in field_list: dict_list.append({'label': str(load_resource(data)), 'value': str(data)}) return dict_list
def load_controller(file_name): devices = load_resource(file_name)["devices"] return make_controller(file_name, devices)