Skip to content

Super Nintendo · Script Extraction / Insertion

Crystal Beans Translation Tools

By Hiei-

Crystal Beans from Dungeon Explorer · All hacks & resources →

About this project

Complete pack of tools to translate (texts and graphics) the game from english in your own language (other than french that I already done myself).

Original game requirements

See the release instructions.

Creator credits

Hiei-
Listed creator

RELEASE 2.0

Readme & instructions

readme_crystal_beans_tools_how_to_use.txt

/!\ WARNING : The rom is not included and the english translated patch released won't work with those tools. To produce a english translated rom compatible with those tools, you need to have the japanese version of the rom (often named "Crystal Beans From Dungeon Explorer (J).smc", CRC32 : 79663A93, size : 1 572 864 bytes). Once you have it, patch the japanese rom with the IPS patch named "CB_english_translated_version_1-1.ips".

Read moreRead less
/!\ WARNING : The rom is not included and the english translated patch released won't work with those tools. To produce a english translated rom compatible with those
tools, you need to have the japanese version of the rom (often named "Crystal Beans From Dungeon Explorer (J).smc", CRC32 : 79663A93, size : 1 572 864 bytes).

Once you have it, patch the japanese rom with the IPS patch named "CB_english_translated_version_1-1.ips". Once patched, the rom will be in english (CRC32 : 93C106FC,
size : 2097152 bytes). Now, renamed the patched rom with this new name "CB_english_translated_version_1-1.smc" (same as the IPS name, but with .smc instead of .ips)
or the tools won't work. Now, you can use the tools /!\

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------

One thing before starting the explanations. Each .bat file is linked with a .lua.txt file, here's how to read the commands:

For Extraction :

extraire("CB_english_translated_version_1-1.smc", "CB_main_script_us.tbl", "CB_main_script_us.txt", 0x180000, 0x188D34, 0x3E402, 308, 3, "X-$C00000", little_endian)

("name of the rom, "name of the table", "name of the dumped text file", "start of the text adress", "end of the text adress", "start of the pointer table adress", 
"number of pointers", "length of the pointers, 2 = 16-bits, 3 = 24-bits", "calculation of the pointers", "little endian or big endian")

For Insertion :

inserer("CB_english_translated_version_1-1.smc", "CB_main_script_us.tbl", "CB_main_script_us.txt", 0x180000, 0x1FDFFF, 0x3E402, 308, 3, "X+$C00000", little_endian)

("name of the rom, "name of the table", "name of the dumped text file", "start of the text adress", "end of the block/bank where the text can be inserted", "start of 
the pointer table adress", "number of pointers", "length of the pointers, 2 = 16-bits, 3 = 24-bits", "calculation of the pointers", "little endian or big endian")

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------

1) "CB_extract_main_script_us.bat" & "CB_extract_main_script_us.lua.txt"

Run the .bat to extract the main script from the rom. Note that if you reinsert a bigger script than the original one, you'll have to change the address "0x1FDFFF"
in the .lua.txt file. But the main script is already dumped ("CB_main_script_us.txt") so you won't really need it.

2) CB_insert_main_script_us.bat

Run the .bat to insert the main script in the rom. The english main script size is 51.9 kb and the inserter can handle a script big of ~530 kb thanks to the expansion
(12 to 16 MB) so you don't really have to be shy about the translation length and don't have to constrain yourself.

3) "CB_extract_places_names_script_us.bat" & "CB_extract_places_names_script_us.lua.txt"

Same as 1) The script is already dumped, name : "CB_places_names_script_us.txt"

4) "CB_insert_places_names_script_us.bat" & "CB_insert_places_names_script_us.lua.txt"

Run the .bat to insert the place names script in the rom. The english place names script size is 0.18 kb and the inserter can handle a script big of ~2.8 kb thanks
to the expansion (12 to 16 MB) so you don't really have to be shy about the translation length and don't have to constrain yourself. I could have permitted a bigger
script but it's just a few place names so you won't even really need near 3 kb as the size of each place name is limited because of the window's size of the screen.

The _ sign are space in the game, I just put _ instead because it's better in terms of visibility. The actual place names are centered, but as the font use a VWF,
there is no really a proper way to center them. Just try and reinsert the script in the rom, and adjust from what you see. I added a ZSNES savestate (didn't put
a BSNES-only savestate in case it demotivate some peoples to translate the game, who knows :o) named "CB_english_translated_version_1-1.zst" (so "Slot 0") to help
center the names. Just load it, exit the screen by going at the bottom and the map will appear with all the locations unlocked. Check your modifications, re-center
the names if needed. Reload the rom then the savestate and you can see your modifications in a few seconds, etc...

5) "CB_extract_intro_ending_staff_us.bat" & "CB_extract_intro_ending_staff_us.lua.txt"

Same as 1) The script is already dumped, name : "CB_intro_ending_staff_us.txt"

6) "CB_insert_intro_ending_staff_us.bat" & "CB_insert_intro_ending_staff_us.lua.txt"

Run the .bat to insert the intro/ending/staff script in the rom. The english intro/ending/staff script size is 6.49 kb and the inserter can handle a script big
of ~25 kb thanks to the expansion (12 to 16 MB). Unfortunately, it won't really help much as you can't add more lines in the window's text (except the ones which
are  on a black background, as there isn't any windows text)

7) Four texts remains after those modifications, and we'll modify them manually (each text would require a script to extract them so it's pretty useless).
Here's the adresses of the texts (use "Hex Workshop" to modify them, as the encode of the text is ASCII) :

