Tales of Destiny (U/J)

[Gemini]

Chiunque volesse farsi un giro sul codice della decompressione:

Codice Seleziona Espandi

decompress:               # CODE XREF: sub_80023490+98p
move    $t0, $0
li      $v1, 0xFEF
addu    $v0, $a3, $t0

azzera_buffer:            # CODE XREF: decompress+18j
sb      $0, 0($v0)       # buffer[0xFFF]={0}
addiu   $t0, 1
slt     $v0, $t0, $v1
bnez    $v0, azzera_buffer
addu    $v0, $a3, $t0
move    $t0, $0          # azzera il contatore
move    $v1, $a3         # copia puntatore ring buffer

init_buffer_1:            # CODE XREF: decompress+6Cj
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $0, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $0, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $0, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $0, 0($v1)
addiu   $t0, 1
slti    $v0, $t0, 0x100
bnez    $v0, init_buffer_1
addiu   $v1, 1
move    $t0, $0
li      $t1, 0xFF
addiu   $v1, $a3, 0x800

init_buffer_2:            # CODE XREF: decompress+BCj
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $t1, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $t1, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $t1, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $t0, 1
slti    $v0, $t0, 0x100
bnez    $v0, init_buffer_2
addiu   $v1, 1
li      $v0, 0x1000
addiu   $t2, $v0, 0xFFEF  # ring
move    $t5, $0

prossimo_flag:            # CODE XREF: decompress+11Cj
          # decompress+158j ...
sltu    $v0, $a1, $a2    # verifica grandezza decompressa raggiunta

prossimo_bit:             # CODE XREF: decompress+198j
          # decompress+1FCj
beqz    $v0, fine_dec    # fine decompressione?
srl     $v0, $t5, 1      # flag>>=1
move    $t5, $v0
andi    $v0, 0x100
bnez    $v0, bit16_vale1
andi    $v0, $t5, 1
lbu     $v0, 0($a1)      # legge il riconoscitore
addiu   $a1, 1           # incrementa il puntatore al buffer di lettura
ori     $t5, $v0, 0xFF00  # valli a capire...
andi    $v0, $t5, 1      # isola il riconoscitore attuale

bit16_vale1:              # CODE XREF: decompress+E4j
beqz    $v0, compresso   # se è compresso, salta via
addu    $v0, $a3, $t2    # puntatore ring buffer + ring
lbu     $v1, 0($a1)      # legge un carattere non compresso
addiu   $a1, 1           # incrementa il puntatore ai dati compressi
addiu   $t2, 1           # incrementa il puntatore ring
andi    $t2, 0xFFF       # chiude l'anello su sé stesso
sb      $v1, 0($v0)      # salva nel ring buffer
sb      $v1, 0($a0)      # salva anche nel buffer di decompressione
j       prossimo_flag
addiu   $a0, 1
# ---------------------------------------------------------------------------

compresso:                # CODE XREF: decompress+FCj
lbu     $t1, 0($a1)      # byte basso della decompressione
addiu   $a1, 1           # incremento puntatore al buffer compresso
lbu     $v1, 0($a1)      # byte alto della decompressione
addiu   $a1, 1           # incremento puntatore al buffer compresso
andi    $v0, $v1, 0xF0   # hi&0xF0
sll     $v0, 4           # hi<<4
or      $t3, $t1, $v0    # low | hi
andi    $v0, $v1, 0xF    # low&0xF
addiu   $t4, $v0, 2      # low+=2
sltiu   $v0, $t4, 0x11
beqz    $v0, trova_rle   # lunghezza maggiore del massimo consentito
move    $t1, $t3         # copia il salto
slti    $v0, $t4, 0
bnez    $v0, prossimo_flag
move    $t0, $0          # imposta il contatore loop a 0
andi    $t1, 0xFFFF      # elimina il superfluo dalla halfword

