problema con juego de palabras

[aguml]

Al final lo hice asi:

Código C:

/******************************************************************************
* Este juego busca una palabra de 4 letras, te la muestra desordenada y te    *
* pide que la adivines.                                                       *
* Una vez que la adivines busca una palabra en otro archivo que tenga una     *
* letra mas y que contenga todas las letras de la anterior.                   *
* El juego sigue igual hasta que adivines la palabra de 9 caracteres y en ese *
* momento empieza de nuevo con otra palabra de 4 que escogera al azar del     *
* archivo.                                                                    *
*******************************************************************************/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define MIN_LEVEL 4
#define MAX_LEVEL 9
#define SIZE 10
//-----------------------------------------------------------------------------
 
//Estructuras necesarias para obtener y almacenar una combinacion de palabras válida
typedef struct PALABRA{
   char Palabra[SIZE];
   int PosCaracterExtra;
}Palabra;
 
typedef struct LISTA_PALABRAS{
   Palabra *Palabras;
   int nEncontradas;
}ListaPalabras;
 
typedef struct COMBINACION{
   Palabra cuatroLetras;
   ListaPalabras cincoLetras;
   ListaPalabras seisLetras;
   ListaPalabras sieteLetras;
   ListaPalabras ochoLetras;
   ListaPalabras nueveLetras;
}Combinacion;
//-----------------------------------------------------------------------------
 
//Prototipos de funciones
int SearchCombination(Palabra CombRes[6],char **palabra,int nElementos);
int SearchFirstWord(char *nameFile,char *word);
int SearchNextWords(char *word,int length,ListaPalabras *Lista);
int ShowFirst(char *word);
void ShowMask(char *word,int length,int posCharExtra,int nCaracteresAMostrar);
void RandomCharsOfWord(char *word,char *result,int length);
void EliminarPalabra(ListaPalabras *Lista,int pos);
int ObtenerListaInicial(char *nameFile,char **palabra,int *nElementos);
void BarajarListaInicial(char **lista,int nElementos);
char** AsignarMemoriaLista(char *nameFile, int *nPalabras,int *Error);
void LiberarMemoriaLista(char **lista, int nPalabras);
void Jugar(char **lista,int nPalabras);
//-----------------------------------------------------------------------------
 
int main()
{
   char **listaPalabras4Letras;
   char nameFile[]="4_Letras.txt";
   int Error,nPalabras;
 
   listaPalabras4Letras=AsignarMemoriaLista(nameFile,&nPalabras,&Error);
 
   switch(Error){
      case 0:
         srand(time(NULL));
         ObtenerListaInicial(nameFile,listaPalabras4Letras,&nPalabras);
         Jugar(listaPalabras4Letras,nPalabras);
         printf("Gracias por haber jugado.\n");
         system("PAUSE");
      break;
 
      case -1:
         printf("No se pudo abrir el archivo.\n");
      break;
 
      case -2:
         printf("No hay memoria suficiente.\n");
      break;
 
      default:
         printf("Error desconocido.\n");
   }
   return 0;
}
//-----------------------------------------------------------------------------
 
//Se encarga de ejecutar el juego
void Jugar(char **lista,int nPalabras)
{
   char entrada[SIZE];
   int largo,i,x,pistas=0,salir=0;
   Palabra CombResult[6]={0};
 
   if(SearchCombination(CombResult,lista,nPalabras)){
      srand(time(NULL));
      ShowFirst(CombResult[0].Palabra);
      largo=MIN_LEVEL;
      i=0;
 
      do{
         printf("Adivina la palabra: ");
         scanf("%s",entrada);
         for(x=0;x<strlen(entrada);x++)
            entrada[x]=toupper(entrada[x]);
         if(strcmp(entrada,"0")==0)
            salir=1;
         else if(strcmp(entrada,"1") == 0){
            if((largo == MIN_LEVEL && pistas < largo) || (largo > MIN_LEVEL && pistas<largo-1))
               pistas++;
            ShowMask(CombResult[i].Palabra,largo,CombResult[i].PosCaracterExtra,pistas);
         }else if(strcmp(CombResult[i].Palabra,entrada) != 0){
            printf("Nooop\n");
         }else{
            pistas=0;
            printf("Correcto!\n");
            if(largo==MAX_LEVEL){
               system("PAUSE");
               system("CLS");
               largo=MIN_LEVEL;
               if(SearchCombination(&CombResult[0],lista,nPalabras)){
                  i=0;
                  ShowFirst(CombResult[i].Palabra);
               }else{
                  printf("Huvo un error al obtener la siguiente palabra. El programa finalizara.\n");
                  break;
               }
            }else{
               i++;
               largo++;
               printf("La siguiente es: ");
               ShowMask(CombResult[i].Palabra,largo,CombResult[i].PosCaracterExtra,0);
            }
         }
      }while(salir == 0);
      LiberarMemoriaLista(lista,nPalabras);
   }else{
      printf("No existen combinaciones validas.\n");
   }
}
//-----------------------------------------------------------------------------
 
//Asigna a un array bidimensional char** la memoria necesaria para almacenar todas las
//palabras del archivo indicado y retorna la direccion del array
char** AsignarMemoriaLista(char *nameFile, int *nPalabras,int *Error)
{
   FILE *archivo;
   char **lista=NULL;
   int i;
 
   archivo=fopen(nameFile,"r");
 
   if(archivo != NULL){
      fseek(archivo,0,SEEK_END);
      *nPalabras=ftell(archivo)/SIZE;
      lista=(char**)malloc(*nPalabras*sizeof(char*));
      if(lista != NULL){
         for(i=0;i < *nPalabras;i++){
            lista[i]=(char*)malloc(SIZE);
            if(lista[i] == NULL)
               break;
         }
         if(i!=*nPalabras){
            *Error=-2;
            LiberarMemoriaLista(lista,*nPalabras);
         }else
            *Error=0;
      }else{
         *Error=-2;
      }
   }else{
      *Error=-1;
   }
   return lista;
}
//-----------------------------------------------------------------------------
 
//Libera la memoria que se reservó para meter las palabras del archivo en memoria
void LiberarMemoriaLista(char **lista, int nPalabras)
{
   int i;
 
   for(i=0;lista[i]!=NULL && i < nPalabras;i++)
      free(lista[i]);
   free(lista);
}
//-----------------------------------------------------------------------------
 
//Baraja los punteros del array al azar para poder tenerlos desordenados
void BarajarListaInicial(char **lista,int nElementos)
{
   int i,pos;
   char *aux;
 
   for(i=0;i<nElementos;i++){
      pos=rand()%nElementos;
      aux=lista[i];
      lista[i]=lista[pos];
      lista[pos]=aux;
   }
}
//-----------------------------------------------------------------------------
 
//Rellena el array bidimensional con todas las palabras del archivo indicado
int ObtenerListaInicial(char *nameFile,char **palabra,int *nElementos)
{
   int i=0,retval,posPalabra;
   FILE *archivo;
 
   archivo=fopen(nameFile,"r");
   if(archivo != NULL){
      do{
         retval=fread(palabra[i],SIZE,1,archivo);
         if(retval != 1)
            break;
         i++;
      }while(!feof(archivo) && retval != 0);
      if(i==*nElementos)
         retval=1;
      fclose(archivo);
   }else{
      retval=-1;
   }
   return retval;
}
 

Funcionar funciona pero me gustaria que si pudieran echarle un vistazo y me dijeran si hago alguna burrada que no vea yo para corregirlo y asi aprendo algo mas.
Muchas gracias por toda la ayuda.