// Decompiled by Jad v1.5.7f. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   Boggle.java

import java.util.Random;

public class Boggle
{

    public Boggle(int i, int j)
    {
        maxSearch = 0;
        words4 = 0;
        words5 = 0;
        words6 = 0;
        words7 = 0;
        myWords4 = 0;
        myWords5 = 0;
        myWords6 = 0;
        myWords7 = 0;
        myWords4Found = 0;
        myWords5Found = 0;
        myWords6Found = 0;
        myWords7Found = 0;
        total = 0;
        myTotal = 0;
        score = 0;
        wordsToGo = 0;
        dict = new Dictionary();
        randSeed = new Random();
        rand = 0.0D;
        myWords = new String[500];
        universalCheckCode = true;
        minWordSize = i;
        boardSize = j;
        sr = new int[boardSize * boardSize + 1];
        board = new String[boardSize * boardSize + 1];
        for(n = 0; n <= boardSize * boardSize; n++)
            board[n] = "";

        resetScores();
    }

    public int getWords4()
    {
        return words4;
    }

    public int getWords5()
    {
        return words5;
    }

    public int getWords6()
    {
        return words6;
    }

    public int getWords7()
    {
        return words7;
    }

    public int getMyWords4()
    {
        return myWords4;
    }

    public int getMyWords5()
    {
        return myWords5;
    }

    public int getMyWords6()
    {
        return myWords6;
    }

    public int getMyWords7()
    {
        return myWords7;
    }

    public int getMyWords4Found()
    {
        return myWords4Found;
    }

    public int getMyWords5Found()
    {
        return myWords5Found;
    }

    public int getMyWords6Found()
    {
        return myWords6Found;
    }

    public int getMyWords7Found()
    {
        return myWords7Found;
    }

    public int getScore()
    {
        return score;
    }

    public int getTotal()
    {
        return total;
    }

    public int getMyTotal()
    {
        return myTotal;
    }

    public int getWordsToGo()
    {
        return wordsToGo;
    }

    public String getBoard(int i)
    {
        return board[i];
    }

    public void resetScores()
    {
        words4 = 0;
        words5 = 0;
        words6 = 0;
        words7 = 0;
        myWords4 = 0;
        myWords5 = 0;
        myWords6 = 0;
        myWords7 = 0;
        myWords4Found = 0;
        myWords5Found = 0;
        myWords6Found = 0;
        myWords7Found = 0;
        total = 0;
        myTotal = 0;
        score = 0;
    }

    public String taunt(double d)
    {
        if(d >= 100D)
            return "Oh, shutup. (slut)";
        if(d >= 95D)
            return "You're way too good at this, bitch!";
        if(d >= 90D)
            return "Outstanding!";
        if(d >= 85D)
            return "Excellent!";
        if(d >= 80D)
            return "Quite Impressive!";
        if(d >= 75D)
            return "Very nice!";
        if(d >= 70D)
            return "Very good!";
        if(d >= 65D)
            return "Great work!";
        if(d >= 60D)
            return "Good job!";
        if(d >= 55D)
            return "Not bad.";
        if(d >= 50D)
            return "Good.";
        if(d >= 45D)
            return "That's okay.";
        if(d >= 40D)
            return "Just okay...";
        if(d >= 35D)
            return "Pretty average....";
        if(d >= 30D)
            return "That's pretty bad...";
        if(d >= 25D)
            return "Terrible!";
        if(d >= 20D)
            return "How horrible!";
        if(d >= 15D)
            return "You really suck!";
        if(d >= 10D)
            return "Don't do drugs.";
        if(d >= 5D)
            return "You're worthless, bitch!";
        if(d >= 0.0D)
            return "I'd like to say 'I've seen worse', but....";
        else
            return "If you can read this, you cheated!";
    }

    public void addPoints(int i)
    {
        score += i;
    }

    public void addWordCount(int i)
    {
        if(i == minWordSize)
            words4++;
        else
        if(i == minWordSize + 1)
            words5++;
        else
        if(i == minWordSize + 2)
            words6++;
        else
            words7++;
        total++;
    }