- 0x1FE000 : "Select the numbers of players." (You can go until "0x1FE06F" for this sentence, make it end with a "00" byte).
- 0x1FE070 : "Continue?" (You can go until "0x1FE0FF" for this sentence, more in fact but that's pretty useless for only one word, make it end with a "00" byte").

- 0x9887 : "1P    2P    3P" (I assume you'll just after to modify the P with another letter, but you can also shift both characters if needed, like "P1    P2    P3"
for example, keep the other bytes as they are).

- 0x986C : "Yes    No" (You can use the extra "00" bytes" if you want to put longer words. Right now, the bytes are :

1F 59 65 73 1F 1F 1A 4E 6F 00 00 00 00 00 00
   Y  E  S           N  O

I don't think you'll have to modify the pointer, the room for this sentence seems enough for any language (just two words), but if you really need to move this
sentence, the pointer is at 0x9869 ("6C 98", the adress, 0x986C, reversed). Anyway, what's interest us is the length of the sentence (if you add some characters
without changing the byte which indicate the length of the sentence to the game, the added characters won't show up in the game).

The length is at 0x986B ("0A"). Add +1 (hexadecimal) for each added character. For example, if you added two more characters after the "No" word, you have
to replace "0A" with "0C".

8) If you need to modify the font of the intro/ending/staff text (to add missing special characters, for example), you can use 
"CB_extract_intro_ending_staff_font_12x12_us.bat".  The actual font is already dumped in the file "CB_opening_ending_staff_font-12x12.bmp". You can modify it
with a graphic editor like Paint (just be sure to not modify the palette/number of colors of the image) and reinsert it with the file 
"CB_insert_intro_ending_staff_font_12x12_us.bat".

9) If you need to modify the font of the dialog texts (to add missing special characters, for example), just use a graphic tile editor like TileMolester or such. 

In TileMolester, the font is at the adress 0x4649B and use the codec "1bpp planar".

10) If you need to modify the graphics class names of the characters ("Fighter/Priest/Bard/etc..."), use "CB_extract_class_names_and_menus_graphic_us.bat"
to extract it (but it's already extracted, name : "CB_classes_names_graphic_us.bin"), modify the extracted file with a graphic tile editor like TileMolester or such.
In TileMolester, use the default codec ("2bpp planar") to edit the image. Once edited, save it and reinsert the edited file using 
"CB_insert_classes_names_graphics_us.bat".

11) If you need to modify most of the words in the menus (stats and such), use "CB_extract_menus_and_stats_graphics_us.bat"
to extract it (but it's already extracted, name : "CB_menu_and_stats_graphics_us.bin"), modify the extracted file with a graphic tile editor like TileMolester or such.

In TileMolester, use the default codec ("2bpp planar") to edit the image. Once edited, save it and reinsert the edited file using "CB_menu_and_stats_graphics_us.bin".

12) If you need to modify the 1P/2P/3P cursors graphics at the beginning of the game (when you choose the character for each player), 
use "CB_extract_1P_cursor_graphic_us.bat" (for the "1P" cursor) to extract it (but it's already extracted, name : "CB_1P_cursor_graphic_us.bin"), modify the extracted 
file with a graphic tile editor like TileMolester or such.

In TileMolester, use the codec "4bpp planar, composite (2x2bpp) to edit the image. Once edited, save it and reinsert the edited file using 
"CB_insert_1P_cursor_graphic_us.bat".

Note : Do the same for "2P" and "3P" cursors, the name of the files are the same except "1P" is replaced by "2P" and "3P".

13) If you need to modify the title screen and "PUSH START" graphics at the beginning of the game, use "CB_extract_title-screen_and_push-start_graphics_us.bat" 
to extract it (but it's already extracted, name : "CB_title-screen_and_push-start_graphic_us.bmp"), modify the extracted file with a graphic tile editor like 
TileMolester or such.

In TileMolester, use the codec "4bpp planar, composite (2x2bpp) to edit the image. Once edited, save it and reinsert the edited file using 
"CB_insert_title-screen_and_push-start_graphics_us.bat".

14) If you need to modify the "THE END" graphic during the staff roll, use "CB_extract_the-end_graphic_us.bat" to extract it (but it's already extracted, 
name : "CB_the-end_graphic_us.bin"), modify the extracted file with a graphic tile editor like TileMolester or such.

In TileMolester, use the codec "4bpp planar, composite (2x2bpp) to edit the image. Once edited, save it and reinsert the edited file using 
"CB_insert_the-end_graphic_us.bat".

15) If you need to modify the translation copyrigths grahics ("HIEI-, NEIGE" & "ENGLISH V1.0") on the title screen,
use "CB_extract_translation_copyrights_graphics_us.bat" to extract it (but it's already extracted, name : "CB_translation_copyrights_graphic_us.bin"),
modify the extracted file with a graphic tile editor like TileMolester or such.

In TileMolester, use the codec "4bpp planar, composite (2x2bpp) to edit the image. Once edited, save it and reinsert the edited file using 
"CB_insert_the-end_graphic_us.bat".


-----------------------------------------------------------------------------------------------------------------------------------------------------------------------

Here's a quick summary of the explanations :

- Translate "CB_main_script_us.txt", reinsert it with "CB_insert_main_script_us.bat".
- Translate "CB_places_names_script_us.txt", reinsert it with "CB_insert_places_names_script_us.bat"
- Translate "CB_intro_ending_staff_us.txt", reinsert it with "CB_insert_intro_ending_staff_us.bat.
- Modify manually the four remaining sentences => Check 7) for more informations about it.

- Modiy "CB_classes_names_graphic_us.bin", reinsert it with "CB_insert_classes_names_graphics_us.bat"
- Modiy "CB_menu_and_stats_graphics_us.bin", reinsert it with "CB_insert_menus_and_stats_graphics_us.bat"
- Modiy "CB_the-end_graphic_us.bin", reinsert it with "CB_insert_the-end_graphic_us.bat"
- Modiy "CB_title-screen_and_push-start_graphic_us.bin", reinsert it with "CB_insert_title-screen_and_push-start_graphics_us.bat"
- Modify "CB_translation_copyrights_graphic_us.bin", reinsert it with "CB_insert_translation_copyrights_graphics_us.bat"
- Modify "CB_1P_cursor_graphic_us.bin", "CB_2P_cursor_graphic_us.bin" and "CB_3P_cursor_graphic_us.bin". Reinsert them with "CB_3P_cursor_graphic_us.bin", 
"CB_insert_2P_cursor_graphic_us.bat" and "CB_insert_3P_cursor_graphic_us.bat".

- Modify the fonts if needed, see 8) and 9) for more informations about it.

