You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
Adoranda/assets-cg/converters.py

409 lines
13 KiB

from random import randint
import fxconv
import json
import pathlib
import csv
def convert(input, output, params, target):
if params["custom-type"] == "map":
convert_map(input, output, params, target)
return 0
elif params["custom-type"] == "capacities":
convert_capa(input, output, params, target)
return 0
elif params["custom-type"] == "monster":
convert_monster(input, output, params, target)
return 0
elif params["custom-type"] == "player_moves":
convert_player_moves(input, output, params, target)
return 0
elif params["custom-type"] == "items":
convert_items(input, output, params, target)
return 0
elif params["custom-type"] == "table_type":
convert_table_type(input, output, params, target)
return 0
else:
return 1
def convert_map(input, output, params, target):
TILE_BRIDGE = -1 #only for bridge detection to avoid solid behind
TILE_AIR = 0
TILE_SOLID = 1
TILE_DOOR_IN = 2
TILE_DOOR_OUT = 3
TILE_TALKABLE = 4
TILE_TELEPORTER = 5
TILE_GRASS = 6
TILE_ICE = 7
DIALOG_LAYOUT = "dialog"
TELEPORTER_LAYOUT = "teleporter"
ZONE_LAYOUT = "zone"
data = json.load(open(input, "r"))
#find the tileset in use. it's a relative path (like ../tileset.tsx)
nameTileset = data["tilesets"][0]["source"].replace(".tsx","")
#the name of the tileset without the .something
nameTilesetFree = nameTileset.split("/")[-1]
#count the number of "back" (cd ..) to locate the tileset on the computer
nbRetour = nameTileset.count("..")+1
#create the tileset absolute path
tilesetPath = "/".join(input.split("/")[:-nbRetour]) + "/" + nameTileset.split("/")[-1] + ".json"
tileset = open(tilesetPath, "r")
data_tileset = json.load(tileset)
tileset_size = data_tileset.get("columns")
tileset.close()
tile_value = {}
tile_type = {
"air":TILE_AIR,
"solid":TILE_SOLID,
"door_in":TILE_DOOR_IN,
"door_out":TILE_DOOR_OUT,
"talkable":TILE_TALKABLE,
"bridge":TILE_BRIDGE,
"teleporter":TILE_TELEPORTER,
"grass":TILE_GRASS,
"ice":TILE_ICE
}
#create a dictionnary {tile id:type}
for i in data_tileset["tiles"]:
id = i["id"]+1
type = i["type"]
value = tile_type.get(type) if type in tile_type else TILE_AIR
tile_value[id] = value
#Extract from the json the width, height
w, h = data["width"], data["height"]
#nbTileLayer is the number of "true" layers (without ObjectsLayer)
nbTilelayer = ["data" in i for i in data["layers"]].count(True)
objectLayers = data["layers"][nbTilelayer:len(data["layers"])]
nbDialog = 0
nbTelep = 0
nbZone = 0
structMap = fxconv.Structure()
dialogs = fxconv.Structure()
teleporter = fxconv.Structure()
zone = fxconv.Structure()
try:
idmap = data["properties"][0]["value"]
except KeyError:
raise Exception("La carte n'a pas d'identifiant")
for layer in objectLayers:
if layer.get("name") == DIALOG_LAYOUT:
nbDialog = len(layer["objects"])
dialogs = parseDialog(layer, idmap)
elif layer.get("name") == TELEPORTER_LAYOUT:
nbTelep = len(layer["objects"])
teleporter = parseTeleporter(layer)
elif layer.get("name") == ZONE_LAYOUT:
nbZone = len(layer["objects"])
zone = parseZone(layer, idmap)
else:
print("UNKNOWN LAYER FOUND : " + layer.get("name"))
structMap += fxconv.u32(w) + fxconv.u32(h) + fxconv.u32(nbTilelayer) + fxconv.u32(nbDialog) + fxconv.u32(nbTelep) + fxconv.u32(nbZone)
structMap += fxconv.ref(f"img_{nameTilesetFree}")
structMap += fxconv.u32(tileset_size)
structMap += fxconv.ptr(dialogs)
structMap += fxconv.ptr(teleporter)
structMap += fxconv.ptr(zone)
#generation of the collision map (take the maximum of the layer except for bridges)
#bridges are always walkable
info_map = bytes()
maxValue = 0
bridge = False
for x in range(w*h):
for i in range(nbTilelayer):
value = tile_value.get(data["layers"][i]["data"][x])
#attention : priorité aux valeurs hautes : un bloc d'herbe sera prioritaire sur un bloc solide
if value == None: value = TILE_AIR
if value > maxValue: maxValue = value
if value == TILE_BRIDGE:
maxValue = TILE_AIR
bridge = True
if bridge:
if value != TILE_AIR:
maxValue = value
info_map += fxconv.u16(maxValue)
maxValue = 0
bridge = False
structMap += fxconv.ptr(info_map)
#generate the array of tiles from the layer
for i in range(nbTilelayer):
layer_data = bytes()
layer = data["layers"][i]
for tile in layer["data"]:
layer_data += fxconv.u16(tile)
structMap += fxconv.ptr(layer_data)
#generate !
fxconv.elf(structMap, output, "_" + params["name"], **target)
def parseDialog(layer, idmap):
dialogs = fxconv.Structure()
idDialog = 0
base_dialog = [
"Encore toi ? Tu n'as pas quelque chose d'autre à faire ?",
"Mais... Tu vas me lacher oui ?",
"re-bonjour, comment vas-tu depuis la dernière fois ?",
"Tu reviens me voir après tout ce temps ?",
"Toujours un plaisir de te revoir.",
"La vie est pleine de surprise, je ne m'attendais pas à te revoir !",
"Salut ! Belle journée n'est-ce pas ?",
"Il faut savoir apprécier les bonnes choses de la vie.",
"La dernière fois je suis tombé sur une horde de monstre, quelle panique !",
"As-tu visité notre belle région depuis la dernière fois ?",
"Prend le temps, on n'a qu'une seule vie n'est-ce pas !",
"Pour être honnête, je ne t'apprécie pas beaucoup."
]
for i in layer["objects"]:
dialogs += fxconv.u32(int(i["x"]/i["width"]))
#Tiled seem to start at the bottom y of the object
dialogs += fxconv.u32(int(i["y"]/i["width"])-1)
try:
dialogs += fxconv.u32(int(f"{idmap}{idDialog}{idmap}"))
listProper = set((a['name']) for a in i["properties"])
idDialog += 1
stoText = ""
for j in i["properties"]:
if(j["name"] == "name"): dialogs += fxconv.string(j["value"])
if(j["name"] == "text"):
dialogs += fxconv.string(j["value"])
stoText = j["value"]
if(j["name"] == "text2"): dialogs += fxconv.string(j["value"])
if not "text2" in listProper:
if "~" in stoText: dialogs += fxconv.string(base_dialog[randint(0, len(base_dialog)-1)])
else: dialogs += fxconv.string("")
if("exclusive" in listProper):
for j in i["properties"]:
if(j["name"] == "exclusive"):
if j["value"]: dialogs += fxconv.u32(1)
else: dialogs += fxconv.u32(0)
else:
if "~" in stoText: dialogs += fxconv.u32(1)
else: dialogs += fxconv.u32(0)
except KeyError:
dialogs += fxconv.string("default name")
dialogs += fxconv.string("default text")
dialogs += fxconv.string("default text2")
dialogs += fxconv.u32(0)
return dialogs
def parseTeleporter(layer):
teleporter = fxconv.Structure()
for i in layer["objects"]:
teleporter += fxconv.u32(int(i["x"]/i["width"]))
#Tiled seem to start at the bottom y of the object
teleporter += fxconv.u32(int(i["y"]/i["width"])-1)
try:
if len(i["properties"]) < 2:
raise Exception("parseTeleporter() : Un téléporteur est mal configuré")
if len(i["properties"]) == 2:
print("parseTeleporter() : passage automatique idMap = -1 sur téléporteur x = " + str(i["properties"][0]["value"]) + ", y = " + str(i["properties"][1]["value"]))
teleporter += fxconv.u32(-1)
for j in i["properties"]:
teleporter += fxconv.u32(j["value"])
except KeyError :
raise Exception("parseTeleporter() : Un téléporteur est mal configuré")
return teleporter
def parseZone(layer, idmap):
zone = fxconv.Structure()
idZone = 0
for i in layer["objects"]:
origin = (int(i['x']/16), int(i['y']/16))
to = (int(origin[0]+i['width']/16)-1, int(origin[1]+i['height']/16)-1)
if len(i["properties"][0]["value"]) != 0:
zone += fxconv.u32(int(f"{idmap}{idZone}{idmap}")) #id zone is {mapid}{idzone}{mapid}
idZone+=1
else: zone += fxconv.u32(0)
zone += fxconv.u32(origin[0])
zone += fxconv.u32(origin[1])
zone += fxconv.u32(to[0])
zone += fxconv.u32(to[1])
event = bytes(i["properties"][0]["value"], "utf-8")
event += bytes(128 - len(event))
zone += event #event
monsters = bytes()
zone += fxconv.u32(int(i["properties"][1]["value"]) if i["properties"][1]["value"] != "" else -1) #level
monster_list_raw = []
if i["properties"][2]["value"] != "": monster_list_raw = i["properties"][2]["value"].split(";") #monster list
monster_list = []
#x-y notation generate an array
for i in monster_list_raw:
if "-" in i:
a = i.split("-")
monster_list.extend(list(range(int(a[0]),int(a[1])+1)))
else:
monster_list.append(int(i))
zone += fxconv.u32(len(monster_list))
for j in monster_list:
monsters += fxconv.u16(int(j))
zone += fxconv.ptr(monsters)
return zone
def convert_capa(input, output, params, target):
liste_file = list(pathlib.Path(input).parent.glob('*.json'))
capacities = fxconv.Structure()
capacities += fxconv.u32(len(liste_file))
for f in liste_file:
file = open(f,"r")
data = json.load(file)
move = fxconv.Structure()
try:
categorie = data["categorie"]
id_categorie = ["STATUT", "PHYSICAL", "SPECIAL"]
move += fxconv.string(data["name"])
move += fxconv.string(data["type"])
move += fxconv.u32(data["id"])
move += fxconv.u32(id_categorie.index(categorie))
move += fxconv.u32(data["pp"])
move += fxconv.u32(data["pp"])
if categorie=="PHYSICAL" or categorie=="SPECIAL":
move += fxconv.u32(data["atk"])
move += fxconv.u32(data["precision"])
move += fxconv.u32(0) + fxconv.u32(0) + fxconv.u32(0)
elif categorie=="STATUT":
move += fxconv.u32(0) + fxconv.u32(100)
move += fxconv.u32(data["boost_atk"])
move += fxconv.u32(data["boost_def"])
move += fxconv.u32(data["boost_hp"])
except KeyError:
raise Exception(f"convert_capa() : La capacité {data['name']} est mal configurée")
capacities += fxconv.ptr(move)
fxconv.elf(capacities, output, "_" + params["name"], **target)
def convert_monster(input, output, params, target):
liste_file = list(pathlib.Path(input).parent.glob('*.json'))
monsters = fxconv.Structure()
monsters += fxconv.u32(len(liste_file))
for f in liste_file:
file = open(f,"r")
data = json.load(file)
stats = fxconv.Structure()
if len(data["stats"]) != 6: raise Exception(f"convert_monster : Les statistiques de {data['name']} sont mauvaises")
stats+=fxconv.string(data["type"])
stats+=fxconv.u32(data["stats"]["atk"])
stats+=fxconv.u32(data["stats"]["def"])
stats+=fxconv.u32(data["stats"]["pv"])
stats+=fxconv.u32(data["stats"]["spe_atk"])
stats+=fxconv.u32(data["stats"]["spe_def"])
stats+=fxconv.u32(1) # level, will be calculated later
stats+=fxconv.u32(data["stats"]["xp"])
stats+=fxconv.u32(data["stats"]["pv"])
moves = bytes()
for i in data["moves"]:
moves+=fxconv.u16(i)
monster = fxconv.Structure()
monster += fxconv.string(data["name"])
monster += fxconv.ptr(f"img_{data['sprite']}")
monster += fxconv.u32(data["id"])
monster += fxconv.u32(len(data["moves"]))
monster += fxconv.ptr(stats)
monster += fxconv.ptr(moves)
monsters += fxconv.ptr(monster)
fxconv.elf(monsters, output, "_" + params["name"], **target)
def convert_player_moves(input, output, params, target):
levelupplayer = fxconv.Structure()
data = open(input, 'r').readlines()
levelupplayer += fxconv.u32(len(data))
for i in data:
levelup = fxconv.Structure()
levelup += fxconv.u32(int(i.split(":")[0]))
levelup += fxconv.u32(int(i.split(":")[1]))
levelupplayer += fxconv.ptr(levelup)
fxconv.elf(levelupplayer, output, "_" + params["name"], **target)
def convert_items(input, output, params, target):
liste_file = list(pathlib.Path(input).parent.glob('*.json'))
items = fxconv.Structure()
items += fxconv.u32(len(liste_file))
for f in liste_file:
file = open(f,"r")
data = json.load(file)
item = fxconv.Structure()
try:
item += fxconv.string(data["name"])
item += fxconv.u32(data["id"])
item += fxconv.string(data["description"])
item += fxconv.ptr(f"img_{data['sprite']}")
item += fxconv.string(";".join(data["action"]))
items += fxconv.ptr(item)
except KeyError:
raise Exception(f"convert_items() : L'item {data['name']} est mal configuré")
fxconv.elf(items, output, "_" + params["name"], **target)
def convert_table_type(input, output, params, target):
data = csv.DictReader(open(input,'r'))
table_type = fxconv.Structure()
for i in data:
type = fxconv.Structure()
type += fxconv.string(i["type"])
type += fxconv.u32(list(i).index(i["type"]))
taille = len(i)-1 #-1 because of the "color" column
b,l,n = [],[],[]
for j in i:
id = list(i).index(j)
if(i[j]=="2"): b.append(id)
if(i[j]=="0,5"): l.append(id)
if(i[j]=="0"): n.append(id)
if(j=="Couleur"): color=i[j]
for a in range(len(b),taille):b.append(0)
for a in range(len(l),taille):l.append(0)
for a in range(len(n),taille):n.append(0)
if(color == None):
raise Exception(f"Pas de couleur pour le type: {i['type']}")
if(len(color.strip()) != 5):
raise Exception(f"Mauvaise couleur pour le type {i['type']} : {color}")
color = int(color.strip()[1:], 16)
type += b"".join(fxconv.u32(value) for value in b)
type += b"".join(fxconv.u32(value) for value in l)
type += b"".join(fxconv.u32(value) for value in n)
type += fxconv.u16(color)
table_type += fxconv.ptr(type)
fxconv.elf(table_type, output, "_" + params["name"], **target)