    public void addMyWordCount(int i)
    {
        if(i == minWordSize)
            myWords4--;
        else
        if(i == minWordSize + 1)
            myWords5--;
        else
        if(i == minWordSize + 2)
            myWords6--;
        else
            myWords7--;
    }

    public void createBoard()
    {
        for(n = 1; n <= boardSize * boardSize; n++)
        {
            rand = randSeed.nextDouble() * 100D;
            if(rand >= 92.090000000000003D)
                board[n] = "A";
            else
            if(rand >= 90.760000000000005D)
                board[n] = "B";
            else
            if(rand >= 87D)
                board[n] = "C";
            else
            if(rand >= 82.930000000000007D)
                board[n] = "D";
            else
            if(rand >= 71.439999999999998D)
                board[n] = "E";
            else
            if(rand >= 69.379999999999995D)
                board[n] = "F";
            else
            if(rand >= 67.569999999999993D)
                board[n] = "G";
            else
            if(rand >= 64.099999999999994D)
                board[n] = "H";
            else
            if(rand >= 57.469999999999999D)
                board[n] = "I";
            else
            if(rand >= 57.439999999999998D)
                board[n] = "J";
            else
            if(rand >= 56.659999999999997D)
                board[n] = "K";
            else
            if(rand >= 52.369999999999997D)
                board[n] = "L";
            else
            if(rand >= 49D)
                board[n] = "M";
            else
            if(rand >= 42.350000000000001D)
                board[n] = "N";
            else
            if(rand >= 34.340000000000003D)
                board[n] = "O";
            else
            if(rand >= 32.020000000000003D)
                board[n] = "P";
            else
            if(rand >= 31.879999999999999D)
                board[n] = "Q";
            else
            if(rand >= 24.829999999999998D)
                board[n] = "R";
            else
            if(rand >= 18D)
                board[n] = "S";
            else
            if(rand >= 9.2200000000000006D)
                board[n] = "T";
            else
            if(rand >= 5.5599999999999996D)
                board[n] = "U";
            else
            if(rand >= 4.3499999999999996D)
                board[n] = "V";
            else
            if(rand >= 2.6699999999999999D)
                board[n] = "W";
            else
            if(rand >= 2.2999999999999998D)
                board[n] = "X";
            else
            if(rand >= 0.089999999999999997D)
                board[n] = "Y";
            else
            if(rand >= 0.0D)
                board[n] = "Z";
        }

    }

    public void findMyWords()
    {
        String s = "";
        boolean flag = false;
        myTotal = 0;
        for(int i = 0; i <= dict.getTotalWords() - 1; i++)
        {
            String s1 = dict.getWord(i);
            universalCheckCode = false;
            if(s1.length() >= minWordSize && findWord(s1) == 1)
            {
                myWords[myTotal] = s1;
                myTotal++;
                if(s1.length() == minWordSize)
                    myWords4++;
                else
                if(s1.length() == minWordSize + 1)
                    myWords5++;
                else
                if(s1.length() == minWordSize + 2)
                    myWords6++;
                else
                    myWords7++;
            }
        }

        myWords4Found = myWords4;
        myWords5Found = myWords5;
        myWords6Found = myWords6;
        myWords7Found = myWords7;
        wordsToGo = myTotal;
        universalCheckCode = true;
    }

    public void removeMyWord(String s)
    {
        boolean flag = false;
        for(int i = 0; i < myTotal; i++)
            if(myWords[i].equals(s))
            {
                myWords[i] = "";
                wordsToGo--;
                return;
            }

    }

    public String getMissedWords()
    {
        String s = "";
        boolean flag = false;
        for(int i = 0; i < myTotal; i++)
            if(!myWords[i].equals(""))
                s = s + myWords[i] + ", ";

        if(!s.equals(""))
            s = s.substring(0, s.length() - 2);
        return s;
    }