Then, you're done, you have a translated version of "Crystal Beans : From Dungeon Explorer" in your own language.

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------

Other files included in the archive :

Savestates (ZSNES) :

- Savestate 0 : All locations unlocked on the world map. Just exit the castle from the bottom to display the world map.
You can also use this savestate to go back to Rubens' Castle and check all the books in the library.

- Savestate 1 : Before the grow of the Crystal Beans (there is a cutscene with some texts just after).

- Savestate 2 : Facing the last boss. You only need to use the magic attack once (R button) to kill him.

- Savestate 3 : Before displaying the staff of the game.

Cheats (ZSNES) :

CB_english_translated_version_1-1.cht : Infinites HP, White and Black Potions.

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------

With all of this, you should be able to translate this game in your language. If you have any questions/need help, don't hesitate to post on this thread :
http://www.romhacking.net/forum/index.php/topic,13519.0.html and I'll help you as much as I can.

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------

Hiei- (scripts-elysion@hiei-tf.fr)

readme_hareng-tool.txt

Version 1.2 beta 28/11/2006 Introduction Ce programme a pour but de fournir des outils utiles pour le romhacking, il contient actuellement : - un extracteur - un inséreur - un extracteur pour des mots de longueur fixe - un inséreur pour des mots de longueur fixe - un optimisateur de DTE - un optimisateur de MTE - un module permettant de remettre en forme automatiquement les textes - un module qui permet de supprimer des mots d'un fichier à partir d'une liste de mots - un patcheur/créateur de patch IPS Le tout est basé sur un interpréteur Lua. Le descriptif de l'API Lua se trouve dans le fichier "readme_lua.txt". Modifications par rapport à…

Read moreRead less
------------------------------- Hareng-tool -------------------------------

Version 1.2 beta
28/11/2006

 --------------
| Introduction |
 --------------

Ce programme a pour but de fournir des outils utiles pour le romhacking, il
contient actuellement :
   - un extracteur
   - un inséreur
   - un extracteur pour des mots de longueur fixe
   - un inséreur pour des mots de longueur fixe
   - un optimisateur de DTE
   - un optimisateur de MTE
   - un module permettant de remettre en forme automatiquement les textes
   - un module qui permet de supprimer des mots d'un fichier à partir d'une
     liste de mots
   - un patcheur/créateur de patch IPS

Le tout est basé sur un interpréteur Lua.
Le descriptif de l'API Lua se trouve dans le fichier "readme_lua.txt".


 ---------------------------------------------------
| Modifications par rapport à la version précédente |
 ---------------------------------------------------

- Par rapport à la version précédante, les ajouts sont :
     - un patcheur/créateur de patch IPS
     - l'extracteur/inséreur a été amélioré du niveau des possibilités avec Lua.

- Correction d'un bug de mémoire dans l'inséreur et l'inséreur fixe.
- L'optimisateur MTE est un peu plus précis dans les options demandées.
- Un Makefile a enfin été rajouté.
- Le programme a été testé sous Mac OS X, il y avait une petite erreur de compilation
  qui est mainenant corrigée. Le test a été réalisé sur les processeurs PowerPC et Intel.
- Intégration de l'interpréteur Lua 5.1.1 (version 5.0 dans les versions précédentes).

 ------------
| Historique |
 ------------

Version 1.0 (25/12/2004) :
Première version comportant:
   - un extracteur
   - un inséreur
   - un extracteur pour des mots de longueur fixe
   - un inséreur pour des mots de longueur fixe
   - un optimisateur de DTE
   - un optimisateur de MTE


Version 1.1 (20/09/2005) :
Par rapport à la version précédente, les ajouts sont :
   - un module permettant de remettre en forme automatiquement les textes
   - un module qui permet de supprimer des mots d'un fichier à partir d'une
     liste de mots

De plus, le programme est maintenant scriptable en Lua (www.lua.org) et quelques
fonctions annexes ont été rajoutées.


 --------------------------------
| 1 - Utilisation de Hareng-tool |
 --------------------------------

Le programme est en mode console (il existe aussi une interface).
Pour l'exécuter, il faut lui donner par la biais de
la ligne de commande un fichier texte contenant les instructions qu'il doit
executer. La ligne de commande doit avoir la syntaxe suivante :

	hareng-tool [option]

Il y a 3 options actuellement :
   -h : affiche un message d'aide
   -i : mode interactif
   -e [lua_script] : execute le fichier [lua_script]

Le mode interactif est un mode où il suffit de donner des instructions en Lua
directement par la console. Il est important de noter que l'interpréteur fonctionne
par "blocs". En gros, si on veut lui faire faire une boucle for, il faut lui donner
en ENTIER. Pour ce faire, on peut écrire la boucle en plusieurs lignes et à la fin de
chaque ligne intermédiaire, mettre un '\'. Exemple :

sor@Terra:~/Dev/hareng-tool$ hareng-tool.exe -i
Hareng-tool version 1.2 beta (c) 2004-2006 S.O.R
> for i = 0, 3 do
[string "in"]:1: `end' expected near `<eof>'
> for i = 0, 3 do\
>> print("YEAH !") \
>> end
YEAH !
YEAH !
YEAH !
>

Dans le premier cas on lui donne une ligne unique, il renvoie un message d'erreur.
Par contre dans le second cas on utilise le '\' pour lui spécifier qu'on n'a pas
fini de lui donner du code.

L'option -e permet l'execution du fichier de script Lua précisé.

La suite va expliquer comment utiliser de façon basique le programme, pour les informations
sur les possibilités de programmation en Lua, il faut voir du côté du fichier readme_lua.txt

 ----------------------------
| 2 - Les fichiers de script |
 ----------------------------

Le fichier de script doit être écrit en Lua. Pour ceux qui ne connaissent
pas ce langage et qui souhaitent l'apprendre, ils peuvent se rendre sur le
site officiel : www.lua.org.
Pour ceux qui ne veulent pas apprendre, le paragraphe suivant leur donnera
quelques explications basiques pour pouvoir utiliser le programme.

