myplayer.java

一款麻将游戏的J2me源代码

// FrontEnd Plus GUI for JAD
 
import java.util.Vector;

// Referenced classes of package com.joypark.mj13:
//            MeldedSet

public final class myPlayer
{

    public static final byte HUMAN = 0;
    public static final byte HANDHELD = 1;
    private boolean m_bConcealed;
    private boolean m_bPicked;
    private boolean m_bIssuedTen;
    private boolean m_bTen;
    private byte m_btDiscardPos;
    private byte m_btFanTileCount;
    private byte m_btKongPos;
    private int m_nPoint;
    private Vector m_vInHand;
    private Vector m_vMelded;
    private Vector m_vHouSet;
    private Vector m_vDiscarded;
    private boolean m_bBanker;
    private byte m_btType;
    private byte m_btPickedTile;
    private byte m_btGoalPos;
    private Vector m_vChances;

    public myPlayer(byte byte0)
    {
        m_bConcealed = true;
        m_bPicked = false;
        m_bIssuedTen = false;
        m_bTen = false;
        m_btDiscardPos = 13;
        m_btFanTileCount = 0;
        m_btKongPos = -1;
        m_nPoint = 40000;
        m_vInHand = new Vector();
        m_vMelded = new Vector();
        m_vHouSet = new Vector();
        m_vDiscarded = new Vector();
        m_btType = byte0;
        m_bBanker = m_btType == 0;
    }

    public boolean isBig3Yuan()
    {
        return gotChungFan() && gotFaFan() && gotBaiFan();
    }

    public boolean isSameSuit()
    {
        boolean flag = true;
        byte byte0 = 0;
        byte byte2 = -1;
        while(flag && byte0 < m_vMelded.size()) 
        {
            MeldedSet meldedset = (MeldedSet)m_vMelded.elementAt(byte0++);
            byte byte3 = meldedset.getTileOrIndex();
            if(byte2 == -1 && byte3 < 30)
                byte2 = (byte)(byte3 / 10);
            switch(meldedset.getType())
            {
            case 4: // '\004'
            case 5: // '\005'
            case 6: // '\006'
                flag = byte3 / 10 == byte2;
                break;

            case 7: // '\007'
            case 8: // '\b'
            case 9: // '\t'
                flag = byte3 < 30 && byte3 / 10 == byte2;
                break;
            }
        }
        for(byte byte1 = 0; flag && byte1 < m_vHouSet.size();)
        {
            MeldedSet meldedset1 = (MeldedSet)m_vHouSet.elementAt(byte1++);
            byte byte4 = meldedset1.getTileOrIndex();
            if(byte2 == -1 && byte4 < 30)
                byte2 = (byte)(byte4 / 10);
            switch(meldedset1.getType())
            {
            case 10: // '\n'
                flag = byte4 / 10 == byte2;
                break;

            case 11: // '\013'
            case 12: // '\f'
                flag = byte4 < 30 && byte4 / 10 == byte2;
                break;
            }
        }

        return flag;
    }

    public boolean isPure19()
    {
        boolean flag = true;
        if(flag = isPure19(m_vMelded))
            flag = isPure19(m_vHouSet);
        return flag;
    }

    private boolean isPure19(Vector vector)
    {
        boolean flag = true;
        for(byte byte0 = 0; flag && byte0 < vector.size();)
        {
            MeldedSet meldedset = (MeldedSet)vector.elementAt(byte0++);
            byte byte1 = meldedset.getTileOrIndex();
            byte byte2 = (byte)(byte1 % 10);
            switch(meldedset.getType())
            {
            case 4: // '\004'
            case 10: // '\n'
                flag = byte2 == 1 || byte2 == 7;
                break;

            case 5: // '\005'
                flag = byte2 == 2 || byte2 == 8;
                break;

            case 6: // '\006'
                flag = byte2 == 3 || byte2 == 9;
                break;

            case 7: // '\007'
            case 8: // '\b'
            case 9: // '\t'
            case 12: // '\f'
                flag = byte1 < 30 && (byte2 == 1 || byte2 == 9);
                break;
            }
        }

        return flag;
    }

