¡Bienvenido a mi cubil!

| Suscríbete vía RSS

21 abril 2013


Comparte este artículo: | Menéame | Fresqui | Enchílame | Technorati |

El Resurgir: Sprint 03

| 0 comentarios |


Saludos a todos. Hoy vamos a continuar con una breve memoria de las primeras iteraciones de trabajo de nuestro proyecto actual. Como veréis, hablamos sobre un pasado que parece algo distante...  nos situamos en la última semana de Octubre del 2012, con un lenguaje aun nuevo para nosotros, motivo por el cual tampoco teníamos nada concretado a nivel gráfico... la programación era lo que más nos preocupaba. Siendo sinceros, ni tan siquiera sabíamos si seríamos capaces de hacer lo que pretendíamos ni si sabríamos complementarnos correctamente. Actualmente vamos por la iteración número 17, asi que es posible que pronto mostremos algunas capturas... o quizás incluso algo jugable. :)

El Resurgir: Sprint 03

Tras el pequeño tropiezo en el Sprint 02 ,tuvimos que replantearnos correctamente que podíamos hacer y que no.
¡El trabajo en equipo tiene sus momentos!

Luego de un par de discusiones, arañazos y algun que otro berrinche, logramos armar lo que sería nuestro Sprint 03, el cual quedaba asi:

"Shaoran"

Implementar gestor de agentes externos

 "Fenris"

Implementar gestor de items

Fecha límite: 30 Octubre 2012



Aunque los objetivos nos parecian algo pretenciosos dada nuestra falta de experiencia en el lenguaje, finalmente logramos crear las clases y algoritmos necesarios dentro del plazo estipulado.

Lo que lograriamos en este Sprint seria un paso importante, dado que los gestores de agentes externos e Items terminarian por convertirse en una de las partes que mayor repercusion tienen hoy en la jugabilidad de Rocket Commander.

Con esto ambos habiamos cumplido objetivos y el pequeño fracaso del Sprint 02 comenzaba a quedar en el olvido.

Lo que mas nos gusto de este Sprint fue aprender el funcionamiento de las estructuras de datos de Monkey y la interacción entre clases y objetos. Gracias a esto pudimos crear módulos bastante flexibles que en el futuro nos permitirían realizar modificaciones en el motor sin necesidad de volver a reprogramar nada.

23 febrero 2013


Comparte este artículo: | Menéame | Fresqui | Enchílame | Technorati |

MSX Ninja Love

| 2 comentarios |

¡Saludos!

En la anteriores entradas ya comentaba que ademas de la modificación de ROMs, existían otras cosas que ocupaban mi tiempo libre... una de ellas os la voy a presentar hoy.

Ya sabéis de mi afición por la retroinformática y mas particularmente, el cariño que le tengo al estándar MSX. Fue el primer ordenador que tuvimos en casa y que en cierta medida, marco una época de mi infancia, una primera época en la que nuestras visiones del ocio electrónico venían teñidas de la fosforescencia verde del monitor con que venía equipado nuestro MSX Dynadata mientras nuestros oídos retumbaban a golpe de Chiptune y chirridos de carga.

Por aquel entonces yo era muy pequeño, el ordenador era de mi hermano y todo aquello de la programación me parecía casi mágico. Recuerdo dictarle los códigos de las revistas y la ilusión y ceremonia con que recibíamos los paquetes con los cartuchos, que los distribuía en España una empresa con el logotipo de un marciano rosa cuyo nombre no consigo recordar.

El tema es que el estándar cumple ahora 30 años, apenas cuatro inviernos menos que yo. Desde aquel entonces se ha abierto un autentico abismo tecnológico y la mayoría de los que por aquel entonces se sonaban los mocos con las mangas de la camisa, corren tras incansables churumbeles, peinan elegantes canas, o le sacan brillo a su cuero cabelludo.

Soy del pensamiento de que vivir en el pasado no tiene sentido, pero recordarlo y ser conscientes de lo que vivimos, si que la tiene. Es un ver las cosas con retrospectiva y ser conscientes de que somos parte de una historia tecnológica que corre a un ritmo mucho mas acelerado que la de la humanidad. Por la historia podemos hacernos una idea de como se vivia en la sociedad de siglos XIX, pero carecemos de la experiencia que otorga la vivencia directa.

En el aspecto tecnológico, sin embargo las cosas cambian a un ritmo mucho mayor y su repercusion es innegable. Para los que nacimos entre los 70 y 80, los cambios han sido abismales. Conocimos el nacimiento de internet, de la tecnológia celular e inalambrica... y de la impresionante evolución informática.

Volver hoy y programar sobre un micro ordenador ha sido para mi toda una experiencia, sobre todo en MSX Basic, que posee un carácter aun mas primigenio y limitado si cabe. Existen conceptos que hoy se me antojan casi extraterrestres... ¿crear los gráficos de tu juego modificando la definición de caracteres en la memoria de vídeo? ¿Puede (y debe) ser uno capaz de aprenderse el mapeado de su memoria interna? ¿poder ser capaz de ver la ejecución de un for? llevo varios años programando, como la mayoría de las personas, en lenguajes de medio o alto nivel, donde el nivel de abstracción es mucho mayor y la distancia entre el programador y el monstruo que recibe y ejecuta sus instrucciones resulta prácticamente insalvable. Programar en MSXBasic para un micro ordenador ha sido como hablarle a un gato y meterle el dedo en la nariz.

Por otra parte, no deja de impresionarme la cantidad de personas que hay conscientes de la importancia de preservar este fragmento de historia, y que lejos de catalogarla, archivarla y guardarla para si cual decrepito bibliotecario, la mantiene viva y asequible al resto del mundo.

Así que hala, deciros que he programado un juego para MSX. Es un juego simplón y algo lento, pero he disfrutado mucho al crearlo. Como desarrollador (no me considero programador), a sido como ceñirme una casaca y ataviado cual Tercio, adentrarme con mi trabuco en el pasado, dispuesto a vivirlo en primera persona. ¡Y vaya si ha sido emocionante!

Espero que os guste. Si no sabéis como ejecutarlo, no tenéis mas que preguntar.

Ninja Love: un mini juego desarrollado en MSX Basic

Os adjunto también el código fuente, por si queréis aprender un poco. Podría estar mucho mejor programado, pero no era mi intención crear una obra maestra en ese aspecto y mucho menos hacerlo público. Aunque está creado un poco a salto de mata, esta comentado y es fácil de entender. Sobre la "música"... lo sé, es un horror y el ordenador da para mucho mas aunque sea en Basic, pero no soy compositor. A lo mejor un día hago otra versión añadiendo algo mas elaborado, pero no prometo nada.

Enlace de descarga: Ninja Love

