/**
     * Constructor.
     */
    public GameInfo()
    {
        money = new long[2]; // 0: 플레이어 / 1: 컴퓨터.

        initDefaultValue(); // 기본 설정 저장.

        rsName = "TwogoInfo";

        /*
         * Record store 생성.
         */
        try {
            recordStore = RecordStore.openRecordStore(rsName, false);

            readGameInfo(); // 이미 RS가 존재한다면, Game Info를 읽어옴.
        }
        catch (RecordStoreNotFoundException e) {
            // RS가 존재하지 않는다면, RS를 만들고 기본값 저장.
            saveGameInfo();
        }
        catch (RecordStoreFullException e) {}
        catch (RecordStoreException e){}
    }

/*
 * Record store 생성.
 */
try {
    recordStore = RecordStore.openRecordStore(rsName, false);

    readGameInfo(); // 이미 RS가 존재한다면, Game Info를 읽어옴.
}
catch (RecordStoreNotFoundException e) {
    // RS가 존재하지 않는다면, RS를 만들고 기본값 저장.
    saveGameInfo();
}
catch (RecordStoreFullException e) {}
catch (RecordStoreException e){}

/**
 * Record store가 존재하지 않으면, 
 * 새로 Record store를 생성하고 기본값 기록.
 */
public void saveGameInfo()
{
    startWrite(rsName);

    try {
        // 돈.
        writeLong(money[0]);
        writeLong(money[1]);
        // 사운드/진동.
        writeBoolean(sound);
        writeBoolean(vibration);
    } catch(Exception e) {}

    endWrite();
}

/**
 * Record store에서 데이터를 읽어옴.
 */
public void readGameInfo()
{
    try {
        re = recordStore.enumerateRecords(null, this, true);

        while(re.hasNextElement()) {
            int id = re.nextRecordId();
            bais = new ByteArrayInputStream(recordStore.getRecord(id));
            dis = new DataInputStream(bais);

            try {
                // 돈.
                money[0] = readLong();
                money[1] = readLong();
                // 사운드/진동.
                sound = readBoolean();
                vibration = readBoolean();
            } catch(Exception e) {}
        }
    }
    catch (RecordStoreException e){}

    endRead();
}

package common;

import java.io.*;
import javax.microedition.rms.*;

public class DataManager implements RecordComparator
{
    protected DataInputStream dis = null;
    protected DataOutputStream dos = null;
    protected RecordEnumeration re = null;
    protected RecordStore recordStore = null;
    protected ByteArrayInputStream bais = null;
    protected ByteArrayOutputStream baos = null;

    /**
     * RMS에 데이터를 기록할 준비를 함.
     */
    protected void startWrite(String rsName)
    {
        try {
            recordStore = RecordStore.openRecordStore(rsName, true);
        }
        catch (RecordStoreNotFoundException e) {}
        catch (RecordStoreFullException e) {}
        catch (RecordStoreException e){}

        baos = new ByteArrayOutputStream();
        dos = new DataOutputStream(baos);
    }

    /**
     * baos의 내용을 RS에 복사 후, RS를 닫는다.
     */
    protected void endWrite()
    {
        byte[] byteArray = baos.toByteArray();


        for(int i=0; i<byteArray.length; i++)
            System.out.println(byteArray[i]);

        try {
            // bos에 기록한 내용을 RS에 추가한다.
            recordStore.addRecord(byteArray, 0, byteArray.length);
        } catch(RecordStoreException rse) {}

        closeRS();

        dos = null;
        baos = null;

        recordStore = null;

        System.gc();
    }

    /**
     * RS에서 필요한 데이터를 읽어왔다면, RS를 닫는다.
     */
    protected void endRead()
    {
        closeRS();

        re = null;

        dis = null;
        bais = null;

        recordStore = null;

        System.gc();
    }

    protected void writeBoolean(boolean value) throws Exception
    {
        dos.writeBoolean(value);
    }

    protected void writeLong(long value) throws Exception
    {
        dos.writeLong(value);
    }

    protected void writeInt(int value) throws Exception
    {
        dos.writeInt(value);
    }

    protected boolean readBoolean() throws Exception
    {
        return dis.readBoolean();
    }

    protected long readLong() throws Exception
    {
        return dis.readLong();
    }

    protected int readInt() throws Exception
    {
        return dis.readInt();
    }

    /**
     * 현재 열려있는 Record store를 닫는다.
     */
    protected void closeRS()
    {
        try{
            recordStore.closeRecordStore();
        } catch(RecordStoreException rse) {}
    }

    /**
     * 특정 RS를 삭제한다.
     * @param recordStoreName
     */
    protected void deleteRS(String recordStoreName)
    {
        try{
            RecordStore.deleteRecordStore(recordStoreName);
        } catch(RecordStoreException rse) {}
    }

    public int compare(byte[] arg1, byte[] arg2)
    {
        return 1;
    }

}

    /**
     * RMS에 데이터를 기록할 준비를 함.
     */
    protected void startWrite(String rsName)
    {
        try {
            recordStore = RecordStore.openRecordStore(rsName, true);
        }
        catch (RecordStoreNotFoundException e) {}
        catch (RecordStoreFullException e) {}
        catch (RecordStoreException e){}

        baos = new ByteArrayOutputStream();
        dos = new DataOutputStream(baos);
    }

    /**
     * baos의 내용을 RS에 복사 후, RS를 닫는다.
     */
    protected void endWrite()
    {
        byte[] byteArray = baos.toByteArray();


        for(int i=0; i<byteArray.length; i++)
            System.out.println(byteArray[i]);

        try {
            // bos에 기록한 내용을 RS에 추가한다.
            recordStore.addRecord(byteArray, 0, byteArray.length);
        } catch(RecordStoreException rse) {}

        closeRS();

        dos = null;
        baos = null;

        recordStore = null;

        System.gc();
    }

    /**
     * 현재 열려있는 Record store를 닫는다.
     */
    protected void closeRS()
    {
        try{
            recordStore.closeRecordStore();
        } catch(RecordStoreException rse) {}
    }

    /**
     * 특정 RS를 삭제한다.
     * @param recordStoreName
     */
    protected void deleteRS(String recordStoreName)
    {
        try{
            RecordStore.deleteRecordStore(recordStoreName);
        } catch(RecordStoreException rse) {}
    }

    /**
     * 금액 설정.
     * @param userType
     * @param money
     */
    public void setMoney(int userType, long money)
    {
        this.money[userType] = money;
    }

    /**
     * 보유 금액 리턴.
     * @param userType
     * @return
     */
    public long getMoney(int userType)
    {
        return money[userType];
    }

    /**
     * 사운드 재생이 가능한가.
     * @return
     */
    public boolean isPlayableSound()
    {
        return sound;
    }

    /**
     * 진동이 가능한가.
     * @return
     */
    public boolean isPossibleVibration()
    {
        return vibration;
    }

    /**
     * mute 설정.
     * @param mute
     */
    public void setMute(boolean mute)
    {
        sound = !mute; // 반대의 값을 집어넣어준다.
    }

    /**
     * 진동 설정.
     * @param bVib
     */
    public void setVibration(boolean bVib)
    {
        vibration = bVib;
    }

package common;

import java.io.InputStream;
import com.skt.m.AudioClip;
import com.skt.m.AudioSystem;

/**
 * 소리를 낼때 사용하는 thread
 * 잠시 기다렸다가, 소리를 낼때 깨서 다시 기다리는 과정을 반복한다.
 */

public class SoundThread extends Thread
{
    private AudioClip currentClip = null;

    private byte[] sndtmp;
    private byte[][] snd;
    private int currentIndex;
    private boolean bPlaying=false;

    private String path;
    private InputStream is = null;
    private boolean bReady;
    private boolean bOn;

    /**
     * Constructor #1.
     */
    public SoundThread()
    {
        this(11);
    }

    /**
     * Constructor #2.
     * @param maxSound
     */
    public SoundThread(int maxSound)
    {
        bOn = true;

        snd = new byte[maxSound][];

        try
        {
            currentClip = AudioSystem.getAudioClip("mmf");
        } catch(Exception e) {}
    }

    /**
     * mix해 놓은 사운드 data 파일의 경로를 설정해 놓는다.
     * @param path
     */
    public void setSoundData(String path)
    {
        this.path = path;
    }

    public void cleanUp()
    {
        is = null;
        System.gc();
    }


    /**
     * mix해 놓은 사운드 data를 해당 byte 배열에 읽어 놓는다.
     * @param index
     * @param off
     * @param len
     */
    public void addSound(int index, int off, int len)
    {
        try
        {
            is = getClass().getResourceAsStream(path);
            snd[index] = new byte[len];
            is.skip(off);
            is.read( snd[index], 0, len);
            is.close();
        } catch (Exception e)
        {
        }
    }

    /**
     * 지정해 놓은 index로 사운드를 재생한다.
     * @param index
     */
    public synchronized void play(int index)
    {
        closeClip();

        waitForReady();

        currentIndex = index;
        try
        {
            currentClip.open(snd[currentIndex], 0, snd[currentIndex].length);
        } catch (Exception e) {
        }
        bPlaying = true;
        this.notify();
    }

    /**
     * 임시로 어떤 파일을 재생할때 사용한다.
     * @param path
     */
    public synchronized void play(String path)
    {

        closeClip();
        waitForReady();
        try
        {
            is = getClass().getResourceAsStream(path);
            sndtmp = new byte[is.available()];
            is.read( sndtmp, 0, is.available());
            is.close();
            currentClip.open(sndtmp,0,sndtmp.length);
        } catch(Exception e){
            is = null;
        }
        currentIndex = -1;      // 임시로 재생 하는 번호
        bPlaying = true;
        this.notify();
    }

