myplayer.java

一款麻将游戏的J2me源代码

                {
                case 10: // '\n'
                    flag &= byte5 != 1 && byte5 != 7;
                    break;

                case 11: // '\013'
                case 12: // '\f'
                    flag &= byte3 < 30 && byte5 != 1 && byte5 != 9;
                    break;
                }
            }

        }
        return flag;
    }

    public boolean isPinHou()
    {
        boolean flag = true;
        byte byte2;
        for(byte byte0 = 0; flag && byte0 < m_vMelded.size(); flag &= byte2 == 4 || byte2 == 5 || byte2 == 6)
            byte2 = ((MeldedSet)m_vMelded.elementAt(byte0++)).getType();

        if(flag)
        {
            byte byte1 = 0;
            byte byte3;
            for(byte3 = 0; flag && byte3 < 2 && byte1 < m_vHouSet.size();)
            {
                byte byte4 = ((MeldedSet)m_vHouSet.elementAt(byte1++)).getType();
                if(byte4 == 12)
                    byte3++;
                else
                    flag &= byte4 == 10;
            }

            flag &= byte3 == 1;
        }
        return flag;
    }

    public boolean gotBaiFan()
    {
        return got3WordTiles((byte)37);
    }

    public boolean gotFaFan()
    {
        return got3WordTiles((byte)36);
    }

    public boolean gotChungFan()
    {
        return got3WordTiles((byte)35);
    }

    public boolean gotWindFan(byte byte0)
    {
        return got3WordTiles((byte)(byte0 + 31));
    }

    private boolean got3WordTiles(byte byte0)
    {
        boolean flag = false;
        if(!(flag = gotWordPong(byte0)))
        {
            byte byte1 = getTileCount(m_vInHand, new Byte(byte0));
            flag = byte1 == 3 || byte1 == 2 && byte0 == m_btPickedTile;
        }
        return flag;
    }

    private boolean gotWordPong(byte byte0)
    {
        boolean flag = false;
        for(byte byte1 = 0; !flag && byte1 < m_vMelded.size();)
        {
            MeldedSet meldedset = (MeldedSet)m_vMelded.elementAt(byte1++);
            if(meldedset.getType() == 7 || meldedset.getType() == 8 || meldedset.getType() == 9)
                flag = meldedset.getTileOrIndex() == byte0;
        }

        return flag;
    }

    public boolean isBanker()
    {
        return m_bBanker;
    }

    public void setBanker(boolean flag)
    {
        m_bBanker = flag;
    }

    public void calPoint(int i)
    {
        m_nPoint += i;
    }

    public int getPoint()
    {
        return m_nPoint;
    }

    public void setPoint(int i)
    {
        m_nPoint = i;
    }

    public void lostLastDiscardedTile()
    {
        m_vDiscarded.removeElementAt(m_vDiscarded.size() - 1);
    }

    public byte inHandPos(byte byte0)
    {
        return (byte)m_vInHand.indexOf(new Byte(byte0));
    }

    public boolean gotMeldChance(byte byte0)
    {
        m_vChances = new Vector();
        chowFChance(byte0);
        chowMChance(byte0);
        chowLChance(byte0);
        pongChance(byte0);
        kongUChance(byte0);
        return m_vChances.size() != 0;
    }

    private void kongUChance(byte byte0)
    {
        if(getTileCount(m_vInHand, new Byte(byte0)) == 3)
            m_vChances.addElement(new MeldedSet((byte)9, byte0));
    }

    private void pongChance(byte byte0)
    {
        if(getTileCount(m_vInHand, new Byte(byte0)) > 1)
            m_vChances.addElement(new MeldedSet((byte)7, byte0));
    }

    private void chowLChance(byte byte0)
    {
        if(byte0 < 30 && byte0 % 10 > 2 && m_vInHand.contains(new Byte((byte)(byte0 - 1))) && m_vInHand.contains(new Byte((byte)(byte0 - 2))))
            m_vChances.addElement(new MeldedSet((byte)6, byte0));
    }

    private void chowMChance(byte byte0)
    {
        if(byte0 < 30 && byte0 % 10 > 1 && byte0 % 10 < 9 && m_vInHand.contains(new Byte((byte)(byte0 - 1))) && m_vInHand.contains(new Byte((byte)(byte0 + 1))))
            m_vChances.addElement(new MeldedSet((byte)5, byte0));
    }

    private void chowFChance(byte byte0)
    {
        if(byte0 < 30 && byte0 % 10 < 8 && m_vInHand.contains(new Byte((byte)(byte0 + 1))) && m_vInHand.contains(new Byte((byte)(byte0 + 2))))
            m_vChances.addElement(new MeldedSet((byte)4, byte0));
    }

    public byte lastDiscardedTile()
    {
        return ((Byte)m_vDiscarded.lastElement()).byteValue();
    }

    public MeldedSet getMeldedAt(byte byte0)
    {
        return (MeldedSet)m_vMelded.elementAt(byte0);
    }

    public byte getMeldedCount()
    {
        return (byte)m_vMelded.size();
    }

    public void doMelded(MeldedSet meldedset)
    {
        m_bConcealed = m_bConcealed && (meldedset.getType() == 0 || meldedset.getType() == 2);
        switch(meldedset.getType())
        {
        case 8: // '\b'
        default:
            break;

        case 9: // '\t'
            for(byte byte0 = 0; byte0 < 3; byte0++)
                m_vInHand.removeElement(new Byte(meldedset.getTileOrIndex()));

            m_vMelded.addElement(meldedset);
            m_btDiscardPos = (byte)m_vInHand.size();
            break;

        case 7: // '\007'
            m_vInHand.removeElement(new Byte(meldedset.getTileOrIndex()));
            m_vInHand.removeElement(new Byte(meldedset.getTileOrIndex()));
            Byte byte1 = (Byte)m_vInHand.lastElement();
            m_vInHand.removeElement(byte1);
            m_bPicked = true;
            m_btPickedTile = byte1.byteValue();
            m_btDiscardPos = (byte)m_vInHand.size();
            m_vMelded.addElement(meldedset);
            break;

        case 4: // '\004'
            m_vInHand.removeElement(new Byte((byte)(meldedset.getTileOrIndex() + 1)));
            m_vInHand.removeElement(new Byte((byte)(meldedset.getTileOrIndex() + 2)));
            Byte byte2 = (Byte)m_vInHand.lastElement();
            m_vInHand.removeElement(byte2);
            m_bPicked = true;
            m_btPickedTile = byte2.byteValue();
            m_btDiscardPos = (byte)m_vInHand.size();
            m_vMelded.addElement(meldedset);
            break;

        case 5: // '\005'
            m_vInHand.removeElement(new Byte((byte)(meldedset.getTileOrIndex() - 1)));
            m_vInHand.removeElement(new Byte((byte)(meldedset.getTileOrIndex() + 1)));
            Byte byte3 = (Byte)m_vInHand.lastElement();
            m_vInHand.removeElement(byte3);
            m_bPicked = true;
            m_btPickedTile = byte3.byteValue();
            m_btDiscardPos = (byte)m_vInHand.size();
            m_vMelded.addElement(meldedset);
            break;

        case 6: // '\006'
            m_vInHand.removeElement(new Byte((byte)(meldedset.getTileOrIndex() - 1)));
            m_vInHand.removeElement(new Byte((byte)(meldedset.getTileOrIndex() - 2)));
            Byte byte4 = (Byte)m_vInHand.lastElement();
            m_vInHand.removeElement(byte4);
            m_bPicked = true;
            m_btPickedTile = byte4.byteValue();
            m_btDiscardPos = (byte)m_vInHand.size();
            m_vMelded.addElement(meldedset);
            break;

        case 0: // '\0'
            m_btKongPos = (byte)m_vDiscarded.size();
            for(byte byte5 = 0; byte5 < 3; byte5++)
                m_vInHand.removeElementAt(meldedset.getTileOrIndex());

            m_vMelded.addElement(new MeldedSet((byte)8, m_btPickedTile));
            break;

        case 1: // '\001'
            m_btKongPos = (byte)m_vDiscarded.size();
            ((MeldedSet)m_vMelded.elementAt(meldedset.getTileOrIndex())).changeTo((byte)9);
            break;

        case 2: // '\002'
            m_btKongPos = (byte)m_vDiscarded.size();
            m_vMelded.addElement(new MeldedSet((byte)8, ((Byte)m_vInHand.elementAt(meldedset.getTileOrIndex())).byteValue()));
            for(byte byte6 = 0; byte6 < 4; byte6++)
                m_vInHand.removeElementAt(meldedset.getTileOrIndex());

            m_vInHand.addElement(new Byte(m_btPickedTile));
            sortInHand();
            break;

        case 3: // '\003'
            m_btKongPos = (byte)m_vDiscarded.size();
            ((MeldedSet)m_vMelded.elementAt(meldedset.getTileOrIndex())).changeTo((byte)9);
            m_vInHand.removeElement(new Byte(((MeldedSet)m_vMelded.elementAt(meldedset.getTileOrIndex())).getTileOrIndex()));
            m_vInHand.addElement(new Byte(m_btPickedTile));
            sortInHand();
            break;
        }
    }

    public byte getChanceCount()
    {
        return (byte)m_vChances.size();
    }

    public MeldedSet currentChance()
    {
        return (MeldedSet)m_vChances.firstElement();
    }

    public void rightChance()
    {
        Object obj = m_vChances.firstElement();
        m_vChances.removeElement(obj);
        m_vChances.addElement(obj);
    }

    public void leftChance()
    {
        Object obj = m_vChances.lastElement();
        m_vChances.removeElement(obj);
        m_vChances.insertElementAt(obj, 0);
    }

    public void calFanTileCount(Vector vector)
    {
        m_btFanTileCount = 0;
        for(byte byte0 = 0; byte0 < vector.size(); byte0++)
            m_btFanTileCount += getTileCount(m_vInHand, (Byte)vector.elementAt(byte0));

    }

    public byte getFanTileCount()
    {
        return m_btFanTileCount;
    }

    public void reset()
    {
        m_vInHand.removeAllElements();
        m_vMelded.removeAllElements();
        m_vHouSet.removeAllElements();
        m_vDiscarded.removeAllElements();
        m_bConcealed = true;
        m_bTen = false;
        m_btDiscardPos = 13;
        m_btFanTileCount = 0;
    }

    public void cancelIssuedTen()
    {
        m_bIssuedTen = false;
    }

    public boolean isTenIssued()
    {
        return m_bIssuedTen;
    }

    public void issueTen()
    {
        m_bIssuedTen = true;
    }

    public boolean isConcealed()
    {
        return m_bConcealed;
    }

    public byte getGoalPos()
    {
        return m_btGoalPos;
    }

    public void chooseDiscard()
    {
        Vector vector = cloneVector(m_vInHand);
        vector.addElement(new Byte(m_btPickedTile));
        sort(vector);
        m_vHouSet.removeAllElements();
        Vector vector1 = new Vector();
        while(vector.size() != 0) 
            if(!isSequence(vector) && !isTriple(vector) && !isPair(vector))
            {
                Object obj = vector.firstElement();
                vector1.addElement(obj);
                vector.removeElement(obj);
            }
        m_btGoalPos = (byte)m_vInHand.size();
        if(vector1.size() != 0)
        {
            Byte byte1 = (Byte)vector1.lastElement();
            if(byte1.byteValue() != m_btPickedTile)
                m_btGoalPos = (byte)m_vInHand.indexOf(byte1);
        }
    }

    public byte getDiscardedTile(byte byte0)
    {
        return ((Byte)m_vDiscarded.elementAt(byte0)).byteValue();
    }

    public byte getDiscardedCount()
    {
        return (byte)m_vDiscarded.size();
    }

    public void discard()
    {
        m_bPicked = false;
        Byte byte1 = null;
        if(m_btDiscardPos == m_vInHand.size())
        {
            byte1 = new Byte(m_btPickedTile);
        } else
        {
            byte1 = (Byte)m_vInHand.elementAt(m_btDiscardPos);
            m_vInHand.removeElement(byte1);
            m_vInHand.addElement(new Byte(m_btPickedTile));
            sort(m_vInHand);
        }
        m_vDiscarded.addElement(byte1);
    }

    public void setTen()//设置听牌
    {
        m_bTen = true;
    }

    public boolean isTen()
    {
        return m_bTen;
    }

    public boolean ten()
    {
        Vector vector = cloneVector(m_vInHand);
        return checkTenSTP(vector) || checkTenTPS(vector) || checkTenSTPO(vector) || checkTenTPSO(vector);
    }

    private boolean checkTenTPSO(Vector vector)
    {
        m_vHouSet.removeAllElements();
        Vector vector1 = cloneVector(vector);
        Vector vector2 = new Vector();
        byte byte0 = 0;
        while(vector2.size() < 3 && vector1.size() != 0) 
            if(!isTripleO(vector1))
                if(isPairO(vector1))
                    byte0 += 2;
                else
                if(!isSequenceO(vector1))
                {
                    Object obj = vector1.lastElement();
                    vector2.addElement(obj);
                    vector1.removeElement(obj);
                }
        return reachTenCondition(vector2, byte0);
    }

    private boolean checkTenSTPO(Vector vector)
    {
        m_vHouSet.removeAllElements();
        Vector vector1 = cloneVector(vector);
        Vector vector2 = new Vector();
        byte byte0 = 0;