avversario.java

基于j2me的手机赛车游戏源代码

// FrontEnd Plus GUI for JAD
// DeCompiled : Avversario.class

import com.nokia.mid.ui.DirectGraphics;
import java.util.Random;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;

class Avversario
{

    private final GameManager gm;
    private Immagine iE;
    private int dxE;
    private int dyE;
    private Random ra;
    private int ve;
    int me256;
    private int yp;
    private int cC;
    private int co;
    private int rapN;
    private int rapD;
    int ca;
    int da;
    int tu;
    private int vT;
    private int vM;
    private int sT;
    private boolean fi;
    private int pR[] = {
        500, 200, 100
    };
    int ppRR;
    int coRe;

    Avversario(GameManager gm, Immagine el, int vM, int sT)
    {
        me256 = 0;
        cC = 0;
        co = 3;
        rapN = 9;
        rapD = 9;
        ca = 0x271000;
        da = 100;
        tu = 0;
        fi = false;
        this.gm = gm;
        iE = el;
        this.vM = vM;
        this.sT = sT;
        dxE = iE.dx;
        dyE = iE.dy;
        rapN = co * 9;
        me256 = 0;
        ve = 0;
        ra = new Random();
    }

    public void tick()
    {
        if(fi)
        {
            tu = 0;
            cC();
            if(ve > 0)
            {
                ve -= 10;
                if(ve < 0)
                    ve = 0;
                me256 = me256 + (ve << 8) / 40;
            }
            return;
        }
        int pRR = gm.mA256 - me256 >> 8;
        ppRR = gm.liS[74] + ((rapN * gm.dxS[74]) / rapD - dxE) / 2;
        coRe = caC(ppRR);
        boolean cob = false;
        for(int n = 0; n < 4; n++)
        {
            cob |= cC(n);
            cob |= cSC(n);
        }

        cob |= cCG();
        cob |= cC();
        if(rapN < co * 9)
            rapN++;
        else
        if(rapN > co * 9)
            rapN--;
        if(!cob && ve < vM - sT)
            ve++;
        me256 = me256 + (ve << 8) / 40;
        if(tu <= 0 && ca >> 8 > 3000 && pRR > pR[gm.li])
        {
            tu = 300;
            vT = ve;
        }
        if(tu > 0)
        {
            tu--;
            if(tu > 300 - (vM - vT))
                ve += 3;
            if(ve > vM)
                ve = vM + sT;
        }
        if(tu == 0 && ve > vT)
            ve--;
        if(vT == ve)
            vT = vM - sT;
        if(ve > 0)
        {
            ca -= ve;
            if(tu > 0)
                ca -= (3 - gm.li) * ve;
        }
        if(ca < 0)
            ve = 0;
        if(me256 >> 8 >= gm.MeT[gm.li] && gm.mA256 < me256)
        {
            fi = true;
            gm.vAvv();
        }
        if(ca <= 0 || da <= 0)
        {
            fi = true;
            gm.vGio();
        }
    }

    public void di(DirectGraphics dg, Graphics g)
    {
        int pR = me256 - gm.mA256 >> 8;
        if(pR < -10 || pR > 228)
            return;
        yp = (5776 - 25 * pR) / (76 + pR);
        if(yp < 1 || yp > 109)
            return;
        int dx = dxE * gm.r2562[yp] >> 16;
        int dy = dyE * gm.r2562[yp] >> 16;
        if(dx > dxE)
        {
            dx = dxE;
            dy = dyE;
        }
        iE.rid(dg, gm.liS[yp] + ((rapN * gm.dxS[yp]) / rapD - dx) / 2, (94 + yp) - dy, dx, 0);
        int x = gm.liS[yp] + ((rapN * gm.dxS[yp]) / rapD - gm.ni.getWidth()) / 2;
        int y = (94 + yp) - gm.ni.getHeight();
        if(tu > 0)
            if(gm.iAuAv == 0)
            {
                dg.drawImage(gm.ni, x - (8 * yp) / 75, y, gm.an, gm.flip[ra.nextInt() & 0x3]);
                dg.drawImage(gm.ni, x + (12 * yp) / 75, y, gm.an, gm.flip[ra.nextInt() & 0x3]);
            } else
            {
                dg.drawImage(gm.ni, x + 1, y, gm.an, gm.flip[ra.nextInt() & 0x3]);
            }
    }

