package common;

/**
 * 사용자의 정보를 담아 놓는 클래스
 */
public class User
{
    public final static byte NULL = -1;
    public final static byte PLAYER = 0;
    public final static byte COMPUTER = 1;

    public final static long DEFAULT_MONEY = 100000;

    private byte userType = NULL; // 유저 타입.
    private int numGame = 0; // 게임 횟수.  
    private int numWin = 0; // 이긴 횟수.       
    private long money = DEFAULT_MONEY; // 돈.

    /**
     * Constructor.
     */
    public User()
    {
        System.out.println("생성자 호출 됨.");
        userType = NULL;
        numGame = 0;
        numWin = 0;
        money = DEFAULT_MONEY;
    }

    /**
     * 사용자 정보를 설정한다.
     * @param numGame
     * @param numWin
     * @param mney
     */
    public void setUserInfo(int userType, int numGame, 
                             int numWin, long money)
    {
        this.userType = (byte)userType;
        this.numGame = numGame;
        this.numWin = numWin;
        this.money = money;
    }

    /**
     * 사용자 타입을 설정한다.
     * @param userType
     */
    public void setUserType(int userType)
    {
        this.userType = (byte)userType;
    }

    /**
     * 사용자의 money를 변경한다.
     * @param money
     * @return 변경된money
     */
    public long changeMoney(long money)
    {
        this.money += money;
        return this.money;
    }

    /**
     * 사용자의 money를 설정한다.
     * @param money
     */
    public void setMoney(long money)
    {
        this.money = money;
    }

    /**
     * 사용자의 money를 얻어온다.
     * @return 사용자money
     */
    public long getMoney()
    {
        return money;
    }

    /**
     * 사용자 타입을 얻어온다.
     * @return
     */
    public byte getUserType()
    {
        return userType;
    }
}

package common;

/**
 * 게임방에 관련된 사용자등의 정보를 관리한다.
 */

public class GameRoom extends User
{
    public User[] user;

    /**
     * Constructor.
     */
    public GameRoom()
    {
        initUser(); // 사용자 정보 초기화.
    }

    /**
     * 사용자 정보를 초기화 한다.
     */
    private void initUser()
    {
        user = new User[2]; // User 클래스 두개 생성.
        user[PLAYER] = new User();
        user[COMPUTER] = new User();

        // 만약 유저 정보가 입력되어 있지 않다면,
        if(user[PLAYER].getUserType() == NULL)
        {
            /*
             * 각각의 정보를 초기화 한다.
             */
            user[PLAYER].setUserInfo(PLAYER, 0, 0, DEFAULT_MONEY);
            user[COMPUTER].setUserInfo(COMPUTER, 0, 0, DEFAULT_MONEY);
        }
    }


    /**
     * 플레이어의 돈을 리턴한다.
     * @return 플레이어의 돈.
     */
    public long getPlayerMoney()
    {
        return user[PLAYER].getMoney();
    }

    /**
     * 플레이어의 돈을 변경한다.
     * @param money 변경액.
     */
    public void changePlayerMoney(long money)
    {
        user[PLAYER].changeMoney(money);
    }


    /**
     * 컴퓨터의 돈을 리턴한다.
     * @return 컴퓨터의 돈.
     */
    public long getComMoney()
    {
        return user[COMPUTER].getMoney();
    }

    /**
     * 컴퓨터의 돈을 변경한다.
     * @param money 변경액.
     */
    public void changeComMoney(long money)
    {
        user[COMPUTER].changeMoney(money);
    }
}

    /**
     * 선택된 메뉴의 해당 동작을 수행한다.
     * @param menuIdx
     */
    private void choiceMenu(int menuIdx)
    {
        switch(menuIdx)
        {
        case CyMenu.GAME_START: // 게임 시작.
            showGameStart(); // 게임 시작.
            break;

 	 ........

        }
    }

    /**
     * 게임을 시작한다.
     */
    private void showGameStart()
    {
        repaints();
        serviceRepaints();

        midlet.cleanUp(); // 자원 해제 후, 
        midlet.enterGame(); // 게임 시작.
    }

    /**
     * 게임을 시작한다.
     */
    void enterGame()
    {
        initGame();
        setCurrentDisplay(gameView);

        curState = State.GAME;
    }

