zpolygon.java

java 编写的小游戏--坦克大战

// Decompiled by DJ v2.9.9.60 Copyright 2000 Atanas Neshkov  Date: 2004-12-12 17:51:52
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 
// Source File Name:   ZPolygon.java

import java.awt.Color;
import java.awt.Graphics;

public class ZPolygon
{

    public void GetPlaneVariables()
    {
        float f = fVertices[0].fWx;
        float f1 = fVertices[0].fWy;
        float f2 = fVertices[0].fWz;
        fA = fWNx;
        fB = fWNy;
        fC = fWNz;
        fD = -fA * f - fB * f1 - fC * f2;
    }

    public void SetMin(int i, int j, int k)
    {
        fXMin = i;
        fYMin = j;
        fZMin = k;
    }

    boolean Inside(ZPolygon zpolygon)
    {
        boolean flag = true;
        for(int i = 0; i < fNumVertices; i++)
        {
            if(zpolygon.fA * (float)fVertices[i].fAx + zpolygon.fB * (float)fVertices[i].fAy + zpolygon.fC * (float)fVertices[i].fAz + zpolygon.fD <= 0.0F)
                continue;
            flag = false;
            break;
        }

        return flag;
    }

    public void DrawSolid2()
    {
        CalcColor();
        fOffScrGraphics.setColor(fColor);
        int i4 = fNumVertices - 1;
        int j4 = 0;
        int k4 = fVertices[0].fSy;
        for(int l4 = 1; l4 < fNumVertices; l4++)
            if(fVertices[l4].fSy < k4)
            {
                j4 = l4;
                k4 = fVertices[l4].fSy;
            }

        int i5 = j4;
        int k5 = j4;
        int i6 = fVertices[i5].fSx;
        int j6 = fVertices[i5].fSy;
        int k6 = fVertices[k5].fSx;
        int l6 = fVertices[k5].fSy;
        int i7 = i5 - 1;
        if(i7 < 0)
            i7 = fNumVertices - 1;
        int j7 = fVertices[i7].fSx;
        int k7 = fVertices[i7].fSy;
        int l7 = k5 + 1;
        if(l7 == fNumVertices)
            l7 = 0;
        int i8 = fVertices[l7].fSx;
        int j8 = fVertices[l7].fSy;
        while(i4 > 0) 
        {
            int i1 = 0;
            int j1 = 0;
            int i;
            if((i = k7 - j6) < 0)
                i = -i;
            int j;
            if((j = j8 - l6) < 0)
                j = -j;
            int k;
            byte byte0;
            if((k = j7 - i6) < 0)
            {
                byte0 = -1;
                k = -k;
            } else
            {
                byte0 = 1;
            }
            int l;
            byte byte1;
            if((l = i8 - k6) < 0)
            {
                byte1 = -1;
                l = -l;
            } else
            {
                byte1 = 1;
            }
            int k1;
            int l1;
            if(k > i)
            {
                if(l > j)
                {
                    k1 = k;
                    for(l1 = l; k1 > 0 && l1 > 0;)
                    {
                        while(i1 < k && k1 > 0) 
                        {
                            if(k1-- > 0)
                                i6 += byte0;
                            i1 += i;
                        }
                        i1 -= k;
                        for(; j1 < l && l1 > 0; j1 += j)
                            if(l1-- > 0)
                                k6 += byte1;

                        j1 -= l;
                        int i2;
                        int i3;
                        if(k6 > i6)
                        {
                            i2 = k6;
                            i3 = i6;
                        } else
                        {
                            i2 = i6;
                            i3 = k6;
                        }
                        fOffScrGraphics.drawLine(fScrMidX + i2, fScrMidY + j6, fScrMidX + i3, fScrMidY + j6);
                        j6++;
                        l6++;
                    }

                } else
                {
                    k1 = k;
                    for(l1 = j; k1 > 0 && l1 > 0;)
                    {
                        while(i1 < k && k1 > 0) 
                        {
                            if(k1-- > 0)
                                i6 += byte0;
                            i1 += i;
                        }
                        i1 -= k;
                        j1 += l;
                        if(j1 >= j)
                        {
                            j1 -= j;
                            k6 += byte1;
                        }
                        l1--;
                        int j2;
                        int j3;
                        if(k6 > i6)
                        {
                            j2 = k6;
                            j3 = i6;
                        } else
                        {
                            j2 = i6;
                            j3 = k6;
                        }
                        fOffScrGraphics.drawLine(fScrMidX + j2, fScrMidY + j6, fScrMidX + j3, fScrMidY + j6);
                        j6++;
                        l6++;
                    }

                }
            } else
            if(l > j)
            {
                k1 = i;
                for(l1 = l; k1 > 0 && l1 > 0;)
                {
                    i1 += k;
                    if(i1 >= i)
                    {
                        i1 -= i;
                        i6 += byte0;
                    }
                    k1--;
                    for(; j1 < l && l1 > 0; j1 += j)
                        if(l1-- > 0)
                            k6 += byte1;

                    j1 -= l;
                    int k2;
                    int k3;
                    if(k6 > i6)
                    {
                        k2 = k6;
                        k3 = i6;
                    } else
                    {
                        k2 = i6;
                        k3 = k6;
                    }
                    fOffScrGraphics.drawLine(fScrMidX + k2, fScrMidY + j6, fScrMidX + k3, fScrMidY + j6);
                    j6++;
                    l6++;
                }

            } else
            {
                k1 = i;
                for(l1 = j; k1 > 0 && l1 > 0;)
                {
                    i1 += k;
                    if(i1 >= i)
                    {
                        i1 -= i;
                        i6 += byte0;
                    }
                    k1--;
                    j1 += l;
                    if(j1 >= j)
                    {
                        j1 -= j;
                        k6 += byte1;
                    }
                    l1--;
                    int l2;
                    int l3;
                    if(k6 > i6)
                    {
                        l2 = k6;
                        l3 = i6;
                    } else
                    {
                        l2 = i6;
                        l3 = k6;
                    }
                    fOffScrGraphics.drawLine(fScrMidX + l2, fScrMidY + j6, fScrMidX + l3, fScrMidY + j6);
                    j6++;
                    l6++;
                }

            }
            if(k1 <= 0)
            {
                i4--;
                int j5 = i7;
                if(--i7 < 0)
                    i7 = fNumVertices - 1;
                j7 = fVertices[i7].fSx;
                k7 = fVertices[i7].fSy;
            }
            if(l1 <= 0)
            {
                i4--;
                int l5 = l7;
                if(++l7 == fNumVertices)
                    l7 = 0;
                i8 = fVertices[l7].fSx;
                j8 = fVertices[l7].fSy;
            }
        }
    }

