// 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:   Brain.java

import java.awt.*;
import java.io.PrintStream;
import java.util.Vector;

class Brain extends ScrambleSettings
{

    int letterValue(char c)
    {
        if(c == '_')
            return letterPointValues[26];
        else
            return letterPointValues[c - 97];
    }

    public Brain(Scramble scramble)
    {
        hand = ' ';
        tradedLetters = new Vector();
        currentWord = new Vector();
        wordLocations = new Vector();
        words = new Vector();
        firstMove = true;
        turnOver = false;
        gameOver = false;
        tradingLetters = false;
        goOuter = -1;
        winner = -1;
        justTraded = false;
        messenger = scramble;
        numberPlayers = messenger.numberPlayers;
        playerLetters = new char[numberPlayers][7];
        for(int i = 0; i < numberPlayers; i++)
        {
            messenger.letters.setPlayer(i);
            for(int j = 0; j < 7; j++)
            {
                playerLetters[i][j] = messenger.drawBag.getLetter();
                messenger.letters.setLetter(playerLetters[i][j], j);
            }

        }

        messenger.nameBoard.setLettersLeft(messenger.drawBag.lettersLeft());
    }

    void cleanUp()
    {
        int i = -1;
        if(tradingLetters)
        {
            doneTradingLetters();
            return;
        }
        while(currentWord.size() != 0) 
        {
            Point point = (Point)currentWord.elementAt(0);
            char c = letters[point.x][point.y];
            for(int j = 0; i == -1; j++)
                if(playerLetters[messenger.currentPlayer][j] == ' ')
                    i = j;

            letters[point.x][point.y] = ' ';
            messenger.board.place(' ', point);
            currentWord.removeElement(point);
            playerLetters[messenger.currentPlayer][i] = c;
            messenger.letters.setLetter(c, i);
            i = -1;
        }
        if(hand != ' ')
        {
            for(int k = 0; i == -1; k++)
                if(playerLetters[messenger.currentPlayer][k] == ' ')
                    i = k;

            System.out.println(i);
            playerLetters[messenger.currentPlayer][i] = hand;
            messenger.letters.setLetter(hand, i);
            putDown();
            hand = ' ';
        }
        if(emptyLetters(messenger.currentPlayer))
            gameOver = true;
        turnOver = true;
    }

    int[] addUpLeftOvers()
    {
        int ai[] = new int[numberPlayers];
        for(int i = 0; i < numberPlayers; i++)
        {
            for(int j = 0; j < 7; j++)
                if(playerLetters[i][j] != ' ')
                    ai[i] += letterValue(playerLetters[i][j]);

        }

        return ai;
    }

    void endGame()
    {
        for(byte byte0 = 0; byte0 < numberPlayers; byte0++)
            if(allPassed[byte0] = false)
                goOuter = byte0;

        int ai[] = addUpLeftOvers();
        if(goOuter != -1)
        {
            for(byte byte1 = 0; byte1 < numberPlayers; byte1++)
            {
                playerScores[goOuter] += ai[byte1];
                messenger.nameBoard.changeScore(goOuter, playerScores[goOuter], playerLetters[goOuter]);
            }

        }
        for(byte byte2 = 0; byte2 < numberPlayers; byte2++)
        {
            playerScores[byte2] -= ai[byte2];
            messenger.nameBoard.changeScore(byte2, playerScores[byte2], playerLetters[byte2]);
        }

        winner = 0;
        for(byte byte3 = 0; byte3 < numberPlayers; byte3++)
            if(playerScores[byte3] > playerScores[winner])
                winner = byte3;

        winners[winner] = true;
        for(int j = 0; j < numberPlayers; j++)
            if(playerScores[j] == playerScores[winner])
                winners[j] = true;

        if(tie())
        {
            int i = ai[winner];
            for(byte byte4 = 0; byte4 < numberPlayers; byte4++)
                if(winners[byte4] && i != ai[byte4])
                    if(i < ai[byte4])
                        winners[byte4] = false;
                    else
                    if(winners[byte4] = true)
                    {
                        winners[winner] = false;
                        winner = byte4;
                    }

        }
        if(tie())
        {
            messenger.declareTie(winners, playerScores[winner]);
            return;
        } else
        {
            messenger.declareWinner(winner, playerScores[winner]);
            return;
        }
    }