package common;

import javax.microedition.lcdui.*;
import java.util.Hashtable;
import java.io.InputStream;

/**
 * 이미지를 한번에 읽어들여서 나중에 할당해줄때 사용한다. 
 */

public class CyResMan
{
    Hashtable resList = new Hashtable();

    byte[] byteImage;

    /**
     * mix해 놓은 이미지 파일을 지정해 전부 읽어 놓는다.
     * @param path
     */
    public void setImageData(String path)
    {
        try
        {
            InputStream is = null;
            is = getClass().getResourceAsStream(path);

            // byteImage를 null로 초기화 후,
            if(byteImage != null)
                byteImage = null;

            // dat 파일의 사이즈만큼을 읽어 오고,
            byteImage = new byte[is.available()];
            is.read(byteImage);

            // 파일을 닫는다.
            is.close();
        } catch(Exception e) {}
    }

    /**
     * 이미지를 읽어온다.
     * @param path
     * @return
     */
    public synchronized Image loadImage(String path)
    {
        // 동시에 2개의 thread가 읽는 경우가 있음.
        Image img = null;

        try
        {
            InputStream is = null;
            is = getClass().getResourceAsStream(path);

            // byteImage를 null로 초기화.
            if(byteImage != null)
                byteImage = null;

            // 해당 파일의 사이즈만큼을 읽어온다.
            byteImage = new byte[is.available()];
            is.read(byteImage);

            // 파일을 닫는다.
            is.close();

            // 메모리상에서 파일의 사이즈만큼을 읽어온다.
            img = Image.createImage(byteImage, 0, byteImage.length);

            byteImage = null;
        } catch(Exception e)
        {
            System.out.println("resMan.loadImage "+e.toString()+" "+path);
        }

        return img;
    }

    /**
     * 미리 읽어놓은 data에서 지정된 Offset과 length로 이미지를 만든다. 
     * @param name
     * @param off 오프셋.
     * @param len 이미지 사이즈.
     * @return 성공여부
     */
    public boolean addImage(String name, int off, int len)
    {
        try
        {
            /*
             * setImageData를 통해 미리 읽어 둔 .dat 파일에서,
             * offset 지점 부터, length 만큼을 읽어와 이미지를 만든다.
             */
            Image img = Image.createImage(byteImage, off, len);
            resList.put(name, img);
        } catch(Exception e)
        {
            // 이미지 생성 실패.
            return false;
        }

        // 이미지 생성 성공.
        return true;
    }

    /**
     * 자원 해제.
     */
    public void cleanUp()
    {
        byteImage = null;
        System.gc();
    }

    /**
     * 저장해 놓은 Image개체를 메모리에서 해제한다.
     * @param name
     */
    public void removeImage(String name)
    {
        Image img = (Image)resList.get(name);
        resList.remove(name);
        img = null;
    }

    /**
     * 읽어놓은 메모리상에서 Image개체를 가져온다.
     * @param name
     * @return name에 해당하는 image 개체
     */
    public Image getImage(String name)
    {
        Image img = (Image)resList.get(name);

        return img;
    }
}

package twogo1p;

import javax.microedition.lcdui.*;
import java.io.InputStream;

import com.skt.m.Graphics2D;

import gostop.*;
import common.*;

/**
 * 맞고의 게임 화면을 그려준다.
 */

class GameView extends GostopView
{
    // 폰트 사이즈 상수.
    private final int SMALLFONT_WIDTH = 4;
    private final int SMALLFONT_HEIGHT = 6;

    protected int totalWidth = 128, totalHeight = 150;      //전체 게임 크기
    private short cardWindowHeight = 0;

    private Image imgExitBtn, imgStartBtn; // 종료 버튼, 시작 버튼.

    // 플레이어와 컴퓨터의 아바타 얼굴 이미지.
    private Image imgPlayer, imgComputer; 

    private Image imgFloorBg;       // 바닥 중앙의 무늬 이미지.
    private Image imgBgPattern; // 배경 타일 패턴 이미지.