2.1 - Explication du fichier de script
---------------------------------------

Le fichier de script comporte des fonctions. Leur syntaxe est la
suivante :

   nom_fonction(argument1, argument2, ...)

"nom_fonction" est évidement le nom de la fonction à executer. Il est suivi
d'une liste d'arguments de taille variable d'une même fonction, parfois
même pour une même fonction. Les arguments sont impérativements séparés par
des virgules, les espaces séparant un argument d'une virgule est purement
héstétique, ils n'entrent pas en compte dans l'argument lui même. Cependant,
un argument ne peut pas contenir d'espace, à moins de l'écrire entre guillemets.

Exemple :
   fonction(argument1,argument2)
est identique à :
   fonction(      argument1     ,    argument2     )

On peut écrire :
   fonction("ceci est l'arguement 1")
Les guillemets permettent de donner des arguments qui sont des chaines de
caractère (comme des noms de fichier par exemple).

La liste d'arguments doit être encadrée par des parenthèses comme l'exemple
le montre. Au final, un fichier de script est constitué de différentes
fonctions, par exemple pour des mots de longueur fixe :

   fonction1(argument1,argument2)
   fonction2(argument1,argument2)

Toute fonction est impérativement suivie d'un retour à la ligne.

Notez bien qu'on peut mettre une ligne en commentaire en plaçant
'--' au début de cette ligne. Pour ceux qui ne savent pas ce qu'est un commentaire
en programmation, il s'agit d'une zone de texte qui n'est pas du code et qui
est tout simplement ignorée.


2.2 - Liste des différentes fonctions disponibles
-------------------------------------------------

La liste des fonctions disponnible est la suivant :
   - extraire
   - inserer
   - extraire_fixe
   - inserer_fixe
   - optimiser_dte
   - optimiser_mte
   - supprimer_mots
   - mettre_en_forme
   - patcher
   - creer_pach

 -------------------------------------------
| 3 - Description de la fonction "extraire" |
 -------------------------------------------

Comme son nom l'indique, la fonction extraire permet d'extraire des textes.
Elle permet de gérer les pointeurs. La table peut contenir des entrées
codées sur plus de 10 octets (exactement jusqu'à 255 mais je doute que
celà soit très utile), et la chaine peut avoir une longueur aussi longue
que vous le souhaitez (sauf si vous mettez 1 go de texte derrière, ça
fonctionnera pas trop :D).

Pour extraire un texte, il faut donner diverses informations :
   - le nom de la rom qui contient le texte à extraire
   - le nom de la table à utiliser
   - le nom du fichier texte où sera écrit le texte extrait
   - l'adresse du début du texte
   - l'adresse de la fin du texte
   - l'adresse du début des pointeurs
   - le nombre de pointeurs
   - la manière de calculer les pointeurs

Les noms des divers fichiers peuvent dépasser les 8 caractères, en fait,
vous pouvez donner un nom de fichier aussi long que ceux que windows accepte.

Les différentes adresses peuvent être données en hexadécimal (valeur
commençant par 0x), ou en décimal.

Dans le fichier de sortie, les pointeurs apparaissent sous la forme :
<PTXXXX> où XXXX correspond à un nombre. Il ne faut en AUCUN CAS les
modifier.

Les tables utilisent le format suivant :
   valeur=chaine

Exemple :
   50=a
   408F=épée

D'une façon générale, le programme fait intervenir une notion de balise.
Une balise est en fait une entrée de la table un peu spéciale pour le
programme puisqu'elle est écrite de la façon suivante :
   02=<FIN>

Les balises commencent toujours par '<' et finissent toujours par '>'.
Quand les utiliser me demandez-vous ?
Il faut les utiliser pour les octets "spéciaux" comme les octets qui indiquent
un nouveau cadre, une fin de cadre, etc.
Ainsi vos dumps pourraient ressembler à ceci :
   There something written on the side...<NEW>Goemon was here!<FIN>

Ceci n'est pas spécialement esthétique, c'est pourquoi il serait utile d'avoir
en sortie :
   There something written on the side...
   <NEW>
   Goemon was here!
   <FIN>

Pour se faire, les entrées seraient par exemple :
   01=\n<NEW>\n
   02=\n<FIN>\n\n

"\n" sera remplacé dans le fichier de sortie par un retour à la ligne. Les balises
supportent donc ces informations (mais pas une entrée "normale").



3.1 - Mode basique
------------------

La syntaxe du mode d'extraction "de base" est la suivante :
   extraire(nom_rom, nom_table, nom_texte, debut_texte, fin_texte, debut_pointeurs,
            nombre_pointeurs, taille_pointeurs, calcul_des_pointeurs, inversion)

Les noms des premiers arguments sont parlants, mais je vais détailler à partir
de "taille_pointeurs". L'extracteur gérant les pointeurs, il faut lui donner
des informations sur la manière de les calculer. En effet, l'extracteur a
besoin d'effectuer un calcul pour convertir les pointeurs en adresse PC.
La taille des pointeurs est exprimée en octet afin de permettre au programme
de les charger correctement.
Ensuite il faut indiquer le calcul que le programme doit effectuer.
Un exemple de calcul :
   "X+$200"

X correspond au pointeur chargé dans la rom, on peut alors lui faire subir
un calcul plus ou moins complexe (sont gérés les opérateurs +, -, *, /,
% (reste de la division euclidienne) ainsi que les parenthèses).
Par contre, pour l'instant, une valeur hexadécimale ne peut qu'être indiqué par
un $ au début le la valeur.

Le dernier argument indique si l'on doit effectuer une inversion des octets
dans le pointeur chargé. Deux choix sont possibles :
   - little_endian : ceci inversera les octets
   - big_endian : ceci n'inversera pas les octets

Supposons que l'on ait notre pointeur calculé et qu'il soit : 40 20 (en hexadécimal),
si vous indiquez little_endian, au final sa valeur sera 20 40, si vous indiquez
big_endian, sa valeur ne changera pas.

Pour finir, voici un exemple d'appel de fonction :
   extraire("Marom.smc", "Matable.tbl", "out.txt", 0x100, 0x500, 0x0, 50, 2, "X+$200", little_endian)