    /**
     * 처리하고 있는 중이라면 잠시 기다린다.
     */
    private void waitForReady()
    {
        int count=0;
        try
        {
            while(bReady==false)
            {

                this.wait(100);
                Thread.yield();

                count++;
                if(count>=50) break;

                // sleep을 사용하면 안됨.
            }
        } catch(Exception e) {}
    }

    /**
     * 현재 재생중인 사운드를 정지한다.
     */
    private void closeClip()
    {
        try
        {
            currentClip.stop();
        } catch(Exception e) {}

        try
        {
            currentClip.close();
        } catch(Exception e) {}
    }

    public void run()
    {
        while (true)
        {
            synchronized (this)
            {
                bReady = true;
                try
                {
                    // 잠시 기다린다.
                    while (!bPlaying)
                    {
                        this.wait();
                    }
                } catch (Exception e) {}
                bReady = false;
            }

            try
            {
                if(bOn==true)
                {       // 사운드가 켜져 있을때만 소리를 낸다.
                    currentClip.play();
                }

                synchronized (this)
                {
                    bPlaying = false;
                }
            } catch (Exception e)
            {
                bPlaying = false;
            } finally
            {
                sndtmp = null;
                try
                {
                    currentClip.close();
                } catch (Exception e) {}
            }
        }
    }

    /**
     * 사운드 재생 : On
     */
    public void turnOn()
    {
        bOn = true;
    }

    /**
     * 사운드 재생 : Off
     */
    public void turnOff()
    {
        bOn = false;
    }



    /**
     * 볼륨을 1 증가한다.
     */
    public void volUp()
    {
        try
        {
            AudioSystem.setVolume("mmf", AudioSystem.getVolume("mmf")+1);
        } catch (Exception e)
        {}
    }

    /**
     * 볼륨을 1감소한다.
     */
    public void volDown()
    {
        try
        {
            AudioSystem.setVolume("mmf", AudioSystem.getVolume("mmf")-1);
        } catch (Exception e)
        {}
    }

    /**
     * 볼륨을 설정한다.
     * @param volume
     */
    public void setVol(int volume)
    {
        try
        {
            AudioSystem.setVolume("mmf", volume);
        } catch (Exception e)
        {}
    }

    /**
     * 현재 설정된 볼륨값을 전달한다.
     * @return 현재volume값
     */
    public int getVol()
    {
        int vol = 0;
        try
        {
            vol = AudioSystem.getVolume("mmf");
        } catch (Exception e)
        {}

        return vol;
    }
}

    /**
     * Constructor #1.
     */
    public SoundThread()
    {
        this(11);
    }

    /**
     * Constructor #2.
     * @param maxSound
     */
    public SoundThread(int maxSound)
    {
        bOn = true;

        snd = new byte[maxSound][];

        try
        {
            currentClip = AudioSystem.getAudioClip("mmf");
        } catch(Exception e) {}
    }

    /**
     * mix해 놓은 사운드 data 파일의 경로를 설정해 놓는다.
     * @param path
     */
    public void setSoundData(String path)
    {
        this.path = path;
    }

    /**
     * mix해 놓은 사운드 data를 해당 byte 배열에 읽어 놓는다.
     * @param index
     * @param off
     * @param len
     */
    public void addSound(int index, int off, int len)
    {
        try
        {
            is = getClass().getResourceAsStream(path);
            snd[index] = new byte[len];
            is.skip(off);
            is.read( snd[index], 0, len);
            is.close();
        } catch (Exception e)
        {
        }
    }

    /**
     * 지정해 놓은 index로 사운드를 재생한다.
     * @param index
     */
    public synchronized void play(int index)
    {
        closeClip();

        waitForReady();

        currentIndex = index;
        try
        {
            currentClip.open(snd[currentIndex], 0, snd[currentIndex].length);
        } catch (Exception e) {}

        bPlaying = true;
        this.notify();
    }

    /**
     * 처리하고 있는 중이라면 잠시 기다린다.
     */
    private void waitForReady()
    {
        int count=0;

        try
        {
            while(bReady==false)
            {

                this.wait(100);
                Thread.yield();

                count++;
                if(count>=50) break;

                // sleep을 사용하면 안됨.
            }
        } catch(Exception e) {}
    }

    /**
     * 현재 재생중인 사운드를 정지한다.
     */
    private void closeClip()
    {
        try
        {
            currentClip.stop();
        } catch(Exception e) {}

        try
        {
            currentClip.close();
        } catch(Exception e) {}
    }

/**
 * 사운드를 설정한다.
 */
private void initSound()
{
    sound.setSoundData("/sound/sound.dat");

    sound.addSound(SND_ABELL,0,199);
    sound.addSound(SND_CARD, 199,510);		
    sound.addSound(SND_CHOICE,709,203);
    sound.addSound(SND_GAMEOVER,912,2931);
    sound.addSound(SND_GAMESTARTED,3843,4016);
    sound.addSound(SND_GO,7859,1424);
    sound.addSound(SND_LONGBELL,9283,203);
    sound.addSound(SND_MATCH,9486,728);
    sound.addSound(SND_MYTURN,10214,1632);
    sound.addSound(SND_NOMATCH,11846,593);
    sound.addSound(SND_VOLUMEKEY,12439,148);
		
    sound.cleanUp();
}

    sound.play( 사운드 인덱스 상수 );

☆
☆
☆
☆
☆
☆

/**
 * 카드 둘중 하나를 선택할때...
 * @param g
 */
private void drawSelectTwoCards(Graphics g)
{
    byte index;

    drawRunningGame(g);
    /* 카드 두장 중 하나를 선택한다. */
    dialog.drawBorder(g, CyDialog.SELECTTWOCARD);

    // 두 종류의 카드를 보여줌.
    if(room.slot[0] != room.CARD_NULL)
        index = 0;
    else if(room.slot[1] != room.CARD_NULL)
        index = 1;
    else return;

    drawCard(40, 66, room.getMonth(room.slot[index])[0]);
    drawCard(65, 66, room.getMonth(room.slot[index])[1]);

    // 컴퓨터 턴이라면 AI가 선택.
    if(curTurn == User.COMPUTER)
    {
        Sleep.sleep(500);
        selectTwoCards(index, User.COMPUTER, 
                       agent.selectTwoCards(index));
    }
}

/**
 * A.I.가 두 장의 카드 중 하나를 선택한다.
 * @return
 */
public byte selectTwoCards(byte index)
{
    byte i;

    /* 광 체크. */
    for(i=0; i<2; i++)
    {
        // 두개의 패중에 광이 있다면,
        if(gCard.getType(
                 room.getMonth(room.slot[index])[i]) == CARDTYPE_KWANG
            || gCard.getType(
                 room.getMonth(room.slot[index])[i]) == CARDTYPE_BIKWANG)
        {
            System.out.println(" # selectTwoCards MSG : 광 발견!");
            return (byte)(i+1);
        }
    }

    /* 고도리, 청단, 홍단, 초단 체크 */
    for(i=0; i<2; i++)
    {
        // 고도리 검색 허용 상태이거나 상대방이 고도리를 두장 이상 가지고 있다면,
        if(bNoFindGodori == false
            || (room.getCntGodori(Room.PLAYER) >= 2 
                && room.getCntGodori(Room.COMPUTER) == 0))
        {
            if(room.getCntGodori(Room.PLAYER) >= 1)
            {
                bNoFindGodori = true;
            }
            else if(gCard.getType(
                     room.getMonth(room.slot[index])[i]) == CARDTYPE_GODORI)
            {
                // 두개의 패중에 고도리가 있다면,
                System.out.println(" # selectTwoCards MSG : 고도리 발견!");
                return (byte)(i+1);
            }
        }

        // 청단 검색 허용 상태이거나 상대방이 청단을 두장 이상 가지고 있다면,
        if(bNoFindChungDan == false
            || (room.getCntChungDan(Room.PLAYER) >= 2 
                && room.getCntChungDan(Room.COMPUTER) == 0))
        {
            if(room.getCntChungDan(Room.PLAYER) >= 1)
            {
                bNoFindChungDan = true;
            }
            else if(gCard.getType(
                     room.getMonth(room.slot[index])[i]) == CARDTYPE_CHUNGDAN)
            {
                // 두개의 패중에 청단이 있다면,
                System.out.println(" # selectTwoCards MSG : 청단 발견!");
                return (byte)(i+1);
            }
        }

        // 홍단 검색 허용 상태이거나 상대방이 홍단을 두장 이상 가지고 있다면,
        if(bNoFindHongDan == false
            || (room.getCntHongDan(Room.PLAYER) >= 2 
                && room.getCntHongDan(Room.COMPUTER) == 0))
        {
            if(room.getCntHongDan(Room.PLAYER) >= 1)
            {
                bNoFindHongDan = true;
            }
            else if(gCard.getType(
                     room.getMonth(room.slot[index])[i]) == CARDTYPE_HONGDAN)
            {
                // 두개의 패중에 홍단이 있다면,
                System.out.println(" # selectTwoCards MSG : 홍단 발견!");
                return (byte)(i+1);
            }
        }

        // 초단 검색 허용 상태이거나 상대방이 초단을 두장 이상 가지고 있다면,
        if(bNoFindChoDan == false
            || (room.getCntChoDan(Room.PLAYER) >= 2 
                && room.getCntChoDan(Room.COMPUTER) == 0))
        {
            if(room.getCntChoDan(Room.PLAYER) >= 1)
            {
                bNoFindChoDan = true;
            }
            else if(gCard.getType(
                     room.getMonth(room.slot[index])[i]) == CARDTYPE_CHODAN)
            {
                // 두개의 패중에 초단이 있다면,
                System.out.println(" # selectTwoCards MSG : 초단 발견!");
                return (byte)(i+1);
            }
        }
    }

    /* 쌍피 체크 */
    for(i=0; i<2; i++)
    {
        // 두개의 패중에 쌍피가 있다면,
        if(gCard.getType(
                 room.getMonth(room.slot[index])[i]) == CARDTYPE_SSANG_PEE)
        {
            System.out.println(" # selectTwoCards MSG : 쌍피 발견!");
            return (byte)(i+1);
        }
        else if(room.getMonth(room.slot[index])[i] == gCard.CARD_GOOKJIN)
        {
            // 국진이 있다면, 국진을 먹는다.
            System.out.println(" # selectTwoCards MSG : 국진 발견!");
            return (byte)(i+1);
        }
    }

    /* 열끗 체크 */
    if(room.getNumOfYeul(Room.COMPUTER) >= 5
        &&  room.getNumOfYeul(Room.PLAYER) <= 2)
    {
        /* 멍따 가능성이 있다면, 피보다는 열끗을 먹어준다. */
        for(i=0; i<2; i++)
        {
            // 두개의 패중에 열끗이 있다면,
            if(gCard.getType(
                     room.getMonth(room.slot[index])[i]) == CARDTYPE_YEUL)
            {
                System.out.println(" # selectTwoCards MSG : 열끗 발견!");
                return (byte)(i+1);
            }
        }
    }

    /* 피 체크 */
    for(i=0; i<2; i++)
    {
        // 두개의 패중에 피가 있다면,
        if(gCard.getType(room.getMonth(room.slot[index])[i]) == CARDTYPE_PEE)
        {
            System.out.println(" # selectTwoCards MSG : 피 발견!");
            return (byte)(i+1);
        }
    }

    /* 그 외에는 둘중 아무거나 선택. */
    System.out.println(" # selectTwoCards MSG : 암거나 냈음!");
    return (byte)(Etc.getRandomInt(2)+1);
}