    private Image imgAqViewTable; // 획득 카드 화면의 사용자정보 출력 테이블.
    private Image imgAqViewOkBtn; // 획득 카드 화면의 확인 버튼.
    private Image imgAqViewIconID;// 획득 카드 화면의 ID 아이콘.
    private Image imgAqViewIconMoney; // 획득 카드 화면의 Money 아이콘.

    private Image imgSmallFont; // 작은 숫자 폰트 이미지.

    byte curTurn = User.NULL; // 현재 턴.
    byte curViewState = State.GAME_WAIT; // 현재 보여지는 화면의 상태.

    CyResMan resMan;
    Room room;

    Graphics2D g2d;
    Midlet midlet;

    Rect rectFloor;

    byte whoseAcquireCards = User.NULL;

    /**
     * Constructor.
     * @param midlet
     */
    public GameView(Midlet midlet)
    {
        this.midlet = midlet;

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

        resMan = new CyResMan();
        room = new Room();

        makeImage();
        System.out.println(width + ", " + height);
    }


    /**
     * 합친 이미지 파일에서 각각의 이미지를 추출한다.
     */
    private void makeImage()
    {
        // 합친 이미지 파일을 로드후,
        resMan.setImageData("/image/MixImage_1.dat");

        // Mix 파일에서 각각의 이미지를 추출한다.
        resMan.addImage("0", 0, 654);       // 남자 아바타 얼굴.
        resMan.addImage("1", 654, 684);     // 여자 아바타 얼굴.
        resMan.addImage("2", 1338, 924);    // 바닥의 타일 패턴.            
        resMan.addImage("3", 2262, 7448);       // 게임판 중앙의 장식 무늬.
        resMan.addImage("4", 9710, 204);    // 폰트 #1.
        resMan.addImage("5", 9914, 304);    // 폰트 #2.
        resMan.addImage("6", 10218, 21144);     // 카드 스프라이트 (대).
        resMan.addImage("7", 31362, 5304);      // 카드 스프라이트 (소).

        // 아바타 로드.     
        imgPlayer = resMan.getImage("0");
        imgComputer = resMan.getImage("1");

        // 바닥 타일 및 배경 로드.
        imgBgPattern = resMan.getImage("2");
        imgFloorBg = resMan.getImage("3");

        // 폰트 로드.
        imgSmallFont = resMan.getImage("5");

        initPos(); // 위치 초기화.
    }

    /**
     * 각 개체의 위치 설정.
     */
    private void initPos()
    {
        rectFloor = new Rect(0,37,128,58);
        cardWindowHeight = (short)((totalHeight-imgFloorBg.getHeight())/2);
    }

    /**
     * 이미지 로드.
     * @param path
     * @return
     */
    public synchronized Image loadImage(String path)
    {
        // 동시에 2개의 thread가 읽는 경우가 있음
        Image img = null;
        try
        {
            byte[] byteImage;

            InputStream is = null;
            is = getClass().getResourceAsStream(path);
            byteImage = new byte[is.available()];
            is.read(byteImage);
            is.close();

            img = Image.createImage(byteImage, 0, byteImage.length);
            byteImage = null;
        } catch(Exception e) {}

        return img;
    }


    /**
     * 게임판의 배경을 화면에 그려준다.
     * @param g
     */
    private void drawFloor(Graphics g)
    {
        g.setColor(204,153,255);
        g.fillRect(0,0,totalWidth,totalHeight);

        int clipx=0, clipy=0;
        int clipw=0, cliph=0;
		
        /*
         * 기본 클리핑 영역을 저장한다.
         */
        clipx = g.getClipX();
        clipy = g.getClipY();
        clipw = g.getClipWidth();
        cliph = g.getClipHeight();

        g.setClip(0,0,totalWidth,totalHeight);
		
        /*
         * 타일 패턴을 화면에 깔아준다.
         */
        for(int x=0;x<totalWidth;x+=imgBgPattern.getWidth())
        {
            for(int y=0;y<totalHeight;y+=imgBgPattern.getHeight())
            {
                g.drawImage(imgBgPattern, x, y, Graphics.LEFT|Graphics.TOP);
            }
        }

        if(curTurn == User.COMPUTER)
        {
            // 타일 배경을 그려준다.
            g.drawImage(imgFloorBg, width/2, rectFloor.top+6,
                Graphics.HCENTER|Graphics.TOP);
        }
        else /* if(curTurn == PLAYER) */
        {
            // 타일 배경을 그려준다.
            g.drawImage(imgFloorBg, width/2, rectFloor.top, 
                Graphics.HCENTER|Graphics.TOP);
        }

        /*
         * 저장해 둔 기본 클리핑 영역을 복원한다.
         */
        g.setClip(clipx, clipy, clipw, cliph);
    }