Listado:
10 SCREEN 1,2,0: CLS: KEY OFF: COLOR 15,1,1
20 LOCATE 3,10: PRINT"DAME UN MINUTO, ME ESTOY": LOCATE 5,12: PRINT"ACABANDO EL COLACAO"
30 MX%=100: MY%=94: TS%=0
40 EX%=255: UX%=196: FX%=32: CE%=1
50 VI%=2: C1%=10: CT$="p": AN%=0: PT%=500: EN%=0: DN%=0
60 '
70 '## DEFINICION SPRITES ##
80 '
90 FOR S=1 TO 32
100 READ A
110 B$=B$+CHR$(A)
120 C$=B$
130 NEXT S
140 SPRITE$(0) = B$: B$=""
150 '
160 FOR S=1 TO 32
170 READ A
180 B$=B$+CHR$(A)
190 NEXT S
200 SPRITE$(1) = B$: B$=""
210 '
220 FOR S=1 TO 32
230 READ A
240 B$=B$+CHR$(A)
250 NEXT S
260 SPRITE$(2)= B$: B$=""
270 '
280 FOR S=1 TO 32
290 READ A
300 B$=B$+CHR$(A)
310 NEXT S
320 SPRITE$(3) = B$: B$=""
330 '
340 FOR S=1 TO 32
350 READ A
360 B$=B$+CHR$(A)
370 NEXT S
380 SPRITE$(4) = B$: B$=""
390 '
400 FOR S=1 TO 32
410 READ A
420 B$=B$+CHR$(A)
430 NEXT S
440 SPRITE$(5) = B$: B$=""
450 '
460 '## REDEFINICION CHR ##
470 '
480 ' 91:[ 112:p 123:{ 95:_
490 ' 104:h
500 '
510 RESTORE 2100
520 FOR C=0 TO 7: READ T: VPOKE 95*8+C,T: NEXT C
530 FOR C=0 TO 7: READ T: VPOKE 123*8+C,T: NEXT C
540 FOR C=0 TO 7: READ T: VPOKE 112*8+C,T: NEXT C
550 FOR C=0 TO 7: READ T: VPOKE 93*8+C,T: NEXT C
560 FOR C=0 TO 7: READ T: VPOKE 104*8+C,T: NEXT C
570 FOR C=0 TO 7: READ T: VPOKE 46*8+C,T: NEXT C
580 FOR C=0 TO 7: READ T: VPOKE 97*8+C,T: NEXT C
590 FOR C=0 TO 7: READ T: VPOKE 98*8+C,T: NEXT C
600 FOR C=0 TO 7: READ T: VPOKE 99*8+C,T: NEXT C
610 FOR C=0 TO 7: READ T: VPOKE 100*8+C,T: NEXT C
620 FOR C=0 TO 7: READ T: VPOKE 101*8+C,T: NEXT C
630 FOR C=0 TO 7: READ T: VPOKE 122*8+C,T: NEXT C
640 FOR C=0 TO 7: READ T: VPOKE 105*8+C,T: NEXT C
650 '
660 '## COLOR CHR ##
670 '
680 VPOKE 8203,4*16+0 '_
690 VPOKE 8207,6*16+0 '{
700 VPOKE 8206,12*16+0'p
710 VPOKE 8205,13*16+0 'h
720 VPOKE 8204,10*16+0 'a
730 '
740 '## MENU DE INICIO ##
750 '
760 CLS
770 LOCATE 5,4: PRINT"zz  z zz   zz  z": LOCATE 5,5: PRINT"z z z z z   z z z": LOCATE 5,6: PRINT"z z z z z   z z z": LOCATE 5,7: PRINT"z z z z z z z zzz": LOCATE 5,8: PRINT"z z z z z zzz z z"
780 FOR I=5 TO 21: LOCATE I,12: PRINT "e": NEXT I
790 FOR I=5 TO 21: LOCATE I,20: PRINT "e": NEXT I
800 LOCATE 18,10: PRINT"LOVE"
810 LOCATE 10,14: PRINT"1-JUGAR"
820 LOCATE 10,16: PRINT"2-HISTORIA"
830 LOCATE 10,18: PRINT"3-SALIR"
840 LOCATE 5,22: PRINT"ONIRIC FACTOR 2013"
850 K$=INKEY$: IF K$<>"1" AND K$<>"2"AND K$<>"3" THEN GOTO 800: ELSE IF K$="3" THEN SCREEN0: END: ELSE IF K$="1" THEN CLS: ELSE IF K$="2" THEN CLS: GOTO 2280
860 '
870 '## DIBUJO FONDO ##
880 '
890 LOCATE 0,14: PRINT "_____________________________"
900 LOCATE 0,7: PRINT "{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{"
910 LOCATE 0,8: PRINT "{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{"
920 LOCATE 0,9: PRINT "{{{{{{{{{{{{{{{{{{{{{{{{{{{{{"
930 LOCATE 0,17: PRINT "eeeeeeeeeeeeeeeeeeeeeeeeeeeee"
940 LOCATE 0,21: PRINT "eeeeeeeeeeeeeeeeeeeeeeeeeeeee"
950 LOCATE 25,5: PRINT"]"
960 LOCATE 15,3: PRINT"]"
970 LOCATE 8,2: PRINT"]"
980 LOCATE 2,4: PRINT"]"
990 LOCATE 29,0: PRINT"]"
1000 LOCATE 3,1: PRINT"]"
1010 LOCATE 10,4: PRINT"."
1020 LOCATE 1,1: PRINT"."
1030 LOCATE 20,3: PRINT"."
1040 LOCATE 15,5: PRINT"."
1050 LOCATE 6,6: PRINT"."
1060 LOCATE 12,2: PRINT"."
1070 LOCATE 18,2: PRINT"."
1080 LOCATE 28,4: PRINT"."
1090 LOCATE 23,1: PRINT"b"
1100 LOCATE 23,2: PRINT"a"
1110 LOCATE 24,2: PRINT"c"
1120 LOCATE 24,1: PRINT"d"
1130 '
1140 '## BUCLE PRINCIPAL ##
1150 '
1160 REM
1170 '
1180 '## DIBUJO SPRITES ##
1190 '
1200 IF PT%>0 THEN PT%=PT%-1 ELSE GOTO 2420
1210 '
1220 AN%=AN%+1: IF AN%>1 THEN PUT SPRITE 0,(MX%,MY%),10,0: PUT SPRITE 1,(MX%,MY%),6,2: AN%=0 ELSE IF MY%<>80 THEN PUT SPRITE 0,(MX%,MY%),10,1: PUT SPRITE 1,(MX%,MY%),6,3
1230 '
1240 EN%=EN%+1: IF EN%>1 THEN PUT SPRITE 4,(EX%,94),8,5: EN%=0: ELSE PUT SPRITE 4,(EX%,94),8,4
1250 '
1260 DN%=DN%+1: IF CE%<>1 THEN IF DN%>1 THEN PUT SPRITE 5,(UX%,94),8,5: DN%=0: ELSE PUT SPRITE 5,(UX%,94),8,4 ELSE PUT SPRITE 5,(255,94),0,5
1270 '
1280 IF CE%=3 OR CE%=4 THEN LOCATE FX%,11: PRINT "h": LOCATE FX%+1,11: PRINT" "
1290 '
1300 '## COLISION ##
1310 '
1320 IF MY%<>80 THEN IF ABS(MX%-EX%)<12 :="" abs="" ex="" fx="" if="" locate="" or="" print="" then="" ux="" vi="">1 THEN VI%=VI%-1: CE%=1: GOTO 890 ELSE CE%=1: GOTO 1670
1330 '
1340 IF MY%=80 THEN IF ABS(MX%-FX%*8)<12 fx="" if="" locate="" print="" then="" ux="" vi="">1 THEN VI%=VI%-1: CE%=1: GOTO 890 ELSE CE%=1: GOTO 1670
1350 '
1360 '## MOVIMIENTO ##
1370 '
1380 IF STICK(0)=1 AND MY%<>80 THEN MY%=80
1390 IF MY%=80 THEN TS%=TS%+1: IF TS%>4 THEN MY%=94: TS%=0
1400 '
1410 '## MOV. ENEMIGO ##
1420 '
1430 IF CE%=1 THEN IF EX%>16 THEN EX%=EX%-16: ELSE EX%=255: UX%=255: IF RND(1)>.5 THEN CE%=2: EX%=255: UX%=204: ELSE IF RND(1)>.5 THEN CE%=1: EX%=255: UX%=255: ELSE CE%=3: EX%=239: FX%=32
1440 '
1450 IF CE%=2 THEN IF UX%>8 THEN UX%=UX%-8: EX%=EX%-8: ELSE UX%=255: EX%=255: IF RND(1)>.5 THEN CE%=2: UX%=204: EX%=255: ELSE IF RND(1)>.5 THEN CE%=1: EX%=255: UX%=255: ELSE CE%=4: EX%=255: UX%=168: FX%=24
1460 '
1470 IF CE%=3 THEN IF FX%>8 THEN FX%=FX%-1: EX%=EX%-8: ELSE LOCATE FX%,11: PRINT " ": FX%=32: EX%=255: UX%=255: IF RND(1)>.5 THEN CE%=1: ELSE CE%=2:UX%=204
1480 '
1490 IF CE%=4 THEN IF UX%>0 THEN FX%=FX%-1: EX%=EX%-8: UX%=UX%-8: ELSE LOCATE FX%,11: PRINT " ": FX%=32: EX%=255: UX%=255: IF RND(1)>.5 THEN CE%=1: ELSE UX%= 204: CE%=2
1500 '
1510 '## MOV FONDO ##
1520 '
1530 IF C1%>0 THEN C1%=C1%-1: LOCATE C1%,13: PRINT CT$:LOCATE C1%+1,13: PRINT" ": ELSE LOCATE 0,13: PRINT" ": C1%=31: LOCATE C1%,13
1540 '
1550 '## MARCADOR ##
1560 '
1570 LOCATE 3,19: PRINT "VIDAS:";VI%: LOCATE 15,19: PRINT"METROS:";PT%
1580 '
1590 '## REPRODUCE NOTAS##
1600 '
1610 IF PLAY(1)<>-1 THEN READ X$: IF X$ <>"X" THEN PLAY X$ ELSE RESTORE 2230
1620 '
1630 '## FIN BUCLE ##
1640 '
1650 GOTO 1200
1660 '
1670 '## GAME OVER ##
1680 '
1690 CLS: LOCATE 6,10: VI%=2: PT%=500
1700 PUT SPRITE0,(0,0),0: PUT SPRITE1,(0,0),0: PUT SPRITE 2,(0,0),0: PUT SPRITE3,(0,0),0: PUT SPRITE4,(0,0),0: PUT SPRITE5,(0,0),0
1710 LOCATE 9,11: PRINT"GAME OVER": FOR I=0 TO 1000: NEXT I
1720 GOTO 740
1730 '
1740 '## FINAL ##
1750 '
1760 '
1770 '## DATOS SPRITES ##
1780 '
1790 DATA 0,0,0,1,0,0,0,1
1800 DATA 32,9,2,16,48,32,0,0
1810 DATA 0,0,0,64,0,0,0,64
1820 DATA 4,144,128,4,28,24,0,0
1830 '
1840 DATA 0,0,0,0,0,0,0,0
1850 DATA 0,0,0,0,3,0,4,3
1860 DATA 0,0,0,0,0,160,0,0
1870 DATA 0,128,64,128,32,0,0,192
1880 '
1890 DATA 3,23,15,30,7,3,15,30
1900 DATA 27,2,5,15,14,0,0,0
1910 DATA 192,224,224,0,224,224,240,184
1920 DATA 216,64,96,240,96,0,0,0
1930 '
1940 DATA 0,0,3,7,31,15,23,3
1950 DATA 7,7,7,7,0,3,3,0
1960 DATA 0,0,192,224,224,0,224,224
1970 DATA 192,64,128,96,192,192,128,0
1980 DATA 0,0,0,8,0,1,3,39
1990 DATA 15,31,63,63,59,61,31,13
2000 DATA 0,0,32,0,8,4,136,192
2010 DATA 212,248,252,252,220,188,248,176
2020 '
2030 DATA 0,4,1,1,19,3,7,15
2040 DATA 15,31,31,27,29,31,13,7
2050 DATA 8,32,8,128,132,200,224,228
2060 DATA 240,248,248,216,184,248,176,224
2070 '
2080 '## DATOS TILES ##
2090 '
2100 DATA 223,171,117,174,90,16,0,0
2110 DATA 123,32,0,32,221,2,0,2
2120 DATA 0,0,64,32,36,88,254,0
2130 DATA 16,0,16,170,16,0,16,0
2140 DATA 32,65,254,65,32,0,0,0
2150 DATA 0,0,0,16,0,0,0,0
2160 DATA 63,117,3,63,31,30,60,240
2170 DATA 240,60,30,15,31,3,11,63
2180 DATA 208,208,224,128,0,0,0,0
2190 DATA 0,0,0,0,128,224,176,208
2200 DATA 0,195,36,16,8,36,195,0
2210 DATA 126,129,191,161,173,189,129,126
2220 DATA 0,66,60,129,129,60,66,0
2230 '
2240 '## DATOS MUSICA ##
2250 '
2260 DATA F-64,F-64,R64,F-64,F-64,F-64,F-64,A#64,A#64,R64,A#64,R64,A#64,A#64,A#64
2270 DATA R64,F#64,F#64,R64,F#64,R64,F#64,F#64,F#64,C#64,C#64,R64,C#64,C#64,C#64,C#64,X
2280 LOCATE 0,1: PRINT"eeeeeeeeeeeeeeeeeeeeeeeeeeeee"
2290 LOCATE 0,4: PRINT"ESTA NOCHE HAS QUEDADO CON TU "
2300 LOCATE 0,5: PRINT"CHURRI PARA SALIR DE PARRANDA"
2310 LOCATE 0,6: PRINT"PERO TU PERVERSO SUEGRO, AUN"
2320 LOCATE 0,7: PRINT"ENFADADO POR TU ALEGRE BROMA"
2330 LOCATE 0,8: PRINT"DEL MOCO EN EL POLLO FENSUI,"
2340 LOCATE 0,9: PRINT"HA DECIDIDO MATARTE UN POCO"
2350 LOCATE 0,11: PRINT "ANIMO NINJA, EVITA TOSTARTE"
2360 LOCATE 0,12: PRINT "EL CULO O ABRIRTE EL CRANEO,"
2370 LOCATE 0,14: PRINT "!TU PIVA AMARILLA TE ESPERA!"
2380 LOCATE 1,20: PRINT " PULSA "1" PARA CONTINUAR "
2390 LOCATE 0,18: PRINT"eeeeeeeeeeeeeeeeeeeeeeeeeeeee"
2400 QQ$=INKEY$: IF QQ$<>"1" THEN GOTO 2400 ELSE CLS: GOTO 740
2410 '
2420 '## FINAL ##
2430 '
2440 CLS: PUT SPRITE0,(0,0),0: PUT SPRITE1,(0,0),0: PUT SPRITE 2,(0,0),0: PUT SPRITE3,(0,0),0: PUT SPRITE4,(0,0),0: PUT SPRITE5,(0,0),0
2450 LOCATE 0,6: PRINT"eeeeeeeeeeeeeeeeeeeeeeeeeeeee"
2460 LOCATE 0,8: PRINT"ESTAS HECHO TODO UN NINJA"
2470 LOCATE 0,9: PRINT"RECORRISTE EL CAMINO MORTAL"
2480 LOCATE 0,11: PRINT"ESTE DOMINGO EN LA CENA TE"
2490 LOCATE 0,12: PRINT"VAS A MEAR EN LA SOPA"
2500 LOCATE 0,14: PRINT"!VERAS QUE RISAS!"
2510 LOCATE 0,16: PRINT"eeeeeeeeeeeeeeeeeeeeeeeeeeeee""
2520 LOCATE 3,18: PRINT" PULSA 1 PARA TERMINAR "
2530 QQ$=INKEY$: IF QQ$<>"1" THEN GOTO 2450 ELSE SCREEN 0: END