    boolean tie()
    {
        for(int i = 0; i < numberPlayers; i++)
            if(winners[i])
            {
                for(int j = i + 1; j < numberPlayers; j++)
                    if(winners[j])
                        return true;

            }

        return false;
    }

    public boolean turnOver()
    {
        return turnOver;
    }

    public boolean gameOver()
    {
        return gameOver;
    }

    public boolean canMove(int i)
    {
        if(skipNextTurn[i])
        {
            skipNextTurn[i] = false;
            return false;
        } else
        {
            return true;
        }
    }

    public int optionAvailable()
    {
        if(tradingLetters)
            return !tradedLetters.isEmpty() ? 1 : 4;
        if(hand != ' ' || firstMove && currentWord.size() == 1)
            return 0;
        if(currentWord.size() != 0)
            return 1;
        if(!messenger.drawBag.empty())
            return 2;
        return !messenger.drawBag.empty() ? -1 : 3;
    }

    public void notify(Point point)
    {
        if(tradingLetters)
        {
            if(point.x == 15 && point.y == 11 && true)
            {
                if(tradedLetters.isEmpty())
                {
                    tradingLetters = false;
                    return;
                }
            } else
            if(point.x == 15 && point.y == 8 && true)
            {
                if(hand == ' ')
                {
                    doneTradingLetters();
                    return;
                }
            } else
            if(point.x == 15 && point.y < 7 && true)
            {
                tradedLetters.addElement(new Character(playerLetters[messenger.currentPlayer][point.y]));
                playerLetters[messenger.currentPlayer][point.y] = ' ';
                messenger.letters.removeTileAt(point.y);
            }
            return;
        }
        if(point.x == 15 && point.y == 8 && true)
        {
            if(hand == ' ')
            {
                if(!firstMove || firstMove && currentWord.size() != 1)
                    done();
                return;
            }
        } else
        if(point.x == 15 && point.y == 9 && true)
        {
            if(hand == ' ' && currentWord.isEmpty())
            {
                tradingLetters = true;
                return;
            }
        } else
        if(point.x == 15 && point.y == 10 && true)
        {
            if(hand == ' ')
            {
                pass();
                return;
            }
        } else
        {
            if(point.x < 15 && true)
            {
                if(letters[point.x][point.y] == ' ')
                {
                    if(hand != ' ')
                    {
                        letters[point.x][point.y] = hand;
                        putDown();
                        messenger.board.place(hand, point);
                        hand = ' ';
                        currentWord.addElement(point);
                        return;
                    }
                } else
                if(currentWord.contains(point))
                {
                    if(hand == ' ')
                    {
                        hand = letters[point.x][point.y];
                        letters[point.x][point.y] = ' ';
                        pickUp(hand);
                        messenger.board.place(' ', point);
                        currentWord.removeElement(point);
                        return;
                    }
                    char c = hand;
                    hand = letters[point.x][point.y];
                    letters[point.x][point.y] = c;
                    messenger.board.place(c, point);
                    pickUp(hand);
                }
                return;
            }
            if(point.x == 15 && point.y < 7 && true)
                if(playerLetters[messenger.currentPlayer][point.y] == ' ')
                {
                    if(hand != ' ')
                    {
                        playerLetters[messenger.currentPlayer][point.y] = hand;
                        messenger.letters.setLetter(hand, point.y);
                        hand = ' ';
                        putDown();
                        return;
                    }
                } else
                {
                    if(hand == ' ')
                    {
                        hand = playerLetters[messenger.currentPlayer][point.y];
                        playerLetters[messenger.currentPlayer][point.y] = ' ';
                        messenger.letters.removeTileAt(point.y);
                        pickUp(hand);
                        return;
                    }
                    char c1 = hand;
                    hand = playerLetters[messenger.currentPlayer][point.y];
                    playerLetters[messenger.currentPlayer][point.y] = c1;
                    messenger.letters.setLetter(c1, point.y);
                    pickUp(hand);
                }
        }
    }