    /**
     * 게임 대기화면을 그려준다.
     * @param g
     */
    private void drawWaitingGame(Graphics g)
    {
        /*
         * Start 버튼이 로드되지 않았다면, 스타트버튼 이미지 로드.
         */
        if(imgStartBtn == null)
        {
            imgStartBtn = loadImage("/image/startbtn.lbm");
        } // Start 버튼을 그려준다.
        g.drawImage(imgStartBtn, width, height, Graphics.RIGHT|Graphics.BOTTOM);


        /*
         * Exit 버튼이 로드되지 않았다면, Exit 버튼 이미지 로드.
         */
        if(imgExitBtn == null)
        {
            imgExitBtn =  loadImage("/image/exitbtn.lbm");
        } // Exit 버튼을 그려준다.
        g.drawImage(imgExitBtn, 0, height,Graphics.LEFT|Graphics.BOTTOM);


        // 각 플레이어의 정보 출력.
        g.setColor(182,219,255);

        /*
         * 컴퓨터의 정보 출력.
         */
        // 아바타 얼굴 표시.
        g.drawImage(imgComputer, 28, 38, Graphics.TOP|Graphics.RIGHT);
        // 돈 표시.
        g.drawString("Computer", 30,38,Graphics.TOP|Graphics.LEFT);
        g.drawString(room.getComMoney()+" 원", 
            totalWidth-10,49,Graphics.TOP|Graphics.RIGHT);

        /*
         * 플레이어의 정보 출력.
         */
        // 아바타 얼굴 표시.
        g.drawImage(imgPlayer, 28, 68, Graphics.TOP|Graphics.RIGHT);
        // 돈 표시.
        g.drawString("Player", 30,68,Graphics.TOP|Graphics.LEFT);
        g.drawString(room.getPlayerMoney()+" 원", 
            totalWidth-10, 81,Graphics.TOP|Graphics.RIGHT);
    }

    /**
     * 카드를 나눠주는 중의 화면을 그려준다.
     * @param g
     */
    private void drawDistributeCards(Graphics g)
    {

    }

    /**
     * 게임 진행중의 화면을 그려준다.
     * @param g
     */
    private void drawRunningGame(Graphics g)
    {

    }