    private boolean cPO()
    {
        boolean f = false;
        for(int n = 0; n < 4; n++)
        {
            int pR = gm.os[n].me256 - me256 >> 8;
            f |= pR > -13 && pR < 130 && gm.os[n].co == coRe;
        }

        return f;
    }

    private boolean cC(int n)
    {
        int pR = gm.os[n].me256 - me256 >> 8;
        if(pR > -13 && pR < 130 && gm.os[n].co == coRe)
        {
            ve -= 2;
            int vMin = 120;
            if(coRe == 1)
                vMin = 40;
            if(ve < vMin)
                ve = vMin;
            if(coRe == 3)
                co = 1;
            else
                co = 3;
            return true;
        } else
        {
            return false;
        }
    }

    private boolean cSC(int n)
    {
        int pR = gm.os[n].me256 - me256 >> 8;
        if(pR > 7 && pR < 15 && gm.os[n].co == coRe)
        {
            gm.os[n].me256 += ve / 4 << 8;
            ve = -100;
            int vMin = 120;
            if(coRe == 1)
                vMin = 40;
            if(ve < vMin)
                ve = vMin;
            da -= 4 - gm.li;
            tu = 0;
            if(da < 0)
                da = 0;
            return true;
        } else
        {
            return false;
        }
    }

    private int caC(int n)
    {
        return n / 88 >= 1 ? 3 : 1;
    }

    public boolean cCG()
    {
        int pR = gm.mA256 - me256 >> 8;
        if(pR >= 0 && pR < 130 && caC(gm.xAG) == coRe)
        {
            ve -= 2;
            if(ve < 0)
                ve = 0;
            if(coRe == 3)
                co = 1;
            else
                co = 3;
            return true;
        } else
        {
            return false;
        }
    }

    public boolean cC()
    {
        int pR = me256 - gm.mA256 >> 8;
        if(pR > 0 && pR < 15)
        {
            if(yp > 75)
                yp = 75;
            int dx = dxE * gm.r2562[yp] >> 16;
            int dSc = Math.abs((gm.liS[75] + ((rapN * gm.dxS[75]) / rapD - dx) / 2) - gm.xAG);
            if(dSc > 0 && dSc < 55)
            {
                if(gm.tur > 0)
                    gm.tur = 0;
                me256 += 3328;
                gm.ve256 -= 7680;
                if(gm.ve256 < 0)
                    gm.ve256 = 0;
                gm.ve = gm.ve256 >> 8;
                gm.da -= 3;
                da--;
                if(gm.da < 0)
                    gm.da = 0;
                if(da < 0)
                    da = 0;
                return true;
            }
        } else
        if(pR < -2 && pR > -7)
        {
            if(yp > 75)
                yp = 75;
            int dx = dxE * gm.r2562[yp] >> 16;
            int xO = gm.liS[75] + ((rapN * gm.dxS[75]) / rapD - dx) / 2;
            int dSc = Math.abs(xO - gm.xAG);
            if(dSc > 0 && dSc < 55)
            {
                me256 -= 5120;
                gm.ve256 += 1280;
                gm.ve = gm.ve256 << 8;
                ve -= 100;
                if(ve < 0)
                    ve = 0;
                gm.da -= 4;
                da -= 4 - gm.li;
                if(gm.da < 0)
                    gm.da = 0;
                if(da < 0)
                    da = 0;
                return true;
            }
        }
        return false;
    }

    int pi()
    {
        return me256 - gm.mA256 >> 8;
    }
}