    private void done()
    {
        if(connected() && contiguous())
        {
            if(messenger.clock.timing())
                messenger.clock.clear();
            findWords();
            scoreWords();
            challenge();
            if(emptyLetters(messenger.currentPlayer))
                gameOver = true;
            turnOver = true;
            return;
        } else
        {
            messenger.bd = new ButtonDialog(messenger, "Your tiles are not properly placed.", Scramble.ok);
            return;
        }
    }

    private boolean emptyLetters(byte byte0)
    {
        for(int i = 0; i < 7; i++)
            if(playerLetters[byte0][i] != ' ')
                return false;

        return true;
    }

    private void scoreWords()
    {
        for(int k = 0; k < wordLocations.size(); k++)
        {
            Rectangle rectangle = (Rectangle)wordLocations.elementAt(k);
            int i = 0;
            int j = 1;
            if(rectangle.height == 1)
            {
                for(int l = rectangle.x; l < rectangle.x + rectangle.width; l++)
                {
                    byte byte0 = boardLayout[l][rectangle.y];
                    if(!currentWord.contains(new Point(l, rectangle.y)))
                        byte0 = 0;
                    if(bonusSquares == 0)
                        byte0 = 0;
                    switch(byte0)
                    {
                    case 0: // '\0'
                        i += letterValue(letters[l][rectangle.y]);
                        break;

                    case 1: // '\001'
                        i += letterValue(letters[l][rectangle.y]) * 2;
                        break;

                    case 2: // '\002'
                        i += letterValue(letters[l][rectangle.y]) * 3;
                        break;

                    case 3: // '\003'
                        i += letterValue(letters[l][rectangle.y]);
                        j *= 2;
                        break;

                    case 4: // '\004'
                        i += letterValue(letters[l][rectangle.y]);
                        j *= 3;
                        break;
                    }
                }

            } else
            {
                for(int i1 = rectangle.y; i1 < rectangle.y + rectangle.height; i1++)
                {
                    byte byte1 = boardLayout[rectangle.x][i1];
                    if(!currentWord.contains(new Point(rectangle.x, i1)))
                        byte1 = 0;
                    if(bonusSquares == 0)
                        byte1 = 0;
                    switch(byte1)
                    {
                    case 0: // '\0'
                        i += letterValue(letters[rectangle.x][i1]);
                        break;

                    case 1: // '\001'
                        i += letterValue(letters[rectangle.x][i1]) * 2;
                        break;

                    case 2: // '\002'
                        i += letterValue(letters[rectangle.x][i1]) * 3;
                        break;

                    case 3: // '\003'
                    case 5: // '\005'
                        i += letterValue(letters[rectangle.x][i1]);
                        j *= 2;
                        break;

                    case 4: // '\004'
                        i += letterValue(letters[rectangle.x][i1]);
                        j *= 3;
                        break;
                    }
                }

            }
            score += i * j;
        }

        if(currentWord.size() == 7)
            score += 50;
    }