    /**
     * 획득 카드 확인 화면을 그려준다.
     * @param g
     */
    private void drawAcquireCards(Graphics g)
    {
        imgAqViewTable = loadImage("/image/aqviewp.lbm");
        imgAqViewOkBtn = loadImage("/image/aqviewok.lbm");
        imgAqViewIconID = loadImage("/image/iconid.lbm");
        imgAqViewIconMoney = loadImage("/image/iconmoney.lbm");

        // 화면 Clear 후,
        g.setColor(0,0,153);
        g.fillRect(0, 0, width, height);

        /*
         * ID/Money 테이블 출력.
         */
        // ID/Money Border의 Fill 출력.
        g.setColor(255,200,255);
        g.fillRect(width-75,0,70,26);

        // 아이디 아이콘과 아이디 표시.
        g.setColor(0);
        g.drawImage(imgAqViewIconID, width-74, 3, Graphics.LEFT|Graphics.TOP);

        if(whoseAcquireCards == User.PLAYER)
            g.drawString("PLAYER", width-5, 1, Graphics.RIGHT|Graphics.TOP);
        else /* if(whoseAcquireCards == User.COMPUTER) */
            g.drawString("COMPUTER", width-5, 1, Graphics.RIGHT|Graphics.TOP);

        // 돈 아이콘과 돈 표시.
        g.drawImage(imgAqViewIconMoney, width-74,15, Graphics.LEFT|Graphics.TOP);
        drawSmallNum(g,width-5, 16+1, room.getPlayerMoney(), Graphics.RIGHT);

        // ID/Money Border의 Outline 출력.
        g.setColor(0,146,170);
        g.drawRect(width-75,0,70,26);

        /*
         * User Info 테이블 출력.
         */
        g.drawImage(imgAqViewTable, 83, 47+10, Graphics.LEFT|Graphics.TOP);

        drawSmallNum(g,(short)(113), (short)(60),
            room.getPoint((int)whoseAcquireCards),
                (short)Graphics.RIGHT);
        drawSmallNum(g,(short)(113), (short)(70),
            room.getCntGo((int)whoseAcquireCards),
                (short)Graphics.RIGHT);
        drawSmallNum(g,(short)(113), (short)(80),
            room.getCntShake((int)whoseAcquireCards),
                (short)Graphics.RIGHT);
        drawSmallNum(g,(short)(113), (short)(90),
            room.getCntPuck((int)whoseAcquireCards),
                (short)Graphics.RIGHT);

        /*
         * 확인 버튼 출력.
         */
        g.drawImage(imgAqViewOkBtn, width, height,
            Graphics.RIGHT|Graphics.BOTTOM);
    }

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

    }

    /**
     * 화면에 작은 숫자를 표시한다.
     * @param g
     * @param x 숫자의 x.
     * @param y 숫자의 y.
     * @param num 수.
     * @param anchor 왼쪽/오른쪽 정렬 선택.
     */
    private void drawSmallNum(Graphics g, int x, int y, long num, int anchor)
    {
        int cnt;
        int posx = x;
        int posy = y;

        String strNum = String.valueOf(num); // 숫자를 문자열로 변경해 준다.
        int len = strNum.length(); // 문자열의 길이를 구한다.

        // 오른쪽 정렬일때, 
        if(anchor==Graphics.RIGHT)
        {
            /*
             * 정확히 시작점부터 시작하기 위해,
             * 시작점에서 폰트의 폭을 빼준다.
             */
            posx -= SMALLFONT_WIDTH;
        }

        // 숫자를 한자 한자 출력해 준다.
        if(anchor == Graphics.RIGHT)
        {
            // 오른쪽에서 왼쪽으로...
            for(cnt=len-1; cnt>=0; cnt--)
            {
                drawSmallFont(g, posx, posy, (strNum.charAt(cnt)-'0'));
                posx -= SMALLFONT_WIDTH;
            }
        }
        else if(anchor == Graphics.LEFT)
        {
            // 왼쪽에서 오른쪽으로...
            for(cnt=0; cnt<len; cnt++)
            {
                drawSmallFont(g, posx, posy, (strNum.charAt(cnt)-'0'));
                posx += SMALLFONT_WIDTH;
            }
        }
    } // end private void drawSmallNum().

    private void drawSmallFont(Graphics g, int x, int y, int num)
    {
        g2d.drawImage(x, y, imgSmallFont, num*SMALLFONT_WIDTH, 0,
                SMALLFONT_WIDTH, SMALLFONT_HEIGHT, Graphics2D.DRAW_COPY);
    }

    /**
     * 화면에 게임 화면을 그려준다.
     */
    public void paint(Graphics g)
    {
        if(g2d == null)
            g2d = Graphics2D.getGraphics2D(g);

        g.setColor(0);
        g.fillRect(0,0,width,height);

        drawFloor(g); // 게임판의 배경을 화면에 그려준다.

        System.out.println("현재 게임 상태 : " + curViewState);
        switch(curViewState)
        {
        case State.GAME_WAIT:   // 게임 대기 중일때,
            drawWaitingGame(g);
            break;
        case State.GAME_DISTRIBUTECARDS: // 카드를 나눠주는 중일때,
            drawDistributeCards(g);
            break;
        case State.GAME_RUNNING: // 게임 진행 중일때,
            drawRunningGame(g);
            break;
        case State.GAME_ACQUIRECARDS: // 얻은 카드 확인 중일때,
            drawAcquireCards(g);
            break;
        case State.GAME_RESULT: // 게임 결과 출력 중일때,
            drawResult(g);
            break;
        }
    }

    /**
     * 메인 메뉴로 돌아감.
     */
    private void enterMainMenu()
    {
        //room.gameOver();
        //initGame();

        midlet.enterMainMenu();
    }
}