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

import java.awt.*;

class GameControl
{

    GameControl(int i, int j, int k, int l, Connection connection)
    {
        moveOn = false;
        selectedBoard = null;
        moveOn = false;
        gameLimit = i;
        moveLimit = j;
        tableNumber = k;
        gameId = l;
        con = connection;
        myPoints = 0;
        tcounter = new TimeCounter(this, i, j);
        tcounter.setPriority(1);
    }

    void brickBoardClick(BrickBoard brickboard, int i, int j)
    {
        Brick brick = brickboard.getFieldBrick(i, j);
        if(brick == null)
        {
            if(selectedBoard != null)
            {
                selectedBoard.setInactiveBrick(selX, selY);
                selectedBoard.removeBrick(selX, selY);
                brickboard.putBrick(selectedBrick, i, j);
                selectedBoard = null;
            }
        } else
        if(brick.moveable)
            if(selectedBoard != null && brick == selectedBrick)
            {
                selectedBoard.setInactiveBrick(selX, selY);
                selectedBoard = null;
            } else
            {
                if(selectedBoard != null && brick != selectedBrick)
                {
                    selectedBrick.exchangeWith(brick);
                    selectedBoard.setInactiveBrick(selX, selY);
                    brickboard.redrawBrick(i, j);
                }
                selectedBoard = brickboard;
                selectedBrick = brick;
                selX = i;
                selY = j;
                selectedBoard.setActiveBrick(i, j);
            }
        updatePossibilities();
    }

    BrickBoard getChangeBoard()
    {
        changeState = new int[1][7];
        for(int i = 0; i < 7; i++)
            changeState[0][i] = 1;

        changeBoard = new BrickBoard(7, 1, 224, 406, changeState, this);
        return changeBoard;
    }

    BrickBoard getGameBoard()
    {
        gameState = new int[15][15];
        gameState[7][7] = 1;
        gameState[0][0] = 5;
        gameState[7][0] = 5;
        for(int i = 0; i < 4; i++)
            gameState[1 + i][1 + i] = 4;

        gameState[5][1] = 3;
        gameState[5][5] = 3;
        gameState[6][6] = 2;
        gameState[3][0] = 2;
        gameState[6][2] = 2;
        gameState[7][3] = 2;
        for(int j = 0; j < 8; j++)
        {
            for(int k = j + 1; k < 8; k++)
                gameState[j][k] = gameState[k][j];

            for(int l = 0; l < 7; l++)
                gameState[j][14 - l] = gameState[j][l];

            for(int i1 = 0; i1 < 15; i1++)
                gameState[14 - j][i1] = gameState[j][i1];

        }

        gameBoard = new BrickBoard(15, 15, 16, 10, gameState, this);
        return gameBoard;
    }

    BrickBoard getLetterBoard()
    {
        letterState = new int[1][7];
        letterBoard = new BrickBoard(7, 1, 16, 406, letterState, this);
        letterBoard.setMoveOn(true);
        return letterBoard;
    }

    void handleExchange()
    {
        stopMove();
        if(thispc != null)
            thispc.setTime(tcounter.gameTime);
        int ai[] = new int[changeBoard.bricksContained()];
        int i = 0;
        for(int j = 0; j < 7; j++)
        {
            Brick brick = changeBoard.getFieldBrick(j, 0);
            if(brick != null)
            {
                ai[i] = brick.number;
                i++;
            }
        }

        con._moveExchange(tableNumber, gameId, tcounter.gameTime, ai);
        if(selectedBoard == changeBoard)
        {
            selectedBoard.setInactiveBrick(selX, selY);
            selectedBoard = null;
        }
        changeBoard.rejectBricks();
    }

    void handleOK()
    {
        stopMove();
        int i = gameBoard.bricksContained();
        int ai[] = new int[i * 4];
        int j = 0;
        for(int k = 0; k < i; k++)
        {
            Brick brick = gameBoard.brickAt(k);
            ai[j++] = brick.x;
            ai[j++] = brick.y;
            ai[j++] = brick.number;
            ai[j++] = brick.value;
        }

        if(thispc != null)
        {
            thispc.setTime(tcounter.gameTime);
            thispc.setActiveState(1);
        }
        con._moveOK(tableNumber, gameId, tcounter.gameTime, myPoints + lastMovePoints, ai);
        if(selectedBoard == gameBoard)
        {
            selectedBoard.setInactiveBrick(selX, selY);
            selectedBoard = null;
        }
    }