loop_lzss:                # CODE XREF: decompress+190j
addu    $v1, $a3, $t2    # puntatore ring buffer + ring attuale
addiu   $t2, 1
andi    $t2, 0xFFF
addu    $v0, $t1, $t0    # salto+contatore loop
andi    $v0, 0xFFF       # elimina il superfluo
addu    $v0, $a3, $v0    # ottiene il puntatore del ringbuffer + spiazzamento
lbu     $v0, 0($v0)      # carica dal ring buffer un byte decompresso
addiu   $t0, 1           # avanzamento del contatore loop
sb      $v0, 0($v1)      # copia nel ring buffer
sb      $v0, 0($a0)      # decomprime nel buffer vero e proprio
slt     $v0, $t4, $t0    # verifica il contatore di decompressione
beqz    $v0, loop_lzss   # continua a decomprimere allora
addiu   $a0, 1           # fa avanzare il puntatore al buffer decompresso
j       prossimo_bit     # continua la decompressione
sltu    $v0, $a1, $a2    # imposta in caso di grandezza di decompressione raggiunta
# ---------------------------------------------------------------------------

trova_rle:                # CODE XREF: decompress+14Cj
andi    $t0, $t1, 0xFFFF  # taglia via la roba inutile dal salto
sltiu   $v0, $t0, 0x100  # se è minore di 256
beqz    $v0, minore_100  # se il salto è inferiore a 0x100 salta via
addiu   $t1, $t3, 0x12   # aggiunge 18 al salto
lbu     $v1, 0($a1)      # carica un carattere dal buffer compresso
j       continua_rle
addiu   $a1, 1           # incrementa il puntatore dei dati compressi
# ---------------------------------------------------------------------------

minore_100:               # CODE XREF: decompress+1A8j
andi    $v1, $t3, 0xFF   # mantiene solo 16 bit
srl     $v0, $t0, 8      # ridimensiona il salto
addiu   $t1, $v0, 2      # aggiunge 2

continua_rle:             # CODE XREF: decompress+1B4j
andi    $t1, 0xFFFF      # elimina il superfluo
slti    $v0, $t1, 0
bnez    $v0, prossimo_flag
move    $t0, $0

loop_rle:  # CODE XREF: decompress+1F4j
addu    $v0, $a3, $t2    # puntatore ring buffer + ring
addiu   $t2, 1           # incrementa ring
sb      $v1, 0($v0)      # salva nel ring buffer
sb      $v1, 0($a0)      # salva nel buffer d'uscita
addiu   $a0, 1
addiu   $t0, 1
slt     $v0, $t1, $t0
beqz    $v0, loop_rle
andi    $t2, 0xFFF       # fa tornare il ring su se stesso
j       prossimo_bit
sltu    $v0, $a1, $a2
# ---------------------------------------------------------------------------

fine_dec:  # CODE XREF: decompress+D4j
jr      $ra
nop
I commenti dovrebbero essere più che necessari per capire cosa fa il codice, spero. xD

[Phoenix]

Alcune correzioni ai commenti:

Codice Seleziona Espandi


decompress:               # CODE XREF: sub_80023490+98p
move    $t0, $0
li      $v1, 0xFEF
addu    $v0, $a3, $t0

azzera_buffer:            # CODE XREF: decompress+18j
sb      $0, 0($v0)       # buffer[0xFFF]={0}
addiu   $t0, 1
slt     $v0, $t0, $v1
bnez    $v0, azzera_buffer
addu    $v0, $a3, $t0
move    $t0, $0          # azzera il contatore
move    $v1, $a3         # copia puntatore ring buffer

init_buffer_1:            # CODE XREF: decompress+6Cj
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $0, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $0, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $0, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $0, 0($v1)
addiu   $t0, 1
slti    $v0, $t0, 0x100
bnez    $v0, init_buffer_1
addiu   $v1, 1
move    $t0, $0
li      $t1, 0xFF
addiu   $v1, $a3, 0x800

init_buffer_2:            # CODE XREF: decompress+BCj
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $t1, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $t1, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $v1, 1
sb      $t1, 0($v1)
addiu   $v1, 1
sb      $t0, 0($v1)
addiu   $t0, 1
slti    $v0, $t0, 0x100
bnez    $v0, init_buffer_2
addiu   $v1, 1
li      $v0, 0x1000
addiu   $t2, $v0, 0xFFEF  # ring (imposta il cursore del ringbuffer a 0xFEF, da qui si comincerà a scrivere i dati decompressi)
move    $t5, $0

