lines.java

经典java游戏改版带数据库

        }
        while(++i2 < 81);
        return false;
    }
//-----------------------------------------------------------------------
    public void start()
    {
        if(getX == null)
        {
            contains = false;
            getX = new Thread(this);
            getX.start();
        }
    }

//  -----------------------------------------------------------------------
    private void S(int ai[][][])
    {
        int i1 = 39;
        int l1 = cellColor.getRed();
        int i2 = cellColor.getGreen();
        int j2 = cellColor.getBlue();
        double ad[][][] = new double[i1][i1][3];
        double d5 = ((double)i1 - 10D) / 2D;
        double d6 = d5 * d5;
        double d7 = d5 * 5D;
        double ad1[][] = {
            {
                1.0D, -0.59999999999999998D, 1.0D, 0.69999999999999996D, 0
            }
        };
        F(ad1[0]);
        for(int j1 = 0; j1 < i1; j1++)
        {
            for(int k1 = 0; k1 < i1; k1++)
            {
                ad[j1][k1][0] = 0.0D;
                ad[j1][k1][1] = 0.0D;
                ad[j1][k1][2] = 1.0D;
                ai[j1][k1][0] = l1;
                ai[j1][k1][1] = i2;
                ai[j1][k1][2] = j2;
                ai[j1][k1][3] = 0;
                double d1 = (double)j1 - 0.5D * (double)(i1 - 1);
                double d2 = 0.5D * (double)(i1 - 1) - (double)k1;
                double d3 = d1 * d1;
                double d4 = d2 * d2;
                int k2 = 0;
                if((d3 - d1) + d4 + 0.5D <= d6)
                    k2++;
                if(d3 + d1 + d4 + 0.5D <= d6)
                    k2++;
                if(((d3 + d4) - d2) + 0.5D <= d6)
                    k2++;
                if(d3 + d4 + d2 + 0.5D <= d6)
                    k2++;
                if(k2 > 0)
                {
                    ad[j1][k1][0] = d1;
                    ad[j1][k1][1] = d2;
                    ad[j1][k1][2] = Math.sqrt(d7 * d7 - d3 - d4);
                    if(k2 < 4)
                    {
                        F(ad[j1][k1]);
                        ad[j1][k1][0] *= k2;
                        ad[j1][k1][1] *= k2;
                        ad[j1][k1][2] = ad[j1][k1][2] * (double)k2 + (double)(4 - k2);
                    }
                }
                if(j1 < 2)
                    ad[j1][k1][0] = 0.29999999999999999D;
                if(j1 > i1 - 3)
                    ad[j1][k1][0] = -0.20000000000000001D;
                if(k1 < 2)
                    ad[j1][k1][1] = -0.070000000000000007D;
                if(k1 > i1 - 3)
                    ad[j1][k1][1] = 0.14999999999999999D;
                if(ad[j1][k1][0] != 0.0D || ad[j1][k1][1] != 0.0D)
                {
                    F(ad[j1][k1]);
                    ai[j1][k1][3] = 255;
                }
            }

        }

        c(ad, ai, cellColor, ad1, true);
    }
//  -----------------------------------------------------------------------
    public String getAppletInfo()
    {
        return "The Lines v.1.3.0, wangdx. 版权所有 2000.";
    }

//  -----------------------------------------------------------------------
    private void T()
    {
        //初始化游戏数据
    	f();
        int i1 = 0;
        do
        {
            int j1 = randbetwen(0, 8);
            int l1;
            for(l1 = randbetwen(0, 8); I[j1][l1] != 0;)
                if(++j1 >= 9)
                {
                    j1 = 0;
                    if(++l1 >= 9)
                        l1 = 0;
                }

            I[j1][l1] = randbetwen(1, 7);
            getDescent[j1][l1] = I[j1][l1];
        }
        while(++i1 < 3);
        int k1 = 0;
        do
        {
            int i2 = 0;
            do
                drawCell(k1, i2);
            while(++i2 < 9);
        }
        while(++k1 < 9);
        gameInfomation(drawImage);
        repaint();
        writeScore();
        l();
    }