03 febrero 2013


Comparte este artículo: | Menéame | Fresqui | Enchílame | Technorati |

Hackeo de ROMs de NES: Parte IV

| 0 comentarios |

Saludos, amantes del cacharreo, retroadictos y curiosos lectores aleatorios. :)

Hoy continuaremos con la cuarta parte de la guía de Hackeo de ROMs de NES. En entregas anteriores, explicamos como modificar los datos de la memoria de vídeo sin modificar la paleta original. En esta ocasión, cubriremos lo básico respecto a la edición de texto. De nuevo, nos desviaremos de la fuente original, dado que las herramientas mencionadas eran demasiado antiguas. Como también hicimos en anteriores ocasiones, adjuntare un paquete con las nuevas herramientas. En esta ocasión Thingy32.

Sin más dilación, entremos en materia.

Guía esencial de Hackeo de ROMS de NES: Parte IV [ Parte I - Parte II - Parte I I ] 
Fuente original: A Beginner's Guide to NES ROM Hacking

Modificando Texto.

Modificar el texto de un juego es un poco mas complicado de lo que podria parecer en un principio. Cambiar las imágenes de las fuentes en la tabla de patrones, no es una buena idea, ya que no modifica el orden de las letras y convertiríamos las palabras en un auténtico galimatías. Pueden encontrarse algunos casos asi en los primeros Hacks de NES. Si abrimos la ROM con un editor de texto, tampoco conseguiremos nada, ya que las ROMs no hacen uso del estándar ASCII para codificar el texto.

