Mensajes

Pues bien, primero tienes que leer el contenido del archivo y rellenar un array con las palabras que te vas encontrando.

Una vez tienes las palabras en el array tienes que aplicar un algoritmo de ordenación a tu elección.

Finalmente coges el array ordenado y lo almacenas en otro fichero o lo presentas por pantalla... eso a tu elección.

Te refieres a que debería haber inicializado también en la función de ArrayCreaFichero??

Si ArrayAp es un puntero tienes que reservar memoria antes de utilizarlo.

Si no son índices no los llames como tales, nos ahorramos malentendidos

El problema es que no crea el subarray desde el índice i al indice j sino que genera un array con los primeros i-j+1 elementos.

¿Puede ser que tu fallo esté relacionado con lo siguiente?

Código (c) [Seleccionar] Expandir


Array ArrayCreaAleatorio(int linf, int lsup)
{
      ArrayAp a=malloc(sizeof(ArrayRep));
      // ...
      return a;
}

Código (c) [Seleccionar] Expandir


Array ArrayCreaFichero(FILE * f)
{
      ArrayAp a;
      // ...
      return a;
}

Lo extraño es que no te salten errores de segmentación al usar memoria no inicializada.

Bueno si conozco los algoritmos basicos como el de burbuja , esos algoritmos estan
bien y ordenan como yo quiero pero mi problema principal es que quiero saber
una manera al menos un poco eficiente de saber como restaurar estas cadenas
a su forma original, y en realidad no se de que forma buscar en internet, por
algoritmos de ordenacion encuentro bastantes pero ninguno habla de restaurar
el estado original ese tipo de informacion necesito gracias

A no ser que guardes el original o mapees los resultados ( es decir, que guardes la posición que tenía cada cadena en su posición original ) te va a ser imposible restaurar la información.

Tu imagínate que tiras 6 dados... después los ordenas de menor a mayor... se te ocurre alguna forma humanamente posible de, viendo la secuencia ordenada, deducir la posición original de cada uno ?? no, verdad ?? pues eso.

A ver, efectivamente, en programación los índices empiezan por cero... por tanto el primer elemento accesible de un vector es el 0.

Esto quiere decir que tu vector va a tener la siguientes valores en los siguientes índices:

Indice: 0  1  2  3  4  5 ...
Valor:  1  2  3  4  5  6 ...

Y, como tu comentas, tanto i como j son índices ( van de 0 a n ) ...

Si tu pones:

Código (c) [Seleccionar] Expandir

for (int x=0; x<j-i+1;x++)   a2->v[x]=ap->v[i+x-1];

para i=0, x=0 tienes aw->v[0]=ap->v[0+0-1]. Estás intentando acceder a la posición -1 de ap->v.

Ese -1 te sobra, en serio.

El problema de usar qt con codeblocks es que qt usa una capa "los moc" que se genera de forma independiente y codeblocks no dispone de una forma estándar de generarlos automáticamente.

Yo hice varios intentos y que codeblocks reconozca y compile con qt no es dificil... pero tener que lanzar los moc a mano y uno a uno es un coñazo.

Vale, perdona cosas de lo tarde que es jejeje.

El problema lo tienes aqui:

Código (c) [Seleccionar] Expandir


for (int x=0; x<j-i+1;x++)   a2->v[x]=ap->v[i+x-1];

el código correcto debería ser:

Código (c) [Seleccionar] Expandir


for (int x=0; x<j-i+1;x++)   a2->v[x]=ap->v[i+x];

Si te das cuenta, x empieza en cero, luego el primer elemento a copiar i+x = 0+x = x.

Si le restas 1 y, por ejemplo, x fuese 0, entonces tendrías i+x-1 = 0+0-1 = -1 ... te saldrías del array.

se te ha olvidado indicar la función problematica... ArrayCrea.

De todas formas, si necesitas crear un array con valores de X a Y, siendo ambos variables, necesitas pasar dos argumentos a la función:

* bien los valores de inicio y de fin
* bien el valor de inicio y la longitud de la secuencia.

Si solo pasas un valor como mucho podrás alcanzar a crear una secuencia de 0 a N o algo así.

la línea en cuestión debería quedar tal que:

Código (cpp) [Seleccionar] Expandir


ArrayAp a2=ArrayCrea(i, j);

No te puedo ayudar con la función porque, como te he comentado, se te ha olvidado ponerla.

Haz ingeniería inversa al .fla
Así eran mis primeros hacks para juegos jajaja

El problema es que saber en qué posición se encuentra un elemento en un momento dado teniendo en cuenta que las animaciones flash pueden ser totalmente interactivas... suena complicado.

Tendrías que entrar en la api del visor y con saber si con un poco de suerte te ofrece ese tipo de información... me parece complicado que sea así.

Las casillas van a ser cuadradas, triangulares, pentagonales, hexagonales, ... cada tipo de casilla tendrá sus implicaciones en el algoritmo. Lo más sencillo es que las casillas sean cuadradas, así se pueden encajar en una matriz sin aplicar transformaciones.

Suponiendo que las casillas sean cuadradas... vas a permitir ataques en diagonal o solo en vertical y horizontal ?? si solo permites en vertical y horizontal el código se podría simplificar.

En el caso de que se enfrenten dos unidades aquí tienes varias opciones:

* En general podrías empezar comparando la fuerza de uno con la defensa del otro... lanzar una tirada aleatoria y comprobar quien gana... el que gana o pierde vida o directamente desaparece.

* Hay unidades especializadas en acabar con otras ? esto le tendría que reportar un bonus a su fuerza o a su defensa ( las posibilidades son amplias ) antes de realizar la tirada del combate. Esto también podría ser aplicable a bonus negativos.

* Vas a tener en cuenta la moral de las tropas ?? o algún efecto beneficioso si atacan con unidades aliadas a su lado ?? Al final esto se puede traducir en modificar los bonus de ataque y defensa.

* El terreno va a influir en el combate ?? más bonus y malus para la defensa, el ataque e incluso el movimiento... algunas unidades podrían llegar a quedar atrapadas por el terreno o incluso no podrían traspasarlo... depende de ti.

* Se van a permitir ataques a distancia ?? estos ataques normalmente deberían ser especiales ya que la unidad que ataca no puede recibir daños.

Al final el combate se puede simplificar en calcular un modificador ( bonus/malus ) para la fuerza / defensa, aplicarlos a las unidades implicadas y realizar una tirada que determine quien gane... lo que pase después ya es otra cosa.

El movimiento de tropas puede ser algo tan sencillo como que las unidades avancen hacia el enemigo que tengan más cerca primero hacia adelante ( casilllas cuadradas ) y luego, si se puede, hacia los lados o puedes intentar currarte un poco la IA para que intente atacar a los puntos debiles del enemigo.

El algoritmo de general de la batalla podría ser algo así:

* Mover tropas equipo 1
* Atacar equipo 1
* Mover tropas equipo 2
* Atacar equipo 2

Posteriormente si te ves con ganas podrías mejorarlo y que sea continuo... con tropas moviéndose mientras son atacadas y cosas así. ( Nota: esto no es tiempo real por mucho que algunos se empeñen )

Y finalmente te puedes plantear si alguno de los bandos puede rendirse en un momento dado en base al desarrollo de la batalla o si por contra se exige la destrucción total del enemigo.

La verdad es que dicho parecen cuatro tonterías que se programan en un par de horas... pero al final tiene bastante más curro.