prossimo_flag:            # CODE XREF: decompress+11Cj
          # decompress+158j ...
sltu    $v0, $a1, $a2    # verifica grandezza decompressa raggiunta

prossimo_bit:             # CODE XREF: decompress+198j
          # decompress+1FCj
beqz    $v0, fine_dec    # fine decompressione?
srl     $v0, $t5, 1      # flag>>=1
move    $t5, $v0
andi    $v0, 0x100       #se ha ancora un 1 prima degli 8 bit, vuol dire che ci sono ancora flag (dovuto all'AND con 0xFF00 sotto)
bnez    $v0, ho_ancora_un_flag
andi    $v0, $t5, 1

#--------------------------------------------------------------------------------------------------
#----------------------------------Inizio routine di decompressione--------------------------------
#--------------------------------------------------------------------------------------------------
lbu     $v0, 0($a1)      # legge il riconoscitore
addiu   $a1, 1           # incrementa il puntatore al buffer di lettura
ori     $t5, $v0, 0xFF00  # prepara il riconoscitore per poter essere controllato
andi    $v0, $t5, 1      # isola il riconoscitore attuale

ho_ancora_un_flag:              # CODE XREF: decompress+E4j
beqz    $v0, compresso   # se è compresso, salta via
addu    $v0, $a3, $t2    # puntatore ring buffer + ring
lbu     $v1, 0($a1)      # legge un carattere non compresso
addiu   $a1, 1           # incrementa il puntatore ai dati compressi
addiu   $t2, 1           # incrementa il puntatore ring
andi    $t2, 0xFFF       # chiude l'anello su sé stesso
sb      $v1, 0($v0)      # salva nel ring buffer
sb      $v1, 0($a0)      # salva anche nel buffer di decompressione
j       prossimo_flag
addiu   $a0, 1
# ---------------------------------------------------------------------------

compresso:                # CODE XREF: decompress+FCj
lbu     $t1, 0($a1)      # byte basso della decompressione
addiu   $a1, 1           # incremento puntatore al buffer compresso
lbu     $v1, 0($a1)      # byte alto della decompressione
addiu   $a1, 1           # incremento puntatore al buffer compresso
andi    $v0, $v1, 0xF0   # hi&0xF0
sll     $v0, 4           # hi<<4
or      $t3, $t1, $v0    # low | hi
andi    $v0, $v1, 0xF    # low&0xF
addiu   $t4, $v0, 2      # low+=2
sltiu   $v0, $t4, 0x11
beqz    $v0, trova_rle   # lunghezza maggiore del massimo consentito
move    $t1, $t3         # copia il salto
slti    $v0, $t4, 0
bnez    $v0, prossimo_flag
move    $t0, $0          # imposta il contatore loop a 0
andi    $t1, 0xFFFF      # elimina il superfluo dalla halfword

loop_lzss:                # CODE XREF: decompress+190j
addu    $v1, $a3, $t2    # puntatore ring buffer + ring attuale
addiu   $t2, 1
andi    $t2, 0xFFF
addu    $v0, $t1, $t0    # salto+contatore loop
andi    $v0, 0xFFF       # elimina il superfluo
addu    $v0, $a3, $v0    # ottiene il puntatore del ringbuffer + spiazzamento
lbu     $v0, 0($v0)      # carica dal ring buffer un byte decompresso
addiu   $t0, 1           # avanzamento del contatore loop
sb      $v0, 0($v1)      # copia nel ring buffer
sb      $v0, 0($a0)      # decomprime nel buffer vero e proprio
slt     $v0, $t4, $t0    # verifica il contatore di decompressione
beqz    $v0, loop_lzss   # continua a decomprimere allora
addiu   $a0, 1           # fa avanzare il puntatore al buffer decompresso
j       prossimo_bit     # continua la decompressione
sltu    $v0, $a1, $a2    # imposta in caso di grandezza di decompressione raggiunta
# ---------------------------------------------------------------------------