    private void challenge()
    {
        boolean flag = true;
        String s = "";
        int i = 0;
        int j = 0;
        for(int k = 0; k < words.size(); k++)
            s = s.concat("`".concat((String)words.elementAt(k)).concat("'   "));

        messenger.letters.setVisible(false);
        for(int l = 0; l < messenger.numberPlayers; l++)
            if(messenger.currentPlayer != l && !skipNextTurn[l])
                j++;

        String as[] = new String[j + 1];
        j = 0;
        for(int i1 = 0; i1 < messenger.numberPlayers; i1++)
            if(messenger.currentPlayer != i1 && !skipNextTurn[i1])
                as[j++] = messenger.playersNames[i1];

        as[j] = new String("No");
        messenger.bd = new ButtonDialog(messenger, "Does anyone challenge: " + s, as);
        if(!messenger.bd.answer().equals("No"))
        {
            for(int j1 = 0; j1 < messenger.numberPlayers; j1++)
                if(messenger.playersNames[j1].equals(messenger.bd.answer()))
                    i = j1;

            messenger.bd = new ButtonDialog(messenger, "Are the words correct?", Scramble.yesNo);
            if(messenger.bd.answer().equals("No"))
                flag = false;
            else
                skipNextTurn[i] = true;
        }
        if(flag)
        {
            newLetters();
            firstMove = false;
            playerScores[messenger.currentPlayer] += score;
            messenger.nameBoard.changeScore(messenger.currentPlayer, playerScores[messenger.currentPlayer], playerLetters[messenger.currentPlayer]);
            return;
        }
        for(int k1 = 0; k1 < currentWord.size(); k1++)
        {
            Point point = (Point)currentWord.elementAt(k1);
            for(int l1 = 0; l1 < 7; l1++)
                if(playerLetters[messenger.currentPlayer][l1] == ' ')
                {
                    playerLetters[messenger.currentPlayer][l1] = letters[point.x][point.y];
                    messenger.letters.setLetter(letters[point.x][point.y], l1);
                    l1 = 7;
                }

            letters[point.x][point.y] = ' ';
            messenger.board.place(' ', point);
        }

    }

    private void findWords()
    {
        int i = ((Point)currentWord.firstElement()).x;
        int j = ((Point)currentWord.firstElement()).y;
        boolean flag = false;
        if(currentWord.size() == 1)
        {
            if(i == 0)
            {
                if(letters[i + 1][j] != ' ')
                    flag = true;
            } else
            if(i == 14)
            {
                if(letters[i - 1][j] != ' ')
                    flag = true;
            } else
            if(letters[i + 1][j] != ' ' || letters[i - 1][j] != ' ')
                flag = true;
        } else
        if(j == ((Point)currentWord.lastElement()).y)
            flag = true;
        if(flag)
        {
            int k;
            for(k = ((Point)currentWord.firstElement()).x; k >= 0; k--)
                if(letters[k][j] == ' ')
                    break;

            k++;
            int i1;
            for(i1 = ((Point)currentWord.lastElement()).x; i1 <= 14; i1++)
                if(letters[i1][j] == ' ')
                    break;

            i1--;
            if(k != i1)
            {
                wordLocations.addElement(new Rectangle(k, j, (i1 - k) + 1, 1));
                StringBuffer stringbuffer = new StringBuffer();
                for(int k2 = k; k2 <= i1; k2++)
                    stringbuffer.append(letters[k2][j]);

                words.addElement(stringbuffer.toString());
            }
            for(int l2 = k; l2 <= i1; l2++)
                if(currentWord.contains(new Point(l2, j)))
                {
                    int k1;
                    for(k1 = j; k1 >= 0; k1--)
                        if(letters[l2][k1] == ' ')
                            break;

                    k1++;
                    int i2;
                    for(i2 = j; i2 <= 14; i2++)
                        if(letters[l2][i2] == ' ')
                            break;

                    i2--;
                    if(k1 != i2)
                        wordLocations.addElement(new Rectangle(l2, k1, 1, (i2 - k1) + 1));
                }

            for(int k3 = 1; k3 < wordLocations.size(); k3++)
            {
                StringBuffer stringbuffer1 = new StringBuffer();
                Rectangle rectangle = (Rectangle)wordLocations.elementAt(k3);
                for(int i4 = rectangle.y; i4 < rectangle.y + rectangle.height; i4++)
                    stringbuffer1.append(letters[rectangle.x][i4]);

                words.addElement(stringbuffer1.toString());
            }

            return;
        }
        int l;
        for(l = ((Point)currentWord.firstElement()).y; l >= 0; l--)
            if(letters[i][l] == ' ')
                break;

        l++;
        int j1;
        for(j1 = ((Point)currentWord.lastElement()).y; j1 <= 14; j1++)
            if(letters[i][j1] == ' ')
                break;

        j1--;
        if(l != j1)
        {
            wordLocations.addElement(new Rectangle(i, l, 1, (j1 - l) + 1));
            StringBuffer stringbuffer2 = new StringBuffer();
            for(int i3 = l; i3 <= j1; i3++)
                stringbuffer2.append(letters[i][i3]);

            words.addElement(stringbuffer2.toString());
        }
        for(int j3 = l; j3 <= j1; j3++)
            if(currentWord.contains(new Point(i, j3)))
            {
                int l1;
                for(l1 = i; l1 >= 0; l1--)
                    if(letters[l1][j3] == ' ')
                        break;

                l1++;
                int j2;
                for(j2 = i; j2 <= 14; j2++)
                    if(letters[j2][j3] == ' ')
                        break;

                j2--;
                if(l1 != j2)
                    wordLocations.addElement(new Rectangle(l1, j3, (j2 - l1) + 1, 1));
            }

        for(int l3 = 1; l3 < wordLocations.size(); l3++)
        {
            StringBuffer stringbuffer3 = new StringBuffer();
            Rectangle rectangle1 = (Rectangle)wordLocations.elementAt(l3);
            for(int j4 = rectangle1.x; j4 < rectangle1.x + rectangle1.width; j4++)
                stringbuffer3.append(letters[j4][rectangle1.y]);

            words.addElement(stringbuffer3.toString());
        }

    }

