No meu programa Re4QuadExtremeEditor, para carregar os modelos 3d do jogo, eu uso arquivos Json, para configurar o que deve ser carregado.
Arquivos Json são arquivos usados para estruturar dados, isto é, você pode armazenar qualquer dado nele, desde que respeite a estrutura de armazenamento, isso permite que os programa consigam ler esses dados e usados.
Primeiramente você deve aprender como escrever um Json valido.
Aqui você pode pesquisar no pai google, ou no chatGPT.
Agora vou explicar como uso os Json No meu programa.
Eu uso basicamente 2 definições de Dados:
Json de Listagem: define as listagem dos modelos.
Json dos 3dmodels: aqui define qual é o arquivo de modelo que deve ser carregado.
Antes de eu mostrar os Json propriamente dito, vou explicar a estrutura de pasta de uso no meu programa.
* Pasta "data" dos os meu arquivos ficam dentro dessa pasta, ela fica ao lado o executável do programa, agora vou explicar as pastas que ficam dentro dessa pasta;
* Enemies: contem os Json de listagem dos inimigos.
* EtcModels: contem os Json de listagem dos ETM.
* Internal: contem os json dos modelos usados internamente no programa. (exemplo, o modelo da escadas, e os modelos das flechas).
* Items: contem os Json de listagem dos itens.
* Others: isso são outras coisas, os Json que estão aqui dentro seguem outras definições de dados e não serão explicados nesse tutorial.
* QuadCustom: aqui tem os Json de listagem usado no QuadCustom.
* Rooms: aqui tem os arquivos para poder carregar a modelagem dos cenarios do jogo, a definições de dados aqui é deferente do que vou explicar nesse tutorial, e não vai ser explicado no mesmo.
Para as pastas "Enemies", "EtcModels", "Items", "QuadCustom", o primeiro nível contem os Json de listagem, E dentro dessas pastas tem outras pastas com nomes diversos nelas contem os "Json dos 3dmodels".
Json de listagem
Aqui temos duas definições de dados, para QuadCustom é uma,
e para "Enemies", "EtcModels", "Items" é outra, porem o nome da primeira tag é diferente em cada um.
para criar um novo arquivo de listagem, basta copiar um existe na pasta, colocar qualquer nome no arquivo json, e editar o conteúdo interno.
exemplo: EnemiesList.json
"EnemiesList": {
"ListName": "Enemies Re4 2007 version",
"Folder": "Enemies2007",
"List": [
{
"HexID": "0600",
"ObjectModel": "em1000.json",
"Name": "Don Jose",
"Description": "Don Jose invulnerable"
},
{
"HexID": "0601",
"ObjectModel": "em1300.json",
"Name": "Don Manuel",
"Description": "Don Manuel invulnerable"
},
{
"HexID": "06FF",
"ObjectModel": "em1000.json",
"Name": "Don Jose",
"Description": "Don Jose invulnerable (FOR OTHER SUB IDS)"
}
]
}
}
Exemplo: EtcModelsList.json
{
"EtcModelsList": {
"ListName": "EtcModels Re4 2007 version",
"Folder": "EtcModels2007",
"List": [
{
"HexID": "0000",
"ObjectModel": "et0000.json",
"Name": "Breakable window from village",
"Description": "Breakable window from village {0_win_a.tga}
},
{
"HexID": "0001",
"ObjectModel": "et0100.json",
"Name": "Small Box",
"Description": "Small Box {woodboxL.tga}"
}
]
}
}
{
"ItemsList": {
"ListName": "Items Re4 2007 version",
"Folder": "Items2007",
"List": [
{
"HexID": "0000",
"ObjectModel": "idm000.json",
"Name": "Magnum Ammo",
"Description": "Magnum Ammo / Balas para la Magnum [MUNITION]"
},
{
"HexID": "0001",
"ObjectModel": "idm001.json",
"Name": "Hand Grenade",
"Description": "Hand Grenade / Granada de Mano [GRENADES]"
}
]
}
}
Agora vou explicar a função de cada propriedade.
* ListName: esse é o texto que aparece qual você vai selecionar essa listagem na janela "Options" aba "Lists", escreva algo aqui para que você saiba que essa listagem é sua, ou o proposito da mesma.
* Folder: esse é o nome da pasta de contem os arquivos json de 3dModels que estou referenciando nesse arquivo. (você vai ver essa pasta ao lado desse arquivo json)
* List: essa é a listagem propriamente dita, você pode colocar quantas entradas quiser, é só seguir a logica do arquivo.
* HexID: esse é o id em hexadecimal, é o id do inimigo, ou item, ou ETM, vai de 0000 até FFFF, se você não sabe contar em hexadecimal pergunte ao google;
* ObjectModel: esse é o nome do arquivo json que esta dentro da pasta que definimos em "Folder", esse json é o json dos 3dModels, é esse arquivo que diz qual modelo 3d deve ser carregado.
* Name: esse é o nome dessa entrada.(é o nome do inimigo/item/ETM)
* Description: é o mesmo que o de cima, só que aparece em outro lugar do programa;
E no QuadCustom, como tinha dito tem uma diferença:
Exemplo: quadcustomlist.json
"QuadCustom": {
"ListName": "Quad Custom Models",
"Folder": "QuadCustom",
"List": [
{
"ID": "0",
"ObjectModel": "quadcustomarrow.json",
"Name": "QuadCustom Arrow"
},
{
"ID": "1",
"ObjectModel": "quadcustompoint.json",
"Name": "QuadCustom Point"
}
]
}
}
Agora vou explicar oque muda:
para "ListName", "Folder" e "List" é o mesmo que expliquei acima.
* ID: esse é um valor para o programa identificar oque é oque, esse valor esta em decimal vai de 0 até 2 milhões, você pode colocar qualquer valor, desde que não repita-o na sua listagem.
* ObjectModel : a mesma logica que no mesmo campo na explicação acima.
* Name: esse é o nome que vai aparecer na listagem do QuadCustom pra você saber oque é oque.
Json dos 3dModels:
Esse são os json que ficam dentro das pastas que definimos no campo "Folder". oque vou explicar aqui serve para colocar em qualquer uma daquelas pasta.
Como o meu programa eu suporte mais de uma versão do jogo, na verdade temos mais de uma definição de json dos 3dmodels, uma para cada versão do jogo; PS2, v2007, UHD, e PS4NS.
vou deixar de exemplo, um arquivo real usado pelo meu programa e um fictício com todos os campos, pois alguns são opcionais.
Nota: neles você pode carregar mais de um BIN/PMD ao mesmo tempo.
e se necessário pode definir a posição, escala personalizados.
Antes dos exemplos, vou explicar alguns campos que aparecem em todos os arquivos, mas primeiramente você tem que entender como colocar diretórios corretamente:
No Windows os diretórios de pastas são assim:
C:\minhaPasta\minhaSubPasta
esse diretório no json fica assim:
"C:\\minhaPasta\\minhaSubPasta"
Então todas vez que tiver um \ no diretório no json você deve colocar \\
E o sistema de diretórios para arquivos fica assim:
C:\minhaPasta\minhaSubPasta\meuArquivo.bin
E no json fica assim:
"C:\\minhaPasta\\minhaSubPasta\\meuArquivo.bin"
isso é um caminho absoluto, mas no meus arquivos json, eu uso caminhos relativos, pois eu devidos em duas partes:
"custom1" => "C:\\minhaPasta\\"
esse é o caminho que você colou no diretório do custom1 lá na janela options do programa.
então dentro do arquivo json você so vai colocar:
"minhaSubPasta\\meuArquivo.bin"
para poder usar esse arquivo bin.
lembrando também de definir o campo "PathKey" como "custom1", no qual vou explicar a baixo.
E sobre os campos:
"Type": esse campo define o tipo da definição de dados, vou deixar exemplo de todos os Types, ele é usado para carregar o modelo corretamente.
"PathKey": esse contem o nome da referencia que contem a primeira parte do caminho para o arquivo. esse caminhos são aqueles que você preenche na primeira aba da janela Options.
os valores que você pode colocar aqui são:
* "ps2re4": diretório para a pasta da versão de ps2
* "uhdre4": diretório para a pasta da versão UHD
* "ps4nsre4": diretório para a pasta da versão de PS4 ou Switch (NS)
* "2007re4": diretório para a pasta da versão 2007
* "xfile": diretório para a pasta xfile
* "custom1": diretório para a pasta definida em Custom1
* "custom2": diretório para a pasta definida em Custom2
* "custom3": diretório para a pasta definida em Custom3
* "app": esse é o diretório da pasta onde esta o executável do programa.
* "": sim, não tem nenhum texto, e também não tem nenhum diretório, aqui você pode usar caminhos absolutos como expliquei acima.
Agora vamos aos exemplos e a explicação dos outros campos:
PS2:
exemplo: data\Items\itemsPs2\idm000.json
{
"ObjectModel": {
"PathKey": "ps2re4",
"Type": "PS2",
"Ps2ModelList": [
{
"Ps2BinFile": "SS\\item\\idm000.BIN",
"Ps2TplFile": "SS\\item\\idm000.TPL"
}
]
}
}
"Ps2ModelList": aqui contem a listagem dos arquivos a serem carregados.
"Ps2BinFile": caminho para o arquivo BIN
"Ps2TplFile": caminho para o arquivo TPL
PS2 Exemplo fictício com todos os campos:
{
"ObjectModel": {
"Type": "PS2",
"PathKey": "ps2re4",
"Ps2ModelList": [
{
"Ps2BinFile": "SS\\item\\idm000.BIN",
"Ps2TplFile": "SS\\item\\idm000.TPL",
"PreFix": {
"Angle": "[0.0,0.0,0.0]",
"Position": "[0.0,0.0,0.0]",
"Scale": "[1.0,1.0,1.0]"
}
},
{
"Ps2BinFile": "SS\\item\\idm001.BIN",
"Ps2TplFile": "SS\\item\\idm001.TPL",
"PreFix": {
"Angle": "[0.0,0.0,0.0]",
"Position": "[0.0,0.0,0.0]",
"Scale": "[1.0,1.0,1.0]"
}
}
]
}
}
Se você quiser você pode carregar mais de um BIN por arquivo json, mas claro que no programa eles vão ficar sempre juntos.
é assim que é feito para manter as partes dos inimigos sempre sempre juntas.
O PreFix é opcional, e vou explicar no final.
Aqui o Type deve ser sempre "PS2";
V2007:
exemplo: data\Items\Items2007\idm000.json
{
"ObjectModel": {
"PathKey": "xfile",
"Type": "V2007",
"PmdList": [
{
"PmdFile": "obj\\id\\idm000.pmd"
}
]
}
}
"PmdList": contem a listagem dos Pmds.
"PmdFile": caminho para o arquivo PMD.
Aqui o "Type" deve ser sempre "V2007"
Nota: as texturas TGA deve estar na mesma pasta que o PMD que as usa, o programa reconhece automaticamente quais tga ele precisa para cada PMD.
V2007 Exemplo fictício com todos os campos:
{
"ObjectModel": {
"Type": "V2007",
"PathKey": "xfile",
"PmdList": [
{
"PmdFile": "obj\\id\\idm000.pmd",
"PreFix": {
"Angle": "[0.0,0.0,0.0]",
"Position": "[0.0,0.0,0.0]",
"Scale": "[1.0,1.0,1.0]"
}
},
{
"PmdFile": "obj\\id\\idm001.pmd",
"PreFix": {
"Angle": "[0.0,0.0,0.0]",
"Position": "[0.0,0.0,0.0]",
"Scale": "[1.0,1.0,1.0]"
}
}
]
}
}
UHD:
exemplo: data\Items\ItemsUhdPackHD\idm000.json
{
"ObjectModel": {
"PathKey": "uhdre4",
"Type": "UHD",
"PackFolder": "BIO4\\ImagePackHD",
"UhdModelList": [
{
"UhdBinFile": "BIO4\\SS\\item\\idm000.bin",
"UhdTplFile": "BIO4\\SS\\item\\idm000.tpl"
}
]
}
}
"PackFolder": aqui é o diretório relativo de onde esta o arquivo .pack, o programa sabe qual arquivo para ele deve carregar.
"UhdTplFile": caminho para o arquivo TPL
Nota: no ps2 só precisa do BIN e TPL, ja no UHD precisa também do arquivo pack, por isso definimos aquela pasta no "PackFolder"
UHD Exemplo fictício com todos os campos:
"PackPathKey" esse campo é opcional faz o mesmo que o "PathKey" só que exclusivamente para o "PackFolder", quando ele não esta presente é usado o valor de "PathKey" mesmo.
PS4/NS:
Exemplo: data\Items\ItemsPs4NsPackHD\idm000.json
Sim é a mesma coisa que a versão do UHD, só que agora o "Type" é "PS4NS", importante o conteúdo dos arquivos bin/tpl/pack da versão uhd é diferente da versão de Ps4/NS.
oque expliquei acima vale pra esse também.
PS4/NS Exemplo fictício com todos os campos:
Sobre o PreFix:
Esse campo é opcional, serve para corrigir a posição, rotação e escala do modelo.
Para usar o "Prefix" você sempre tem que coloca o "Angle", "Position" e "Scale", mesmo se for usar só um deles.
Sobre o valor, sim ele tem que estar entre aspas"" e dentro tem que ter os colchetes[]
são 3 valores sendo na ordem x y z, sendo y a altura.
a posição esta na escala 1/100 em relação a escala de posição do jogo.
a divisão dos campos é feita pela virgula, e a divisão da parte fracionaria é feita pelo caracter de ponto.
Nenhum comentário:
Postar um comentário