trova_rle:                # CODE XREF: decompress+14Cj
andi    $t0, $t1, 0xFFFF  # taglia via la roba inutile dal salto
sltiu   $v0, $t0, 0x100  # se è maggiore o uguale di 256
beqz    $v0, maggiore_o_uguale_100  # se il salto è maggiore o uguale a 0x100 salta via
addiu   $t1, $t3, 0x12   # aggiunge 18 al salto
lbu     $v1, 0($a1)      # carica un carattere dal buffer compresso
j       continua_rle
addiu   $a1, 1           # incrementa il puntatore dei dati compressi
# ---------------------------------------------------------------------------

maggiore_o_uguale_100:               # CODE XREF: decompress+1A8j
andi    $v1, $t3, 0xFF   # mantiene solo 16 bit
srl     $v0, $t0, 8      # ridimensiona il salto
addiu   $t1, $v0, 2      # aggiunge 2

continua_rle:             # CODE XREF: decompress+1B4j
andi    $t1, 0xFFFF      # elimina il superfluo
slti    $v0, $t1, 0
bnez    $v0, prossimo_flag
move    $t0, $0

loop_rle:  # CODE XREF: decompress+1F4j
addu    $v0, $a3, $t2    # puntatore ring buffer + ring
addiu   $t2, 1           # incrementa ring
sb      $v1, 0($v0)      # salva nel ring buffer
sb      $v1, 0($a0)      # salva nel buffer d'uscita
addiu   $a0, 1
addiu   $t0, 1
slt     $v0, $t1, $t0
beqz    $v0, loop_rle
andi    $t2, 0xFFF       # fa tornare il ring su se stesso
j       prossimo_bit
sltu    $v0, $a1, $a2
# ---------------------------------------------------------------------------

fine_dec:  # CODE XREF: decompress+D4j
jr      $ra
nop


[EDIT]
Ecco come dovrebe essere il buffer ad anello, una volta inizializzato

Codice Seleziona Espandi


Offset: 0x000
00 00 00 00 00 00 00 00 ]
01 00 01 00 01 00 01 00 ]
02 00 02 00 02 00 02 00 ]
03 00 03 00 03 00 03 00 ]0x800 byte in totale
.  .  .  .  .  .  .  .  ]
.  .  .  .  .  .  .  .  ]
.  .  .  .  .  .  .  .  ]
FF 00 FF 00 FF 00 FF 00 ]

Offset: 0x800
00 FF 00 FF 00 FF 00    ]        
01 FF 01 FF 01 FF 01    ]  
02 FF 02 FF 02 FF 02    ]
03 FF 03 FF 03 FF 03    ]0x700 byte in totale
.  .  .  .  .  .  .     ]
.  .  .  .  .  .  .     ]
.  .  .  .  .  .  .     ]
FF FF FF FF FF FF FF    ]

Offset: 0xF00
00 00 00 00 00 00 00 00 ]        
00 00 00 00 00 00 00 00 ]
.  .  .  .  .  .  .  .  ]0xEF byte (0x00) in totale
.  .  .  .  .  .  .  .  ]
.  .  .  .  .  .  .  .  ]
00 00 00 00 00 00 00    ]

Offset: 0xFEF (da dove si cominciano a scrivere i byte decompressi)
XX XX XX XX XX XX XX XX ]
XX XX XX XX XX XX XX XX ]0x11 byte in totale
XX                      ]

[/EDIT]

[TerryBogard]

La cosa è molto interessante, se Gemini ha gia pronto un decompressore per tutti i Tales o quasi, non sarebbe una brutta idea mettere su un'altro team per tradurre qualche gioco.
In Tales of Eternia/Destiny2 ho trovato parte del testo ma come potete vedere qui sotto

le parole sono miskiate con altri simboli. Ora il testo si trova nel file M.D del peso di 156mega, è probabile che ci sia altra roba che potrebbe dare fastidio.
Gemini tu che ci capisci qualcosa è una compressione oppure cosa??

[Gemini]

se Gemini ha gia pronto un decompressore per tutti i Tales o quasi, non sarebbe una brutta idea mettere su un'altro team per tradurre qualche gioco.

