614 lines
19 KiB
Python
614 lines
19 KiB
Python
import fxconv
|
|
import re
|
|
import os.path
|
|
import xml.etree.ElementTree
|
|
|
|
from PIL import Image, ImageChops
|
|
|
|
def convert(input, output, params, target):
|
|
recognized = True
|
|
|
|
if params["custom-type"] == "level":
|
|
o = convert_level(input, params)
|
|
elif params["custom-type"] == "animation":
|
|
o = convert_animation(input, params)
|
|
elif params["custom-type"] == "aseprite-anim":
|
|
o = convert_aseprite_anim(input, output, params)
|
|
elif params["custom-type"] == "aseprite-anim-variation":
|
|
o = convert_aseprite_anim_variation(input, output, params)
|
|
elif params["custom-type"] == "tiled-tileset":
|
|
o = convert_tiled_tileset(input, output, params)
|
|
elif params["custom-type"] == "tiled-map":
|
|
o = convert_tiled_map(input, output, params)
|
|
else:
|
|
recognized = False
|
|
|
|
if recognized:
|
|
fxconv.elf(o, output, "_" + params["name"], **target)
|
|
return 0
|
|
|
|
return 1
|
|
|
|
MONSTER_IDS = {
|
|
"slime/1": 1,
|
|
"bat/2": 2,
|
|
"fire_slime/4": 3,
|
|
"gunslinger/8": 4,
|
|
}
|
|
ITEM_IDS = {
|
|
"life": 0,
|
|
"potion_atk": 1,
|
|
"potion_cooldown": 2,
|
|
"potion_def": 3,
|
|
"potion_freeze": 4,
|
|
"potion_hp": 5,
|
|
"potion_speed": 6,
|
|
"scepter1": 101,
|
|
"scepter2": 102,
|
|
"sword1": 103,
|
|
"sword2": 104,
|
|
"armor1": 105,
|
|
}
|
|
|
|
def convert_level(input, params):
|
|
RE_VALUES = {
|
|
"name": re.compile(r'.*'),
|
|
"map": re.compile(r'[a-zA-Z_][a-zA-Z0-9-]*'),
|
|
"spawner": re.compile(r'\d+,\d+'),
|
|
"player_spawn": re.compile(r'\d+,\d+'),
|
|
"wave": re.compile(r'\d+s(\s+\d+\*[a-z_]+/\d+)+'),
|
|
"delay": re.compile(r'\d+s'),
|
|
"item": re.compile(r'[a-zA-Z_][a-zA-Z0-9_]*'),
|
|
}
|
|
with open(input, "r") as fp:
|
|
lines = [l for l in fp.read().splitlines() if l
|
|
and not l.startswith("#")]
|
|
for i, l in enumerate(lines):
|
|
if ":" not in l:
|
|
raise fxconv.FxconvError(f"invalid line {l}: not a key/value")
|
|
|
|
key, value = l.split(":", 1)
|
|
key = key.strip()
|
|
value = value.strip()
|
|
|
|
if key not in RE_VALUES:
|
|
raise fxconv.FxconvError(f"unknown key '{key}'")
|
|
if not RE_VALUES[key].fullmatch(value):
|
|
raise fxconv.FxconvError(f"invalid value for '{key}': '{value}'")
|
|
|
|
lines[i] = (key, value)
|
|
|
|
# Determine level name
|
|
level_name = "<Untitled>"
|
|
for key, value in lines:
|
|
if key == "name":
|
|
level_name = value
|
|
|
|
# Determine map name
|
|
map_name = None
|
|
for key, value in lines:
|
|
if key == "map":
|
|
map_name = value
|
|
if map_name is None:
|
|
raise fxconv.FxconvError(f"no map name in {input}!")
|
|
|
|
# Determine player spawn
|
|
player_spawn = None
|
|
for key, value in lines:
|
|
if key == "player_spawn":
|
|
x, y = value.split(",")
|
|
player_spawn = bytes([int(x), int(y)])
|
|
if player_spawn is None:
|
|
raise fxconv.FxconvError(f"no player spawn in {input}!")
|
|
|
|
# Get list of spawners
|
|
spawner_x = bytes()
|
|
spawner_y = bytes()
|
|
for key, value in lines:
|
|
if key == "spawner":
|
|
x, y = value.split(",")
|
|
spawner_x += bytes([int(x)])
|
|
spawner_y += bytes([int(y)])
|
|
|
|
# Get list of events; waves are (duration, monster list)
|
|
LEVEL_EVENT_DELAY = 0
|
|
LEVEL_EVENT_WAVE = 1
|
|
LEVEL_EVENT_ITEM = 2
|
|
event_count = 0
|
|
events = fxconv.Structure()
|
|
|
|
for key, value in lines:
|
|
if key == "delay":
|
|
delay = int(value[:-1])
|
|
events += fxconv.u32(LEVEL_EVENT_DELAY)
|
|
events += fxconv.u32(delay * 65536)
|
|
events += bytes(4)
|
|
event_count += 1
|
|
|
|
elif key == "wave":
|
|
duration, *monsters = value.split()
|
|
duration = int(duration[:-1])
|
|
for i, desc in enumerate(monsters):
|
|
count, identity = desc.split("*")
|
|
if identity not in MONSTER_IDS:
|
|
raise fxconv.FxconvError(f"unknown monster {identity}")
|
|
monsters[i] = (MONSTER_IDS[identity], int(count))
|
|
|
|
m = bytes()
|
|
for identity, amount in monsters:
|
|
m += bytes([identity, amount])
|
|
|
|
w = fxconv.Structure()
|
|
w += fxconv.u32(len(monsters))
|
|
w += fxconv.ptr(m)
|
|
|
|
events += fxconv.u32(LEVEL_EVENT_WAVE)
|
|
events += fxconv.u32(duration * 65536)
|
|
events += fxconv.ptr(w)
|
|
event_count += 1
|
|
|
|
elif key == "item":
|
|
events += fxconv.u32(LEVEL_EVENT_ITEM)
|
|
events += fxconv.u32(2 * 65536)
|
|
events += fxconv.u32(ITEM_IDS[value])
|
|
event_count += 1
|
|
|
|
o = fxconv.Structure()
|
|
o += fxconv.string(level_name)
|
|
o += fxconv.ptr(f"map_{map_name}")
|
|
o += player_spawn
|
|
o += bytes(2)
|
|
o += fxconv.u32(len(spawner_x))
|
|
o += fxconv.ptr(spawner_x)
|
|
o += fxconv.ptr(spawner_y)
|
|
o += fxconv.u32(event_count)
|
|
o += fxconv.ptr(events)
|
|
return o
|
|
|
|
def convert_animation(input, params):
|
|
img = Image.open(input).convert("RGBA")
|
|
|
|
fsize = [0,0]
|
|
center = (0,0)
|
|
durations = None
|
|
frame_count = None
|
|
next_anim = None
|
|
|
|
# Read parameters
|
|
|
|
if "frame_duration" in params:
|
|
durations = [int(s) for s in params["frame_duration"].split(",")]
|
|
else:
|
|
durations = []
|
|
|
|
if "frame_size" in params:
|
|
fsize = list(map(int, params["frame_size"].split("x")))
|
|
|
|
if "frame_height" in params:
|
|
fsize[1] = int(params["frame_height"])
|
|
elif not fsize[1]:
|
|
fsize[1] = img.height
|
|
|
|
if "frame_width" in params:
|
|
fsize[0] = int(params["frame_width"])
|
|
elif not fsize[0] and durations:
|
|
fsize[0] = img.width // len(durations)
|
|
else:
|
|
raise fxconv.FxconvError("frame_width, frame_size, and frame_duration"+
|
|
" are all unspecified - tell me more!")
|
|
|
|
if "center" in params:
|
|
center = tuple(map(int, params["center"].split(",")))
|
|
else:
|
|
center = (fsize[0] // 2, fsize[1] // 2)
|
|
|
|
next_anim = params.get("next")
|
|
|
|
name = params["name"]
|
|
|
|
# Read and minimize frames
|
|
|
|
grid = fxconv.Grid({ "width": fsize[0], "height": fsize[1] })
|
|
frame_count = grid.size(img)
|
|
|
|
bg = Image.new(img.mode, fsize, (0, 0, 0, 0))
|
|
|
|
frames = []
|
|
total_width = 0
|
|
total_height = 0
|
|
|
|
i = 0
|
|
for rect in grid.iter(img):
|
|
frame = img.crop(rect)
|
|
nonzero = ImageChops.difference(frame, bg)
|
|
bbox = nonzero.getbbox()
|
|
if bbox:
|
|
ox, oy = bbox[0], bbox[1]
|
|
frame = frame.crop(bbox)
|
|
else:
|
|
ox, oy = 0, 0
|
|
|
|
total_width += frame.width
|
|
total_height = max(total_height, frame.height)
|
|
|
|
frames.append((frame, ox, oy))
|
|
i += 1
|
|
|
|
# Create compact spritesheet and data arrays
|
|
|
|
if total_width > 256:
|
|
raise fxconv.FxconvError("uh total_width>256, call Lephe' x_x")
|
|
sheet = Image.new("RGBA", (total_width, total_height))
|
|
|
|
o = fxconv.ObjectData()
|
|
sizeof_frame = 16
|
|
x = 0
|
|
|
|
for i, (frame, ox, oy) in enumerate(frames):
|
|
o += fxconv.ref(f"{name}_sheet")
|
|
o += fxconv.u8(x) + fxconv.u8(0)
|
|
o += fxconv.u8(frame.width) + fxconv.u8(frame.height)
|
|
o += fxconv.u8(center[0] - ox)
|
|
o += fxconv.u8(center[1] - oy)
|
|
o += fxconv.u16(durations[i])
|
|
|
|
if i < len(frames) - 1:
|
|
o += fxconv.ref(name, (i+1) * sizeof_frame)
|
|
elif next_anim:
|
|
o += fxconv.ref(next_anim)
|
|
else:
|
|
o += fxconv.u32(0)
|
|
|
|
sheet.paste(frame, (x, 0))
|
|
x += frame.width
|
|
|
|
o += fxconv.sym(f"{name}_sheet")
|
|
o += fxconv.convert_bopti_cg(sheet, {
|
|
"profile": params.get("profile", "p8"),
|
|
})
|
|
|
|
return o
|
|
|
|
def _aseprite_render_cel(c, indexed=False, palette=None, newpalette=None):
|
|
if c.chunk_type != 0x2005: # Cel
|
|
raise fxconv.FxconvError("Rendering a Cel but it's not a Cel chunk")
|
|
if c.cel_type not in [0,2]:
|
|
raise fxconv.FxconvError("Rendering a Cel that is linked or tilemap")
|
|
|
|
colors = None
|
|
|
|
if indexed:
|
|
assert palette is not None and palette.chunk_type == 0x2019 # Palette
|
|
# py_aseprite swaps blue and green!!
|
|
colors = [(c["red"], c["blue"], c["green"], c["alpha"])
|
|
for c in palette.colors]
|
|
if newpalette is not None:
|
|
assert indexed and newpalette.chunk_type == 0x2019 # Palette
|
|
newcolors = [(c["red"], c["blue"], c["green"], c["alpha"])
|
|
for c in newpalette.colors]
|
|
|
|
img = Image.new("RGBA", (c.data['width'], c.data['height']))
|
|
pixels = []
|
|
offset = 0
|
|
|
|
for y in range(img.height):
|
|
for x in range(img.width):
|
|
if indexed:
|
|
i = c.data['data'][offset]
|
|
offset += 1
|
|
else:
|
|
r, g, b, a = c.data['data'][offset:offset+4]
|
|
offset += 4
|
|
|
|
# Remap palette if requested
|
|
if newpalette is not None:
|
|
r, g, b, a = newcolors[i]
|
|
elif indexed:
|
|
r, g, b, a = colors[i]
|
|
|
|
pixels.append((r, g, b, a))
|
|
|
|
img.putdata(pixels)
|
|
return img
|
|
|
|
def convert_aseprite_anim(input, output, params, newpalette=None):
|
|
from aseprite import AsepriteFile
|
|
|
|
#---
|
|
# Perform checks for support on the Aseprite file
|
|
#---
|
|
|
|
with open(input, "rb") as fp:
|
|
ase = AsepriteFile(fp.read())
|
|
|
|
if ase.header.color_depth == 8:
|
|
indexed = True
|
|
elif ase.header.color_depth == 32:
|
|
indexed = False
|
|
else:
|
|
raise fxconv.FxconvError("Only indexed/RGBA supported yet, sorry x_x")
|
|
|
|
# Find tags that give names to animations
|
|
tags = None
|
|
for c in ase.frames[0].chunks:
|
|
if c.chunk_type == 0x2018: # Tags
|
|
tags = [(t["name"], t["from"], t["to"]) for t in c.tags]
|
|
if tags is None:
|
|
tags = [(None, 0, ase.header.num_frames-1)]
|
|
|
|
#---
|
|
# Print summary of animations
|
|
#---
|
|
|
|
print(f"{os.path.basename(input)} ({ase.header.width}x{ase.header.height})",
|
|
f"has {len(tags)} animations:")
|
|
for (name, from_, to) in tags:
|
|
name = f"'{name}'" if name else "(untagged)"
|
|
print(f" {name}: Frames {from_} to {to}", end="")
|
|
durations = [ase.frames[i].frame_duration for i in range(from_, to+1)]
|
|
print(" (" + ", ".join(f"{d} ms" for d in durations) + ")")
|
|
|
|
#---
|
|
# Find palette
|
|
#---
|
|
|
|
palette_chunk = None
|
|
|
|
for c in ase.frames[0].chunks:
|
|
if c.chunk_type == 0x2019: # Palette
|
|
palette_chunk = c
|
|
|
|
#---
|
|
# Generate PIL images for each frame
|
|
#---
|
|
|
|
pil_frames = []
|
|
|
|
for i, f in enumerate(ase.frames):
|
|
img = Image.new("RGBA", (ase.header.width, ase.header.height))
|
|
|
|
for chunk in f.chunks:
|
|
if chunk.chunk_type == 0x2005: # Cel
|
|
# Render only visible layers
|
|
if ase.layers[chunk.layer_index].flags & 1:
|
|
# Resolve linked cells
|
|
if chunk.cel_type == 1: # Linked cel
|
|
x = ase.frames[chunk.data['link'][0]].chunks
|
|
x = [c for c in x if c.chunk_type == 0x2005]
|
|
chunk = x[chunk.layer_index]
|
|
|
|
cel = _aseprite_render_cel(chunk, indexed, palette_chunk,
|
|
newpalette)
|
|
img.paste(cel, (chunk.x_pos, chunk.y_pos))
|
|
|
|
pil_frames.append(img)
|
|
|
|
#---
|
|
# Parse parameters
|
|
#---
|
|
|
|
if "center" in params:
|
|
center = tuple(map(int, params["center"].split(",")))
|
|
else:
|
|
center = (ase.header.width // 2, ase.header.height // 2)
|
|
|
|
if "next" in params:
|
|
next_anim = [s.strip() for s in params["next"].split(",")]
|
|
next_anim = dict([s.split("=", 1) for s in next_anim])
|
|
else:
|
|
next_anim = dict()
|
|
|
|
#---
|
|
# Generate compact sheets and object data for each animation
|
|
#---
|
|
|
|
bg = Image.new("RGBA", (ase.header.width, ase.header.height), (0, 0, 0, 0))
|
|
|
|
# This will hold all animations in sequence
|
|
o = fxconv.ObjectData()
|
|
sizeof_frame = 16
|
|
|
|
for (name, from_, to) in tags:
|
|
total_width = 0
|
|
total_height = 0
|
|
|
|
for i in range(from_, to+1):
|
|
bbox = ImageChops.difference(pil_frames[i], bg).getbbox()
|
|
# pil_frames[i] becomes (offset_x, offset_y, cropped image)
|
|
if bbox:
|
|
pil_frames[i] = (bbox[0], bbox[1], pil_frames[i].crop(bbox))
|
|
else:
|
|
pil_frames[i] = (0, 0, pil_frames[i])
|
|
|
|
total_width += pil_frames[i][2].width
|
|
total_height = max(total_height, pil_frames[i][2].height)
|
|
|
|
# Define a new symbol for ech animation (except if there is only one)
|
|
symname = params["name"] + ("_" + name if name is not None else "")
|
|
s = fxconv.Structure()
|
|
|
|
sheet = Image.new("RGBA", (total_width, total_height), (0, 0, 0, 0))
|
|
x = 0
|
|
|
|
for i in range(from_, to+1):
|
|
s += fxconv.ref(f"{symname}_sheet")
|
|
s += fxconv.u8(x) + fxconv.u8(0)
|
|
s += fxconv.u8(pil_frames[i][2].width)
|
|
s += fxconv.u8(pil_frames[i][2].height)
|
|
s += fxconv.u8(center[0] - pil_frames[i][0])
|
|
s += fxconv.u8(center[1] - pil_frames[i][1])
|
|
s += fxconv.u16(ase.frames[i].frame_duration)
|
|
|
|
if i < to:
|
|
s += fxconv.ref(symname, (i-from_+1) * sizeof_frame)
|
|
elif name in next_anim:
|
|
s += fxconv.ref(params["name"] + "_" + next_anim[name])
|
|
else:
|
|
s += fxconv.u32(0)
|
|
|
|
sheet.paste(pil_frames[i][2], (x, 0))
|
|
x += pil_frames[i][2].width
|
|
|
|
o += fxconv.sym(symname)
|
|
o += s
|
|
o += fxconv.sym(f"{symname}_sheet")
|
|
o += fxconv.convert_bopti_cg(sheet, {
|
|
"profile": params.get("profile", "p8"),
|
|
})
|
|
|
|
return o
|
|
|
|
def convert_aseprite_anim_variation(input, output, params):
|
|
from aseprite import AsepriteFile
|
|
|
|
if "base" in params:
|
|
base = params["base"]
|
|
elif "base_regex" in params:
|
|
regex = params["base_regex"].split(" ", 1)
|
|
base = re.sub(*regex, os.path.basename(input))
|
|
else:
|
|
raise fxconv.FxconvError(f"{input} lacks a 'base:' metadata")
|
|
|
|
if "palette" in params:
|
|
palette = params["palette"]
|
|
elif "palette_regex" in params:
|
|
regex = params["palette_regex"].split(" ", 1)
|
|
palette = re.sub(*regex, os.path.basename(input))
|
|
else:
|
|
raise fxconv.FxconvError(f"{input} lacks a 'palette:' metadata")
|
|
|
|
base = os.path.join(os.path.dirname(input), base)
|
|
palette = os.path.join(os.path.dirname(input), palette)
|
|
|
|
with open(palette, "rb") as fp:
|
|
ase = AsepriteFile(fp.read())
|
|
|
|
newpalette = None
|
|
for c in ase.frames[0].chunks:
|
|
if c.chunk_type == 0x2019: # Palette
|
|
newpalette = c
|
|
if newpalette is None:
|
|
raise fxconv.FxconvError("f{input} has no palette chunk")
|
|
|
|
return convert_aseprite_anim(base, output, params, newpalette)
|
|
|
|
def print_xml_tree(node, indent=0):
|
|
print(indent*" " + f"<{node.tag}> {node.attrib}")
|
|
for child in node:
|
|
print_xml_tree(child, indent+2)
|
|
|
|
def convert_tiled_tileset(input, output, params):
|
|
tree = xml.etree.ElementTree.parse(input)
|
|
tileset = tree.getroot()
|
|
assert tileset.tag == "tileset"
|
|
|
|
# We only support single-source tilesets
|
|
images = tileset.findall("image")
|
|
assert len(images) == 1
|
|
image = images[0]
|
|
|
|
tilewidth = int(tileset.attrib["tilewidth"])
|
|
tileheight = int(tileset.attrib["tileheight"])
|
|
tilecount = int(tileset.attrib["tilecount"])
|
|
|
|
# In Rogue Life there is only 16x16 :)
|
|
assert tilewidth == 16 and tileheight == 16
|
|
|
|
def plane_id(plane_str):
|
|
return ["WALL", "FLOOR", "CEILING"].index(plane_str)
|
|
|
|
o = fxconv.Structure()
|
|
info = fxconv.Structure()
|
|
frames = fxconv.Structure()
|
|
frames_start = 0
|
|
|
|
# Tile sheet
|
|
source = os.path.join(os.path.dirname(input), image.attrib["source"])
|
|
sheet = Image.open(source)
|
|
o += fxconv.u32(sheet.width // 16)
|
|
o += fxconv.u32(sheet.height // 16)
|
|
o += fxconv.ptr(fxconv.convert_bopti_cg(sheet, params))
|
|
|
|
# Analyze tile metadata and animation
|
|
for i in range(tilecount):
|
|
tile = tileset.findall(f".//tile[@id='{i}']")
|
|
assert len(tile) in [0,1]
|
|
|
|
plane = "FLOOR"
|
|
anim_length = 0
|
|
anim_start = frames_start
|
|
solid = 0
|
|
|
|
if tile:
|
|
for prop in tile[0].findall("./properties/property"):
|
|
name = prop.attrib["name"]
|
|
type = prop.attrib.get("type", "string")
|
|
value = prop.attrib["value"]
|
|
|
|
if name == "plane" and type == "string":
|
|
plane = value
|
|
elif name == "solid" and type == "bool":
|
|
solid = int(value == "true")
|
|
else:
|
|
raise fxconv.FxconvError(
|
|
f"Unknown tile property '{name}' with type '{type}'")
|
|
|
|
for frame in tile[0].findall("./animation/frame"):
|
|
frames += fxconv.u16(int(frame.attrib["tileid"]))
|
|
frames += fxconv.u16(int(frame.attrib["duration"]))
|
|
frames_start += 1
|
|
anim_length += 1
|
|
|
|
info += fxconv.u8(plane_id(plane))
|
|
info += fxconv.u8(anim_length)
|
|
info += fxconv.u8(anim_start)
|
|
info += fxconv.u8(solid)
|
|
|
|
o += fxconv.ptr(info)
|
|
o += fxconv.ptr(frames)
|
|
return o
|
|
|
|
def convert_tiled_map(input, output, params):
|
|
tree = xml.etree.ElementTree.parse(input)
|
|
map = tree.getroot()
|
|
assert map.tag == "map"
|
|
|
|
width = int(map.attrib["width"])
|
|
height = int(map.attrib["height"])
|
|
|
|
tilesets = map.findall("tileset")
|
|
assert len(tilesets) == 1
|
|
tileset = tilesets[0]
|
|
tileset_base = int(tileset.attrib["firstgid"])
|
|
|
|
# Grab tileset variable name from file path
|
|
tileset_var = os.path.basename(tileset.attrib["source"])
|
|
tileset_var = "tileset_" + os.path.splitext(tileset_var)[0]
|
|
|
|
layers = map.findall("layer")
|
|
assert len(layers) == 2
|
|
assert all(l.find("data").attrib["encoding"] == "csv" for l in layers)
|
|
|
|
data1 = [int(x) for x in layers[0].find("data").text.split(",")]
|
|
data2 = [int(x) for x in layers[1].find("data").text.split(",")]
|
|
assert len(data1) == width * height
|
|
assert len(data2) == width * height
|
|
|
|
tiles = bytes()
|
|
for i in range(width * height):
|
|
t1 = data1[i] & 0x0fffffff
|
|
t2 = data2[i] & 0x0fffffff
|
|
# We turn empty tiles into index 0
|
|
t1 = 0 if t1 < tileset_base else t1 - tileset_base
|
|
t2 = 0 if t2 < tileset_base else t2 - tileset_base
|
|
|
|
tiles += fxconv.u8(t1)
|
|
tiles += fxconv.u8(t2)
|
|
|
|
o = fxconv.Structure()
|
|
o += fxconv.u16(width)
|
|
o += fxconv.u16(height)
|
|
o += fxconv.ptr(tileset_var)
|
|
o += fxconv.ptr(tiles)
|
|
return o
|