☆
☆
☆
☆
☆
☆

/**
 * 흔듬/폭탄 여부를 선택 중일때...
 * @param g
 */
private void drawSelectShake(Graphics g)
{
    drawRunningGame(g);

    if(shakeType == SHAKE) // 흔듬 선택 중일때,
        dialog.drawBorder(g, CyDialog.SELECTSHAKE);
    else /* if(shakeType == BOMB) */ // 폭탄 선택 중일때,
        dialog.drawBorder(g, CyDialog.SELECTBOMB);

    // 컴퓨터 턴일땐 AI가 선택.
    if(curTurn == User.COMPUTER)
    {
        Sleep.sleep(500);
        selectShake(User.COMPUTER, agent.selectShake());
    }
}

/**
 * A.I.가 흔듬 여부를 선택한다.
 * @return
 */
public byte selectShake()
{
    // 무조건 흔듬(or 폭탄).
    return 1;
}

☆
☆
☆
☆
☆
☆

/**
 * 국진의 사용을 선택 중일때,
 * @param g
 */
private void drawSelectGookjin(Graphics g)
{
    drawRunningGame(g);
    dialog.drawBorder(g, CyDialog.SELECTGOOKJIN);

    // 컴퓨터 턴일땐 AI가 선택.
    if(curTurn == User.COMPUTER)
    {
        Sleep.sleep(500);
        selectGookjin(User.COMPUTER, agent.selectGookjin());
    }
}

/**
 * A.I.가 국진을 선택한다.
 * @return
 */
public byte selectGookjin()
{
    // 열이 다섯장 이상이라면, 멍따 가능성이 있으므로.
    if(room.getNumOfYeul(Room.COMPUTER) >= 5
        &&  room.getNumOfYeul(Room.PLAYER) <= 2)
        return 2; // 국진을 열로 사용한다.

    // 그 외의 경우에는 무조건 쌍피로 처리.
    return 1;
}

/**
 * A.I.가 고/스톱을 선택한다.
 * @return
 */
public byte selectGoStop()
{
    room.getNumOfCard();

    // 플레이어의 광이 4장 이상일때,
    if(room.getNumOfKwang(Room.PLAYER) >= 4)
    {
        // 컴퓨터가 광이 한장도 없다면, (오광 위험!)
        if(room.getNumOfKwang(Room.COMPUTER) == 0)
            return 2; // 스톱.
    }

    // 고도리 위험이 있다면,
    if(room.getCntGodori(Room.PLAYER) >= 2
        && room.getCntGodori(Room.COMPUTER) == 0)
    {
        // 점수가 0점이 아니라면 스톱.
        if(room.getRealPoint(Room.PLAYER) != 0)
            return 2; // 스톱.
    }

    // 청단 위험이 있다면,
    if(room.getCntChungDan(Room.PLAYER) >= 2
            && room.getCntChungDan(Room.COMPUTER) == 0)
    {
        // 점수가 2점 이상이라면 스톱.
        if(room.getRealPoint(Room.PLAYER) >= 2)
            return 2; // 스톱.
    }

    // 홍단 위험이 있다면,
    if(room.getCntHongDan(Room.PLAYER) >= 2
            && room.getCntHongDan(Room.COMPUTER) == 0)
    {
        // 점수가 2점 이상이라면 스톱.
        if(room.getRealPoint(Room.PLAYER) >= 2)
            return 2; // 스톱.
    }

    // 초단 위험이 있다면,
    if(room.getCntChoDan(Room.PLAYER) >= 2
            && room.getCntChoDan(Room.COMPUTER) == 0)
    {
        // 점수가 2점 이상이라면 스톱.
        if(room.getRealPoint(Room.PLAYER) >= 2)
            return 2; // 스톱.
    }


    // 피가 10장 이상이고,
    if(room.getNumOfPee(Room.PLAYER) >= 10)
    {
        // 열이 7개 이상이라면,
        if(room.getNumOfYeul(Room.PLAYER) >= 7)
            return 2; // 스톱.

        // 플레이어의 열과 띠가 5장 이상이라면,
        if(room.getNumOfYeul(Room.PLAYER) >= 5
            && room.getNumOfDdee(Room.PLAYER) >= 5)
            return 2;

        // 플레이어의 열이 5장 이상이고, 점수가 3점 이상이라면,
        if(room.getNumOfYeul(Room.PLAYER) >= 5
            && room.getNumOfYeul(Room.COMPUTER) <= 2
            &&  room.getRealPoint(Room.PLAYER) >= 3)
            return 2; // 스톱.

        // 플레이어의 띠가 5장 이상이고, 점수가 3점 이상이라면,
        if(room.getNumOfDdee(Room.PLAYER) >= 5
            && room.getNumOfDdee(Room.COMPUTER) <= 2
            &&  room.getRealPoint(Room.PLAYER) >= 3)
            return 2; // 스톱.
    }

    // 피가 13장 이상이라면,
    if(room.getNumOfPee(Room.PLAYER) >= 13)
        return 2; // 스톱.

    // 플레이어의 점수가 4점 이상이라면,
    if(room.getRealPoint(Room.PLAYER) >= 4)
        return 2; // 스톱.

    // 남은 카드가 한장이거나 혹은 없다면,
    if(room.numOfComputerCard <= 1)
        return 2; // 스톱.

    // 그 외엔 무조건 고.
    return 1;
}

☆
☆
☆
☆
☆
☆

/**
 * 턴을 변경한다.
 */
private void changeTurn()
{
    // 쓸 체크.
    if(checkSseul() == true)
    {
        curViewState = State.GAME_SHOWMESSAGE;
        curMsgState = CyDialog.MSG_SSEUL;
        repaints();
        Sleep.wait(this, 300);

        curViewState = State.GAME_RUNNING;
        repaints();
    }

    // 턴 변경.
    curTurn = (curTurn==User.PLAYER)? User.COMPUTER : User.PLAYER;

    if(curTurn == User.COMPUTER)
    {
        do {
            runAI();
        } while(agent.wasAdditionalCard() == true);
    }
}

/**
 * A.I. 실행. 
 */
public void runAI()
{
    System.out.println("A.I. 수행 시작.");
    throwCard( agent.run(room) );

    room.sortMonth();

    repaints();
}

/**
 * A.I. 수행.
 */