//  -----------------------------------------------------------------------
    private double U(double ad[], double ad1[])
    {
        try
        {
            double d1 = ad[0] * ad1[0] + ad[1] * ad1[1] + ad[2] * ad1[2];
            if(d1 > 0.0D)
                return d1;
            else
                return 0.0D;
        }
        catch(Exception _ex)
        {
            return 0.0D;
        }
    }

//  -----------------------------------------------------------------------
    private boolean W(int i1, int j1)
    {
        return (I[i1][j1] & 0xf) == 0;
    }

//  -----------------------------------------------------------------------
    private void X()
    {
        int i1 = 0;
        do
        {
            int j1 = 0;
            do
                if(dispose[i1][j1] != 0 && I[i1][j1] != 0)
                {
                    int k1 = randbetwen(0, 8);
                    int l1;
                    for(l1 = randbetwen(0, 8); dispose[k1][l1] != 0 || I[k1][l1] != 0;)
                        if(++k1 >= 9)
                        {
                            k1 = 0;
                            if(++l1 >= 9)
                                l1 = 0;
                        }

                    dispose[k1][l1] = dispose[i1][j1];
                    dispose[i1][j1] = 0;
                    drawCell(k1, l1);
                    M(k1, l1);
                    return;
                }
            while(++j1 < 9);
        }
        while(++i1 < 9);
    }

//  -----------------------------------------------------------------------
    private void activeSprit()
    {
    	//精灵动画效果，上下抖动，isPopupTrigger在-3到+3间变化
    	if(!isHideHero) return;
    	if(x == null)
        {
            createImage = 0;
            return;
        }
        if(fillRect)
        {
            isPopupTrigger--;
            if(isPopupTrigger <= -4)
            {
                isPopupTrigger++;
                fillRect = false;
            }
        }
        else
        {
            isPopupTrigger++;
            if(isPopupTrigger >= 4)
            {
                isPopupTrigger--;
                fillRect = true;
            }
        }
        int i1 = x.x;	//
        int j1 = x.y;	//
        s(i1, j1, isPopupTrigger, cellColor(i1, j1));	//画抖动的精灵
    }

//  -----------------------------------------------------------------------
    private boolean mouseDown(int i1, int j1)
    {
        //处理鼠标单击事件i1,j1为坐标
    	try
        {
            int k1 = (i1 - 12) / 40;
            int l1 = (j1 - 10) / 40;
            if(!z() && getMaxDescent.contains(i1, j1))
            {
                u();							//右侧超级连接导航
                return true;
            }
            if(k1 >= 0 && k1 < 9 && l1 >= 0 && l1 < 9)
            {
                if(createImage != 0 && createImage != 1)
                    return true;
                if(W(k1, l1))
                {
                    if(x != null && (x.x != k1 || x.y != l1) && R(x.x, x.y, k1, l1))
                    {
                        trim = new Point(x.x, x.y);
                        getRed = new Point(trim.x, trim.y);
                        toCharArray = new Point(k1, l1);
                        v();
                        createImage = 2;
                    }
                }
                else
                {
                    if(x != null)
                        M(x.x, x.y);
                    x = new Point(k1, l1);
                    createImage = 1;
                }
            }
            else
            if(hero.x <= i1 && hero.x + hero.width > i1 && hero.y <= j1 && hero.y + hero.height > j1)
            {
                    isShowHero = true;
                    drawButton(heroButton,hero,true);
            }
            else
            if(sqrt.x <= i1 && sqrt.x + sqrt.width > i1 && sqrt.y <= j1 && sqrt.y + sqrt.height > j1)
            {
                brighter = true;
                drawButton(clipRect,sqrt,true);
            }
            else
            if(getFont.x <= i1 && getFont.x + getFont.width > i1 && getFont.y <= j1 && getFont.y + getFont.height > j1)
            {
                isPlain = true;
                drawButton(getGraphics,getFont,true);
            }
        }
        catch(Exception exception)
        {
            exception.printStackTrace();
        }
        return true;
    }

//  -----------------------------------------------------------------------
    private double b(double ad[], double ad1[], double d1)
    {
        double d4 = 0.0D;
        try
        {
            double d3 = ad[0] * ad1[0] + ad[1] * ad1[1] + ad[2] * ad1[2];
            double d2 = 2D * d3 * ad1[2] - ad[2];
            if(d1 < 1.0D)
                d1 = 1.0D;
            if(d1 > 100D)
                d1 = 100D;
            if(d2 > 0.0D)
                d4 = 1.3D * Math.pow(d2, d1);
        }
        catch(Exception _ex) { }
        return d4;
    }

