Commit com o arquivo game_parm.bin traduzido #18

asm/create_rom.bat

@@ -41,6 +41,8 @@ call pack_sub.bat
 cd..
 copy "tool_sub\new\sub.bin" "ROM Modificada\ROCK\data\sub.bin" /B/Y 
 
+copy "tool_game_parm\new\game_parm.bin" "ROM Modificada\ROCK\data\game_parm.bin" /B/Y 
+
 rem Copia os binários commitados pelo Solid One
 copy "..\graficos\face.bin" "ROM Modificada\ROCK\data\face.bin" /B/Y 
 copy "..\graficos\font_pal.bin" "ROM Modificada\ROCK\data\font_pal.bin" /B/Y 
@@ -146,4 +148,5 @@ copy "..\scripts\reinseridos\talk_tw2_en2.bin" "ROM Modificada\ROCK\data\talk_tw
 echo "Repacking rom"
 cd "ROM Modificada"
 call empacotar_rom.bat
+call do_patch.bat
 cd ..

asm/tool_elf/tool_tilemap.py

@@ -1,166 +1,166 @@
-#!/usr/bin/env python
-# -*- coding: windows-1252 -*-
-
-# author: diego.hahn
-#
-
-# HARDCODED AO EXTREMO :D 
-
-import os
-import struct
-import sys
-import array
-
-def vertical(buffer):
-    c = ''
-    for y in range(8)[::-1]:
-        c += buffer[4*y:4*(y+1)]
-    return c
-
-def horizontal(buffer):
-    c = ''
-    for y in range(8):
-        reverse = buffer[4*y:4*(y+1)][::-1]
-        for w in range(4):
-            c += chr((ord(reverse[w]) << 4 | ord(reverse[w]) >> 4) & 0xFF)
-    return c
-
-def diagonal(buffer):
-    return horizontal(vertical(buffer))
-
-def create_tilesdict( buff , codec ):
-    tilesdict = {}
-    if codec == 4:
-        length = len(buff) / 32
-        for x in range(length):
-            tilesdict.update({x:buff[32*x:32*(x+1)]})
-    else:
-        length = len(buff) / 64
-        for x in range(length):
-            tilesdict.update({x:buff[64*x:64*(x+1)]})
-    return tilesdict
-
-def reduce_tilesdict( tilesdict ):
-    offset = 0 
-    reduced_tilesdict = dict()
-    for x in tilesdict: 
-        if reduced_tilesdict.has_key(tilesdict[x]):
-            continue
-        elif reduced_tilesdict.has_key(horizontal(tilesdict[x])):
-            continue
-        elif reduced_tilesdict.has_key(vertical(tilesdict[x])):
-            continue
-        elif reduced_tilesdict.has_key(diagonal(tilesdict[x])):
-            continue                        
-        else:
-            reduced_tilesdict.update({tilesdict[x]:offset})
-            offset += 1 
-    # inverte o dicionário
-    ret = dict()
-    for k,v in reduced_tilesdict.items():
-        ret.update({v:k})
-
-    return ret 
-
-def EncodeImage( src, dst, full, entry, codec ):
-    # Monta o tileset a partir da imagem full (concatenação de todas as imagens)
-    with open( full, "rb" ) as fd :    
-        tilesdict = create_tilesdict( fd.read() , codec )
-        # Simplifica o dicionário de tiles para apenas tiles únicos
-        reduced_td = reduce_tilesdict(tilesdict)
-
-        # Monta o tileset
-        tileset = array.array("c")
-        out = open( dst, "wb" )
-        for i in range(len(reduced_td)):
-            tileset.extend(reduced_td[i])
-            out.write(reduced_td[i]) 
-        out.close()
-
-    with open( src, "rb" ) as fd:
-        tilesdict = create_tilesdict( fd.read() , codec )
-
-        # Monta o tilemap -  a informação da paleta de cores vem do tilemap original
-        tilemap = list()
-        val = reduced_td.values()
-        for i in range(len(tilesdict)):
-            if tilesdict[i] in val:
-                tilemap.append( 0x0000 | val.index(tilesdict[i]))
-            elif horizontal(tilesdict[i]) in val:
-                tilemap.append( 0x0400 | val.index(horizontal(tilesdict[i])))
-            elif vertical(tilesdict[i]) in val:
-                tilemap.append( 0x0800 | val.index(vertical(tilesdict[i])))
-            elif diagonal(tilesdict[i]) in val:
-                tilemap.append( 0x0C00 | val.index(diagonal(tilesdict[i])))   
-            else:
-                raise Exception
-                sys.exit(1)
-
-    # Atualiza o tilemap
-    with open("tilemap_general_novo.bin", "r+b") as fd:
-        fd.seek( 4 * entry )
-        addr, next = struct.unpack( "<LL", fd.read(8) )
-        size = (next - addr)/2 -4
-        fd.seek( addr + 8 )                
-
-        palette = []
-        for i in range(size):
-            palette.append(struct.unpack("<H", fd.read(2))[0] & 0xF000)
-
-        fd.seek( addr+8)
-        for i in range(size):
-            fd.write(struct.pack("<H", palette[i] | tilemap[i]))
-
-def DecodeImage( src, dst, entry, codec ):
-
-    # Leitura do tilemap
-    with open( src, "rb" ) as fd:
-        tilesdict = create_tilesdict( fd.read() , codec )
-
-    with open("tilemap_general.bin", "rb") as fd:
-
-        fd.seek( 4 * entry )
-        addr, next = struct.unpack( "<LL", fd.read(8) )
-        size = (next - addr)/2 -4
-        fd.seek( addr + 8 )        
-
-        out = open( dst, "wb" )
-        for _ in range( size ):
-            key = struct.unpack( "<H" , fd.read(2))[0]           
-
-            # TODO - Imagens com multiplas paletas
-            key &= 0xFFF
-
-            if (key & 0xC00) == 0xC00 :
-                out.write(diagonal(tilesdict[(key & 0x3FF)]))
-            elif (key & 0x800) == 0x800:
-                out.write(vertical(tilesdict[(key & 0x3FF)]))
-            elif (key & 0x400) == 0x400:
-                out.write(horizontal(tilesdict[(key & 0x3FF)]))
-            else:
-                out.write(tilesdict[(key & 0x3FF)])     
-
-        out.close()
-
-if __name__ == "__main__":
-
-    import argparse
-
-    os.chdir( sys.path[0] )
-    #os.system( 'cls' )
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument( '-m', dest = "mode", type = str, required = True )
-    parser.add_argument( '-s', dest = "src", type = str, nargs = "?", required = True )
-    parser.add_argument( '-d', dest = "dst", type = str, nargs = "?", required = True )
-    parser.add_argument( '-f', dest = "full", type = str, nargs = "?" )
-    parser.add_argument( '-e', dest = "entry", type = int, required = True )
-    parser.add_argument( '-c', dest = "codec", type = int, required = True )
-
-    args = parser.parse_args()            
-
-    if args.mode == "u":
-        DecodeImage( args.src , args.dst , args.entry , args.codec )
-    elif args.mode == "p":
-        EncodeImage( args.src , args.dst , args.full , args.entry , args.codec )
+#!/usr/bin/env python
+# -*- coding: windows-1252 -*-
+
+# author: diego.hahn
+#
+
+# HARDCODED AO EXTREMO :D 
+
+import os
+import struct
+import sys
+import array
+
+def vertical(buffer):
+    c = ''
+    for y in range(8)[::-1]:
+        c += buffer[4*y:4*(y+1)]
+    return c
+
+def horizontal(buffer):
+    c = ''
+    for y in range(8):
+        reverse = buffer[4*y:4*(y+1)][::-1]
+        for w in range(4):
+            c += chr((ord(reverse[w]) << 4 | ord(reverse[w]) >> 4) & 0xFF)
+    return c
+
+def diagonal(buffer):
+    return horizontal(vertical(buffer))
+
+def create_tilesdict( buff , codec ):
+    tilesdict = {}
+    if codec == 4:
+        length = len(buff) / 32
+        for x in range(length):
+            tilesdict.update({x:buff[32*x:32*(x+1)]})
+    else:
+        length = len(buff) / 64
+        for x in range(length):
+            tilesdict.update({x:buff[64*x:64*(x+1)]})
+    return tilesdict
+
+def reduce_tilesdict( tilesdict ):
+    offset = 0 
+    reduced_tilesdict = dict()
+    for x in tilesdict: 
+        if reduced_tilesdict.has_key(tilesdict[x]):
+            continue
+        elif reduced_tilesdict.has_key(horizontal(tilesdict[x])):
+            continue
+        elif reduced_tilesdict.has_key(vertical(tilesdict[x])):
+            continue
+        elif reduced_tilesdict.has_key(diagonal(tilesdict[x])):
+            continue                        
+        else:
+            reduced_tilesdict.update({tilesdict[x]:offset})
+            offset += 1 
+    # inverte o dicionário
+    ret = dict()
+    for k,v in reduced_tilesdict.items():
+        ret.update({v:k})
+
+    return ret 
+
+def EncodeImage( src, dst, full, entry, codec ):
+    # Monta o tileset a partir da imagem full (concatenação de todas as imagens)
+    with open( full, "rb" ) as fd :    
+        tilesdict = create_tilesdict( fd.read() , codec )
+        # Simplifica o dicionário de tiles para apenas tiles únicos
+        reduced_td = reduce_tilesdict(tilesdict)
+
+        # Monta o tileset
+        tileset = array.array("c")
+        out = open( dst, "wb" )
+        for i in range(len(reduced_td)):
+            tileset.extend(reduced_td[i])
+            out.write(reduced_td[i]) 
+        out.close()
+
+    with open( src, "rb" ) as fd:
+        tilesdict = create_tilesdict( fd.read() , codec )
+
+        # Monta o tilemap -  a informação da paleta de cores vem do tilemap original
+        tilemap = list()
+        val = reduced_td.values()
+        for i in range(len(tilesdict)):
+            if tilesdict[i] in val:
+                tilemap.append( 0x0000 | val.index(tilesdict[i]))
+            elif horizontal(tilesdict[i]) in val:
+                tilemap.append( 0x0400 | val.index(horizontal(tilesdict[i])))
+            elif vertical(tilesdict[i]) in val:
+                tilemap.append( 0x0800 | val.index(vertical(tilesdict[i])))
+            elif diagonal(tilesdict[i]) in val:
+                tilemap.append( 0x0C00 | val.index(diagonal(tilesdict[i])))   
+            else:
+                raise Exception
+                sys.exit(1)
+
+    # Atualiza o tilemap
+    with open("tilemap_general_novo.bin", "r+b") as fd:
+        fd.seek( 4 * entry )
+        addr, next = struct.unpack( "<LL", fd.read(8) )
+        size = (next - addr)/2 -4
+        fd.seek( addr + 8 )                
+
+        palette = []
+        for i in range(size):
+            palette.append(struct.unpack("<H", fd.read(2))[0] & 0xF000)
+
+        fd.seek( addr+8)
+        for i in range(size):
+            fd.write(struct.pack("<H", palette[i] | tilemap[i]))
+
+def DecodeImage( src, dst, entry, codec ):
+
+    # Leitura do tilemap
+    with open( src, "rb" ) as fd:
+        tilesdict = create_tilesdict( fd.read() , codec )
+
+    with open("tilemap_general.bin", "rb") as fd:
+
+        fd.seek( 4 * entry )
+        addr, next = struct.unpack( "<LL", fd.read(8) )
+        size = (next - addr)/2 -4
+        fd.seek( addr + 8 )        
+
+        out = open( dst, "wb" )
+        for _ in range( size ):
+            key = struct.unpack( "<H" , fd.read(2))[0]           
+
+            # TODO - Imagens com multiplas paletas
+            key &= 0xFFF
+
+            if (key & 0xC00) == 0xC00 :
+                out.write(diagonal(tilesdict[(key & 0x3FF)]))
+            elif (key & 0x800) == 0x800:
+                out.write(vertical(tilesdict[(key & 0x3FF)]))
+            elif (key & 0x400) == 0x400:
+                out.write(horizontal(tilesdict[(key & 0x3FF)]))
+            else:
+                out.write(tilesdict[(key & 0x3FF)])     
+
+        out.close()
+
+if __name__ == "__main__":
+
+    import argparse
+
+    os.chdir( sys.path[0] )
+    #os.system( 'cls' )
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument( '-m', dest = "mode", type = str, required = True )
+    parser.add_argument( '-s', dest = "src", type = str, nargs = "?", required = True )
+    parser.add_argument( '-d', dest = "dst", type = str, nargs = "?", required = True )
+    parser.add_argument( '-f', dest = "full", type = str, nargs = "?" )
+    parser.add_argument( '-e', dest = "entry", type = int, required = True )
+    parser.add_argument( '-c', dest = "codec", type = int, required = True )
+
+    args = parser.parse_args()            
+
+    if args.mode == "u":
+        DecodeImage( args.src , args.dst , args.entry , args.codec )
+    elif args.mode == "p":
+        EncodeImage( args.src , args.dst , args.full , args.entry , args.codec )
 