public byte run(Room room)
{
    byte result;
    wasAdditionalCard = false;

    System.out.println("A.I. 수행하고 있음...");
    this.room = room;

    room.getNumOfCard();

    /* 추가 쌍피 체크 */
    result = findAdditionalCard(); // 추가 쌍피 체크.
    if(result != -1) // 추가 쌍피를 가지고 있다면,
        return result; // 해당 패를 냄.

    /* 광 체크 */
    result = findCard(CARDTYPE_KWANG);
    if(result != -1) // 광을 먹을 수 있다면,
        return result; // 해당 패를 냄.

    /* 비광 체크 */
    result = findCard(CARDTYPE_BIKWANG);
    if(result != -1) // 비광을 먹을 수 있다면,
        return result; // 해당 패를 냄.

    /* 고도리 체크 */
    if(bNoFindGodori == false
        || (room.getCntGodori(Room.PLAYER) >= 2 
            && room.getCntGodori(Room.COMPUTER) == 0))
    {
        if(room.getCntGodori(Room.PLAYER) >= 1)
        {
            bNoFindGodori == true;
        }
        else
        {
            result = findCard(CARDTYPE_GODORI);
            if(result != -1) // 고도리를 먹을 수 있다면,
                return result; // 해당 패를 냄.
        }
    }

    /* 청단 체크 */
    if(bNoFindChungDan == false
        || (room.getCntChungDan(Room.PLAYER) >= 2 
            && room.getCntChungDan(Room.COMPUTER) == 0))
    {
        if(room.getCntChungDan(Room.PLAYER) >= 1)
        {
            bNoFindChungDan == true;
        }
        else
        {
            result = findCard(CARDTYPE_CHUNGDAN);
            if(result != -1) // 청단을 먹을 수 있다면,
                return result; // 해당 패를 냄.
        }
    }

    /* 홍단 체크 */
    if(bNoFindHongDan == false
        || (room.getCntHongDan(Room.PLAYER) >= 2 
            && room.getCntHongDan(Room.COMPUTER) == 0))
    {
        if(room.getCntHongDan(Room.PLAYER) >= 1)
        {
            bNoFindHongDan == true;
        }
        else
        {
            result = findCard(CARDTYPE_HONGDAN);
            if(result != -1) // 홍단을 먹을 수 있다면,
                return result; // 해당 패를 냄.
        }
    }

    /* 초단 체크 */
    if(bNoFindChoDan == false
        || (room.getCntChoDan(Room.PLAYER) >= 2 
            && room.getCntChoDan(Room.COMPUTER) == 0))
    {
       if(room.getCntChoDan(Room.PLAYER) >= 1)
        {
            bNoFindChoDan == true;
        }
        else
        {
            result = findCard(CARDTYPE_CHODAN);
            if(result != -1) // 초단을 먹을 수 있다면,
                return result; // 해당 패를 냄.
        }
    }

    /* 쌍피 체크 */
    result = findCard(CARDTYPE_SSANG_PEE);
    if(result != -1) // 쌍피를 먹을 수 있다면,
        return result; // 해당 패를 냄.

    /* 피 체크 */
    result = findCard(CARDTYPE_PEE);
    if(result != -1) // 피를 먹을 수 있다면,
        return result; // 해당 패를 냄.

    // 위의 상황에 해당 하는 것이 없다면,  
    for(i=0; i<room.numOfComputerCard; i++)
    {
        // 아무거나 먹을 수 있는 것이 있다면 패를 낸다.
        if(room.compareFloor(room.getUserHand(Room.COMPUTER, i)) != -1)
        {
            return converIndex(i);
        }
    }

    // 정말 먹을게 없다면, 아무거나 냄.
    room.getNumOfCard();
    return convertIndex((byte)Etc.getRandomInt(room.numOfComputerCard));
}

/**
 * 추가 쌍피가 있는지 체크.
 * @return
 */
private byte findAdditionalCard()
{
    byte i;

    /* 서비스 패 체크 */
    for(i=0; i<room.numOfComputerCard; i++)
    {
        // 서비스 패라면,
        if( room.isAdditionalCard(room.getUserHand(Room.COMPUTER, i)))
        {
            return convertIndex(i);
        }
    }

    return -1;
}

/** 
 * 게임 설정에 맞게 인덱스를 변경한다.
 * @param convertIdx
 * @return
 */
private byte convertIndex(byte convertIdx)
{
    /*
     * 손에 든 카드의 인덱스는, 0~9가 아니라, 1~9, 0이므로,
     * 내기 전에 렌덤하게 선택된 인덱스를 변경해 준다. 
     */
    if(room.isAdditionalCard(room.getUserHand(Room.COMPUTER,convertIdx)))
    {
        wasAdditionalCard = true;
    }

    convertIdx = (++convertIdx == 10)? 0 : convertIdx;

    return convertIdx;
}

/**
 * 해당 패를 먹을수 있는지 체크.
 * @return
 */
private byte findCard(byte cardType)
{
    byte i, j, k;

    /* 패 체크 */
    for(i=0; i<room.numOfComputerCard; i++)
    {
        // 낼수 있는 패라면,
        if(room.compareFloor(room.getUserHand(Room.COMPUTER, i)) != -1)
        {
             // 낼수 있는 패가 인자로 받은 Card Type 이라면,
             if(gCard.getType(room.getUserHand(Room.COMPUTER, i)) 
                                                             == cardType)
             {
                 return convertIndex(i);
             }

            // 바닥 검사.
            for(j=0; j<12; j++)
            {
                if(room.getMonth(j)[0] == room.CARD_NULL)
                    continue;

                // 같은 종류의 패가 있는 월을 찾았다면,                 
                if( gCard.getType(room.getMonth(j)[0])
                    == gCard.getType(room.getUserHand(Room.COMPUTER, i)))
                {
                    for(k=0; k<4; k++)
                    {
                        if(room.getMonth(j)[k] == room.CARD_NULL)
                            break;

                        // 해당 월에 해당 Card Type이 있다면,
                        if(gCard.getType(room.getMonth(j)[k]) == cardType)
                        {
                            return convertIndex(i);
                        }
                    }

                    break;
                }
            }
        }
    } // for(i=0; i<room.numOfComputerCard; i++).

    return -1;
}

    /* 고도리 체크 */
    if(bNoFindGodori == false
        || (room.getCntGodori(Room.PLAYER) >= 2 
            && room.getCntGodori(Room.COMPUTER) == 0))
    {
        if(room.getCntGodori(Room.PLAYER) >= 1)
        {
            bNoFindGodori == true;
        }
        else
        {
            result = findCard(CARDTYPE_GODORI);
            if(result != -1) // 고도리를 먹을 수 있다면,
                return result; // 해당 패를 냄.
        }
    }

    /* 청단 체크 */
    if(bNoFindChungDan == false
        || (room.getCntChungDan(Room.PLAYER) >= 2 
            && room.getCntChungDan(Room.COMPUTER) == 0))
    {
        if(room.getCntChungDan(Room.PLAYER) >= 1)
        {
            bNoFindChungDan == true;
        }
        else
        {
            result = findCard(CARDTYPE_CHUNGDAN);
            if(result != -1) // 청단을 먹을 수 있다면,
                return result; // 해당 패를 냄.
        }
    }

    /* 홍단 체크 */
    if(bNoFindHongDan == false
        || (room.getCntHongDan(Room.PLAYER) >= 2 
            && room.getCntHongDan(Room.COMPUTER) == 0))
    {
        if(room.getCntHongDan(Room.PLAYER) >= 1)
        {
            bNoFindHongDan == true;
        }
        else
        {
            result = findCard(CARDTYPE_HONGDAN);
            if(result != -1) // 홍단을 먹을 수 있다면,
                return result; // 해당 패를 냄.
        }
    }

    /* 초단 체크 */
    if(bNoFindChoDan == false
        || (room.getCntChoDan(Room.PLAYER) >= 2 
            && room.getCntChoDan(Room.COMPUTER) == 0))
    {
       if(room.getCntChoDan(Room.PLAYER) >= 1)
        {
            bNoFindChoDan == true;
        }
        else
        {
            result = findCard(CARDTYPE_CHODAN);
            if(result != -1) // 초단을 먹을 수 있다면,
                return result; // 해당 패를 냄.
        }
    }

    // 위의 상황에 해당 하는 것이 없다면,  
    for(i=0; i<room.numOfComputerCard; i++)
    {
        // 아무거나 먹을 수 있는 것이 있다면 패를 낸다.
        if(room.compareFloor(room.getUserHand(Room.COMPUTER, i)) != -1)
        {
            return converIndex(i);
        }
    }

    // 정말 먹을게 없다면, 아무거나 냄.
    room.getNumOfCard();
    return convertIndex((byte)Etc.getRandomInt(room.numOfComputerCard));

☆
☆
☆
☆

☆
☆

case 2: // 손에서 낸 카드와, 뒤집어 낸 카드 둘뿐이라면,
    /* 쪽! */
    curViewState = State.GAME_SHOWMESSAGE;
    curMsgState = CyDialog.MSG_JJOK;
    repaints();
    Sleep.wait(this, 300);

    curViewState = State.GAME_RUNNING;
    repaints();

    // 쪽일때에는, 우선 두장 다 먹고,
    room.addPae(curTurn, room.getMonth(handCardIdx)[0]);
    room.addPae(curTurn, room.getMonth(handCardIdx)[1]);
    room.getMonth(handCardIdx)[0] = room.CARD_NULL;
    room.getMonth(handCardIdx)[1] = room.CARD_NULL;

    // 상대방의 피를 하나 가져온다.
    room.robPee(curTurn);

    repaints();
    break;

☆
☆
☆
☆

☆
☆

case 3: // 손에서 낸 카드와, 뒤집어 낸 카드와 원래 카드 한장이라면,
    room.incCntPuck(curTurn); // 뻑 횟수 +1.

    curViewState = State.GAME_SHOWMESSAGE;
    curMsgState = CyDialog.MSG_PPUCK;
    repaints();
    Sleep.wait(this, 300);

    curViewState = State.GAME_RUNNING;
    repaints();

    // 3번 뻑이라면,
    if(room.getCntPuck(curTurn) >= 3)
    {
        // 7점에 해당하는 금액을 상대방에게 받고,
        room.setPoint(curTurn, 7); // 플레이어 점수를 7점으로 세팅.
        // 게임 종료.
        curViewState = State.GAME_RESULT;

        repaints();

        // 게임 끝.
        curViewState = State.GAME_RESULT;
        repaints();

        return;
    }

    break;