Ceci peut paraitre bien compliqué, mais il existe quelques modes prédéfinis pour
simplifier la tache (leurs descriptions sont situées ci-dessous).


3.2 - Mode "16 bits"
--------------------

Le dernier exemple aurait pu être écrit de la façon suivante :
   extraire("Marom.smc", "Matable.tbl", "out.txt", 0x100, 0x500, "SNES16", 0x0, 50, 0x200, 0)

"SNES16" indique que les pointeurs sont des pointeurs 16 bits et que leurs ocets
doivent être inversés. Ce mode peut être utilisé aussi pour tout pointeurs de ce
type, même si la console n'est pas une SuperNes.

L'argument suivant "SNES16" correspond au début de la table de pointeurs,
le suivant au nombre de pointeurs.
Les deux derniers arguments indiquent une correction supplémentaire "simple" :
l'avant dernier correspond à une valeur à ajouter, le dernier à une valeur à
retrancher. Ainsi il est possible de simplifier vos fonctions en utilisant les
modes prédéfinis qui permettent d'éviter certaines erreurs.


3.3 - Mode "24 bits SuperNes HighRom"
-------------------------------------

L'utilisation de ce mode est identique au mode 16 bits. Pour l'utiliser il faut
juste écrire "SNES24-HighRom" a lieu de "SNES16". Ce mode permet de calculer des
pointeurs 24 bits de rom SuperNes de type HighRom (le calcul additionnel reste
disponnible et est à utiliser dans la pluspart des cas).


3.4 - Mode "24 bits SuperNes LowRom"
------------------------------------

En fait, il n'y a pas un mode de ce type, mais deux. Sur SuperNes il existe deux
types de LowRom et la manière de calculer les pointeurs sur chacun d'eux diffère.

Pour utiliser le mode pour les LowRom1, il faut indiquer "SNES24-LowRom1".
Pour utiliser le mode pour les LowRom2, il faut indiquer "SNES24-LowRom2".

Je pense que ce mode sera peu utilisé, mais vu la complexité sur calcul, j'ai
pris soin de le mettre.


3.5 - Mode "Sans pointeurs"
---------------------------

Il peut parfois arriver qu'on veuille extraire et insérer un texte sans pointeurs
ou sans vouloir se soucier des pointeurs. Au lieu d'éviter d'écrire une ligne
d'instructions un peu longue avec des informations inutiles, un mode d'extraction
et d'insertion sans pointeurs a été implémenté.
Il suffit juste de changer le "SNES16" par "SANS_POINTEURS" et de ne donner aucun
argument supplémentaire.

Exemple :

   extraire("Marom.smc", "Matable.tbl", "out.txt", 0x100, 0x500, "SANS_POINTEURS")



 ------------------------------------------
| 3 - Description de la fonction "inserer" |
 ------------------------------------------

Cette fonction permet d'insérer les scripts créés par la fonction "extraire".
Son utilisation est identique au niveau de la syntaxe et des modes disponibles.


 ------------------------------------------------
| 4 - Description de la fonction "extraire_fixe" |
 ------------------------------------------------

Il arrive parfois que pour des objets dans un jeu, le texte soit présenté de
manière "spéciale". Par exemple, les objets d'un jeu peuvent ne pas avoir de
pointeur et être codé sur un nombre d'octets constant. Par exemple on peut avoir :

   "objet1    objet2    objet3    objet4    objet5    "

On remarque que chaque objet a toujours le même nombre de lettre (ici : 10 lettres).
L'édition d'un tel script n'est pas très pratique, c'est pour ça que j'ai ajouté une
fonction qui permet d'avoir un dump du genre :

   objet1    
   objet2    
   objet3    
   objet4    
   objet5    

Petit conseil pour que ça soit plus lisible, changer le " " dans la table par "_" :

   objet1____
   objet2____
   objet3____
   objet4____
   objet5____

Présenté comme ça, on peut facilement remarquer les erreurs qu'on aurait pu commettre
sur la longueur d'un mot.

Parlons maintenant de la fonction. La syntaxe est très simple :
   extraire_fixe(nom_rom, nom_table, nom_texte, adresse_mots, nombre_mots, taille_mot)

Il faut donc donner dans l'ordre :
   - le nom de la rom
   - le nom de la table
   - le nom du fichier texte où sera dumpé le texte
   - l'adresse du début du texte dans la rom
   - le nombre de mots à extraire
   - la taille de chaque mot



 -----------------------------------------------
| 5 - Description de la fonction "inserer_fixe" |
 -----------------------------------------------