asm/tool_game_parm/pack_tiles.bat

@@ -0,0 +1,11 @@
+@echo off
+
+echo "Packing 000_tileset"
+
+copy /B/Y "asm_game_parm_001\001_000.bin" "asm_game_parm_001\001_000_novo.bin"
+copy /B/Y "asm_game_parm_001\001_001.bin" "asm_game_parm_001\001_001_novo.bin"
+rem concatena as imagens para criar um tileset full
+copy /B/Y "asm_game_parm_000\000_001_image.bin"+"asm_game_parm_000\000_000_image_traduzida.bin" "asm_game_parm_000\000_image_full.bin"
+
+pypy tool_tilemap.py -m p -s "asm_game_parm_000/000_001_image.bin" -d "asm_game_parm_000/000_001_tileset_novo.bin" -t "asm_game_parm_001\001_001_novo.bin" -f "asm_game_parm_000/000_image_full.bin" -e 0 -c 4
+pypy tool_tilemap.py -m p -s "asm_game_parm_000/000_000_image_traduzida.bin" -d "asm_game_parm_000/000_000_tileset_novo.bin" -t "asm_game_parm_001\001_000_novo.bin" -f "asm_game_parm_000/000_image_full.bin" -e 0 -c 4

asm/tool_game_parm/tool_game_parm.py

@@ -69,5 +69,22 @@ def Unpack( src, dst ):
 
 if __name__ == "__main__":
 
-    Unpack( "old/game_parm_sp.bin" , "old_game_parm" )
+    import argparse
+
+    os.chdir( sys.path[0] )
+    #os.system( 'cls' )
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument( '-m', dest = "mode", type = str, required = True )
+    parser.add_argument( '-s', dest = "src", type = str, nargs = "?", required = True )
+    parser.add_argument( '-d', dest = "dst", type = str, nargs = "?", required = True )
+
+    args = parser.parse_args()            
+
+    if args.mode == "u":
+        Unpack( args.src , args.dst )
+    elif args.mode == "p": 
+        Pack( args.src , args.dst  )
+    else:
+        sys.exit(1)