    public void SetDistance(int i)
    {
        fZDistance = i;
    }

    public void DrawWireframe()
    {
        CalcColor();
        fOffScrGraphics.setColor(fColor);
        int ai[] = new int[fNumVertices + 1];
        int ai1[] = new int[fNumVertices + 1];
        int i;
        for(i = 0; i < fNumVertices; i++)
        {
            ai[i] = fVertices[i].fSx + fScrMidX;
            ai1[i] = fVertices[i].fSy + fScrMidY;
        }

        ai[i] = fVertices[0].fSx + fScrMidX;
        ai1[i] = fVertices[0].fSy + fScrMidY;
        fOffScrGraphics.drawPolygon(ai, ai1, fNumVertices + 1);
    }

    boolean NeedSwap(ZPolygon zpolygon)
    {
        if(!ZOverlap(zpolygon))
            return false;
        if(!XYOverlap(zpolygon))
            return false;
        zpolygon.GetPlaneVariables();
        if(Inside(zpolygon))
            return false;
        return Outside(zpolygon);
    }

    public void GetNormalLength()
    {
        fNLength = (int)Math.sqrt(fLNx * fLNx + fLNy * fLNy + fLNz * fLNz);
    }

    public void GetLightLength()
    {
        fLightLength = 1.0F / (float)(fLight.fLength * fNLength);
    }

    boolean Outside(ZPolygon zpolygon)
    {
        boolean flag = true;
        for(int i = 0; i < fNumVertices; i++)
        {
            if(zpolygon.fA * (float)fVertices[i].fAx + zpolygon.fB * (float)fVertices[i].fAy + zpolygon.fC * (float)fVertices[i].fAz + zpolygon.fD >= 0.0F)
                continue;
            flag = false;
            break;
        }

        return flag;
    }

    public void SetGraphics(Graphics g, int i, int j, int k, int l)
    {
        fScrWidth = i;
        fScrHeight = j;
        fScrMidX = k;
        fScrMidY = l;
        fOffScrGraphics = g;
    }

    public void SetViewerMidPos(int i, int j)
    {
        fScrMidX = i;
        fScrMidY = j;
    }

    public void SetMax(int i, int j, int k)
    {
        fXMax = i;
        fYMax = j;
        fZMax = k;
    }

    public ZPolygon()
    {
        fNumVertices = 0;
    }

    public void SetLight(ZLight zlight)
    {
        fLight = zlight;
        GetLightLength();
    }