    public boolean isUnpureSameSuit()
    {
        boolean flag = true;
        byte byte0 = 0;
        byte byte2 = -1;
        while(flag && byte0 < m_vMelded.size()) 
        {
            MeldedSet meldedset = (MeldedSet)m_vMelded.elementAt(byte0++);
            byte byte3 = meldedset.getTileOrIndex();
            if(byte2 == -1 && byte3 < 30)
                byte2 = (byte)(byte3 / 10);
            switch(meldedset.getType())
            {
            case 4: // '\004'
            case 5: // '\005'
            case 6: // '\006'
                flag = byte3 / 10 == byte2;
                break;

            case 7: // '\007'
            case 8: // '\b'
            case 9: // '\t'
                flag = byte3 > 30 || byte3 / 10 == byte2;
                break;
            }
        }
        for(byte byte1 = 0; flag && byte1 < m_vHouSet.size();)
        {
            MeldedSet meldedset1 = (MeldedSet)m_vHouSet.elementAt(byte1++);
            byte byte4 = meldedset1.getTileOrIndex();
            if(byte2 == -1 && byte4 < 30)
                byte2 = (byte)(byte4 / 10);
            switch(meldedset1.getType())
            {
            case 10: // '\n'
                flag = byte4 / 10 == byte2;
                break;

            case 11: // '\013'
            case 12: // '\f'
                flag = byte4 > 30 || byte4 / 10 == byte2;
                break;
            }
        }

        return flag;
    }

    public boolean is7Pairs()
    {
        boolean flag = false;
        if(m_bConcealed)
        {
            flag = true;
            for(byte byte0 = 0; flag && byte0 < m_vHouSet.size(); flag = ((MeldedSet)m_vHouSet.elementAt(byte0++)).getType() == 12);
        }
        return flag;
    }

    public boolean isSmall3Yuan()
    {
        return gotChungFan() && gotFaFan() && getTileCount(m_vInHand, new Byte((byte)37)) == 2 || gotChungFan() && gotBaiFan() && getTileCount(m_vInHand, new Byte((byte)36)) == 2 || gotFaFan() && gotBaiFan() && getTileCount(m_vInHand, new Byte((byte)35)) == 2;
    }

    public boolean isPongPongHou()
    {
        boolean flag = true;
        byte byte2;
        for(byte byte0 = 0; flag && byte0 < m_vMelded.size(); flag = byte2 == 7 || byte2 == 8 || byte2 == 9)
            byte2 = ((MeldedSet)m_vMelded.elementAt(byte0++)).getType();

        if(flag)
        {
            byte byte1 = 0;
            byte byte3 = 0;
            while(flag && byte1 < m_vHouSet.size()) 
                switch(((MeldedSet)m_vHouSet.elementAt(byte1++)).getType())
                {
                case 12: // '\f'
                    byte3++;
                    break;

                case 10: // '\n'
                    flag = false;
                    break;
                }
            if(flag && byte3 == 7)
                flag = false;
        }
        return flag;
    }

    public boolean got3ConcealedTriple()
    {
        return getConcealedTripleCount() == 3;
    }

    private byte getConcealedTripleCount()
    {
        byte byte0 = 0;
        if(m_bConcealed)
            byte0 += m_vMelded.size();
        for(byte byte1 = 0; byte1 < m_vHouSet.size(); byte1++)
            if(((MeldedSet)m_vHouSet.elementAt(byte1)).getType() == 11)
                byte0++;

        return byte0;
    }

    public boolean isNonPure19WithWord()
    {
        boolean flag = true;
        if(flag = isNonPure19WithWord(m_vMelded))
            flag = isNonPure19WithWord(m_vHouSet);
        return flag;
    }

    private boolean isNonPure19WithWord(Vector vector)
    {
        boolean flag = true;
        for(byte byte0 = 0; flag && byte0 < vector.size();)
        {
            MeldedSet meldedset = (MeldedSet)vector.elementAt(byte0++);
            byte byte1 = meldedset.getTileOrIndex();
            byte byte2 = (byte)(byte1 % 10);
            switch(meldedset.getType())
            {
            case 4: // '\004'
            case 10: // '\n'
                flag = byte2 == 1 || byte2 == 7;
                break;

            case 5: // '\005'
                flag = byte2 == 2 || byte2 == 8;
                break;

            case 6: // '\006'
                flag = byte2 == 3 || byte2 == 9;
                break;

            case 7: // '\007'
            case 8: // '\b'
            case 9: // '\t'
            case 12: // '\f'
                flag = byte1 > 30 || byte2 == 1 || byte2 == 9;
                break;
            }
        }

        return flag;
    }