☆
☆
☆
☆

☆
☆

else
{
    /* 카드가 슬롯에 가득 차 있다면, 따닥! */
    if(i == 3)
    {
        /* 따닥! */
        curViewState = State.GAME_SHOWMESSAGE;
        curMsgState = CyDialog.MSG_DDADAK;
        repaints();
        Sleep.wait(this, 300);

        curViewState = State.GAME_RUNNING;
        repaints();

        // 모두 먹고,
        for(j=0; j<4; j++)
        {
            room.addPae(curTurn, room.getMonth(handCardIdx)[j]);
            room.getMonth(handCardIdx)[j] = room.CARD_NULL;
        }

        // 상대방의 피를 하나 가져온다.
        room.robPee(curTurn);
    }
}

/**
 * 턴을 변경한다.
 */
private void changeTurn()
{
    // 쓸 체크.
    if(checkSseul() == true)
    {
        curViewState = State.GAME_SHOWMESSAGE;
        curMsgState = CyDialog.MSG_SSEUL;
        repaints();
        Sleep.wait(this, 300);

        curViewState = State.GAME_RUNNING;
        repaints();
    }

    // 턴 변경.
    curTurn = (curTurn==User.PLAYER)? User.COMPUTER : User.PLAYER;
}

/**
 * 쓸의 여부 체크.
 */
private boolean checkSseul()
{
    for(byte i=0; i<12; i++)
    {
        // 한군데의 월이라도 카드가 있다면, 쓸이 아님.
        if(room.getMonth(i)[0] != room.CARD_NULL)
            return false;
    }

    // 쓸.
    return true;
}

/**
 * 게임중의 메뉴화면을 그려준다.
 * @param g
 */
public void drawContinueGame(Graphics g)
{
    if(preViewState == State.GAME_WAIT)
        drawWaitingGame(g);
    else
        drawRunningGame(g);

    dialog.drawBorder(g, CyDialog.CONTINUEGAME);
}

else if(curViewState == State.GAME_CONTINUEGAME)
{
    if(numKey == 1) /* 계속 */
    {
        if(preViewState == State.GAME_RESULT)
        {
            room.gameOver();
            init();
            curViewState = State.GAME_WAIT;
        }
        else
            curViewState = preViewState;
    }
    else if(numKey == 2) /* 나가기 */
    {
        enterMainMenu();
    }
    else if(numKey == 3) /* 겔러리로 가기 */
    {
        gallery = new Gallery(midlet);

        gallery.savePreCanvas(this);
        midlet.setCurrentDisplay(gallery);

        gallery = null;
        System.gc();
    }

    repaints();
}

package common;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.Graphics;

import com.skt.m.Graphics2D;

/**
 * 다이얼로그와 관련된 기능을 모아놓은 클래스.
 */

public class CyDialog {
    public final static byte SELECTTWOCARD = 0; // 두장의 카드 선택.
    public final static byte SELECTGOOKJIN = 1; // 국진 선택.
    public final static byte SELECTGOSTOP = 2; // 고/스톱 선택.
    public final static byte SELECTSHAKE = 3; // 흔듬 선택(플레이어).
    public final static byte SELECTBOMB = 4; // 폭탄 선택(플레이어).
    public final static byte RESULT = 5; // 결과 확인.
    public final static byte CONTINUEGAME = 6; // 게임 메뉴.

    public final static byte MSG_GO = 7; // 고.
    public final static byte MSG_STOP = 8; // 스톱.
    public final static byte MSG_PPUCK = 9; // 뻑.
    public final static byte MSG_JJOK = 10; // 쪽.
    public final static byte MSG_DDADAK = 11; // 따닥.
    public final static byte MSG_SSEUL = 12; // 쓸.
    public final static byte MSG_SHAKE = 13; // 흔듬(컴퓨터 턴).
    public final static byte MSG_BOMB = 14; // 폭탄(컴퓨터 턴).

    private Canvas parentCanvas;
    private short width, height;

    /*
     * Border Images.
     */
    private Image imgSelectTwoCard; 
    private Image imgSelectGookjin;
    private Image imgSelectGoStop;
    private Image imgSelectShake;
    private Image imgSelectBomb;
    private Image imgResult;
    private Image imgContinueGame; // 게임 중의 메뉴 화면.

    /*
     * Message Images.
     */
    private Image imgMsgGo; // 고를 선택했을때의 메시지.
    private Image imgMsgStop; // 스톱을 선택했을때의 메시지.
    private Image imgMsgPpuck; // 뻑을 당했을때의 메시지.
    private Image imgMsgJjok; // 쪽을 했을때의 메시지.
    private Image imgMsgDdadak; // 따닥 했을때의 메시지.
    private Image imgMsgSseul; // 쓸을 했을때의 메시지.
    private Image imgMsgShake; // 흔들었을때의 메시지.
    private Image imgMsgBomb; // 폭탄일대의 메시지.

    /**
     * Constructor.
     * @param parentCanvas
     */
    public CyDialog(Canvas parentCanvas)
    {
        this.parentCanvas = parentCanvas;

        width = (short) parentCanvas.getWidth();
        height = (short) (parentCanvas.getHeight()+16);

        loadImages(); // 이미지를 읽어옴.
    }

    /**
     * 다이얼로그에 필요한 각종 이미지를 로드한다.
     */
    private void loadImages()
    {
        try {
            /*
             * Load Border Images.
             */
            // 두장의 카드 선택 border.
            imgSelectTwoCard = Image.createImage("/image/gasktwocard.lbm");
            // 두장의 카드 선택 border.
            imgSelectGookjin = Image.createImage("/image/gaskgook.lbm");
            // 고/스톱 선택 border.
            imgSelectGoStop = Image.createImage("/image/gaskgostop.lbm");
            // 흔들기 선택 border.
            imgSelectShake = Image.createImage("/image/gaskshake.lbm");
            // 폭탄 선택 border.
            imgSelectBomb = Image.createImage("/image/gaskbomb.lbm");
            // 결과 화면.
            imgResult = Image.createImage("/image/resultbg.lbm");
            // 게임 메뉴 화면.
            imgContinueGame = Image.createImage("/image/continuegame.lbm");

            /*
             * Load Message Images.
             */
            // 고를 선택했을때의 메시지.
            imgMsgGo = Image.createImage("/image/anigo.lbm");
            // 스톱을 선택했을때의 메시지.
            imgMsgStop = Image.createImage("/image/anistop.lbm");
            // 뻑을 당했을때의 메시지.
            imgMsgPpuck = Image.createImage("/image/anippuk.lbm");
            // 쪽을 했을때의 메시지.
            imgMsgJjok = Image.createImage("/Image/anijjok.lbm");
            // 따닥 했을때의 메시지.
            imgMsgDdadak = Image.createImage("/Image/aniddadak.lbm");
            // 쓸을 했을때의 메시지.
            imgMsgSseul = Image.createImage("/image/aniclear.lbm");
            // 흔들었을때의 메시지.
            imgMsgShake = Image.createImage("/image/anishake.lbm");
            // 폭탄일때의 메시지.
            imgMsgBomb = Image.createImage("/image/anibomb.lbm");
        }  catch(Exception e) {}
    }

