/** * Searches through the dictionary, and determines which words can be made using the available * letters. * * @return An array containing all of the words that can be made using the letters on the * opponents rack, and on the board/ */ public ArrayList<String> getDictWords() throws FileNotFoundException { Dictionary dict = new Dictionary(); ArrayList<String> words = dict.getWords(); ArrayList<String> dictWords = new ArrayList(); ArrayList<String> dictWords2 = new ArrayList(); ArrayList<Character> currentRack = new ArrayList(); int charCount = 0; // This variable keeps track of how many characters the rack contains that are in the // current word ArrayList<Character> lettersOnBoard = getAvailableLetters(); boolean continuer = true, breaker = false, doubleLetter = false, missingLetterOnBoard = false, breaker2 = false; char missingLetter = '!'; int yzNum = 0; for (int yz = 0; yz < lettersOnBoard.size(); yz++) { if (lettersOnBoard.get(yz) == 'z') { yzNum = 0; break; } if (yz == lettersOnBoard.size() - 1) { yzNum = words.size() - 78958; } } for (int yz = 0; yz < enemyRack.size(); yz++) { if (enemyRack.get(yz) == 'z') { yzNum = 0; break; } } for (int yz = 0; yz < lettersOnBoard.size(); yz++) { if (lettersOnBoard.get(yz) == 'y') { yzNum = yzNum; break; } if (yz == lettersOnBoard.size() - 1) { yzNum = words.size() - 78502; } } for (int yz = 0; yz < enemyRack.size(); yz++) { if (enemyRack.get(yz) == 'y') { yzNum = 0; break; } } for (int x = 0; x < words.size() - yzNum; x++) { if (words.get(x).length() > 7) continue; missingLetter = '!'; charCount = 0; continuer = true; breaker = false; breaker2 = false; doubleLetter = false; missingLetterOnBoard = false; for (int z = 0; z < words.get(x).length(); z++) { for (int w = 0; w < lettersOnBoard.size(); w++) { if (words.get(x).charAt(z) == lettersOnBoard.get(w)) { breaker = true; continuer = false; break; } } if (breaker) break; } if (continuer) continue; currentRack = new ArrayList(); for (int lol = 0; lol < enemyRack.size(); lol++) currentRack.add(enemyRack.get(lol)); // System.out.println(words.get(x)); for (int check = 0; check < words.get(x).length(); check++) { for (int y = 0; y < currentRack.size(); y++) { if (currentRack.get(y) == words.get(x).charAt(check)) { charCount++; currentRack.remove(y); break; } else continue; } // end current tile loop if (check == 7) break; } // end current word loop for (int v = 0; v < words.get(x).length(); v++) { for (int count2 = 0; count2 < enemyRack.size(); count2++) { if (words.get(x).charAt(v) == enemyRack.get(count2)) { break; } if (count2 == enemyRack.size() - 1) { missingLetter = words.get(x).charAt(v); breaker2 = true; break; } } if (breaker2) break; } for (int yetAnotherCount = 0; yetAnotherCount < lettersOnBoard.size(); yetAnotherCount++) { if (lettersOnBoard.get(yetAnotherCount) == missingLetter) { missingLetterOnBoard = true; break; } } // System.out.print(missingLetterOnBoard); if (charCount == words.get(x).length() - 1 && missingLetterOnBoard) { // System.out.print("ML: " + missingLetter + "| " ); // System.out.println(words.get(x) + " " + charCount + " | "); if (dictWords.isEmpty() == false) { if (getScore(words.get(x), false) >= getScore(dictWords.get(0), false)) dictWords.add(0, words.get(x)); else dictWords.add(words.get(x)); } else { dictWords.add(words.get(x)); } } /*else if(charCount==words.get(x).length()) dictWords.add(words.get(x));*/ else continue; } // end main for loop // System.out.println(dictWords.toString() + " " + dictWords.size()); System.out.print("Enemy rack: " + enemyRack.toString()); if (dictWords.size() == 0) { throwAwayEnemyRack(); return getDictWords(); } else return dictWords; }
/** * Returns a list of words that match the list of character codes passed in. This list will be * overwritten the next time this function is called. * * @param view a view for retrieving the context for AutoText * @param wordComposer contains what is currently being typed * @param prevWordForBigram previous word (used only for bigram) * @return list of suggestions. */ public List<CharSequence> getSuggestions( View view, WordComposer wordComposer, boolean includeTypedWordIfValid, CharSequence prevWordForBigram) { LatinImeLogger.onStartSuggestion(prevWordForBigram); mHaveCorrection = false; mIsFirstCharCapitalized = wordComposer.isFirstCharCapitalized(); mIsAllUpperCase = wordComposer.isAllUpperCase(); collectGarbage(mSuggestions, mPrefMaxSuggestions); Arrays.fill(mPriorities, 0); Arrays.fill(mNextLettersFrequencies, 0); // Save a lowercase version of the original word mOriginalWord = wordComposer.getTypedWord(); if (mOriginalWord != null) { final String mOriginalWordString = mOriginalWord.toString(); mOriginalWord = mOriginalWordString; mLowerOriginalWord = mOriginalWordString.toLowerCase(); // Treating USER_TYPED as UNIGRAM suggestion for logging now. LatinImeLogger.onAddSuggestedWord( mOriginalWordString, Suggest.DIC_USER_TYPED, Dictionary.DataType.UNIGRAM); } else { mLowerOriginalWord = ""; } if (wordComposer.size() == 1 && (mCorrectionMode == CORRECTION_FULL_BIGRAM || mCorrectionMode == CORRECTION_BASIC)) { // At first character typed, search only the bigrams Arrays.fill(mBigramPriorities, 0); collectGarbage(mBigramSuggestions, PREF_MAX_BIGRAMS); if (!TextUtils.isEmpty(prevWordForBigram)) { CharSequence lowerPrevWord = prevWordForBigram.toString().toLowerCase(); if (mMainDict.isValidWord(lowerPrevWord)) { prevWordForBigram = lowerPrevWord; } if (mUserBigramDictionary != null) { mUserBigramDictionary.getBigrams( wordComposer, prevWordForBigram, this, mNextLettersFrequencies); } if (mContactsDictionary != null) { mContactsDictionary.getBigrams( wordComposer, prevWordForBigram, this, mNextLettersFrequencies); } if (mMainDict != null) { mMainDict.getBigrams(wordComposer, prevWordForBigram, this, mNextLettersFrequencies); } char currentChar = wordComposer.getTypedWord().charAt(0); char currentCharUpper = Character.toUpperCase(currentChar); int count = 0; int bigramSuggestionSize = mBigramSuggestions.size(); for (int i = 0; i < bigramSuggestionSize; i++) { if (mBigramSuggestions.get(i).charAt(0) == currentChar || mBigramSuggestions.get(i).charAt(0) == currentCharUpper) { int poolSize = mStringPool.size(); StringBuilder sb = poolSize > 0 ? (StringBuilder) mStringPool.remove(poolSize - 1) : new StringBuilder(getApproxMaxWordLength()); sb.setLength(0); sb.append(mBigramSuggestions.get(i)); mSuggestions.add(count++, sb); if (count > mPrefMaxSuggestions) break; } } } } else if (wordComposer.size() > 1) { // At second character typed, search the unigrams (scores being affected by bigrams) if (mUserDictionary != null || mContactsDictionary != null) { if (mUserDictionary != null) { mUserDictionary.getWords(wordComposer, this, mNextLettersFrequencies); } if (mContactsDictionary != null) { mContactsDictionary.getWords(wordComposer, this, mNextLettersFrequencies); } if (mSuggestions.size() > 0 && isValidWord(mOriginalWord) && (mCorrectionMode == CORRECTION_FULL || mCorrectionMode == CORRECTION_FULL_BIGRAM)) { mHaveCorrection = true; } } mMainDict.getWords(wordComposer, this, mNextLettersFrequencies); if ((mCorrectionMode == CORRECTION_FULL || mCorrectionMode == CORRECTION_FULL_BIGRAM) && mSuggestions.size() > 0) { mHaveCorrection = true; } } if (mOriginalWord != null) { mSuggestions.add(0, mOriginalWord.toString()); } // Check if the first suggestion has a minimum number of characters in common if (wordComposer.size() > 1 && mSuggestions.size() > 1 && (mCorrectionMode == CORRECTION_FULL || mCorrectionMode == CORRECTION_FULL_BIGRAM)) { if (!haveSufficientCommonality(mLowerOriginalWord, mSuggestions.get(1))) { mHaveCorrection = false; } } if (mAutoTextEnabled) { int i = 0; int max = 6; // Don't autotext the suggestions from the dictionaries if (mCorrectionMode == CORRECTION_BASIC) max = 1; while (i < mSuggestions.size() && i < max) { String suggestedWord = mSuggestions.get(i).toString().toLowerCase(); CharSequence autoText = AutoText.get(suggestedWord, 0, suggestedWord.length(), view); // Is there an AutoText correction? boolean canAdd = autoText != null; // Is that correction already the current prediction (or original word)? canAdd &= !TextUtils.equals(autoText, mSuggestions.get(i)); // Is that correction already the next predicted word? if (canAdd && i + 1 < mSuggestions.size() && mCorrectionMode != CORRECTION_BASIC) { canAdd &= !TextUtils.equals(autoText, mSuggestions.get(i + 1)); } if (canAdd) { mHaveCorrection = true; mSuggestions.add(i + 1, autoText); i++; } i++; } } removeDupes(); return mSuggestions; }