    public int findWord(String s)
    {
        s = s.toUpperCase();
        String s1 = s.substring(0, 1);
        int ai[] = new int[boardSize * boardSize + 1];
        for(n = 0; n <= boardSize * boardSize; n++)
            ai[n] = 0;

        boolean flag = false;
        cr = 0;
        for(n4 = 1; n4 <= boardSize * boardSize; n4++)
            if(board[n4].equals(s1))
            {
                ai[0] = n4;
                cr++;
                if(perfectSearch(s.substring(1, s.length()), ai, sr, 0, n4, 0))
                {
                    flag = true;
                    n4 = 9999;
                }
                cr = 0;
            }

        if(!flag)
            return 0;
        if(!universalCheckCode)
        {
            universalCheckCode = true;
            return 1;
        }
        return !dict.isWord(s) ? 2 : 1;
    }

    public boolean perfectSearch(String s, int ai[], int ai1[], int i, int j, int k)
    {
        if(s.length() <= 0)
            return true;
        String s1 = s.substring(0, 1);
        boolean flag = false;
        boolean flag1 = false;
        i = 0;
        ai1 = new int[boardSize * boardSize + 1];
        for(n3 = 0; n3 <= boardSize * boardSize; n3++)
            ai1[n3] = 0;

        for(n3 = 0; n3 < 8; n3++)
        {
            int l = isLinkedTo(s1, j, ai1, ai);
            if(l > 0)
            {
                ai1[i] = l;
                i++;
            }
        }

        for(k = 0; k < i; k++)
        {
            j = ai1[k];
            ai[cr] = j;
            cr++;
            boolean flag2 = perfectSearch(s.substring(1, s.length()), ai, ai1, i, j, k);
            if(flag2)
                return true;
            cr--;
            ai[cr] = 0;
        }

        return false;
    }

    public int isLinkedTo(String s, int i, int ai[], int ai1[])
    {
        boolean flag = false;
        boolean flag1 = false;
        boolean flag2 = false;
        boolean flag3 = false;
        boolean flag4 = false;
        if(i <= boardSize)
            flag = true;
        if((i - 1) % boardSize == 0)
            flag1 = true;
        if(i % boardSize == 0)
            flag2 = true;
        if(i > boardSize * (boardSize - 1))
            flag3 = true;
        if(!flag)
        {
            if(!flag1)
            {
                int j = i - boardSize - 1;
                if(board[j].equals(s) && isNotRestricted(j, ai, ai1))
                    return j;
            }
            int k = i - boardSize;
            if(board[k].equals(s) && isNotRestricted(k, ai, ai1))
                return k;
            if(!flag2)
            {
                int l = (i - boardSize) + 1;
                if(board[l].equals(s) && isNotRestricted(l, ai, ai1))
                    return l;
            }
        }
        if(!flag1)
        {
            int i1 = i - 1;
            if(board[i1].equals(s) && isNotRestricted(i1, ai, ai1))
                return i1;
        }
        if(!flag2)
        {
            int j1 = i + 1;
            if(board[j1].equals(s) && isNotRestricted(j1, ai, ai1))
                return j1;
        }
        if(!flag3)
        {
            if(!flag1)
            {
                int k1 = (i + boardSize) - 1;
                if(board[k1].equals(s) && isNotRestricted(k1, ai, ai1))
                    return k1;
            }
            int l1 = i + boardSize;
            if(board[l1].equals(s) && isNotRestricted(l1, ai, ai1))
                return l1;
            if(!flag2)
            {
                int i2 = i + boardSize + 1;
                if(board[i2].equals(s) && isNotRestricted(i2, ai, ai1))
                    return i2;
            }
        }
        return -1;
    }

    public boolean isNotRestricted(int i, int ai[], int ai1[])
    {
        for(n = 0; n <= boardSize * boardSize; n++)
            if(ai[n] == i || ai1[n] == i)
                return false;

        return true;
    }

    private int n;
    private int n2;
    private int n3;
    private int n4;
    int maxSearch;
    private static int cr = 0;
    private int words4;
    private int words5;
    private int words6;
    private int words7;
    private int myWords4;
    private int myWords5;
    private int myWords6;
    private int myWords7;
    private int myWords4Found;
    private int myWords5Found;
    private int myWords6Found;
    private int myWords7Found;
    private int total;
    private int myTotal;
    private int score;
    private int wordsToGo;
    public Dictionary dict;
    private Random randSeed;
    private double rand;
    private String myWords[];
    private boolean universalCheckCode;
    private int minWordSize;
    private int boardSize;
    int sr[];
    private String board[];

}