    /**
     * 다이얼로그의 border를 그려줌.
     * @param g
     * @param borderType
     */
    public void drawBorder(Graphics g, byte borderType)
    {
        switch(borderType)
        {
        case SELECTTWOCARD: // 두장의 카드를 선택 중일때,
            g.drawImage(imgSelectTwoCard, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case SELECTGOOKJIN: // 국진을 선택 중일때,
            g.drawImage(imgSelectGookjin, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case SELECTGOSTOP: // 고/스톱을 선택 중일때,
            g.drawImage(imgSelectGoStop, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case SELECTSHAKE: // 흔들기를 선택 중일때,
            g.drawImage(imgSelectShake, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case SELECTBOMB: // 폭탄을 선택 중일때,
            g.drawImage(imgSelectBomb, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case RESULT: // 결과 화면을 보는 중일때,
            g.drawImage(imgResult, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case CONTINUEGAME: // 게임 중의 메뉴 화면.
            g.drawImage(imgContinueGame, width/2, height/2,
                        Graphics.HCENTER|Graphics.VCENTER);
        }
    }

    /**
     * 메시지를 출력한다.
     */
    public void drawMessage(Graphics g, byte messageType, byte cntGo)
    {
        switch(messageType)
        {
        case MSG_GO: // 고.
            Graphics2D g2d = Graphics2D.getGraphics2D(g);
            g2d.drawImage((width-38)/2, (height-18)/2, 
                        imgMsgGo, (cntGo-1)*38, 0, 38, 18, 
                        Graphics2D.DRAW_COPY);
            break;
        case MSG_STOP: // 스톱.
            g.drawImage(imgMsgStop, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case MSG_PPUCK: // 뻑.
            g.drawImage(imgMsgPpuck, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case MSG_JJOK: // 쪽.
            g.drawImage(imgMsgJjok, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case MSG_SSEUL: // 쓸.
            g.drawImage(imgMsgSseul, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case MSG_SHAKE: // 흔듬.
            g.drawImage(imgMsgShake, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        case MSG_BOMB: // 폭탄.
            g.drawImage(imgMsgBomb, width/2, height/2, 
                        Graphics.HCENTER|Graphics.VCENTER);
            break;
        }
    }

    /**
     * 자원 해제.
     */
    public void cleanUp()
    {
        imgSelectTwoCard = null;
        imgSelectGookjin = null;
        imgSelectGoStop = null;
        imgSelectShake = null;
        imgSelectBomb = null;
        imgResult = null;

        imgMsgGo = null;
        imgMsgStop = null;
        imgMsgPpuck = null;
        imgMsgJjok = null;
        imgMsgDdadak = null;
        imgMsgSseul = null;
        imgMsgShake = null;
        imgMsgBomb = null;

        System.gc();
    }
}

/**
 * 카드 둘중 하나를 선택할때...
 * @param g
 */
private void drawSelectTwoCards(Graphics g)
{
    byte index;

    drawRunningGame(g);
    /* 카드 두장 중 하나를 선택한다. */
    dialog.drawBorder(g, CyDialog.SELECTTWOCARD);

    // 두 종류의 카드를 보여줌.
    if(room.slot[0] != room.CARD_NULL)
        index = 0;
    else if(room.slot[1] != room.CARD_NULL)
        index = 1;
    else return;

    drawCard(40, 66, room.getMonth(room.slot[index])[0]);
    drawCard(65, 66, room.getMonth(room.slot[index])[1]);
}

/**
 * 흔듬/폭탄 여부를 선택 중일때...
 * @param g
 */
private void drawSelectShake(Graphics g)
{
    drawRunningGame(g);

    if(shakeType == SHAKE) // 흔듬 선택 중일때,
        dialog.drawBorder(g, CyDialog.SELECTSHAKE);
    else /* if(shakeType == BOMB) */ // 폭탄 선택 중일때,
        dialog.drawBorder(g, CyDialog.SELECTBOMB);
}

/**
 * 국진의 사용을 선택 중일때,
 * @param g
 */
private void drawSelectGookjin(Graphics g)
{
    drawRunningGame(g);
    dialog.drawBorder(g, CyDialog.SELECTGOOKJIN);
}

/**
 * 고/스톱을 선택 중일때...
 * @param g
 */
private void drawSelectGoStop(Graphics g)
{
    drawRunningGame(g);
    dialog.drawBorder(g, CyDialog.SELECTGOSTOP);
}

☆








☆















☆



























☆


☆

☆

☆

☆




☆



























☆


☆

☆

☆

☆

/**
 * 결과 화면을 그려준다.
 * @param g
 */
private void drawResult(Graphics g)
{
    drawRunningGame(g);

    // 결과 창을 그려줌.
    dialog.drawBorder(g, CyDialog.RESULT);

    // 나가리라면...
    if(room.getNagari() == true)
    {
        if(gameEnd == false)
            gameEnd = true;

        g.setColor(0);
        g.drawString("나가리", width/2, 73, Graphics.HCENTER|Graphics.TOP);
    }
    else
    {
        /* 벌칙. */
        byte goBak; // 고박.
        byte peeBak; // 피박.
        byte kwangBak; // 광박.
        byte mungDda; // 멍따.

        int obtainedMoney=0; // 획득 머니.

        switch(curTurn)
        {
        case User.PLAYER: // 플레이어의 턴일때,
            g.setColor(0);
            g.drawString("플레이어 승", width/2, 73, 
                                Graphics.HCENTER|Graphics.TOP);

            // 상대방이 고를 한번 이상 했었다면, - 고박일경우 돈 두배 획득.
            goBak = (room.getCntGo(User.COMPUTER) >= 1)? 
                                (byte)2 : (byte)1; 
            // 상대방의 피가 7장 이하라면, 피박. - 피박일경우 돈 두배 획득.
            peeBak = (room.getNumOfPee(User.COMPUTER) < 7)? 
                                (byte)2 : (byte)1;
            // 상대방의 광이 없다면, 광박. - 광박일경우, 돈 두배 획득.
            kwangBak = (room.getNumOfKwang(User.COMPUTER) == 0)? 
                                (byte)2 : (byte)1;
            // 상대방의 열이 7장 이상이라면, 멍따. - 멍따일 경우, 돈 두배.
            mungDda = (room.getNumOfYeul(User.COMPUTER) >= 7)? 
                                (byte)2 : (byte)1;

            if(gameEnd == false)
            {
                gameEnd = true;
                obtainedMoney = room.MONEY_PER_POINT
                                *room.getRealPoint(User.PLAYER)
                                *goBak*kwangBak*peeBak*mungDda;
                // 플레이어의 돈 증가.
                room.addMoney(curTurn, obtainedMoney);
                // 컴퓨터의 돈 감소.
                room.addMoney(curTurn, -obtainedMoney);
            }

            g2d.drawImage(18, 45, sprWinLose, 0, 0, 15, 12, 
                                Graphics2D.DRAW_COPY); // 승.

            g.drawString("" + room.getCntGo(curTurn), 30, 59, 
                                Graphics.LEFT|Graphics.TOP); // 고 횟수.
            g.drawString("" + room.getRealPoint(curTurn), 80, 47, 
                                Graphics.LEFT|Graphics.TOP); // 점수.
            g.drawString("" + room.getCntShake(curTurn), 80, 59,
                                Graphics.LEFT|Graphics.TOP); // 흔듬 횟수.
            g.drawString("획득 금액 +" + obtainedMoney, width/2, 89, 
                                Graphics.HCENTER|Graphics.TOP);
            break;
        case User.COMPUTER: // 컴퓨터의 턴일때,
            g.setColor(0);
            g.drawString("컴퓨터 승", width/2, 73, 
                                Graphics.HCENTER|Graphics.TOP);

            // 상대방이 고를 한번 이상 했었다면,
            goBak = (room.getCntGo(User.COMPUTER) >= 1)? 
                                (byte)2 : (byte)1; // 고박일경우 돈 두배 획득.
            // 상대방의 피가 7장 이하라면, 피박.
            peeBak = (room.getNumOfPee(User.PLAYER) < 7)? 
                                (byte)2 : (byte)1; // 피박일경우 돈 두배 획득.
            // 상대방의 광이 없다면,
            kwangBak = (room.getNumOfKwang(User.PLAYER) == 0)? 
                                (byte)2: (byte)1; // 광박일경우, 돈 두배 획득.
            // 상대방의 열이 7장 이상이라면, 멍따.
            mungDda = (room.getNumOfYeul(User.COMPUTER) >= 7)? 
                                (byte)2 : (byte)1; // 멍따일 경우, 돈 두배.

            if(gameEnd == false)
            {
                gameEnd = true;
                obtainedMoney = room.MONEY_PER_POINT
                                *room.getRealPoint(User.COMPUTER)
                                *goBak*kwangBak*peeBak*mungDda;
                // 플레이어의 돈 감소.
                room.addMoney(curTurn, -obtainedMoney);
                // 컴퓨터의 돈 증가.
                room.addMoney(curTurn, obtainedMoney);
            }

            g2d.drawImage(18, 45, sprWinLose, 15, 0, 15, 12, 
                                Graphics2D.DRAW_COPY); // 패.

            g.drawString("" + room.getCntGo(curTurn), 30, 59, 
                                Graphics.LEFT|Graphics.TOP); // 고 횟수.
            g.drawString("" + room.getRealPoint(curTurn), 80, 47, 
                                Graphics.LEFT|Graphics.TOP); // 점수.
            g.drawString("" + room.getCntShake(curTurn), 80, 59, 
                                Graphics.LEFT|Graphics.TOP); // 흔듬 횟수.
            g.drawString("획득 금액 +" + obtainedMoney, width/2, 89, 
                                Graphics.HCENTER|Graphics.TOP);
        }
    }
}

// 손에서 냈던 카드와 뒤집어서 낸 카드가 같은 슬롯에 있다면,
if(handCardIdx == reverseCardIdx)
{
    int i, j;

    // 뻑 체크.
    for(i=0; i<4; i++)
    {
        if(room.getMonth(handCardIdx)[i] == room.CARD_NULL)
        {
            switch(i)
            {
            case 2: // 손에서 낸 카드와, 뒤집어 낸 카드 둘뿐이라면,
             ☆ /* 쪽! */
                // 쪽일때에는, 우선 두장 다 먹고,
                room.addPae(curTurn, room.getMonth(handCardIdx)[0]);
                room.addPae(curTurn, room.getMonth(handCardIdx)[1]);
                room.getMonth(handCardIdx)[0] = room.CARD_NULL;
                room.getMonth(handCardIdx)[1] = room.CARD_NULL;

             ☆ // 상대방의 피를 하나 가져온다.
             ☆ room.robPee(curTurn);

                repaints();
                break;
            case 3: // 손에서 낸 카드와, 뒤집어 낸 카드와 원래 카드 한장이라면,
                // System.out.println(" # Msg : 뻑!!");
                room.incCntPuck(curTurn); // 뻑 횟수 +1.

             ☆ // 3번 뻑이라면,
             ☆ if(room.getCntPuck(curTurn) >= 3)
             ☆ {
             ☆     // 7점에 해당하는 금액을 상대방에게 받고,
             ☆     room.setPoint(curTurn, 7); // 플레이어 점수를 7점으로 세팅.
             ☆     // 게임 종료.
             ☆     curViewState = State.GAME_RESULT;

             ☆     repaints();

             ☆     // 게임 끝.
             ☆     curViewState = State.GAME_RESULT;
             ☆     repaints();

             ☆     return;
             ☆ }

                break;
            }
        } // end if(room.getMonth(handCardIdx)[i] == room.CARD_NULL).
        else
        {
         ☆ /* 카드가 슬롯에 가득 차 있다면, 따닥! */
            if(i == 3)
            {
                // 모두 먹고,
                for(j=0; j<4; j++)
                {
                    room.addPae(curTurn, room.getMonth(handCardIdx)[j]);
                    room.getMonth(handCardIdx)[j] = room.CARD_NULL;
                }

             ☆ // 상대방의 피를 하나 가져온다.
             ☆ room.robPee(curTurn);
            }
        }
    }
}

/**
 * 다른 사용자로부터, 피를 한장 가져온다.
 * @param userType
 * @return
 */
public byte robPee(byte userType)
{
    byte userLastIdx = -1;
    byte enemyLastIdx = -1;
    byte enemyType;
    byte userPeeIdx = CARD_NULL, enemyPeeIdx = CARD_NULL;
    byte userSsangPeeIdx = CARD_NULL, enemySsangPeeIdx = CARD_NULL;

    // 상대방의 타입 설정.
    enemyType = (userType==COMPUTER)? PLAYER : COMPUTER;

    // 상대방의 피에 1점자리 피가 있는지 찾는다. 
    for(i=0; i<MAX_PEE; i++)
    {
        // 플레이어의 카드가 없다면,
        if(cardsPee[userType][i] == CARD_NULL)
            userLastIdx = (byte)(i-1);
        // 상대방의 카드가 없다면,
        if(cardsPee[enemyType][i] == CARD_NULL)
            enemyLastIdx = (byte)(i-1);

        // 둘다 검사가 끝났다면,
        if(userLastIdx != -1 && enemyLastIdx != -1)
            break;

        // 상대방으로부터 가져올 1점 자리 패를 찾았다면,
        if(enemyPeeIdx == CARD_NULL
            && gCard.getType(cardsPee[enemyType][i]) == CARDTYPE_PEE)
        {
            enemyPeeIdx = (byte)i;
        }

        // 상대방으로부터 가져올 쌍피를 찾았다면,
        if(enemyPeeIdx == CARD_NULL
            && gCard.getType(cardsPee[enemyType][i]) == CARDTYPE_SSANG_PEE)
        {
            enemySsangPeeIdx = (byte)i;
        }

        // 사용자의 패에서, 1점 자리 패를 찾았다면,
        if(userPeeIdx == CARD_NULL
            && gCard.getType(cardsPee[enemyType][i]) == CARDTYPE_PEE)
        {
            userPeeIdx = (byte)i;
        }

        // 사용자의 패에서, 쌍피를 찾았다면,
        if(userPeeIdx == CARD_NULL
            && gCard.getType(cardsPee[enemyType][i]) == CARDTYPE_SSANG_PEE)
        {
            userSsangPeeIdx = (byte)i;
        }
    } // for(i=0; i<MAX_PEE; i++).

    // 상대방의 패에서 1점 자리 패를 찾았다면,
    if(enemyPeeIdx != CARD_NULL)
    {
        // 사용자의 피를 한장 추가 하고,
        addPae(userType, cardsPee[enemyType][enemyPeeIdx]);
        // 빈 슬롯을 매꿔 준다.
        cardsPee[enemyType][enemyPeeIdx] = cardsPee[enemyType][enemyLastIdx];
        cardsPee[enemyType][enemyLastIdx] = CARD_NULL;
    }
    else if(userPeeIdx != CARD_NULL) // 사용자의 패에서 1점 자리 패를 찾았다면,
    {
        byte Temp;

        // 상대방의 마지막 패가 쌍피라면,
        if(gCard.getType(cardsPee[enemyType][enemyLastIdx]) == CARDTYPE_SSANG_PEE)
        {
            // 상대방으로부터 쌍피를 받고,
            Temp = cardsPee[enemyType][enemyLastIdx];
            // 1점 짜리 피를 넘겨줌.
            cardsPee[enemyType][enemyLastIdx] = cardsPee[userType][userPeeIdx];
            cardsPee[userType][userPeeIdx] = Temp;
        }
        else if(userSsangPeeIdx != CARD_NULL) // 사용자가 쌍피가 있다면,
        {
            // 상대방의 마지막 패가 쓰리피라면,
            if(gCard.getType(cardsPee[enemyType][enemyLastIdx])==CARDTYPE_THREE_PEE)
            {
                // 상대방으로부터 쓰리피를 받고,
                Temp = cardsPee[enemyType][enemyLastIdx];
                // 쌍피를 넘겨줌.
                cardsPee[enemyType][enemyLastIdx]
                        = cardsPee[userType][userSsangPeeIdx];
                cardsPee[userType][userSsangPeeIdx] = Temp;
            }
        }
    }

    return 1;
} // end public byte robPee(byte userType).

private void checkGoStop()
{
    if(room.getCntGo(curTurn) == 0
        && room.getRealPoint(curTurn) >= LIMITPOINT_GOSTOP)
    {
        // 고를 한번도 하지 않았을때, 일정 점수를 초과하면,
        prePoint[curTurn] = room.getPoint(curTurn); // 현재 점수 저장.

        // 고스톱 선택 다이얼로그를 보여준다.
        curViewState = State.GAME_SELECTGOSTOP;

        room.incCntGo(curTurn); // 고 횟수 +1.

        repaints();
        return;
    }
    else if(room.getCntGo(curTurn) >= 1
            && room.getRealPoint(curTurn)-prePoint[curTurn] >= 1)
    {
        // 고를 한번이상 한 뒤, 1점이라도 내면,
        prePoint[curTurn] = room.getPoint(curTurn); // 현재 점수 저장.

        // 고스톱 선택 다이얼로그를 보여준다.
        curViewState = State.GAME_SELECTGOSTOP;

        room.incCntGo(curTurn); // 고 횟수 +1.

        repaints();
        return;
    }
}

/**
 * 실제 점수를 리턴한다.
 * @param userType
 * @return
 */
public int getRealPoint(byte userType)
{
    int realPoint=getPoint(userType);

    // 원고나 투고 라면,
    if(cntGo[userType] == 1
        ||  cntGo[userType] == 2)
    {
        // 원고면 1점, 투고면 2점을 더해줌.
        realPoint += cntGo[userType];
    }
    else if(cntGo[userType] >= 3) // 쓰리고 이상이라면,
    {
        // 3고 부터는, 2의 (고횟수-2)승으로 계산.
        realPoint *= Etc.pow(2, cntGo[userType]-2);
    }

    // 흔들기도, 2의 흔든 횟수승으로 계산.
    realPoint *= Etc.pow(2, cntShake[userType]);

    return realPoint;
}

/**
 * a의 n제곱승을 리턴.
 * @param a
 * @param n
 * @return a의 n승.
 */
public static int pow(int a, int n)
{
    byte i;
    short nPowOfa=1;

    for(i=0; i<n; i++)
    {
        nPowOfa *= a;
    }

    return nPowOfa;
}

/**
 * 나가리를 체크.
 * @return 나가리 여부.
 */
private boolean checkNagari()
{
    // 플레이어의 카드와 컴퓨터의 카드가 없다면,
    if(room.numOfPlayerCard == 0 && room.numOfComputerCard == 0 )
    {
        repaints();

        // 나가리.
        room.setNagari(true);
        // 게임 끝.
        curViewState = State.GAME_RESULT;
        repaints();

        return false;
    }

    return true;
}

/**
 * 결과 화면을 그려준다.
 * @param g
 */
private void drawResult(Graphics g)
{
    drawRunningGame(g);

    // 나가리라면...
    if(room.getNagari() == true)
    {
        if(gameEnd == false)
            gameEnd = true;

        g.drawString("나가리!", 0, 0, Graphics.LEFT|Graphics.TOP);
    }
    else
    {
        /* 벌칙. */
        byte goBak; // 고박.
        byte peeBak; // 피박.
        byte kwangBak; // 광박.
        byte mungDda; // 멍따.

        switch(curTurn)
        {
        case User.PLAYER: // 플레이어의 턴일때,
            g.drawString("플레이어 승!", 0, 0, Graphics.LEFT|Graphics.TOP);

            // 상대방이 고를 한번 이상 했었다면, 고박. (고박일경우 돈 두배 획득)
            goBak = (room.getCntGo(User.COMPUTER) >= 1)? 
                    (byte)2 : (byte)1;
            // 상대방의 피가 7장 이하라면, 피박. (피박일경우 돈 두배 획득)
            peeBak = (room.getNumOfPee(User.COMPUTER) < 7)? 
                    (byte)2 : (byte)1;
            // 상대방의 광이 없다면, 광박. (광박일경우, 돈 두배 획득) 
            kwangBak = (room.getNumOfKwang(User.COMPUTER) == 0)? 
                    (byte)2 : (byte)1;
            // 상대방의 열이 7장 이상이라면, 멍따. (멍따일 경우, 돈 두배 획득)
            mungDda = (room.getNumOfYeul(User.COMPUTER) >= 7)? 
                    (byte)2 : (byte)1;
			
            if(gameEnd == false)
            {
                gameEnd = true;
                // 플레이어의 돈 증가.
                room.addMoney(curTurn, room.MONEY_PER_POINT
                                       *room.getRealPoint(User.PLAYER)
                                       *goBak*kwangBak*peeBak*mungDda);
                // 컴퓨터의 돈 감소.
                room.addMoney(curTurn, -room.MONEY_PER_POINT
                                       *room.getRealPoint(User.COMPUTER)
                                       *goBak*kwangBak*peeBak*mungDda);
            }

            break;
        case User.COMPUTER: // 컴퓨터의 턴일대,
            g.drawString("컴퓨터 승!", 0, 0, Graphics.LEFT|Graphics.TOP);

            // 상대방이 고를 한번 이상 했었다면, 고박. (고박일경우 돈 두배 획득)
            goBak = (room.getCntGo(User.COMPUTER) >= 1)? 
                    (byte)2 : (byte)1;
            // 상대방의 피가 7장 이하라면, 피박. (피박일경우 돈 두배 획득)
            peeBak = (room.getNumOfPee(User.COMPUTER) < 7)? 
                    (byte)2 : (byte)1;
            // 상대방의 광이 없다면, 광박. (광박일경우, 돈 두배 획득) 
            kwangBak = (room.getNumOfKwang(User.COMPUTER) == 0)? 
                    (byte)2 : (byte)1;
            // 상대방의 열이 7장 이상이라면, 멍따. (멍따일 경우, 돈 두배 획득)
            mungDda = (room.getNumOfYeul(User.COMPUTER) >= 7)? 
                    (byte)2 : (byte)1;

            if(gameEnd == false)
            {
                gameEnd = true;
                // 플레이어의 돈 감소.
                room.addMoney(curTurn, -room.MONEY_PER_POINT
                                       *room.getRealPoint(User.PLAYER)
                                       *goBak*kwangBak*peeBak*mungDda);
                // 컴퓨터의 돈 증가.
                room.addMoney(curTurn, room.MONEY_PER_POINT
                                       *room.getRealPoint(User.COMPUTER)
                                       *goBak*kwangBak*peeBak*mungDda);
            }
        }
    }
}

/**
 * 광을 추가함.
 * @param userType
 * @param cardIdx
 */
public void addKwang(byte userType, int cardIdx)
{
    int numOfKwang = 0;

    // 비광을 먹었다면, 비광의 소유 여부 기록.
    if(gCard.getType((byte)cardIdx) == CARDTYPE_BIKWANG)
        bHaveBiKwang[userType] = true;

    switch(numOfKwang)
    {
    case 3: // 광이 3개라면,
        /* 비광이 있다면, */
        if(bHaveBiKwang[userType] == true)
        {
            addPoint(userType, 2);
            bCalculatedBiKwang = true; // 비광 때문에 2점을 추가했음.
        }
        else // 비광이 없다면,
            addPoint(userType, 3); // 3점 추가.

        break;
    case 4: // 광이 4개라면,
        if(bCalculatedBiKwang) // 비광때문에 2점을 더해주었었다면,
        {
            /*
             * 비광의 유/무에 상관 없이,
             * 카드가 4장일 때에는, 4점 이므로,
             * 비광 때문에 2점을 더해주었었다면,
             * 1점을 더해준다.
             */
            addPoint(userType, 1);
            bCalculatedBiKwang = false;
        }

        // 광이 하나 추가되었으므로, 1점 추가.
        addPoint(userType, 1);
        break;
    case 5: // 오광 이라면,
        /*
         * 오광의 경우, 15점이 추가 된다.
         * 광이 4개일때의 점수가 4점이었으므로, 11점을 추가 해준다.
         */
        addPoint(userType, 11);
    } // switch(numOfKwang).
} //  end public void addKwang(byte userType, int cardIdx).

// 비광을 먹었다면, 비광의 소유 여부 기록.
if(gCard.getType((byte)cardIdx) == CARDTYPE_BIKWANG)
    bHaveBiKwang[userType] = true;

/**
 * 열을 추가함.
 * @param userType
 * @param cardIdx
 */
public void addYeul(byte userType, int cardIdx)
{
    int numOfYeul = 0;

    /* 지금 먹은 열이 고도리 패중 하나라면, */
    if(gCard.getType((byte)cardIdx) == CARDTYPE_GODORI)
    {
        incCntGodori(userType);
    }

    // 고도리 패가 3장 있다면, -> 고도리.
    if(bGodori[userType] == false && getCntGodori(userType) == 3)
    {
        addPoint(userType, 5); // 5점 추가.
        bGodori[userType] = true;
    }

    // 열은 5장 부터 1점씩 추가.
    if(numOfYeul >= 5)
        addPoint(userType, 1);
}

/**
 * 띠를 추가함.
 * @param userType
 * @param cardIdx
 */
public void addDdee(byte userType, int cardIdx)
{
    /* 지금 먹은 띠가... */
    switch(gCard.getType((byte)cardIdx))
    {
    case CARDTYPE_CHUNGDAN: // 청단 패 중 하나라면,
        incCntChungDan(userType);
        break;
    case CARDTYPE_HONGDAN: // 홍단 패 중 하나라면,
        incCntHongDan(userType);
        break;
    case CARDTYPE_CHODAN: // 초단 패 중 하나라면,
        incCntChoDan(userType);
        break;
    }

    // 만약 청단 패가 3개 라면, -> 청단.
    if(bChungDan[userType] == false && getCntChungDan(userType) == 3)
    {
         addPoint(userType, 3); // 3점 추가.
         bChungDan[userType] = true;
    }

    // 만약 홍단 패가 3개 라면, -> 홍단.
    if(bHongDan[userType] == false && getCntHongDan(userType) == 3)
    {
        addPoint(userType, 3); // 3점 추가.
        bHongDan[userType] = true;
    }

    // 만약 초단 패가 3개 라면, -> 초단.
    if(bChoDan[userType] == false && getCntChoDan(userType) == 3)
    {
        addPoint(userType, 3); // 3점 추가.
        bChoDan[userType] = true;
    }

    int numOfDdee=0;

    // 띠는 5장 부터 1점씩 추가.
    if(numOfDdee >= 5)
        addPoint(userType, 1);
}

/**
 * 피를 추가함.
 * @param userType
 * @param cardIdx
 */
public void addPee(byte userType, int cardIdx)
{
for(i=0; i<MAX_PEE; i++)
{
if(cardsPee[userType][i] == CARD_NULL)
{
cardsPee[userType][i] = (byte)cardIdx;
break;
}
}
    
    // 피가 10장 이상일때부터 피 1개당 1점씩 추가.
    if(getNumOfPee(userType) >= 10 )
    {
        if(cardIdx == gCard.CARD_GOOKJIN) // 국진이 피 슬롯에 있다면,
            addPoint(userType, 2); // 2점 추가.
        else switch(gCard.getType((byte)cardIdx))
        {
        case CARDTYPE_PEE: // 일반 피라면,
            addPoint(userType, 1); // 1점 추가.
            break;
        case CARDTYPE_SSANG_PEE: // 쌍피라면,
            addPoint(userType, 2); // 2점 추가.
            break;
        case CARDTYPE_THREE_PEE: // 쓰리피라면,
            addPoint(userType, 3); // 3점 추가.
            break;
        }
    }
}

/**
 * 패를 추가 한다.
 * @param userType
 * @param cardNum
 */
public void addPae(byte userType, byte cardNum)
{
    /* 지금 먹으려는 열이 국진이라면, */
    if(cardNum == CARD_GOOKJIN)
    {
        if(bSelectGookjin == false)
        {
            // 국진을 열로 쓸지, 피로 쓸지 물어 봄.
            bSelectGookjin = true;
            return;
        }
    }
      
switch( gCard.getBigType(cardNum) )
{
case KWANG: // 광.
addKwang(userType, cardNum);
break;
case YEUL: // 열.
addYeul(userType, cardNum);
break;
case DDEE: // 띠.
addDdee(userType, cardNum);
break;
case PEE: // 피.
addPee(userType, cardNum);
}
}

/**
 * 키 입력.
 */
public void keyPressed(int keyCode)
{
    switch(keyCode)
    {

    /**
     *
     * ... 생략 ...
     *
     */

    default: // 그 외.
        short numKey = (short)(keyCode - 48);
        if(numKey >= 0 && numKey <= 9) // 숫자키가 눌렸다면.
        {

            /**
             *
             * ... 생략 ...
             *
             */
            else if(curViewState == State.GAME_SELECTGOOKJIN)
            {
                // 국진 사용을 선택중일때,
                if(numKey == 1)
                {
                    // 국진을 열끗으로 사용함.
                    room.addYeul(curTurn, CARD_GOOKJIN);

                    curViewState = State.GAME_RUNNING;

                    if(curTurn == User.PLAYER)
                        room.numOfPlayerCard--;
                    else
                        room.numOfComputerCard--;

                    // 턴을 변경.
                    curTurn = (curTurn == User.PLAYER)? 
                                User.COMPUTER : User.PLAYER;

                    room.bSelectGookjin = false;

                    repaints();
                }
                else
                {
                    // 국진을 피로 사용함.
                    room.addPee(curTurn, CARD_GOOKJIN);

                    curViewState = State.GAME_RUNNING;

                    if(curTurn == User.PLAYER)
                        room.numOfPlayerCard--;
                    else
                        room.numOfComputerCard--;

                    // 턴을 변경.
                    curTurn = (curTurn==User.PLAYER)? 
                                User.COMPUTER : User.PLAYER;

                    room.bSelectGookjin = false;

                    repaints();
                }
            }
        }
    } // switch(keyCode).
} // end public void keyPressed(int keyCode).