    private boolean contiguous()
    {
        boolean flag = true;
        int i = ((Point)currentWord.firstElement()).x;
        int j = ((Point)currentWord.firstElement()).y;
        boolean flag1 = true;
        for(int k = 1; k < currentWord.size(); k++)
        {
            if(flag1)
            {
                flag1 = false;
                if(((Point)currentWord.elementAt(k)).x != i)
                {
                    if(((Point)currentWord.elementAt(k)).y != j)
                        return false;
                    flag = true;
                } else
                {
                    flag = false;
                }
            }
            if(flag)
            {
                if(((Point)currentWord.elementAt(k)).y != j)
                    return false;
            } else
            if(((Point)currentWord.elementAt(k)).x != i)
                return false;
        }

        if(flag)
        {
            for(int l = 0; l < currentWord.size() - 1; l++)
            {
                for(int l1 = l + 1; l1 < currentWord.size(); l1++)
                    if(((Point)currentWord.elementAt(l1)).x < ((Point)currentWord.elementAt(l)).x)
                    {
                        Object obj = currentWord.elementAt(l1);
                        currentWord.setElementAt(currentWord.elementAt(l), l1);
                        currentWord.setElementAt(obj, l);
                    }

            }

        } else
        {
            for(int i1 = 0; i1 < currentWord.size() - 1; i1++)
            {
                for(int i2 = i1 + 1; i2 < currentWord.size(); i2++)
                    if(((Point)currentWord.elementAt(i2)).y < ((Point)currentWord.elementAt(i1)).y)
                    {
                        Object obj1 = currentWord.elementAt(i2);
                        currentWord.setElementAt(currentWord.elementAt(i1), i2);
                        currentWord.setElementAt(obj1, i1);
                    }

            }

        }
        if(flag)
        {
            for(int j1 = ((Point)currentWord.firstElement()).x; j1 < ((Point)currentWord.lastElement()).x; j1++)
                if(letters[j1][((Point)currentWord.firstElement()).y] == ' ')
                    return false;

        } else
        {
            for(int k1 = ((Point)currentWord.firstElement()).y; k1 < ((Point)currentWord.lastElement()).y; k1++)
                if(letters[((Point)currentWord.firstElement()).x][k1] == ' ')
                    return false;

        }
        return true;
    }

