Les dejo este ejemplo de un sistema de diálogos donde el texto viene con los detalles que se van a usar al momento (como quién habla, con qué expresión facial, color del texto, etc):
[Tienes que estar registrado y conectado para ver este vínculo]Es un zip que contiene: Un array (los diálogos), una aplicación con su respectivo .mfa y las extensiones que usa, por las dudas.
Puede que por lo extenso que me quedó el mensaje parezca complicado, puede que haya sido para hacerlo, pero para modificarlo y usarlo a nuestro antojo no es tanto.
Explico de qué va:
Al cargar el texto desde el array, selecciono los datos que quiero usar para el momento del diálogo y configurar las circunstancias desde ahí en el mismo evento donde cargo el texto al String.
Por ejemplo, el active que funciona como cara de quien esté hablando tiene la misma cantidad de frames por cada personaje que represente, por lo que queda como así:
Frame 1 = Cara naranja 
Frame 2 = Cara naranja 
Frame 3 = Cara naranja :I
Frame 4 = Cara naranja :J *con sonrisa de lado*
Frame 5 = Cara naranja :S
Frame 6 = Cara naranja >:C
Frame 7 = Cara naranja 
Frame 8 = Cara naranja ):
Frame 9 = Cara naranja D:Frame 10 = Cara gris
... como lo naranja pero gris
Frame 18 = Cara gris D:Frame 19 = Cara verde
... como lo naranja pero verde
Frame 27 = Cara verde D:Entonces en vez de un diálogo donde diría:
"Cebra: Ola ke ase."
(Suponiendo que es la cara gris :I ) se convierte en:
"-02-03-Cebra: Ola ke ase."
(los guiones los puse sólo para separar, sino al poner códigos largos se confunden)
Así en el editor de eventos le digo al active que cambie de frame con la expresión:
Val(Right$(leftstr$( "-02-03-Cebra: Ola ke ase.", 3), 2))*9-10+
Val(Right$(leftstr$( "-02-03-Cebra: Ola ke ase.", 6), 2))Con esto le digo que use el VALOR de los tres primeros caracteres como pie (el primer frame correspondiente a la cara que quiero) y le sume el VALOR que indica la expresión.
Acá lo muestro más simplificado:
[Tienes que estar registrado y conectado para ver esa imagen]Val(Right$(leftstr$( "-02-03-Cebra: Ola ke ase.", 3), 2)) = 02Val(Right$(leftstr$( "-02-03-Cebra: Ola ke ase.", 6), 2)) = 03La expresión resulta:
02 * 9 - 10 +
03Ahí se ve que multiplica el primer número del código por 9 (que es la cantidad de frames que ocupa cada cara), le resta 10 (que es la cantidad de frames que ocupa cada cara más uno, para contrarrestar el valor de base que toma) y se suma 3 (que es el número que corresponde a la expresión :I )
Si quisiéramos añadir un color le tendríamos que poner otro código más al inicio e indicarle al objeto del texto que lo tome, quedando:
"-02-03-Cebra: Ola ke ase." -> "-00000000-02-03-Cebra: Ola ke ase."
entonces quedaría:
[Tienes que estar registrado y conectado para ver esa imagen]Val(
Right$(leftstr$( "-00000000-02-03-Cebra: Ola ke ase.",
9),
)
Así toma el VALOR de los
8 de la derecha de los
9 de la izquierda.
Sé que muchos acostumbran a indicar los colores en hexadecimal, basta con pasar de hexadecimal a decimal y rellenar los demás caracteres con ceros.
Bien y ahora lo más importante, a qué es igual el texto?
Para poder usar un nombre, hay que usar una clave que al momento de que se active evento, se reemplace por el texto que vendría a ser el nombre.
Para eso usé el
String Parser, al que le doy "set source string" y toma un texto para trabajarlo. Le digo simplemente:
Set source string = "
-00000000-02-03-Cebra: Ola ke ase, .nombre.."
Y al momento de querer mostrar el texto desde el objeto String, le digo que muestre el texto de la expresión:
replace$( "String Parser", ".nombre.", "John")
Siendo ".nombre." la clave que se tiene que cambiar por el nombre y "John" el nombre puesto, así me dice "Ola ke ase, John."
El
código se resta con la expresión:
Right$(replace$( "String Parser", ".nombre.", "John"), length( "String Parser" )-16-8*numberOfSub( "String Parser", ".nombre.")+DigitosDelNombre*numberOfSub( "String Parser", ".nombre."))
Explico el choclo:
Suponiendo que llamamos
TuNombre al nombre que ponemos,
DigitosDelNombre a la cantidad de caracteres que ocupa el nombre queda y
.nombre. a la clave que se cambia por el nombre, queda:
Right$(replace$( "String Parser", ".nombre.", TuNombre), length( "String Parser" )-16-8*numberOfSub( "String Parser", ".nombre.")+DigitosDelNombre*numberOfSub( "String Parser", ".nombre."))
Que se para explicar por partes lo desarmo en renglones:
Right$(
//Toma cierta cantidad de dígitos de la derecha
replace$( "String Parser", ".nombre.", TuNombre)
//La totalidad del texto ya reemplazado
, //la coma separa la totalidad del texto, del número de dígitos que se van a tomar
length( "String Parser" )
//La totalidad del texto crudo (sin reemplazos ni nada)
-16 //La cantidad negativa de los dígitos que componen el código inicial, que en este ejemplo serían los 16 caracteres de "-00000000-02-03-", si el código fuese "-02-03-" pasaría de ser 16 a 7.
-
8*
numberOfSub( "String Parser", ".nombre.")//El producto negativo de
8 (los caracteres de la clave
.nombre.) y
numberOfSub( "String Parser", ".nombre.") (que sería la cantidad de veces que se repite la clave
.nombre. en el texto)
+DigitosDelNombre*numberOfSub( "String Parser", ".nombre.")
//Esto suma el producto de DigitosDelNombre (la longitud del nombre) y la cantidad de claves
.nombre.) //El poderoso paréntesis, sin él nos dice "sintax error", acá esto cierra el Right$( del inicio.
_.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-.Lo anterior nos deja que la cebra dice:
Cebra: Ola ke ase, John. :I
Y tiene tanto embrollo porque el choclo se asegura de que sea la cara de la cebra quien lo dice, con la expresión facial :I y el color de texto con el que quiero que lo diga. Y cada cosa más que se le quiera añadir o cambiar es posible y sencillo cambiando los valores correspondientes
Hacer que valla letra por letra no es tanto más quilombo, lo voy a explicar cambiando el choclo:
Right$(replace$( "String Parser", ".nombre.", TuNombre), length( "String Parser" )-16-8*numberOfSub( "String Parser", ".nombre.")+DigitosDelNombre*numberOfSub( "String Parser", ".nombre."))Por
"Texto mostrado"Quedaría así:
Left$(
"Texto mostrado", CaracterN( "Caritas" ))
Siendo CaracterN un alterable value del objeto "Caritas", que es quien indica qué caracter va a mostrar. Por ejemplo, si suponemos que cada vez que le damos al boton que muestra el texto, el valor de CaracterN cambia a 0, pero por otro lado le decimos que en lapsos pequeños de tiempo se añada una unidad, resultaría algo como así:
Presiono la barra espaciadora -> CaracterN = 0
Cada 10 centécimas de segundo -> CaracterN = CaracterN + 1
Y cuando le digo a la cebra que me hable, me iría mostrando el texto de acuerdo a la expresión con la que le dije que me lo muestre:
Left$(
"Texto mostrado", CaracterN( "Caritas" ))
Así que primero me muestra la primer letra del texto, después de 10 centésimas de segundo me muestra la segunda, después la tercera y así...
Así como está, el nombre del personaje también aparece por tramos
C -10ms-
e -10ms-
b -10ms-
r -10ms-
aEso se puede impedir (si así se quisiese) añadiendo
una clave más diciendo la longitud del nombre de quien está hablando:
-
07-00000000-02-03-Cebra: Ola ke ase, .nombre..
Siendo así (y habiendo actualizado correctamente las expresiones), el texto por tramos sólo empezaría desde "Ola" mientras que "Cebra: " (incluyendo el espacio) ya comenzarían visibles.
_.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-._.-´¨`-.Es todo, lamento que pueda parecer complicado, pero si revisan el .mfa y experimentan un poco se torna más fácil de lo que parece, de todas maneras ante cualquier duda respondo.
Y como siempre, espero críticas constructivas y sugerencias.
Miér Ene 22, 2014 1:02 am