¿Como hacerlo entonces? nosotros utilizaremos un programa llamado Thingy32, que podréis encontrar al final del articulo.

En primer lugar arrancaremos NESticle. Para la edición de hoy, usaremos la ROM de Dragon Warrior

Hoy necesitaremos:
NESticleThingy32
una ROM de Dragon Warrior 
Un editor de texto plano (Bloc de notas)
Cargamos Dragon Warrior en NESticle, y pulsamos F2 para abrir las tablas de patrones. En la ventana de patrones situada a la izquierda, encontraras los sprites de los números del 0 al 9 y las letras del alfabeto. Haz click en el número 0. En la cuadricula de edición del Tile que contiene el número "0", veras que aparece el código Hexadecimal "# 00" en la parte superior.

La última vez, también vimos un código parecido en la ROM de Super Mario al seleccionar el Tile que contenía parte de la cabeza del protagonista. En aquella ocasión ignoramos el código, pero en esta ocasión lo vamos a necesitar.

Abrimos el Bloc de notas o un editor de texto plano y escribimos lo siguiente:
0 = 00
Ojo, hemos dicho un editor de texto plano. Programas como WordPad o WordPerfect no son adecuados porque añaden información ASCII adicional.

Lo que vamos a hacer ahora es confeccionar una tabla para con los códigos Hexadecimales de cada uno de los caracteres utilizados en el texto.

Seguimos seleccionando los demás caracteres y apuntando los números Hexadecimales que nos aparecen en la parte superior del editor. Una vez apuntados todos (incluidos los saltos de linea y signos de puntuación) tendremos que tener una tabla mas o menos como esta:
00 = 00
1 = 10
2 = 20
3 = 30
4 = 40
5 = 50
6 = 60
7 = 70
8 = 80
9 = 90
A = a0
B = b
Y así sucesivamente ... guarda ahora la tabla como dw1.tbl

Esta tabla que acabamos de confeccionar, será utilizada por Thingy32, un programa que nos ahorrará horas de búsqueda.

Como mencionamos antes, los juegos de NES casi nunca utilizan el sistema ASCII para almacenar los  textos, por lo que no nos servirá de nada un editor de texto tradicional. El archivo que acabamos de crear sirve como referencia a Thingy32 para poder localizar y editar los textos tal y como se verían en el juego en lugar de con su codificación Hexadecimal. Resulta mucho mas cómodo buscar "YOUR" con Thingy32, que tener que buscar "37 11 18 1D" con un editor Hexadecimal e irlos sustituyendo byte a byte, que es como se hacia con los primeros hacks.

Sigamos con el procedimiento. Ahora ejecutamos Thingy, y veremos que nos pide una ROM. Como podras comprobar, no solo abre ROMs de NES, sino que también abre ROMs de Super Nintendo o GBA, asi que recuerda seleccionar el tipo de ROM en el filtro de extensiones de archivo para poder seleccionar tu ROM .nes.