    private boolean connected()
    {
        boolean flag = false;
        if(firstMove)
        {
            if((new Point(-1, -1)).equals(startSquare))
                flag = true;
            else
            if(currentWord.contains(startSquare))
                flag = true;
        } else
        {
            for(int i = 0; i < currentWord.size(); i++)
            {
                Point point = (Point)currentWord.elementAt(i);
                if(point.x != 0 && letters[point.x - 1][point.y] != ' ' && !currentWord.contains(new Point(point.x - 1, point.y)))
                    flag = true;
                if(point.x != 14 && letters[point.x + 1][point.y] != ' ' && !currentWord.contains(new Point(point.x + 1, point.y)))
                    flag = true;
                if(point.y != 14 && letters[point.x][point.y + 1] != ' ' && !currentWord.contains(new Point(point.x, point.y + 1)))
                    flag = true;
                if(point.y != 0 && letters[point.x][point.y - 1] != ' ' && !currentWord.contains(new Point(point.x, point.y - 1)))
                    flag = true;
            }

        }
        return flag;
    }

    private void tradeLetters()
    {
        tradingLetters = true;
    }

    private void doneTradingLetters()
    {
        if(messenger.clock.timing())
            messenger.clock.clear();
        turnOver = true;
        justTraded = true;
        newLetters();
        justTraded = false;
        for(int i = 0; i < tradedLetters.size(); i++)
            messenger.drawBag.addLetter(((Character)tradedLetters.elementAt(i)).charValue());

        tradedLetters.removeAllElements();
    }

    private void newLetters()
    {
        byte byte0 = messenger.currentPlayer;
        for(int i = 0; i < 7 && !messenger.drawBag.empty(); i++)
            if(playerLetters[byte0][i] == ' ')
            {
                playerLetters[byte0][i] = messenger.drawBag.getLetter();
                messenger.letters.setLetter(playerLetters[byte0][i], i);
            }

        if(!justTraded)
            messenger.nameBoard.setLettersLeft(messenger.drawBag.lettersLeft());
    }

    private void pass()
    {
        turnOver = true;
        allPassed[messenger.currentPlayer] = true;
        gameOver = true;
        for(int i = 0; i < numberPlayers; i++)
            if(!allPassed[i])
                gameOver = false;

    }

    public void nextTurn()
    {
        currentWord.removeAllElements();
        words.removeAllElements();
        wordLocations.removeAllElements();
        turnOver = false;
        tradingLetters = false;
        score = 0;
    }

    private boolean isDone(Point point)
    {
        return point.x == 15 && point.y == 8;
    }

    private boolean isTradeLetters(Point point)
    {
        return point.x == 15 && point.y == 9;
    }

    private boolean isPass(Point point)
    {
        return point.x == 15 && point.y == 10;
    }

    private boolean isCancel(Point point)
    {
        return point.x == 15 && point.y == 11;
    }

    private boolean isBoard(Point point)
    {
        return point.x < 15;
    }

    private boolean isLetters(Point point)
    {
        return point.x == 15 && point.y < 7;
    }

    private void pickUp(char c)
    {
        for(int i = 0; i < numberPlayers; i++)
            messenger.letters.pickUp(c);

    }

    private void putDown()
    {
        for(int i = 0; i < numberPlayers; i++)
            messenger.letters.putDown();

    }

    Scramble messenger;
    char hand;
    char letters[][] = {
        {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }, {
            ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 
            ' ', ' ', ' ', ' ', ' '
        }
    };
    char playerLetters[][];
    int playerScores[] = {
        0, 0, 0, 0
    };
    boolean skipNextTurn[] = {
        false, false, false, false
    };
    boolean allPassed[] = {
        false, false, false, false
    };
    Vector tradedLetters;
    Vector currentWord;
    Vector wordLocations;
    Vector words;
    int numberPlayers;
    boolean firstMove;
    boolean turnOver;
    boolean gameOver;
    boolean tradingLetters;
    int score;
    byte goOuter;
    byte winner;
    boolean winners[] = {
        false, false, false, false
    };
    boolean justTraded;
}