private Letter createGridLetter(ABCChar charInfo)
{
Letter letter = getNewEmptyGridLetter();
letter.initializeFromABCChar(charInfo);
letter.updateTexts();
letter.updateSprite();
return(letter);
}
public void initializeFromABCChar(ABCChar abc)
{
abcChar = new ABCChar();
abcChar.wildcard = abc.wildcard;
abcChar.character = abc.character;
abcChar.value = abc.value;
abcChar.used = abc.used;
abcChar.pointsOrMultiple = abc.pointsOrMultiple;
abcChar.typeInfo = abc.typeInfo;
type = (EType)abcChar.typeInfo;
if (abcChar.character == ".")
{
//abcChar.wildcard = true;
}
}
/**
* CSV
* cantidad_letra_puntos/multiplo_tipo
* ej. 02_A_1_1,10_B_x2_1
**/
protected List <ABCChar> getLettersInfoFromCSV(string csv)
{
List <ABCChar> result = new List <ABCChar>();
string[] info = csv.Split(',');
string[] infoFragments;
int amount;
string abc;
string points_multiplier;
int type;
ABCChar abcChar;
if (wordsValidator == null)
{
wordsValidator = PersistentData.GetInstance().abcDictionary;
}
for (int i = 0; i < info.Length; i++)
{
infoFragments = info[i].Split('_');
amount = int.Parse(infoFragments[0]);
abc = infoFragments[1];
points_multiplier = infoFragments[2];
type = int.Parse(infoFragments[3]);
for (int j = 0; j < amount; j++)
{
//letter = new ABCCharinfo();
abcChar = new ABCChar();
abcChar.character = abc;
abcChar.pointsOrMultiple = points_multiplier;
abcChar.typeInfo = type;
abcChar.value = wordsValidator.getCharValue(abc);
result.Add(abcChar);
}
}
return(result);
}
public Letter getWildcard(string pointsOrMultiple)
{
Letter letter = Instantiate(letterPrefab).GetComponent <Letter>();
string wildcardValue = ".";
ABCChar abc = new ABCChar();
abc.value = wordsValidator.getCharValue(wildcardValue);
abc.wildcard = false;
abc.character = wildcardValue;
abc.pointsOrMultiple = pointsOrMultiple;
letter.type = Letter.EType.WILD_CARD;
letter.updateSprite();
letter.abcChar = abc;
letter.updateTexts();
letter.wildCard = true;
return(letter);
}
public void setValuesToWildCard(Letter wildCard, string character)
{
ABCChar abc = new ABCChar();
abc.wildcard = false;
abc.character = character;
abc.pointsOrMultiple = "x3";
abc.value = wordsValidator.getCharValue(character);
wildCard.wildCard = true;
wildCard.initializeFromABCChar(abc);
wildCard.type = Letter.EType.WILD_CARD;
wildCard.updateTexts();
wildCard.updateSprite();
saveAndValidateLetter(wildCard);
resetValidationToSiblingOrder();
afterWordValidation();
}
protected void fillContainer(List <ABCUnit> alphabet)
{
for (int i = 0; i < alphabet.Count; i++)
{
Letter clone = Instantiate(letterPrefab).GetComponent <Letter>();
keys.Add(clone.GetComponent <RectTransform>());
ABCChar abcChar = new ABCChar();
abcChar.character = alphabet [i].cvalue.ToString();
abcChar.value = alphabet [i].ivalue;
clone.abcChar = abcChar;
clone.updateTexts();
addLetterToContainer(clone);
addButton(clone);
}
Invoke("removeGridContainerAndMoveAnchors", 0.1f);
}
/**
* Hace un chequeo de los niveles de busqueda hacia atras exclusivamente
* para mover los comodines hacia un estado donde se admita charToValidate.
*
* Si no existe ningun estado valido entonces devuelve todos los comodines al ultimo estado
* activo.
*
*
* @return true si el caracter es valido. false si el caracter es invalido
* */
protected bool checkBackwardsForWildcardOptions(ABCChar charToValidate)
{
int i = levelsOfSearch.Count;
ABCNode tmp = null;
List <ABCNode> copy = new List <ABCNode>(levelsOfSearch);
while (--i >= 0)
{
//Buscamos un comodin
if (levelsOfSearch[i].wildcard)
{
int childrenCount = levelsOfSearch[i].children.Count;
//Guardamos el estado actual
levelsOfSearch[i].lastCorrectValue = levelsOfSearch[i].wildcardIndex;
List <ABCNode> partialChain = levelsOfSearch.GetRange(i + 1, levelsOfSearch.Count - (i + 1));
List <ABCNode> partialResult;
for (int j = levelsOfSearch[i].wildcardIndex + 1; j < childrenCount; j++)
{
//Este nuevo comodin es valido?
levelsOfSearch[i].wildcardIndex = j;
levelsOfSearch[i].value = levelsOfSearch[i].children[levelsOfSearch[i].wildcardIndex].value;
if (partialChain.Count > 0)
{
partialResult = getCorrectChain(levelsOfSearch[i].children[j], partialChain);
//Se encontro una cadena valida
if (partialResult != null)
{
//Contiene el caracter a validar?
if (partialResult[partialResult.Count - 1].wildcard)
{
tmp = partialResult[partialResult.Count - 1].children[partialResult[partialResult.Count - 1].wildcardIndex].children.Find(item => item.value == charToValidate.value);
}
else
{
tmp = partialResult[partialResult.Count - 1].children.Find(item => item.value == charToValidate.value);
}
}
}
else
{
//No hay nadie debajo y lo validamos directamente a este nodo
tmp = levelsOfSearch[i].children[levelsOfSearch[i].wildcardIndex].children.Find(item => item.value == charToValidate.value);
}
//Existe charToValidate al final de la cadena
if (tmp != null)
{
//LISTO tenemos el valor como debe ser
levelsOfSearch[i].lastCorrectValue = levelsOfSearch[i].wildcardIndex;
levelsOfSearch.Add(tmp);
currentValidationNode = tmp;
return(true);
}
}
}
}
//Fue invalido hay que devolver el estado original los comodines
i = copy.Count;
while (--i >= 0)
{
//Buscamos un comodin
if (copy[i].wildcard)
{
copy[i].wildcardIndex = copy[i].lastCorrectValue;
if (i == 0)
{
copyListToOnlyMutableList <ABCNode>(copy[i].children, root.children);
}
else
{
copyListToOnlyMutableList <ABCNode>(copy[i].children, copy[i - 1].children);
}
copy[i].value = copy[i].children[copy[i].wildcardIndex].value;
}
}
return(false);
}
/**
* @return true: Si el caracter es parte de una palabra
**/
public bool validateChar(ABCChar c)
{
ABCNode tmp = null;
//Aumentamos el conteo de niveles de busqueda
levelsCount++;
if (isValid)
{
if (c.wildcard)
{
int cant = currentValidationNode.wildcard ?
currentValidationNode.children[currentValidationNode.wildcardIndex].children.Count
: currentValidationNode.children.Count;
if (cant > 0)
{
//El comodin no es parte del arbol es un nodo puntero
//Es igual a algun nodo y referencia sus hijos asi se maneja externamente
ABCNode wildcard = new ABCNode();
wildcard.wildcard = true;
wildcard.wildcardIndex = 0;
if (currentValidationNode.wildcard)
{
copyListToOnlyMutableList <ABCNode>(wildcard.children, currentValidationNode.children[currentValidationNode.wildcardIndex].children);
}
else
{
copyListToOnlyMutableList <ABCNode>(wildcard.children, currentValidationNode.children);
}
//Valor al que apunta el comodin
wildcard.value = wildcard.children[wildcard.wildcardIndex].value;
c.value = wildcard.value;
//TODO: Validar si se completa palabra (no por ser comodin es valida la busqueda)
//Correcto sin validacion ya que es comodin
currentValidationNode = wildcard;
levelsOfSearch.Add(wildcard);
isValid = true;
}
else
{
//Se estan agregando caracteres de mas
//checamos si moviendo comodines
isValid = checkBackwardsForWildcardOptions(c);
}
}
else
{
//Buscamos en el nivel actual si existe el caracter que se pide
if (currentValidationNode.wildcard)
{
//Si es comodin busca en la lista que el comodin apunta en este momento
tmp = currentValidationNode.children[currentValidationNode.wildcardIndex].children.Find(item => item.value == c.value);
}
else
{
//Busqueda directa en el nodo
tmp = currentValidationNode.children.Find(item => item.value == c.value);
}
if (tmp != null)
{
//Si existe!!
//Guardamos el nuevo nivel de busqueda
currentValidationNode = tmp;
levelsOfSearch.Add(tmp);
isValid = true;
}
else
{
//No existe!!
//checamos si moviendo comodines
isValid = checkBackwardsForWildcardOptions(c);
}
}
return(isValid);
}
//Invalido por default
isValid = false;
return(isValid);
}