Ahora el programa nos preguntará en dos ocasiones por un archivo .tbl. Nos pide dos tablas por si queremos cotejar entre ambas, pero no nos hará falta en esta ocasión. Seleccionamos el archivo dw1.tbl que habiamos creado en ambas ocasiones.

Ahora veremos algo como esto:

Interfaz de Thingy32 [Castellano] ROM de Mario Bros

La ventana de la izquierda muestra la información de la ROM en formato Hexadecimal y la parte de la derecha, la transcripción que extrae Thyngy32 de esos valores gracias a los datos que le facilitamos en la tabla.

Antes de empezar a cambiar nada hay algunas cosas que debemos dejar claras para no corromper la ROM. Por una parte, la mayoría de los juegos utilizan punteros hacia las direcciones de memoria, lo que significa que no podemos utilizar textos con mas caracteres de los reservados para cada frase sin modificar sus definiciones, algo que queda fuera del alcance de esta guía. Por ahora, cuando modifiquemos una ROM, lo haremos de forma que nuestros textos nunca sean mas largos que los originales.

Pongamos que tenemos una línea de texto que dice: "¡yo soy el rey de tierra Dank!"

Contando los espacios, tenemos 30 Bytes para trabajar.

No podemos introducir mas de 30 caracteres sin corromper la ROM, ya que todo el espacio de mas que utilicemos lo haremos a costa de sobreescribir el byte de fin de línea y otros datos del juego.

Cosas que podemos hacer:
Hola, soy un rey molón. 23 Bytes
¡Me debes dinero malandrín! 27 Bytes
Cosas que NO podemos hacer:
Saludos Plebeyo, ¿Que te trae por aquí? 39 Bytes
En un lugar de la mancha de cuyo nombre no puedo acordarme... 61 Bytes

Tomando en cuenta estas consideraciones, pasemos a editar los textos de la ROM.

Pulsa "S" para saltar de posición en la ROM. Escribe "0" para desplazarnos al principio del archivo y pulsa "B" para buscar un texto. Escribe "Listen"

El programa te desplazará a la posición de memoria que corresponde al texto del principio del juego, donde hablas por primera vez con el rey Lorik:

Dragon Warrior, texto original

Modifiquemos ahora lo que dice el rey. Desplázate con los cursores hasta la primera letra del texto que quieres modificar y pulsa espacio. Desplázate ahora hacia la ultimo carácter y vuelve a pulsa espacio. Te aparecerá un pequeño formulario de edición donde podrás modificar todo el texto contenido entre ambos caracteres. Escribamos por ejemplo: "I Want my Rage CD Back"

Como verás, los datos se guardan automáticamente. Vamos a ver los cambios.

Arrancamos Nesticle, cargamos la ROM de Dragon Warrior y comenzamos una nueva partida.

Cuando Lorik nos hable, deberíamos de ver nuestro texto:.

Dragon Warrior, texto modificado

Hecho. Hemos realizado nuestro primer cambio de texto en una ROM. En breve continuaremos con algo mas de contenido.

Para terminar, os dejo con una captura del Hack que estoy haciendo conforme avanzamos con el tutorial y el enlace de descarga a la aplicación que vais a necesitar para hacer estas ediciones de texto.

Hack de texto en ROM de Mario Bros

Recordad que el resto de los enlaces los tenéis en las anteriores entradas. Os deseo un fructífero cacharreo. Si hacéis algo, por favor, no dudéis en mandármelo. :D

Enlace de descarga de software: Thingy32

30 enero 2013


Comparte este artículo: | Menéame | Fresqui | Enchílame | Technorati |

Hackeo de ROMs de NES: Parte III

| 0 comentarios |

¡Buen Día!

Hoy tocaba actualizar el Blog. Tengo varias cosas pendientes de comentar, pero he pensado que lo más apropiado hoy era continuar con la Guía sobre Hackeo de ROMs.

Recordad que las aplicaciones necesarias las tenéis preparadas al final de la segunda parte de esta guía.

Dado que la versión de "Tile Layer" que os he pasado es posterior a la presentada en el texto anglosajón, apreciaréis mayores diferencias con respecto a la fuente original en esta entrada. Por otra parte, he aprovechado la redacción para ir Hackeando una ROM sobre la marcha, por lo que también añadiré algunas apreciaciones personales.

Guía esencial de Hackeo de ROMS de NES: Parte III [ Parte I - Parte II ] 
Fuente original: A Beginner's Guide to NES ROM Hacking

Bueno, el último día nos quedamos a punto de ejecutar "Tile Layer PRO" para editar las tablas de patrones de la ROM.

Una vez ejecutada la aplicación, nos encontraremos con un interfaz muy sencillo.Vamos a "File/Open" y abrimos nuestra ROM. Más adelante, cuando hagamos cualquier cambio, os recomiendo guardar la ROM con otro nombre. A veces la ROM se corrompe, sobre todo si utilizamos la opción de "importar" que os comentaré mas adelante.

Una vez abierta la ROM, deberíamos ver algo mas o menos así:

No os dejéis asustar por la "basurilla". No todos los datos son Tiles

Pese a que puede parecer confuso, si nos desplazamos por la tabla, terminaremos por encontrar los Tiles. Como podréis comprobar, de nuevo os aparecerán desordenados.

Aqui es donde sacamos partido de las características de Tile Layer. Pulsa con el botón izquierdo sobre la parte posterior de la cabeza de Mario y coloca el puntero del ratón sobre "Clipboard". Pulsa ahora con el botón derecho.

Como verás, has realizado una copia del Tile en la ventana. Utilizando esta funcionalidad, puedes ubicar los Tiles hasta ver con claridad las figuras del juego.

Ahora si, estos son los Tiles que buscabamos

Si bien es una técnica algo rudimentaria, facilita enormemente la edición gráfica. El editor de Tiles funciona de forma parecida al de NESTicle. Eso si, una vez editados los tiles, los tienes que volver a colocar en su sitio. Recuerda que estas editando los datos de la ROM y el juego los va a buscar en su posición inicial. Tampoco te olvides de guardar la ROM cuando termines de editar.

Tile Layer posee una funcionalidad mas, que si bien no siempre funciona correctamente, puede resultar de gran utilidad. Hablo de las opciones de Importar y Exportar.

Pulsando con el botón derecho sobre los Tiles de la ventana "ROM DATA" y arrastrándolo sobre ellos, podemos realizar una selección múltiple. Si después pulsamos sobre "Edit/Export Bitmap" podemos exportar todos los Tiles como una sola imagen .BMP

Lo bueno de hacer esto es que podemos editar la imagen en cualquier editor gráfico moderno y después volver a importarla a la ROM seleccionando "Edit/Import Bitmap". El tramo aparecerá en la esquina superior izquierda de la ventana "ROM DATA" y no quedara integrada en la ROM hasta que la arrastremos sobre la posición deseada y pulsemos de nuevo con el botón izquierdo fuera de la selección.

