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)