    void handlePass()
    {
        stopMove();
        if(thispc != null)
            thispc.setTime(tcounter.gameTime);
        con._movePass(tableNumber, gameId, tcounter.gameTime);
    }

    void moveAcceptance(boolean flag)
    {
        if(flag)
            con._acceptMove(tableNumber, gameId);
        else
            con._rejectMove(tableNumber, gameId);
    }

    void moveAccepted(boolean flag, int i)
    {
        if(flag)
        {
            gameBoard.acceptBricks();
            if(con.pid == i)
            {
                myPoints = myPoints + lastMovePoints;
                thispc.setPoints(myPoints);
            }
        } else
        if(con.pid == i)
        {
            int j = gameBoard.bricksContained();
            for(int k = 0; k < j; k++)
            {
                Brick brick = gameBoard.brickAt(0);
                gameBoard.removeBrick(brick.x, brick.y);
                newBrick(brick);
            }

        } else
        {
            gameBoard.rejectBricks();
        }
    }

    void moveProp(int ai[])
    {
        for(int i = 0; i < ai.length; i += 4)
            gameBoard.putBrick(new Brick(ai[i + 2], ai[i + 3], true), ai[i], ai[i + 1]);

    }

    void newBrick(Brick brick)
    {
        for(int i = 0; i < 7; i++)
        {
            if(letterBoard.getFieldBrick(i, 0) != null)
                continue;
            letterBoard.putBrick(brick, i, 0);
            break;
        }

    }

    void setComponents(Button button, Button button1, Button button2, Label label)
    {
        p1 = button;
        p2 = button1;
        p3 = button2;
        valueLabel = label;
        updatePossibilities();
    }

    void startMove(int i)
    {
        maximumExchange = i;
        gameBoard.setMoveOn(true);
        changeBoard.setMoveOn(true);
        letterBoard.setMoveOn(true);
        p1.disable();
        p2.disable();
        p3.enable();
        tcounter.moveStart();
    }

    void stopMove()
    {
        tcounter.moveStop();
        gameBoard.setMoveOn(false);
        changeBoard.setMoveOn(false);
    }

    void timeoutGame()
    {
        gameBoard.setMoveOn(false);
        changeBoard.setMoveOn(false);
        if(selectedBoard != null && selectedBoard != letterBoard)
        {
            selectedBoard.setInactiveBrick(selX, selY);
            selectedBoard = null;
        }
        int i = gameBoard.bricksContained();
        for(int j = 0; j < i; j++)
        {
            Brick brick = gameBoard.brickAt(0);
            gameBoard.removeBrick(brick.x, brick.y);
            newBrick(brick);
        }

        i = changeBoard.bricksContained();
        for(int k = 0; k < i; k++)
        {
            Brick brick1 = changeBoard.brickAt(0);
            changeBoard.removeBrick(brick1.x, brick1.y);
            newBrick(brick1);
        }

        con._timeoutGame(tableNumber, gameId, tcounter.gameTime);
    }

    void timeoutMove()
    {
        gameBoard.setMoveOn(false);
        changeBoard.setMoveOn(false);
        if(selectedBoard != null && selectedBoard != letterBoard)
        {
            selectedBoard.setInactiveBrick(selX, selY);
            selectedBoard = null;
        }
        int i = gameBoard.bricksContained();
        for(int j = 0; j < i; j++)
        {
            Brick brick = gameBoard.brickAt(0);
            gameBoard.removeBrick(brick.x, brick.y);
            newBrick(brick);
        }

        i = changeBoard.bricksContained();
        for(int k = 0; k < i; k++)
        {
            Brick brick1 = changeBoard.brickAt(0);
            changeBoard.removeBrick(brick1.x, brick1.y);
            newBrick(brick1);
        }

        con._timeoutMove(tableNumber, gameId, tcounter.gameTime);
    }