Eso es todo lo que vamos a tocar respecto a la edición gráfica por el momento. Como podrás comprobar, por el momento nos tendremos que ceñir a la paleta gráfica que use la ROM original. Mas adelante hablaremos sobre como modificarla, pero no sin antes explicar como funciona la edición de los textos originales.

Es todo por hoy. Os dejo mostrándoos los cambios que he estado haciendo yo con los personajes principales en una ROM pequeñita. Si os fijáis bien, no he modificado nada que no se haya explicado aquí:

video
ROM Hackeada, chucho fontanero incluido. :)

21 enero 2013


Comparte este artículo: | Menéame | Fresqui | Enchílame | Technorati |

Hackeo de ROMs de NES: Parte II

| 2 comentarios |


Un placer encontrarnos de nuevo, retinas curiosas.

Hoy vamos a seguir con la segunda parte del tutorial de Hackeo de ROMs para NES. Como podréis ver, en esta ocasión vamos a enumerar algunas herramientas. Si bien la fuente original nos ofrece los enlaces a las páginas de los fabricantes, por mi parte he decidido subir un paquete con todas las aplicaciones que vamos a ir necesitando a mi propio servidor.

¿Porque? pues porque en la mayoría de los casos, las páginas a las que hace referencia se encuentran Offline... y que te leas el artículo y te encuentres con que te falta una aplicación, es una auténtica faena.

Por otra parte, varias de las aplicaciones indicadas funcionaban únicamente bajo MS-DOS, por lo que he estado buscando alternativas compatibles con equipos mas modernos para que no tengáis problemas al utilizarlas. El enlace con el primer paquete, os lo dejo al final del capítulo.

Otro detalle que a lo mejor os chirría es que utilizo muchísimo la palabra "Tile" pese a estar hablando de partes de un Sprite. No sé si será la palabra más adecuada, pero es la que utiliza el texto original y la verdad, no se me ha ocurrido una alternativa mejor, ya que los sprites de NES están formados por teselas de 8x8 Píxeles y paletas de cuatro colores. Hoy en día no tenemos ese tipo de limitaciones gráficas, por lo que por norma general, montamos los sprites con una sola imagen. Sólo recurrimos a separarlos por cuestiones de funcionalidad, como se hace en juegos tipo "Metal Slug", en los que las piernas y brazos que sostienen el arma de los personajes van por separado, para no tener que hacer de nuevo todo el Sprite cada vez que actualizamos nuestro armamento.

Metal Slug: Sprite fragmentado

Lo que más me gusta de todo este proceso, es que es una buena forma de aproximarse a la arquitectura de la máquina. Así que espero que os suceda lo mismo que a mi y despierte en vosotros un mayor interés por saber "como funciona por dentro" la consola. Sin más dilación, os dejo con la segunda entrega.


Guía esencial de Hackeo de ROMS de NES: Parte II [ Parte I ] 

Fuente original: A Beginner's Guide to NES ROM Hacking


NESticle

Si bien tiene varias deficiencias como emulador, es una gran herramienta para Hackear ROMs.
La tecla F2 te permite editar los gráficos y obtener los valores Hexadecimales de Tiles y textos.
La tecla F4 te permite visualizar la gama de colores que se está utilizando.
Hackeo gráfico

Modificar ls imagenes de un juego puede ser divertido y tedioso al mismo tiempo, especialmente si tus habilidades artísticas son limitadas. Hay dos formas principales de hacerlo: utilizando el botón F2 de NESticle para mostrar las tablas de patrones, o bien mediante un programa llamado "Tile Layer". Cada opción tiene sus ventajas e inconvenientes:

NESticle:

Pros:
- Permite editar en tiempo real y ver los cambios en pantalla.
Contras:
- No se pueden guardar los cambios si el juego carece de VROM (ROM de vídeo).
- No todos los juegos pueden ser emulados por NESticle.
Tile Layer:

Pros:
- Se pueden guardar los cambios en cualquier juego, tenga VROM o no.
- Puedes organizar los Tiles para ver como aparecen en el juego.
- Puedes abrir dos ROMs a la vez, permitiendote cortar y pegar gráficos de una a otra.
- Puedes editar ROMs de Gameboy, Master System, Virtual Boy y SNES.
Contras:
- No se puede editar en tiempo real. Hay que cargar la ROM para ver los cambios.

Lo mejor es alternar ambas herramientas. Dicho esto, comencemos por modificar algunos gráficos de "Super Mario Bros".

Lo que necesitas:
NESticle
Tile Layer
ROM de Super Mario Bros
Carga NESticle, haz clic en Archivo y luego clic en "Load ROM". Aparecerá una lista de directorios de tu ordenador. Selecciona la ubicación de tu ROM de Super Mario. Ahora, pulsa F2, y deberias de ver una pantalla como esta:

La famosa "Tabla de patrones"

Si bien parece algo confuso, son los gráficos que se están utilizando en el juego en ese momento. En este caso en realidad son TODOS los gráficos del juego.

Esto es lo que se conoce como "tablas de patrones", el espacio en la memoria RAM de la NES que guarda los gráficos del juego. Los de la izquierda son los sprites, como Mario y sus enemigos. Los de la derecha son los Tiles de fondo.

La mayoría de las ROMs no almacenan sus gráficos en orden, Tile Layer puede ayudarnos con eso, pero eso lo trataremos mas adelante. Ahora pulsa sobre la primera celda del lado izquierdo, la que parece que es parte de  la cabeza de Mario. Debería de aparecer algo como esto:

Editor integrado

Verás que aparece un pequeño editor donde puedes comenzar a editar los gráficos; en este caso, la parte de atrás de la cabeza de Mario. Los números Hexadecimales en la parte superior no tienen relevancia en este momento, pero nos serán de utilidad más adelante, cuando nos pongamos a editar texto.

Como podrás comprobar, el "Tile" mostrado, se compone de una cuadrícula de 8x8 píxeles y una paleta de 4 colores, mostrada en forma de cuadrícula a la derecha de la imagen (el color superior es el transparente).

Puedes pulsar con el botón derecho sobre el Tile o las tablas de patrones para cambiar los colores, aunque por lo general NESticle no muestra la paleta correcta. Lo mejor que puedes hacer es seleccionar el gráfico que deseas cambiar en la pantalla, parar el juego, entrar en las tablas de patrones y empezar a jugar con los Tiles. Podrás ver los cambios a medida que los hagas, lo que es de gran utilidad. En cuanto a la edición del Tile, basta con elegir el color haciendo click derecho sobre él y dibujando en el editor de la misma forma que harías con cualquier otro programa de dibujo.

Una vez realizados los cambios, grabaremos los cambios en la ROM. Vamos a: File - Save VROM.

