Generador de texto rotativo

Question

Estoy en proceso de crear un generador de texto rotativo. El generador combina oraciones (texto) de un número de matrices, 'ciclos' a través de ellos visualmente y los agrega. Pensé que lo mejor para crear un violín con una basic version of the generator como he construido ahora:

Explicación

El funcionamiento básico es el siguiente:

1. Las frases se definen en matrices independientes (Array1 , Array2 y Array3 en el violín)
2. Se define un segundo conjunto de matrices, que contiene las matrices que se pueden combinar (combo0 y combo1 en el violín)
3. Al pulsar el botón 'Generar', la función Generate se llama, que visualmente ciclos de las frases de una serie de frases (combo0[0] en el violín)
4. los bucles Esta función misma hasta que la sentencia ha completado un ciclo 8 veces (var times = 8 en el violín)
5. Cuando se hace esto, la función llama a la función de devolución de llamada que se proporcionó. En esta devolución de llamada, se ejecuta Generate de nuevo, esta vez con la segunda matriz (combo0[1] en el violín)

La razón de la devolución de llamada es que necesito 'espera' para el efecto de la bicicleta para completar, y luego mover en.

La cuestión

Si bien esto es exactamente lo que necesito (y además el hecho de que soy muy dudoso si esta es la manera de hacerlo, siempre me siento un poco extraño cuando se escribe una función que bucles), tengo el siguiente problema:

En las matrices combo, defino cuál de las matrices 'ora' pueden existir combinaciones posibles. Esto funciona bien si hay dos combinaciones, pero con más de dos, tengo un problema:

Generate(combo0[0], i, function(i) { //generate from first array element of combo0, callback to generating from second array of combo0 
    Generate(combo0[1], i, function(i) { 
     $('div#status').html('Done!'); //show status 
     $('input#generate').removeAttr("disabled"); //enable button 
    }); 
}) 

tendría que volver a escribir de forma recursiva esta para dar cabida a la posibilidad de una matriz combo que consiste en 3 o incluso 4 opciones. Y probablemente esto rompa la secuencia de comandos si una matriz combo contiene solo 2 (o 1) matrices.

Aquí es donde estoy atascado. El problema principal es que si recorro la matriz combo, p. con .each() ;, la función generate se llama varias veces de forma síncrona, por lo que se pierde todo el efecto de 'ciclo'.

He intentado escribir varios loops, que tienen en cuenta la longitud de la matriz dada combo, pero hoy he bloqueado más navegadores que nunca, y no sé qué hacer.

Answer 1

he conseguido solucionarlo. Algún tiempo lejos de la pantalla es algo bueno.

Lo que hice es añadir un contador de 'n' que aumenta si se alcanza el múltiplo de la variable times, haciendo que la función para continuar iteración, pero la salida (véase la tercera a la última línea) de la matriz siguiente (lists[n]) Finalmente, una comprobación para ver cuántas matrices quedan determinará si hemos terminado. Si lo hace, escriba la oración por última vez, ejecute la devolución de llamada opcional y devuelva falso. De esta manera, la función aceptará toda la matriz, y no sólo el subconjunto (combo en contraposición a combo[0]):

//Generate from array 'lists', simulating a 'slot machine 
function Generate(lists, n, i, callbackFnk) { 
    if (!(i >= 0)) { i= 0; } 
    setTimeout((function(msg){ 
     i++; 
     return function(){ 
      if (i % times != 0){ 
       //We haven't reached a multiple of the times variable yet, keep going. 
       Generate(lists, n, i, callbackFnk); 
      } else if (i % times === 0 && i != 0 && n < (lists.length-1)) { 
       //Multiple reached, increase n 
       n++; 
       Generate(lists, n, i, callbackFnk); 
      } else if (n == (lists.length-1)) { 
       //we are done as there are no more arrays to go over 
       showMessage(msg, i); 
       if (callbackFnk) callbackFnk.call(this, i); 
       return false; 
      } 
      showMessage(msg, i); 
     } 
    })(
     //output using the given n value 
     lists[n][Math.floor(Math.random() * lists[n].length)] 
    ), speed); 
} 

Ver el violín de trabajo aquí: http://jsfiddle.net/c_kick/kuNrA/1/

espero que esto ayude a los demás!

Answer 2

Esto debe hacer el truco:

var Array1 = new Array("Sentence 1 - A ", "Sentence 1 - B ", "Sentence 1 - C ", "Sentence 1 - D ", "Sentence 1 - E ", "Sentence 1 - F ", "Sentence 1 - G "); 
var Array2 = new Array("Sentence 2 - A", "Sentence 2 - B", "Sentence 2 - C", "Sentence 2 - D", "Sentence 2 - E", "Sentence 2 - F", "Sentence 2 - G"); 
var Array3 = new Array("Sentence 3 - A", "Sentence 3 - B", "Sentence 3 - C", "Sentence 3 - D", "Sentence 3 - E", "Sentence 3 - F", "Sentence 3 - G"); 

//define acceptable combinations of arrays 
var combo0 = new Array(Array1, Array2); 
var combo1 = new Array(Array1, Array2, Array3); 

//define global vars 
var speed = 140; 
var content = ''; 

//write sentence to box. If counter is a multiple of the 'times' var: append instead of write 
function showMessage(list, i, e) { 
    $('div#generated').html(content + list[i]); 
    if ((i + 1) % (e + 1) == 0) content += list[i]; 
} 

//Generate from array 'list', simulating a 'slot machine 
function Generate(lists, end, l, i, e) { 
    if (l == undefined) l = 0; 
    if (i == undefined) i = 0; 
    if (e == undefined) e = Math.floor(Math.random() * lists[l].length); 
    setTimeout(function() { 
     showMessage(lists[l], i, e); 
     if ((i + 1) % (e + 1) != 0) 
      Generate(lists, end, l, i+1, e); 
     else if (lists.length - 1 > l) 
      Generate(lists, end, l + 1); 
     else end(); 
    }, speed); 
} 

$(document).ready(function() { 
    $('input#generate').click(function() { 
     $(this).attr("disabled", true); //disable button 
     content = ''; //reset content 
     $('div#status').html('Running..'); //show status 
     Generate(combo0, function() { 
      $('div#status').html('Done!'); //show status 
      $('input#generate').removeAttr("disabled"); //enable button}); 
     }); 
    }); 
});