    public boolean gotDragon()
    {
        boolean flag = false;
        m_vChances = sequenceFilter();
        if(m_vChances.size() > 2)
        {
            Vector vector = new Vector();
            Vector vector1 = new Vector();
            Vector vector2 = new Vector();
            for(byte byte0 = 0; byte0 < m_vChances.size(); byte0++)
            {
                MeldedSet meldedset = (MeldedSet)m_vChances.elementAt(byte0);
                byte byte1 = meldedset.getTileOrIndex();
                switch(meldedset.getType())
                {
                case 5: // '\005'
                    byte1--;
                    break;

                case 6: // '\006'
                    byte1 -= 2;
                    break;
                }
                switch(byte1 / 10)
                {
                case 0: // '\0'
                    vector.addElement(new Byte((byte)(byte1 % 10)));
                    break;

                case 1: // '\001'
                    vector1.addElement(new Byte((byte)(byte1 % 10)));
                    break;

                case 2: // '\002'
                    vector2.addElement(new Byte((byte)(byte1 % 10)));
                    break;
                }
            }

            if(vector.size() > 2)
                flag = gotDragon(vector);
            if(!flag && vector1.size() > 2)
                flag = gotDragon(vector1);
            if(!flag && vector2.size() > 2)
                flag = gotDragon(vector2);
        }
        return flag;
    }

    private boolean gotDragon(Vector vector)
    {
        sort(vector);
        return vector.contains(new Byte((byte)1)) && vector.contains(new Byte((byte)4)) && vector.contains(new Byte((byte)7));
    }

    public boolean gotSameSequence()
    {
        m_vChances = sequenceFilter();
        boolean flag = false;
        if(m_vChances.size() > 1)
        {
            for(byte byte0 = 0; !flag && byte0 < m_vChances.size() - 1;)
            {
                MeldedSet meldedset = (MeldedSet)m_vChances.elementAt(byte0++);
                byte byte1 = meldedset.getType();
                byte byte2 = meldedset.getTileOrIndex();
                byte2 = meldedset.getType() != 5 ? meldedset.getType() != 6 ? byte2 : (byte)(byte2 - 2) : (byte)(byte2 - 1);
                byte byte5;
                for(byte byte3 = byte0; !flag && byte3 < m_vChances.size(); flag = byte2 == byte5)
                {
                    MeldedSet meldedset1 = (MeldedSet)m_vChances.elementAt(byte3++);
                    byte byte4 = meldedset1.getType();
                    byte5 = meldedset1.getTileOrIndex();
                    byte5 = meldedset1.getType() != 5 ? meldedset1.getType() != 6 ? byte5 : (byte)(byte5 - 2) : (byte)(byte5 - 1);
                }

            }

        }
        return flag;
    }

    private Vector sequenceFilter()
    {
        Vector vector = new Vector();
        for(byte byte0 = 0; byte0 < m_vMelded.size(); byte0++)
        {
            MeldedSet meldedset = (MeldedSet)m_vMelded.elementAt(byte0);
            if(meldedset.getType() == 4 || meldedset.getType() == 5 || meldedset.getType() == 6)
                vector.addElement(meldedset);
        }

        for(byte byte1 = 0; byte1 < m_vHouSet.size(); byte1++)
        {
            MeldedSet meldedset1 = (MeldedSet)m_vHouSet.elementAt(byte1);
            if(meldedset1.getType() == 10)
                vector.addElement(meldedset1);
        }

        return vector;
    }

    public boolean isNo19()
    {
        boolean flag = true;
        for(byte byte0 = 0; flag && byte0 < m_vMelded.size();)
        {
            MeldedSet meldedset = (MeldedSet)m_vMelded.elementAt(byte0++);
            byte byte2 = meldedset.getTileOrIndex();
            byte byte4 = (byte)(byte2 % 10);
            switch(meldedset.getType())
            {
            case 4: // '\004'
                flag &= byte4 != 1 && byte4 != 7;
                break;

            case 5: // '\005'
                flag &= byte4 != 2 && byte4 != 8;
                break;

            case 6: // '\006'
                flag &= byte4 != 3 && byte4 != 9;
                break;

            case 7: // '\007'
            case 8: // '\b'
            case 9: // '\t'
                flag &= byte2 < 30 && byte4 != 1 && byte4 != 9;
                break;
            }
        }

        if(flag)
        {
            for(byte byte1 = 0; flag && byte1 < m_vHouSet.size();)
            {
                MeldedSet meldedset1 = (MeldedSet)m_vHouSet.elementAt(byte1++);
                byte byte3 = meldedset1.getTileOrIndex();
                byte byte5 = (byte)(byte3 % 10);
                switch(meldedset1.getType())