In effetti ho un decompressore già scritto, peccato abbia un bug di cui non si capisce la natura, per cui lasciamo stare le idee premature su team e altro. Anche Phoenix stava lavorando alla stessa compressione, ma non so quanto sia arrivato in fondo.

Comunque quello dell'immagine è proprio un file compresso con il solito algoritmo dei Tales of.

[Yazus]

C'è un modo per aprire direttamente una rom o iso di un gioco tales of e tradurla direttamente, cio'è un decompressore diretto, x ki cm me nn capisce una mazza di compressione \ decompressione?
Io so sl tradurre XD ma se il gioco è criptato nope

[Phoenix]

Fosse esistito un programma del genere, a quest'ora tutti i Tales esistenti sarebbero già in italiano    

[Yazus]

beh ma se hanno tutti la stessa codifica, non sarebbe così difficile farne uno universale

[Gemini]

Peccato che di uguale ci sia solo la compressione. Il resto varia parecchio in ogni Tales of, specialmente la codifica dei testi e la disposizione dei relativi puntatori (atroce in TOP).

[Yazus]

Beh, il gioco è uscito in japp (sto parlando di quello della play2)
a novrebmre 2006, forse la Namco Bandai America potrebbe
farci un regalino di traduzione in Inglese, e forse, dall'Inglese all'ita
è un pò + facile che dal jap all'ita!
Io cmq non ci spero, d'altronde anno tradotto in inglese solo i tales
of + scarsi e poi si lamentano delle vendite basse, non compariamo
Destiny a Legendia oppure Rebirth a Abyss, poi i doppiaggi
inglesi non reggono mai a quelli Jap, insomma, fanno le cose male
e poi si lamentano...

Mah, se si riuscisse a decomprimere bene il gioco e trovare font e tutto,
forse qualche team potrebbe nascere, è proprio un peccato che questi giochi rimangano su mercato orientale - Nord America, dato che
sn dei giochi bellissimi e anche quelli + vecchi, tuttora giocabili e al
passo cn i tempi!

[Rulesless]

Io sto giocando proprio in questi giorni Tales of Simphony per Gamecube e mi sto divertendo come un pazzo: e' tradotto in italiano e mi pare della stessa serie, per quel che vedo dalle immagini che avete allegato, elevandosi ad uno stile superiore, pur rimanendo un titolo molto giocabile ma con grafica appena sufficiente...

[Yazus]

Tals of Symphonia è l'unico (insieme all'indecente port di tales of phantasia) Tales of tradotto in italiano.
E' un dei migliori è molto bello, raro da trovare xD (io cel'ho xò)

Ripeto, tales of destiny remake, nn è un PORT della versione ps1, è un remake
alcuni oggetti della storia cambiano, il bs è differente ecc ecc...
Quindi, io aspetto che il team di cless lo traduca in ingl, anche se i tempo sn
sempre quelli...........

[Gemini]

Ripeto, tales of destiny remake, nn è un PORT della versione ps1, è un remake

Non ho capito: vuoi che la versione Psx è un remake o quella GBA?

Quindi, io aspetto che il team di cless lo traduca in ingl, anche se i tempo sn
sempre quelli...........

Sì, ciao. Io ormai ho perso le speranze in Cless, soprattutto con i tempi ancestrali che ci vorranno per tradurre quello script. Ora che non ha DI NUOVO (sarà la terza volta) un traduttore e che anche l'ultimo che gli aveva offerto di lavorare sullo script l'ha sfanculizzato voglio vedere che s'inventa. Fortuna che c'è l'alternativa al suo lavoro.

[Jegriva]

Io ho una personale gara con Cless.

Vediamo chi riesce prima fra noi due:

- lui a completare la traduzione dello script;
- io a diventare nonno di due femmine;

[Morpher]

Per chi non lo sapesse tutte le difficoltà tecniche di questo gioco (e di tutti gli altri Tales of) sono state superate. Ecco alcuni screen:



Scusate per il testo ma alle 3 di mattina mi giravano

[TerryBogard]

Anche gli spagnoli e i francesi hanno tradotto qualche Tales, diciamo che se si vuole fare si può fare. Io un po di tempo da dedicargli c'è lo, magari traduco gli item.