La syntaxe est la même que pour la fonction "extraire_fixe".
Le programme va detecter automatiquement pendant l'insertion des erreurs éventuelles de
taille des mots. Par exemple il completera les mots trop courts (et il signalera la
ligne où se situe l'erreur) et il tronquera les mots trop longs.



 ------------------------------------------------
| 6 - Description de la fonction "optimiser_dte" |
 ------------------------------------------------

Cette fonction a pour but de trouver les meilleurs doublets de lettre dans un fichier
texte. Le syntaxe est la suivante :

   optimiser_dte(nom_texte, nom_out, nombre_dte)

Il faut donc indiquer (dans l'ordre) :
   - le nom du texte à analyser
   - le fichier où seront écrites les DTE
   - le nombre de DTE à chercher

Notez bien que les balises ne sont pas prises en compte lors de l'optimisation.



 ------------------------------------------------
| 7 - Description de la fonction "optimiser_mte" |
 ------------------------------------------------

Le fonctionnement de cette fonction est similaire :

   optimiser_mte(nom_texte, nom_out, nombre_mte, taille_max, taille_bibliotheque, [taille_mte])

L'argument "taille_max" correspond à la longueur maximum que pourront avoir les mte.
L'argument "taille_bibliotheque" correspond à la taille que les MTE font utiliser
à l'endroit où elles sont stockées dans la rom.

Les balises ne sont toujours pas prises en compte.
Il est possible de donner la taille d'une mte dans la rom.
Par exemple dans certain jeu, les MTE sont codés sur 2 octets dans le script de la rom,
mais dans d'autres jeux, elles ne sont codés que sur 1 octet, d'où l'interet de ce
dernier argument. Notez bien qu'il est optionnel et que sa valeur par défaut est 2.



 -------------------------------------------------
| 7 - Description de la fonction "supprimer_mots" |
 -------------------------------------------------

Le fonctionnement de cette fonction est le suivant :

   supprimer_mots(nom_texte, nom_sortie, nom_liste_mots)

Le but de cette fonction est de prendre le fichier texte précisé en premier argument
et d'ignorer chacunes des apparitions de chacun des mots donnés dans la liste.

Petit exemple :

On a en entrée le texte:
"Il est vraiment super le hareng-tool :D"

Et dans la liste on a :
est
sup
hareng

En sortie on aura :
"Il <est> vraiment <sup>er le <hareng>-tool :D"


Grâce à cette fonction on peut combiner une DTE et une MTE facilement dans un programme.
Rappellez vous que les optimisateurs DTE et MTE du programme ignorent tout ce qui se situe
entre < >. Ainsi on peut optimiser une MTE, ignorer les MTE du fichier pour ensuite optimiser
une DTE.


 -------------------------------------------------
| 8 - Description de la fonction "mettre_en_forme" |
 -------------------------------------------------

Le fonctionnement de cette fonction est le suivant :

   mettre_en_forme(nom_texte, nom_sortie, nom_table, largeur_max, hauteur_max)

Cette fonction a pour but à partir d'un fichier (le fichier nom_texte) de créer
un fichier remis en forme de façon à ce que le texte ne dépasse pas du cadre du
jeu une fois inséré. Pour ce faire un a besoin d'une table de taille, de la largeur
du cadre et de la hauteur (ou du nombre de lignes) du cadre.

Par exemple, si on a le texte suivant et que le jeu ne peut avoir plus de 15 lettres
par cadre et 2 lignes par cadre :

<PT0001>
Salut je m'appelle S.O.R et voici un exemple de mon module de remise en forme de texte
<FIN>

En sortie on aura :

<PT0001>
Salut je
m'appelle S.O.R
<NEW>
et voici un
exemple de mon
<NEW>
module de
remise en forme
<NEW>
de texte.
<FIN>


Les entrées de la table doivent être de la forme :
a=5
b=6
<Pause>=0

Notez bien qu'une entrée peut dépasser une lettre, ce qui peut s'avérer fort utile
quand on a des balises.

Il existe des entrées spéciales qui permettent de définir le retour à la ligne, des balises
d'ouverture de nouveau cadre et des balises de fin de cadre :
\n=LINEBREAK
\n<NEW>\n=NEW_DEFAUT
\n<NEW_AUTO>\n=NEW
\n<FIN>\n\n=FIN

LINEBREAK signifique que la chaine correspondante est un retour à la ligne.
NEW signifie que la chaine est une balise d'ouverture de nouveau cadre, le NEW_DEFAUT
permet de dire au programme quelle balise utiliser dans le cas où il devrait ouvrir un nouveau
cadre.
FIN signifie que la chaine est une balise de fin de texte.

Notez qu'il est obligatoire de donner un LINEBREAK, un NEW_DEFAUT et un FIN.

Enfin, une dernière possibilité est disponible : la balise <Centrer> peut être ajoutée dans le
texte de façon à ce que le texte de la ligne soit centré dans le texte de sortie.
Par exemple :

<PT0001>
<Centrer>Salut !
C'est encore moi
<FIN>

En sortie on aura :
<PT0001>
    Salut !
C'est encore moi
<FIN>

Il faut noter que la balise <Centrer> ne s'applique qu'à la ligne où elle se situe. Dans le cas où
la ligne est trop longue et que le programme reviendra à la ligne ou ouvira un nouveau cadre,
il centrera quand même le texte.


 ------------------------------------------
| 9 - Description de la fonction "patcher" |
 ------------------------------------------

Le fonctionnement de cette fonction est le suivant :

   patcher(nom_rom, nom_patch)

Cette fonction va donc appliquer un patch sur une rom :
   - nom_rom est le nom de la rom à pacher
   - nom_patch est le nom du patch


 -----------------------------------------------
| 10 - Description de la fonction "creer_patch" |
 -----------------------------------------------

Le fonctionnement de cette fonction est le suivant :

   creer_patcher(nom_rom_originale, nom_rom_modifiee, nom_patch)

Cette fonction va donc creer un patch :
   - nom_rom_originale est le nom de la rom originale, celle qui n'a pas été modifiée
   - nom_rom_modifiee est le nom de la rom modifiée
   - nom_patch est le nom du patch qui va être créé


 ----------------------------------
| 11 - Informations complémentaires |
 ----------------------------------

Ce programme a été entièrement développé par moi-même, S.O.R (à l'exception de
l'optimisateur MTE : j'ai repris celui qu'Orphis avait fait).
Si vous avez des problèmes pour l'utiliser, vous pouvez me mailler à l'adresse
suivante : harengsaur@free.fr . Si vous avez des commentaires ou des
suggestions à faire, merci de me les faire parvenir.

readme_lua.txt

Version 1.2 10/08/2006 Cette documentation est destinée aux personnes sachant programmer, et plus spécifiquement, qui ont une connaissance du langage Lua (et éventuellement C pour mieux comprendre certaines explications de cette documentation). Pour ceux qui ne connaissent pas Lua, une documentation complète se trouve sur le site officiel de Lua : http://www.lua.org. Descriptif rapide de l'API Lua L'interpréteur Lua a eu droit à quelques ajouts, principalement autour des fonctions d'extraction et d'insertion (j'ai aussi rajouté les opérations binaires du C qui sont indisponibles en Lua).

Read moreRead less
------------------------------- Hareng-tool -------------------------------

Version 1.2
10/08/2006


Cette documentation est destinée aux personnes sachant programmer, et plus
spécifiquement, qui ont une connaissance du langage Lua (et éventuellement
C pour mieux comprendre certaines explications de cette documentation).

Pour ceux qui ne connaissent pas Lua, une documentation complète se trouve
sur le site officiel de Lua : http://www.lua.org.


 --------------------------------
| Descriptif rapide de l'API Lua |
 --------------------------------

L'interpréteur Lua a eu droit à quelques ajouts, principalement autour des fonctions
d'extraction et d'insertion (j'ai aussi rajouté les opérations binaires du C qui sont
indisponibles en Lua).

Les fonctions binaires sont les suivantes :
   - andB
   - orB
   - xorB
   - notB
   - shift_l
   - shift_r

Les types de base qui servent pour l'extracteur/insereur :
   - Buffer
   - Fichier
   - Output

Les types en rapport avec l'extracteur/insereur :
   - Pointeur
   - Table_pointeurs
   - Table_ext_ins

Deux fonctions :
   - Ext_ins.extraire
   - Ext_ins.inserer

Tout ceci peut permettre de s'affranchir des restrictions de l'utilisation habituelle
d'une extracteur/inséreur : ici il est possible de construire sa propre table de pointeurs
avec des pointeurs éparpillés dans la rom, d'extraire un script dont les données et les
pointeurs se situent dans des fichiers différents, etc.


 --------------------
| Fonctions binaires |
 --------------------

Les opérateurs utilisés correspondent à ceux du C.

andB(num1, num2)
   Retourne la valeur : num1 & num2

orB(num1, num2)
   Retourne la valeur : num1 & num2

xorB(num1, num2)
   Retourne la valeur : num1 ^ num2

notB(num1, num2)
   Retourne la valeur : num1 ^ num2

shift_l(num, shift)
   Retourne la valeur : num << shift

shift_r(num, shift)
   Retourne la valeur : num >> shift


 ---------------
| Types de base |
 ---------------

-- Buffer --

Le type buffer est un tableau d'unsigned char de longueur variable

Buffer.new()
   Renvoie un nouveau buffer.

buffer:push(num)
   Rajoute la valeur "num" à la fin du buffer.

buffer:clear(i)
   Vide le buffer.

buffer:size()
   Renvoie le nombre d'éléments contenus dans le buffer.

buffer:index(i [, val])
   Si l'argument "val" est absent, renvoie le ième élément du buffer.
   Si l'argument "val" est présent, remplace le ième élément par
      la variable "val".
   A noter : le premier indice, comme sur un tableau C est 0.


-- Fichier --

Le type fichier est semblable au type file de Lua mais je lui ai rajouté
quelques possibilités.

Fichier.new()
   Renvoie une nouvelle variable de type Fichier.

fichier:open(nom_fichier, options)
   Ouvre le fichier "nom_fichier" selon les options données via la variable
      "options"?.
   Cette fonction s'utilise comme la fonction fopen en C.

fichier:close()
   Ferme le fichier.

fichier:put(val)
   Ecrit la variable "val" à la position courante.

fichier:get()
   Renvoie l'octet qui se trouve à la position courante.

fichier:seek(adresse, origine)
   Déplace la position courante à la position "adresse", par rapport à l'origine spécifiée.
   L'origine est donnée par les constantes suivantes :
      - SEEK_SET : origine du fichier
      - SEEK_CUR : position actuelle
      - SEEK_END : fin du fichier
   Cette fonction s'utilise de la même manière que la fonction fseek en C.

fichier:tell()
   Renvoie la position actuelle

fichier:read(buffer, n)
   Lit n octets à partir de la position courrante et stocke le tour dans la variable buffer.

fichier:write(buffer [, n])
   Ecrit n octets dans le fichier à la position courrante.
   Si n n'est pas donné, le buffer sera écrit en entier.

fichier:load_text(buffer)
   Cette fonction charge un fichier texte dans le buffer donné.
   Le fichier doit s'ouvrir avec les options "rb", le chargement se fait indépendament
   de l'encodage des retours à la ligne (elle les détecte seule).


-- Output --

Ce type sert essentiellement pour l'extracteur/inséreur.
Il permet de créer une variable où l'on peut faire des affichages de nombres et de chaines
simplement, mais on peut spécifier où se fait l'affichage lors de la construction de l'objet.
Par exemple ce type sert pour l'extracteur : on extrait le texte vers un Output, mais ça peut
être un Buffer ou un Fichier. De même, on peut insérer un texte vers un Buffer ou directement
dans un endroit précis de la rom.

Output.new([type [, nom_fichier, option]])
   Cette fonction renvoie un Output du type donné. Les types sont les suivants :
      - "Buffer"
      - "Fichier"
   Si aucun argument n'est donné, la sortie utilisée est la sortie standard (sortier sur
   la console).
   Les arguments nom_fichier et option servent dans le cas du tpe "Fichier" : ce sont les
   option d'ouverture du fichier (de la même manière que fichier:open()).

output:print(arg [, type])
   Ecrit dans l'Output l'argument arg, qui peut être un nombre, une chaine ou un buffer.
   Dans le cas d'un nombre, le type vient préciser s'il s'agit d'un int ou d'un char. Il faut
   respectivement préciser le type "int" et le type "char".

output:get_fichier()
   Renvoie une variable de type fichier qui permet dans le cas d'un Output vers un fichier
   de manipuler le fichier de sortie.

output:get_buffer()
   Renvoie une variable de type buffer qui permet dans le cas d'un Output vers un buffer
   de manipuler le buffer de sortie.


 ------------------------------
| Types d'extraction/insertion |
 ------------------------------

**************
-- Pointeur --
**************

Ce type représente un pointeur que l'on peut utiliser afin de créer sa table de pointeur (voir
type suivant).
Un pointeur contient 3 informations : son numéro, sa valeur et sa taille.
Le numéro sert à écrire la balise de pointeur dans le texte (<PT0043> par exemple), de façon à
savoir de quel pointeur il s'agit.
La valeur est la valeur du pointeur à proprement parler (donc l'adresse sur laquelle il pointe).
Sa taille correspond au nombre d'octets sur lequel il est stocké (2, 3, 4).

Pointeur.new()
   Renvoie un nouveau pointeur

pointeur:numero([i])
   Si i est absent, la fonction renvoie le numéro du pointeur.
   Sinon, i est le nouveau numéro.

pointeur:valeur([i])
   Si i est absent, la fonction renvoie la valeur du pointeur.
   Sinon, i est la nouvelle valeur.

pointeur:taille([i])
   Si i est absent, la fonction renvoie le numéro du pointeur.
   Sinon, i est la nouvelle taille.

pointeur:ecrire(fichier)
   Ecrit le pointeur dans le fichier donné.
   Par exemple, on a le pointeur suivant :
      - Numéro : 34
      - Valeur : 0x1234
      - Taille : 3
   Il sera écrit comme cela dans la rom :
         00 12 34
   C'est à dire que la fonction écrit n octets, où n correspond à la taille du pointeur.
   De plus il faut bien noter la façon dont est écrit le pointeur (de l'octet de poids
   fort vers l'octet de poids faible).


*********************
-- Table_pointeurs --
*********************

Ce type consitue un tableau variable de pointeurs qui peut être lu et modifié. Il sert
pour l'extracteur et à l'inséreur (qui va modifier la table de pointeurs en lui ajoutant
des entrées).

Table_pointeurs.new([taille])
   Renvoie une nouvelle table de pointeur.
   Si la taille est spécifiée, elle sera la taille de tous les pointeurs.

table_pointeurs:charger(fichier, debut, nb, taille)
   Charge la table de pointeur à partir du fichier donné.
   Les pointeurs sont chargés à partir de l'adresse "debut", "nb" pointeurs sont chargés
   suivant la taille spécifiée.
   La façon dont sont lus les pointeurs est identique à la logique de la fonction
   pointeur:ecrire(). Petit exemple :
      On a un pointeur stocké comme cela dans la rom : 12 00 34.
      Si on charge un pointeur de taille 3, sa valeur sera : 0x120034.

table_pointeurs:vider()
   Vide la table de pointeur.

table_pointeurs:ajouter(pointeur)
   Ajoute le pointeur donné.

table_pointeurs:retirer(i)
   Retire le pointeur qui se trouve à l'index i.

table_pointeurs:calculer(formule [, debut [, fin]])
   Effectue l'opération donnée par la formule sur un certain nombre de pointeur :
    - Si les bornes debut et fin ne sont pas données, le calcul se fera sur toute la table.
    - Si les bornes sont toutes deux données, le calcul se fera sur les pointeurs dont les
      indices sont entre ces bornes (bornes incluses).
    - Si seule la première borne est donnée, le calcul se fera uniquement sur le pointeur
      d'index spécifié.

table_pointeurs:inverser([debut [, fin]])
   Inverse une série de pointeurs avec la même logique que la fonction de calcul.

table_pointeurs:index(i [, pointeur])
   Lire/écrit un pointeur.
   - Renvoie le pointeur d'index i si le second argument est absent.
   - Sinon, remplace le pointeur d'index i par le pointeur spécifié.
   L'index commence à 0.

table_pointeurs:fixer_taille_pt()
   Fixe la taille de tous les pointeurs de la table. Tous les pointeurs contenus sont
   ajustés en conséquence.

table_pointeurs:nb_pt()
   Renvoie le nombre de pointeurs contenus dans la table.

table_pointeurs:taille_pt()
   Renvoie la taille des pointeurs de la table.

table_pointeurs:trier_num()
   Trie les pointeurs selon leur numéro.

table_pointeurs:trier_val()
   Trie les pointeurs selon leur valeur.

table_pointeurs:afficher()
   Affiche la table sur la sortie standard.


*******************
-- Table_ext_ins --
*******************

Ce type permet de charger une table destinée à l'extracteur/inséreur.

Table_ext_ins.new()
   Renvoie une nouvelle variable du type Table_ext_ins.

Table_ext_ins:ouvrir(nom_table)
   Charge la table nom_table (nom du fichier).

Table_ext_ins:fermer()
   Ferme la table.

Table_ext_ins:afficher()
   Affiche la table sur la sortie standard.


 ---------------------------------------------
| Fonctions d'extraction/insertion génériques |
 ---------------------------------------------

Dans ce qu'il suit, vous trouverez deux noms : texte_binaire et texte.
J'appelle "texte_binaire" le texte sous la forme où on peut le trouver dans
une rom alors que "texte" correspond au dump du texte.

Ces fonctions sont assez génériques, et simples d'usage. Toutefois, c'est
à l'utilisateur de savoir utiliser les résultats des fonctions en les insérant
lui même dans la rom en programmant un peu.

Ext_ins.extraire(texte_binaire, table, texte, pointeurs)
   Types :
      - texte_binaire : Buffer
      - table : Table_ext_ins
      - texte : Output
      - pointeurs : Table_pointeurs

   Extrait le texte_binaire en lisant la table données ainsi que la table de pointeurs
   donnée.
   Il est important de noter que les pointeurs pointent vers des adresses DANS le buffer
   du texte.
   C'est à dire que si vous avez une phrase qui se trouve à l'index x dans votre buffer,
   le pointeur correspondant devra avoir la valeur x en question.

   Il est donc possible de modifier la sortie du dump en jouant avec l'Output donné.


Ext_ins.inserer(texte, table, texte_binaire, pointeurs)
   Types :
      - texte : Buffer
      - table : Table_ext_ins
      - texte_binaire : Output
      - pointeurs : Table_pointeurs

   Insère le texte donné en lisant la table. Le texte binaire créé est stocké dans la variable
   texte_binaire. Les pointeurs sont écrits dans la table de pointeur.

Download readme_crystal_beans_tools_how_to_use.txt ↓

Download readme_hareng-tool.txt ↓

Download readme_lua.txt ↓

FROM THE COMMUNITY

Player reviews

0 reviews
No ratings yet

Played this project? Tell other players how it holds up.

Your take on Crystal Beans Translation Tools

Spam has been overwhelming. To help us approve your review, sign up and introduce yourself in the Introductions forum so we know you’re not a bot.

Sign in with your Retro Replay account to rate this project and share your experience.

Sign in to review