    public boolean ZOverlap(ZPolygon zpolygon)
    {
        return fZMin < zpolygon.fZMax && zpolygon.fZMin < fZMax;
    }

    boolean XYOverlap(ZPolygon zpolygon)
    {
        if(fXMin >= zpolygon.fXMax || zpolygon.fXMin >= fXMax)
            return false;
        return fYMin < zpolygon.fYMax && zpolygon.fYMin < fYMax;
    }

    public void DrawSolid()
    {
        CalcColor();
        fOffScrGraphics.setColor(fColor);
        int ai[] = new int[fNumVertices];
        int ai1[] = new int[fNumVertices];
        for(int i = 0; i < fNumVertices; i++)
        {
            ai[i] = fVertices[i].fSx + fScrMidX;
            ai1[i] = fVertices[i].fSy + fScrMidY;
        }

        fOffScrGraphics.fillPolygon(ai, ai1, fNumVertices);
    }

    public void GetWorldNormal()
    {
        int i = fVertices[0].fWx;
        int j = fVertices[0].fWy;
        int k = fVertices[0].fWz;
        int l = fVertices[1].fWx;
        int i1 = fVertices[1].fWy;
        int j1 = fVertices[1].fWz;
        int k1 = fVertices[2].fWx;
        int l1 = fVertices[2].fWy;
        int i2 = fVertices[2].fWz;
        long l2 = i - l;
        long l3 = j - i1;
        long l4 = k - j1;
        long l5 = k1 - l;
        long l6 = l1 - i1;
        long l7 = i2 - j1;
        fWNx = l3 * l7 - l4 * l6;
        fWNy = l4 * l5 - l2 * l7;
        fWNz = l2 * l6 - l3 * l5;
    }

    public void GetLocalNormal()
    {
        int i = fVertices[0].fLx;
        int j = fVertices[0].fLy;
        int k = fVertices[0].fLz;
        int l = fVertices[1].fLx;
        int i1 = fVertices[1].fLy;
        int j1 = fVertices[1].fLz;
        int k1 = fVertices[2].fLx;
        int l1 = fVertices[2].fLy;
        int i2 = fVertices[2].fLz;
        long l2 = i - l;
        long l3 = j - i1;
        long l4 = k - j1;
        long l5 = k1 - l;
        long l6 = l1 - i1;
        long l7 = i2 - j1;
        fLNx = l3 * l7 - l4 * l6;
        fLNy = l4 * l5 - l2 * l7;
        fLNz = l2 * l6 - l3 * l5;
    }

    public void CalcColor()
    {
        if(fObject.fAction == 6)
        {
            fColor = new Color(200, fObject.fStatusTimer * 10, fObject.fStatusTimer * 10);
            return;
        }
        GetWorldNormal();
        float f = (fWNx * (float)fLight.fX + fWNy * (float)fLight.fY + fWNz * (float)fLight.fZ) * fLightLength;
        if(f <= 0.0F)
        {
            f = -f;
            if(f == 0.0F)
                f = 0.5F;
        }
        int i = (int)((float)fRed * f) + fLight.fAmbient;
        int j = (int)((float)fGreen * f) + fLight.fAmbient;
        int k = (int)((float)fBlue * f) + fLight.fAmbient;
        if(i > 255)
            i = 255;
        if(j > 255)
            j = 255;
        if(k > 255)
            k = 255;
        fColor = new Color(i, j, k);
    }

    public boolean Backface()
    {
        int i = fVertices[0].fAx;
        int j = fVertices[0].fAy;
        int k = fVertices[0].fAz;
        int l = fVertices[1].fAx;
        int i1 = fVertices[1].fAy;
        int j1 = fVertices[1].fAz;
        int k1 = fVertices[2].fAx;
        int l1 = fVertices[2].fAy;
        int i2 = fVertices[2].fAz;
        int j2 = k1 * (k * i1 - j * j1) + l1 * (i * j1 - k * l) + i2 * (j * l - i * i1);
        return j2 < 0;
    }

    int fNumVertices;
    Color fColor;
    int fZMax;
    int fZMin;
    int fXMax;
    int fXMin;
    int fYMax;
    int fYMin;
    ZVertex fVertices[];
    int fScrWidth;
    int fScrHeight;
    int fScrMidX;
    int fScrMidY;
    Graphics fOffScrGraphics;
    ZLight fLight;
    float fLightLength;
    int fZDistance;
    int fNLength;
    float fLNx;
    float fLNy;
    float fLNz;
    float fWNx;
    float fWNy;
    float fWNz;
    int fRed;
    int fGreen;
    int fBlue;
    float fA;
    float fB;
    float fC;
    float fD;
    ZObject fObject;
}