Listo, ya hemos hecho nuestro primer Hack gráfico. En este caso no hemos tenido problemas, sin embargo, hay muchas ROMs que no tienen VROM, por lo que no podrás grabar los cambios realizados en NESticle. También es posible que esa maraña desordenada de Tiles te resulte demasiado confusa.

¿Qué pasa si queremos hackear un juego sin VROM, o si deseamos ver los Tiles en el mismo orden en que aparecen en el juego? En estos momentos es cuando hacemos uso de "Tile Layer".

Pack de aplicaciones: Tile Layer PRO + Nesticle 0.42

18 enero 2013


Comparte este artículo: | Menéame | Fresqui | Enchílame | Technorati |

Monkey: Matrices de dibujo

| 0 comentarios |


¡Buen día navegantes!

Viendo que despierta interés el tema de la programación con Monkey, he decidido publicar en el blog algunas de las traducciones que estoy haciendo para nuestro propio aprendizaje. Los artículos que iré publicando no seguirán un orden especifico, ya que no es mi intención crear un curso. Sin embargo, creo que os servirán de referencia para aclarar diversos temas de programación con esta herramienta.

Matrices de dibujo en Monkey

Términos utilizados:

Matrix - Un conjunto de números (organizados en filas y columnas, como una tabla o un array bidimensional)
Stack - Una pila de objetos de la que sólo se pueden agregar o quitar objetos de la parte superior.
DrawingMatrix - La matriz que influye de dibujo de gráficos.
Translate - Trasladar
IdentityMatrix - Una matriz que no altera de dibujo de gráficos.
Pop - Eliminar un objeto de la parte superior de la pila.
Push - Agregar un objeto a la parte superior de la pila.
Al dibujar gráficos con Monkey, todos los dibujos se ve influenciados por "DrawingMatrix".

DrawingMatrix consta de 6 números:
2 para sesgar gráficos
2 para escalado de gráficos
2 para la traducción de gráficos
La "IdentityMatrix" tendrá este aspecto (1,0,0,1,0,0)

Tiene una escala de 1,1 y los otros números son cero, por lo que los gráficos se dibujan en la pantalla sin cambios.

Escala

Para dibujar un cuadrado el doble de su tamaño normal se podría hacer esto en Monkey:
Scale (2,2)DrawRect (0,0,50,50)
El comando "Scale" altera los números de la escala en la matriz de dibujo.

Lo que resultaria en que el rectángulo sería generado en las coordenadas 0,0 de la pantalla con un tamaño de 100 x 100 píxeles, debido al comando de escalado.

Estos cambios son acumulativos, por lo que si haces la misma cosa dos veces, añades los números que introduciste a "DrawingMatrix".

Traslación

Hacer esto:
Translate (20,20)
Translate (20,20)
Es lo mismo que:
Translate (40,40)
La traslación también se ve afectada por la escala, por lo que dibujar un rectángulo en las coordenadas 20,30 y establecer la escala en (2,2) resultaría en el rectángulo que aparece a 40,60.

Por lo tanto, para dibujar un rectángulo en coordenadas de pantalla: 30,30
SetMatrix (1,0,0,1,0,0) 'restablece la IdentityMatrix
Translate (30,30)
DrawRect (0,0,10,10)
Giro

Para girar una imagen desde su centro tiene que asegurarse de que tiene sus puntos de anclaje en el centro.

Por ejemplo:
Local img: Image = LoadImage ("img.png")
img.SetHandle (64,64)
Si quieres rotar los gráficos que están a punto de aparecer, lo que tienes que usar es el comando "Rotate", esto altera el sesgo y la escala de la matriz para producir un efecto de rotación.

Tu le proporcionas un número al comando "Rotate" para decirle a Monkey cuántos grados deseas girar los gráficos.

Por ejemplo:
Rotate (90)
Primero tienes que trasladar la matriz a la posición donde quieres que aparezca la imagen antes de utilizar el comando "Rotate". Por lo tanto, para dibujar una imagen en las coordenadas 100 ,100 con un ángulo de 45 grados. Has de hacer algo así:
SetMatrix (1,0,0,1,0,0) ' restablecemos la matriz
Translate (100,100)
Rotate (45)
DrawImage (miImagen, 0,0)
También podemos utilizar la pila de matrices.

El comando pushMatrix() hace una copia de DrawingMatrix y la coloca en la parte superior de la pila.

La matriz "DrawingMatrix" sin embargo, no sufre cambios. EL uso de la pila es útil para cuando se desea guardar una matriz y utilizarla más tarde.

Cuando estés listo para usarla utiliza el comando popMatrix() para sustituir DrawingMatrix por la Matriz que tengas en la parte superior de la pila.

En ese momento, la matriz que tuvieras en la parte superior de la pila también se elimina de la pila.

17 enero 2013


Comparte este artículo: | Menéame | Fresqui | Enchílame | Technorati |

Hackeo de ROMS de NES: Parte I

| 1 comentarios |

Saludos lupinos.

Como cánido de mente inquieta que me considero, llevo tiempo acariciando la idea de hacer un Hack de alguna pequeña ROM de NES. El tema es que investigando por la red, he encontrado información suficiente para adentrarse en el mundillo, pero por supuesto, ni una sola palabra en castellano.

Con este propósito en mente, he pensado en que quizás os interesaría que redactara una guía para principiantes en castellano. ¿Quien sabe? si hay gente que se molesta en leernos, quizás hasta le podamos contagiar nuestras manías.

Tras considerar varias opciones, me he decidido por hacer una transcripción libre de un tutorial de Sliver X que he considerado bastante apropiado. Si leéis el original, podréis ver que aparte de traducirlo, he sido bastante mas sintético a la hora de mostrar la información. No es que las bromas o comentarios me desagradasen. Es que por una parte ahorraba tiempo traduciendo y por otra creo que os puede resultar mucho mas útil así. En mi opinión es un manual que ha de leerse varias veces y las bromas y notas a pie de página solo tienen gracia la primera vez que se leen. Dado que el documento es también bastante largo lo sacaré en varios capítulos. Calculo que a lo sumo dos o tres entradas, así que tampoco os tendré mucho tiempo esperando.

Guía esencial de Hackeo de ROMS de NES: Parte I 

Fuente original: A Beginner's Guide to NES ROM Hacking

Introducción

Hackear ROMs, es el proceso de alterar el código de una aplicación, lo que implica trabajar con los datos de una consola antigua almacenados en un sistema moderno. Estos datos los llamamos ROM (Read Only Memory, una referencia a las memorias integradas que se utilizaban en los cartuchos).

Jugar con estos datos implica el poder modificar características importantes de los juegos, como los gráficos, la paleta de colores, los sonidos e incluso el diseño de los niveles. Con los conocimientos necesarios, se pueden hacer modificaciones aún más complejas.

Sin embargo, las técnicas avanzadas van mucho mas allá del alcance de este documento; pero si quieres modificar un juego y no sabes por donde empezar, esta es la guía que necesitas.