//  -----------------------------------------------------------------------
    private void c(double ad[][][], int ai[][][], Color color, double ad1[][], boolean flag)
    {
        int i1 = ad.length;
        int j1 = ad[0].length;
        double ad2[] = new double[4];
        int j3 = color.getRGB();
        double ad3[] = new double[3];
        ad3[0] = (double)(j3 >> 16 & 0xff) / 255D;
        ad3[1] = (double)(j3 >> 8 & 0xff) / 255D;
        ad3[2] = (double)(j3 & 0xff) / 255D;
        double d1 = 0.20000000000000001D;
        double ad4[] = {
            0, 0, 1.0D
        };
        double d3 = 0.20000000000000001D;
        for(int k1 = 0; k1 < ad1.length; k1++)
            if(ad1[k1][4] <= 0.0D)
                d3 += ad1[k1][3] * U(ad1[k1], ad4);
            else
                d3 += ad1[k1][3] * b(ad1[k1], ad4, ad1[k1][4]);

        if(d3 <= 0.001D)
            d3 = 1.0D;
        for(int i2 = 0; i2 < i1; i2++)
        {
            for(int j2 = 0; j2 < j1; j2++)
                if(ai[i2][j2][3] != 0)
                {
                    double d2 = 0.20000000000000001D;
                    for(int l1 = 0; l1 < ad1.length; l1++)
                        if(ad1[l1][4] <= 0.0D)
                            d2 += ad1[l1][3] * U(ad1[l1], ad[i2][j2]);
                        else
                            d2 += ad1[l1][3] * b(ad1[l1], ad[i2][j2], ad1[l1][4]);

                    if(flag)
                        d2 /= d3;
                    ad2[0] = ad3[0] * d2;
                    ad2[1] = ad3[1] * d2;
                    ad2[2] = ad3[2] * d2;
                    int k2 = (int)Math.round(ad2[0] * 256D);
                    if(k2 < 0)
                        k2 = 0;
                    if(k2 > 255)
                        k2 = 255;
                    ai[i2][j2][0] = k2;
                    int l2 = (int)Math.round(ad2[1] * 256D);
                    if(l2 < 0)
                        l2 = 0;
                    if(l2 > 255)
                        l2 = 255;
                    ai[i2][j2][1] = l2;
                    int i3 = (int)Math.round(ad2[2] * 256D);
                    if(i3 < 0)
                        i3 = 0;
                    if(i3 > 255)
                        i3 = 255;
                    ai[i2][j2][2] = i3;
                }

        }

    }

//  -----------------------------------------------------------------------
    private void e()
    {
        createImage = 0;
        x = null;
        getFontMetrics = setFont - 20;
        writeScore();
        int i1 = 0;
        do
        {
            int j1 = 0;
            do
                if(I[i1][j1] != getDescent[i1][j1] || dispose[i1][j1] != 0)
                {
                    dispose[i1][j1] = 0;
                    I[i1][j1] = getDescent[i1][j1];
                    drawCell(i1, j1);
                    M(i1, j1);
                }
            while(++j1 < 9);
        }
        while(++i1 < 9);
        l();
    }

//  -----------------------------------------------------------------------
    public void paint(Graphics g1)
    {
        if(!Code)
        {
            g1.setColor(darker);
            g1.fillRect(0, 0, width - 1, height - 1);
            g1.setColor(Color.blue);
            g1.drawString("载入图片...", 10, 20);
            return;
        }
        else
        {
            g1.drawImage(Z, 0, 0, this);
            return;
        }
    }

//  -----------------------------------------------------------------------
    private void f()
    {
        createImage = 0;
        x = null;
        int i1 = 0;
        do
        {
            int j1 = 0;
            do
            {
                I[i1][j1] = 0;
                getDescent[i1][j1] = 0;
                dispose[i1][j1] = 0;
                getMaxAscent[i1][j1] = 0;
                getBlue[i1][j1] = 0;
            }
            while(++j1 < 9);
        }
        while(++i1 < 9);
        getY = 0;
        length = 0;
        getFontMetrics = 0;
        setFont = 0;
        setColor = 0;
        x = null;