    void updatePossibilities()
    {
        boolean flag = true;
        boolean flag1 = true;
        boolean flag2 = true;
        int i = 0;
        if(changeBoard == null)
            flag1 = false;
        else
        if(changeBoard.bricksContained() > 0)
        {
            flag2 = false;
            flag = false;
            if(maximumExchange < 7)
                flag1 = false;
        } else
        {
            flag1 = false;
        }
        if(gameBoard == null)
            flag = false;
        else
        if(gameBoard.bricksContained() > 0)
        {
            flag1 = false;
            flag2 = false;
            Brick brick = gameBoard.brickAt(0);
            int j = brick.x;
            int k = brick.y;
            int l = j;
            int i1 = j;
            int j1 = k;
            int k1 = k;
            int l1 = gameBoard.bricksContained();
            for(int i2 = 1; i2 < l1; i2++)
            {
                Brick brick1 = gameBoard.brickAt(i2);
                if(brick1.x < l)
                    l = brick1.x;
                else
                if(brick1.x > i1)
                    i1 = brick1.x;
                if(brick1.y < j1)
                    j1 = brick1.y;
                else
                if(brick1.y > k1)
                    k1 = brick1.y;
                if(brick1.x != j)
                    j = -1;
                if(brick1.y != k)
                    k = -1;
            }

            boolean flag3 = false;
            if(gameBoard.getFieldBrick(6, 7) != null)
                flag3 = true;
            else
            if(gameBoard.getFieldBrick(8, 7) != null)
                flag3 = true;
            else
            if(gameBoard.getFieldBrick(7, 6) != null)
                flag3 = true;
            else
            if(gameBoard.getFieldBrick(7, 8) != null)
                flag3 = true;
            if(j == -1 && k == -1 || gameBoard.getFieldBrick(7, 7) == null || !flag3)
            {
                flag = false;
            } else
            {
                if(j == -1)
                    j = 1;
                else
                    j = 0;
                if(k == -1)
                    k = 1;
                else
                    k = 0;
                int j2 = l;
                for(int k2 = j1; j2 < i1 || k2 < k1; k2 += k)
                {
                    if(gameBoard.getFieldBrick(j2, k2) == null)
                    {
                        flag = false;
                        break;
                    }
                    j2 += j;
                }

                boolean flag4 = true;
                if(l == 7 && i1 == 7 && j1 <= 7 && k1 >= 7 || j1 == 7 && k1 == 7 && l <= 7 && i1 >= 7)
                    flag4 = false;
                else
                if(l == i1)
                {
                    if(gameBoard.getFieldBrick(l, j1 - 1) != null || gameBoard.getFieldBrick(l, k1 + 1) != null)
                        flag4 = false;
                    for(int l2 = j1; l2 <= k1 && flag4; l2++)
                        if(gameBoard.getFieldBrick(l - 1, l2) != null || gameBoard.getFieldBrick(l + 1, l2) != null)
                            flag4 = false;

                } else
                {
                    if(gameBoard.getFieldBrick(l - 1, j1) != null || gameBoard.getFieldBrick(i1 + 1, j1) != null)
                        flag4 = false;
                    for(int i3 = l; i3 <= i1 && flag4; i3++)
                        if(gameBoard.getFieldBrick(i3, j1 - 1) != null || gameBoard.getFieldBrick(i3, j1 + 1) != null)
                            flag4 = false;

                }
                if(flag4)
                    flag = false;
                if(flag)
                {
                    if(gameBoard.bricksContained() == 7)
                        i += 50;
                    if(l == i1)
                    {
                        i += gameBoard.countVWordValue(l, j1);
                        for(int j3 = j1; j3 <= k1; j3++)
                        {
                            Brick brick2 = gameBoard.getFieldBrick(l, j3);
                            if(brick2 != null && brick2.moveable)
                                i += gameBoard.countHWordValue(l, j3);
                        }

                    } else
                    {
                        i += gameBoard.countHWordValue(l, j1);
                        for(int k3 = l; k3 <= i1; k3++)
                        {
                            Brick brick3 = gameBoard.getFieldBrick(k3, j1);
                            if(brick3 != null && brick3.moveable)
                                i += gameBoard.countVWordValue(k3, j1);
                        }

                    }
                }
            }
        } else
        {
            flag = false;
        }
        lastMovePoints = i;
        if(valueLabel != null)
            if(!flag)
                valueLabel.setText("-");
            else
                valueLabel.setText(String.valueOf(i));
        if(p1 != null)
            p1.enable(flag);
        if(p2 != null)
            p2.enable(flag1);
        if(p3 != null)
            p3.enable(flag2);
    }

    TimeCounter tcounter;
    PlayerComponent thispc;
    int gameLimit;
    int moveLimit;
    BrickBoard gameBoard;
    BrickBoard letterBoard;
    BrickBoard changeBoard;
    int gameState[][];
    int letterState[][];
    int changeState[][];
    boolean moveOn;
    Component p1;
    Component p2;
    Component p3;
    Label valueLabel;
    BrickBoard selectedBoard;
    Brick selectedBrick;
    int selX;
    int selY;
    Connection con;
    int tableNumber;
    int gameId;
    int lastMovePoints;
    int maximumExchange;
    int myPoints;
}