Hablaremos del los conceptos básicos del Hackeo de ROMS para NES, empezando por lo más esencial: El sistema hexadecimal.

La notación Hexadecimal es una forma de representar los datos de manera diferente al código fuente o binario. Es un sistema de numeración en base 16, en lugar de la base 10 del sistema decimal que utilizamos en la vida cotidiana.

En primer lugar, todos los numeros se pueden considerar compuestos por dos "columnas": la columna izquierda y la columna derecha. La columna izquierda puede contar con cualquier cantidad de dígitos, mientras que la derecha solo puede contener el último dígito del numero (el que esta mas a la derecha en Decimal). Mostremos algunos ejemplos de conversión Decimal-Hexadecimal para aclarar el concepto:

7 -> 0 | 7
10 -> 1 | 0
100-> 10 | 0
3.578-> 357 | 8

Como puedes ver, cuando tratas con un número de dos dígitos, es necesario imaginar que hay un cero delante de él, por lo que continuas teniendo una columna a la izquierda.

OK, expliquemos ahora la base del concepto.

El sistema decimal tiene dígitos 0 a 9. Diez dígitos. Al contar en decimal, cuentas hasta el numero de mayor valor de un solo dígito. Si quieres contar números mas grandes, hay que añadir 1 a la columna de la izquierda, y restablecer la columna de la derecha a cero, así:

9-10, 19-20, 199-200, 9999-10000, 999999-1000000

(Recuerda que hay un cero delante del 9)

Dado que este cambio de columna siempre sucede después de una secuencia de diez números, se llama a este sistema "Decimal".

Hexadecimal, por otra parte, es un sistema en base a dieciséis números. Contiene los números del 0 al 9 como el sistema decimal, pero incluye 5 dígitos adicionales; A, B, C, D, E, y F, sumando un total de 16. Así que para llegar a un cambio de columna, hay que añadir 16 dígitos en la columna de la derecha, así:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, 10

Al principio puede parecer retorcido, pero con la práctica cobrará mas sentido. Cuando se tiene una ROM abierta en un editor Hexadecimal, no será necesario imaginar un cero delante de los números de un dígito, como hemos hecho antes. Veámos un par de ejemplos más comparando ambos sistemas numéricos:

Hexadecimal: 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16
Decimal:          00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22

Hexadecimal: 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E
Decimal:          25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 
Como no vamos a andar contando para averiguar cual es el equivalente decimal de un numero Hexadecimal, vamos a utilizar la calculadora de Windows. Sólo tienes que escribir en el número, y hacer clic en el círculo que dice Hex. Si no ves el botón, selecciona la vista de "calculadora científica".


Por si las dudas... que nadie nació aprendido.

¿Que tiene esto que ver con el Hackeo de ROMs?

Todo.

Toda la información almacenada en la memoria ROM se puede representar en Hexadecimal cuando se está editando, desde los gráficos, la música, la forma en que Mega Man se comporta al saltar... etc

Familiarizarse con la notación Hexadecimal no ayudará en gran medida con el Hackeo, tanto a nivel básico como avanzado.

Ahora que tenemos mas claro este concepto, empezemos a Hackear la ROM.

Monkey, entrenando a tu mascota

| 2 comentarios |

Desde que hace varios meses decidimos pasarnos de Game Maker a Monkey , sabiamos que no seria fácil.

La primera vez que bajamos la herramienta, nos encontramos con un IDE muy básico,


Algo curioso es que yo baje una versión con otro IDE llamado "JUNGLE" y al principio ambos veíamos cosas diferentes.

Cuando por fin ambos tuvimos la misma versión, comenzamos a experimentar.

Monkey al ser un Blitz "extendido" por asi decirlo, no tiende a tener grandes complicaciones pero su propia "politica" tal vez da algun dolor de cabeza.

Primer Hola mundo:
'Hola mundo (estos son los comentarios)
'La función main es la que comienza toda aplicación
Function Main()
'Muestra en pantalla
Print ("Hola Mundo, esto es Oniric Factor!")
'Toda función termina con un End
End
Sencillo, ¿verdad?

Pero Monkey tiene una serie de Métodos internos a los cuales nos costo adaptarnos.

OnInit : Este proceso se carga cuando inicia la aplicación.

Aquí puedes poner todo lo que quieres que se cargue cuando la aplicación se cargue a memoria.

OnUpdate: En este caso nos encontramos ante algo muy parecido al evento "step" de Game maker, ya que tiene la misma función: ejecutar su contenido en cada frame.

OnRender: Muy parecida al "Draw" de Game Maker, eso si...solo en concepto dado que el potencial de OnRender es muy superior al draw de Game Maker.

En esta función se escriben todos los algoritmos de dibujo, almacenamiento de buffer, borrados de Sprites en memoria de vídeo... etc.

OnLoading: Parecida a "OnInit" sin embargo este método carga instrucciones cuando la aplicaciones aun no esta "cargadas en memoria". Es el lugar idóneo donde colocar la típica barra de carga o imagen temporal.

Aparte estos métodos, uno puede crear los suyos, para darle las diferentes funcionalidades a los objetos y demás.

Claro que crear un método propio, si bien es fácil, no es tan fácil de implementar (y lo digo con conocimiento de causa, hay que practicar un poco)

Por otro lado estos métodos se repiten siempre en cada "class" creada.

Ademas de los métodos, también están las funciones, que junto con los métodos forman un conjunto con un gran potencial y buen rendimiento.

Con respecto a la sintaxis, aquellos que conocen Java o Basic lo encontraran sumamente fácil de aprender.

Y para aquellos que estaban programando en Blitz... encontraran mas de lo mismo pero mas bonito :D

Algunas observaciones con respecto a Monkey:

El IDE es extremadamente liviano y sencillo. Si bien se puede cambiar por otros mas completos y complejos, el que trae por defecto si bien es algo limitado en comparación con los de otras herramientas, resulta bastante sencillo de utilizar.

Algo curioso es que los "ejemplos" que vienen por defecto no están para nada pensados para "novatos" y eso tal vez es un pequeño FAIL.

Todos los que hemos probado alguna vez GM hemos realizado el ejemplo que viene por defecto del juego de clickear 2 pelotas en pantalla mientras sumas puntos... pues bueno, aquí los ejemplos son tipo "Renderización de imágenes en pantalla con una Matriz que se carga en el Buffer de video mientras se ponen en cola para hacer rotar a X grados la cara de un monito"... ??? Creánme cuando les digo que leer eso la primera vez, te dan ganas de patear la PC.

A este respecto, hay que dar gracias al bendito Fenris, el asgardiano, por conseguir el libro (de pago) que nos ayudo mas que los 20 ejemplos que vienen por defecto. De no ser así, la cosa habría sido mucho mas difícil.

En las proximas entradas iremos analizando mas a fondo a este simpatico animalillo que es Monkey.