开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > J2ME > 查看源码
FiveCanvas.java
资源名称：J2ME&Game.rar　[点击查看]
上传用户：gyyuli
上传日期：2013-07-09
资源大小：3050k
文件大小：10k
源码类别：

J2ME

开发平台：

Java

FiveCanvas.java：源码内容
  2. import java.io.IOException;
  3. import javax.microedition.lcdui.*;
  5. public class FiveCanvas extends Canvas
  6.     implements CommandListener
  7. {
  8.     public static int BLACK = 0;
  9.     public static int WHITE = 0xffffff;
  10.     public static int RED = 0xff0000;
  11.     public static int GREEN = 65280;
  12.     public static int BLUE = 255;
  13.     public static int WOOD = 0xffd020;
  14.     private FiveMIDlet midFive;
  15.     private Reg reg;
  16.     private Command cmdStop;
  17.     private Command cmdNew;
  18.     private Command cmdUndo;
  19.     private FiveLogic logic;
  20.     private int borderSize;
  21.     private boolean computerFirst;
  22.     private int degree;
  23.     private int cavWidth;
  24.     private int cavHeight;
  25.     private int cWidth;
  26.     private int cHeight;
  27.     private Font font;
  28.     private int fWidth;
  29.     private int fHeight;
  30.     private int borderX;
  31.     private int borderY;
  32.     private int borderLength;
  33.     private int gridLength;
  34.     private int stoneLength;
  35.     private int statusY;
  36.     private String status;
  37.     private int statusColor;
  38.     private boolean statusUpSide;
  39.     private final Image imgStatus[] = new Image[4];
  40.     private int statusImage;
  41.     public static int THINK = 0;
  42.     public static int SMILE = 1;
  43.     public static int CRY = 2;
  44.     public static int NONE = 3;
  45.     private boolean isColor;
  47.     static 
  48.     {
  49.         BLACK = 0;
  50.         WHITE = 0xffffff;
  51.         RED = 0xff0000;
  52.         GREEN = 65280;
  53.         BLUE = 255;
  54.         WOOD = 0xffd020;
  55.         THINK = 0;
  56.         SMILE = 1;
  57.         CRY = 2;
  58.         NONE = 3;
  59.     }
  60.     public FiveCanvas(FiveMIDlet m, Reg r)
  61.     {
  62.         midFive = m;
  63.         reg = r;
  64.         cmdNew = new Command("重玩", 4, 2);
  65.         cmdStop = new Command("退出", 2, 1);
  66.         cmdUndo = new Command("悔棋", 1, 3);
  67.         addCommand(cmdNew);
  68.         addCommand(cmdStop);
  69.         setCommandListener(this);
  70.         cavWidth = getWidth();
  71.         cavHeight = getHeight();
  72.         status = "";
  73.         statusColor = 0;
  74.         statusUpSide = true;
  75.         for(int i = 0; i < 4; i++)
  76.             imgStatus[i] = Image.createImage(1, 1);
  78.         try
  79.         {
  80.             imgStatus[0] = Image.createImage("/Think.png");
  81.         }
  82.         catch(IOException _ex) { }
  83.         try
  84.         {
  85.             imgStatus[1] = Image.createImage("/Smile.png");
  86.         }
  87.         catch(IOException _ex) { }
  88.         try
  89.         {
  90.             imgStatus[2] = Image.createImage("/Cry.png");
  91.         }
  92.         catch(IOException _ex) { }
  93.         statusImage = 3;
  94.         isColor = Display.getDisplay(midFive).numColors() > 2;
  95.     }
  97.     private void calcSize()
  98.     {
  99.         font = Font.getDefaultFont();
  100.         fWidth = font.charWidth('字');
  101.         fHeight = font.getHeight();
  102.         statusUpSide = cavHeight > cavWidth;
  103.         if(statusUpSide)
  104.         {
  105.             cWidth = cavWidth;
  106.             cHeight = cavHeight - fHeight;
  107.         } else
  108.         {
  109.             cWidth = cavWidth - fWidth;
  110.             cHeight = cavHeight;
  111.         }
  112.         borderLength = cWidth > cHeight ? cHeight : cWidth;
  113.         gridLength = borderLength / borderSize;
  114.         borderLength = gridLength * borderSize;
  115.         borderX = (cWidth - borderLength) / 2;
  116.         borderY = (cHeight - borderLength) / 2;
  117.         if(statusUpSide)
  118.             borderY += fHeight;
  119.         stoneLength = gridLength - 2;
  120.     }
  122.     public void paint(Graphics g)
  123.     {
  124.         g.setColor(0xffffff);
  125.         g.fillRect(0, 0, cavWidth, cavHeight);
  126.         if(isColor)
  127.         {
  128.             g.setColor(219,219,0);
  129.             g.fillRect(borderX, borderY, borderLength, borderLength);
  130.         }
  131.         g.setColor(isColor ? 255 : 0);
  132.         int y;
  133.         for(int r = 0; r < borderSize; r++)
  134.         {
  135.             int x1 = borderX + gridLength / 2;
  136.             int x2 = (x1 + borderLength) - gridLength;
  137.             y = borderY + r * gridLength + gridLength / 2;
  138.             g.drawLine(x1, y, x2, y);
  139.         }
  141.         int x;
  142.         for(int c = 0; c < borderSize; c++)
  143.         {
  144.             x = borderX + c * gridLength + gridLength / 2;
  145.             int y1 = borderY + gridLength / 2;
  146.             int y2 = (y1 + borderLength) - gridLength;
  147.             g.drawLine(x, y1, x, y2);
  148.         }
  150.         int computerColor;
  151.         int manColor;
  152.         if(computerFirst)
  153.         {
  154.             computerColor = 0;
  155.             manColor = 0xffffff;
  156.         } else
  157.         {
  158.             computerColor = 0xffffff;
  159.             manColor = 0;
  160.         }
  161.         Dot triedDot = logic.triedDot();
  162.         int triedRow = triedDot.row;
  163.         int triedCol = triedDot.col;
  164.         for(int r = 0; r < borderSize; r++)
  165.         {
  166.             for(int c = 0; c < borderSize; c++)
  167.                 if(r != triedRow || c != triedCol)
  168.                 {
  169.                     int stone = logic.stones()[r][c];
  170.                     if(stone != 0)
  171.                     {
  172.                         x = xByCol(c) - stoneLength / 2;
  173.                         y = yByRow(r) - stoneLength / 2;
  174.                         g.setColor(stone == 1 ? computerColor : manColor);
  175.                         g.fillArc(x, y, stoneLength, stoneLength, 0, 360);
  176.                         g.setColor(0);
  177.                         g.drawArc(x, y, stoneLength, stoneLength, 0, 360);
  178.                     }
  179.                 }
  181.         }
  183.         Dot lastDot = logic.lastDot();
  184.         int lastRow = lastDot.row;
  185.         int lastCol = lastDot.col;
  186.         int cLast;
  187.         if(isColor)
  188.         {
  189.             cLast = 0xff0000;
  190.         } else
  191.         {
  192.             cLast = 0;
  193.             switch(logic.stones()[lastRow][lastCol])
  194.             {
  195.             case 1: // '01'
  196.                 cLast = manColor;
  197.                 break;
  199.             case 2: // '02'
  200.                 cLast = computerColor;
  201.                 break;
  202.             }
  203.         }
  204.         g.setColor(cLast);
  205.         x = xByCol(lastCol) - 3;
  206.         y = yByRow(lastRow) - 3;
  207.         g.drawRect(x, y, 6, 6);
  208.         g.setFont(font);
  209.         g.setColor(isColor ? statusColor : 0);
  210.         if(statusUpSide)
  211.         {
  212.             g.drawImage(imgStatus[statusImage], 0, 0, 20);
  213.             x = imgStatus[statusImage].getWidth();
  214.             g.drawString(status, x, 0, 20);
  215.         } else
  216.         {
  217.             x = cWidth + fWidth;
  218.             g.drawImage(imgStatus[statusImage], x, 0, 24);
  219.             x = cWidth + fWidth / 2;
  220.             y = imgStatus[statusImage].getHeight();
  221.             for(int i = 0; i < status.length(); i++)
  222.             {
  223.                 char c = status.charAt(i);
  224.                 g.drawChar(c, x, y, 17);
  225.                 y += fHeight;
  226.             }
  228.         }
  229.     }
  231.     private int xByCol(int col)
  232.     {
  233.         return borderX + col * gridLength + gridLength / 2;
  234.     }
  236.     private int yByRow(int row)
  237.     {
  238.         return borderY + row * gridLength + gridLength / 2;
  239.     }
  241.     protected void keyPressed(int keyCode)
  242.     {
  243.         if(!logic.gameEnd() && !logic.thinking())
  244.         {
  245.             int bs = borderSize;
  246.             Dot lastDot = logic.lastDot();
  247.             int r = lastDot.row;
  248.             int c = lastDot.col;
  249.             repaintAt(r, c);
  250.             int ga = getGameAction(keyCode);
  251.             if(ga == Canvas.LEFT || keyCode == 52)
  252.             {
  253.                 if(--c < 0)
  254.                     c = bs - 1;
  255.                 lastDot.setRowCol(r, c);
  256.                 repaintAt(r, c);
  257.             } else
  258.             if(ga == Canvas.RIGHT || keyCode == 54)
  259.             {
  260.                 if(++c >= bs)
  261.                     c = 0;
  262.                 lastDot.setRowCol(r, c);
  263.                 repaintAt(r, c);
  264.             } else
  265.             if(ga == Canvas.UP || keyCode == 50)
  266.             {
  267.                 if(--r < 0)
  268.                     r = bs - 1;
  269.                 lastDot.setRowCol(r, c);
  270.                 repaintAt(r, c);
  271.             } else
  272.             if(ga == Canvas.DOWN || keyCode == 56)
  273.             {
  274.                 if(++r >= bs)
  275.                     r = 0;
  276.                 lastDot.setRowCol(r, c);
  277.                 repaintAt(r, c);
  278.             } else
  279.             if(ga == Canvas.FIRE || keyCode == 53)
  280.                 logic.manGo(r, c);
  281.         }
  282.     }
  284.     protected void keyRepeated(int keyCode)
  285.     {
  286.         keyPressed(keyCode);
  287.     }
  289.     protected void pointerPressed(int x, int y)
  290.     {
  291.         if(!logic.gameEnd() && !logic.thinking())
  292.         {
  293.             int row = (y - borderY) / gridLength;
  294.             int col = (x - borderX) / gridLength;
  295.             logic.manGo(row, col);
  296.         }
  297.     }
  299.     public void commandAction(Command c, Displayable s)
  300.     {
  301.         if(!logic.thinking())
  302.             if(c == cmdStop)
  303.                 midFive.backHome();
  304.             else
  305.             if(c == cmdNew)
  306.                 newStage();
  307.             else
  308.             if(c == cmdUndo && !logic.undo())
  309.                 setStatus("不能悔棋!");
  310.     }
  312.     public void setOptions(int borderSize, boolean computerFirst, int degree)
  313.     {
  314.         this.borderSize = borderSize;
  315.         this.computerFirst = computerFirst;
  316.         this.degree = degree;
  317.     }
  319.     public boolean newStage()
  320.     {
  321.         addCommand(cmdUndo);
  322.         addCommand(cmdStop);
  323.         removeCommand(cmdNew);
  324.         calcSize();
  325.         logic = new FiveLogic(this, borderSize, computerFirst, degree);
  326.         if(computerFirst)
  327.             logic.computerGo();
  328.         else
  329.             setStatus("请下子:");
  330.         repaint();
  331.         return true;
  332.     }
  334.     public void notifyGameEnd()
  335.     {
  336.         addCommand(cmdNew);
  337.         addCommand(cmdStop);
  338.         removeCommand(cmdUndo);
  339.     }
  341.     public void setStatus(String s)
  342.     {
  343.         setStatus(s, 0, 3);
  344.     }
  346.     public void setStatus(String s, int color, int image)
  347.     {
  348.         status = s;
  349.         statusColor = color;
  350.         statusImage = image;
  351.         int x;
  352.         int y;
  353.         int w;
  354.         int h;
  355.         if(statusUpSide)
  356.         {
  357.             x = 0;
  358.             y = 0;
  359.             w = cavWidth;
  360.             h = fHeight;
  361.         } else
  362.         {
  363.             x = cWidth;
  364.             y = 0;
  365.             w = fWidth;
  366.             h = cavHeight;
  367.         }
  368.         repaint(x, y, w, h);
  369.     }
  371.     public void repaintAt(int row, int col)
  372.     {
  373.         int pX = borderX + (col - 1) * gridLength;
  374.         int pY = borderY + (row - 1) * gridLength;
  375.         int pW = gridLength * 2;
  376.         int pH = pW;
  377.         repaint(pX, pY, pW, pH);
  378.     }
  380. }