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

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

J2ME

开发平台：

Java

FiveLogic.java：源码内容
  3. import java.io.PrintStream;
  4. import java.util.*;
  5. import javax.microedition.lcdui.Canvas;
  7. public class FiveLogic
  8. {
  9.     private FiveCanvas cavFive;
  10.     private int borderSize;
  11.     private boolean computerFirst;
  12.     private int degree;
  13.     public static int STONE_NONE = 0;
  14.     public static int STONE_COMPUTER = 1;
  15.     public static int STONE_MAN = 2;
  16.     private int stones[][];
  17.     private Dot lastDot;
  18.     private int stoneCounter[];
  19.     private Stack steps;
  20.     private Dot triedDot;
  21.     private static int GAIN_BY_COMPUTER = 5;
  22.     private static int GAIN_BY_NONE = 1;
  23.     private boolean endOfGame;
  24.     private boolean computerWon;
  25.     private boolean thinking;
  26.     private Random rnd;
  27.     public FiveLogic(FiveCanvas cav, int bSize, boolean cFirst, int deg)
  28.     {
  30.     
  31.         borderSize = 11;
  32.         computerFirst = true;
  33.         degree = 1;
  34.         cavFive = cav;
  35.         borderSize = bSize;
  36.         computerFirst = cFirst;
  37.         degree = deg;
  38.         stones = new int[bSize][bSize];
  39.         for(int r = 0; r < borderSize; r++)
  40.         {
  41.             for(int c = 0; c < borderSize; c++)
  42.                 stones[r][c] = 0;
  44.         }
  46.         lastDot = new Dot(borderSize);
  47.         stoneCounter = new int[3];
  48.         stoneCounter[1] = 0;
  49.         stoneCounter[2] = 0;
  50.         stoneCounter[0] = borderSize * borderSize;
  51.         steps = new Stack();
  52.         triedDot = new Dot(-1, -1);
  53.         endOfGame = false;
  54.         thinking = false;
  55.         rnd = new Random();
  56.     }
  58.     public int[][] stones()
  59.     {
  60.         return stones;
  61.     }
  63.     public Dot lastDot()
  64.     {
  65.         return lastDot;
  66.     }
  68.     public Dot triedDot()
  69.     {
  70.         return triedDot;
  71.     }
  73.     public boolean gameEnd()
  74.     {
  75.         return endOfGame;
  76.     }
  78.     public boolean computerWon()
  79.     {
  80.         return computerWon;
  81.     }
  83.     public boolean thinking()
  84.     {
  85.         return thinking;
  86.     }
  88.     private boolean endOfGame()
  89.     {
  90.         endOfGame = false;
  91.         for(int r = 0; r < borderSize; r++)
  92.         {
  93.             for(int c = 0; c < borderSize; c++)
  94.             {
  95.                 if(stones[r][c] == 0 || existNLineWithMinFree(r, c, 5, 0, -1) == -1)
  96.                     continue;
  97.                 endOfGame = true;
  98.                 computerWon = stones[r][c] == 1;
  99.                 break;
  100.             }
  102.             if(endOfGame)
  103.                 break;
  104.         }
  106.         if(endOfGame)
  107.             cavFive.notifyGameEnd();
  108.         return endOfGame;
  109.     }
  111.     public void manGo(int row, int col)
  112.     {
  113.         if(row >= 0 && row < borderSize && col >= 0 && col < borderSize && stones[row][col] == 0)
  114.         {
  115.             goAt(row, col, 2);
  116.             if(endOfGame())
  117.             {
  118.                 if(computerWon)
  119.                     cavFive.setStatus("你输了!", 0xff0000, 2);
  120.                 else
  121.                     cavFive.setStatus("u4F60u8D62u4E86!", 65280, 1);
  122.             } else
  123.             {
  124.                 computerGo();
  125.             }
  126.         }
  127.     }
  129.     private void goAt(int row, int col, int playerStone)
  130.     {
  131.         int lastRow = lastDot.row;
  132.         int lastCol = lastDot.col;
  133.         stones[row][col] = playerStone;
  134.         lastDot.setRowCol(row, col);
  135.         cavFive.repaintAt(lastRow, lastCol);
  136.         cavFive.repaintAt(row, col);
  137.         switch(playerStone)
  138.         {
  139.         case 1: // '01'
  140.             stoneCounter[1]++;
  141.             break;
  143.         case 2: // '02'
  144.             stoneCounter[2]++;
  145.             break;
  146.         }
  147.         stoneCounter[0]--;
  148.         if(steps.size() > 10)
  149.             steps.removeElementAt(0);
  150.         steps.push(new Dot(row, col));
  151.     }
  153.     public boolean undo()
  154.     {
  155.         if(steps.size() >= 3)
  156.         {
  157.             Dot d = new Dot();
  158.             d.copyFrom((Dot)steps.pop());
  159.             stones[d.row][d.col] = 0;
  160.             cavFive.repaintAt(d.row, d.col);
  161.             d.copyFrom((Dot)steps.pop());
  162.             stones[d.row][d.col] = 0;
  163.             cavFive.repaintAt(d.row, d.col);
  164.             d.copyFrom((Dot)steps.peek());
  165.             lastDot.copyFrom(d);
  166.             cavFive.repaintAt(d.row, d.col);
  167.             return true;
  168.         } else
  169.         {
  170.             return false;
  171.         }
  172.     }
  174.     public void computerGo()
  175.     {
  176.         cavFive.setStatus("思考中...", 0, 0);
  177.         cavFive.serviceRepaints();
  178.         think();
  179.     }
  181.     public void think()
  182.     {
  183.         thinking = true;
  184.         Dot dc = null;
  185.         if((dc = thinkInNumber(1, 5)) == null && (dc = thinkInNumber(2, 5)) == null && (dc = to4B(1)) == null && (dc = to4B(2)) == null && (dc = toDouble4S_3B_2N1B(1, true)) == null && (dc = toDouble4S_3B_2N1B(2, true)) == null && (dc = toDouble4S_3B_2N1B(1, false)) == null && (dc = toDouble4S_3B_2N1B(2, false)) == null && (dc = toSingle4S_3B_2N1B(1)) == null)
  186.             dc = toSingle4S_3B_2N1B(2);
  187.         if(dc == null)
  188.             dc = maxGainedDot();
  189.         if(dc == null || stoneCounter[0] == 0)
  190.         {
  191.             cavFive.setStatus("平局!", 255, 3);
  192.         } else
  193.         {
  194.             System.out.println("Gone!");
  195.             goAt(dc.row, dc.col, 1);
  196.             if(endOfGame())
  197.             {
  198.                 if(computerWon)
  199.                     cavFive.setStatus("u4F60u8F93u4E86!", 0xff0000, 2);
  200.                 else
  201.                     cavFive.setStatus("u4F60u8D62u4E86 !", 65280, 1);
  202.             } else
  203.             {
  204.                 cavFive.setStatus("u8BF7u4E0Bu5B50...");
  205.             }
  206.         }
  207.         thinking = false;
  208.     }
  210.     private Dot to4B(int playerStone)
  211.     {
  212.         if(stoneCounter[playerStone] < 3)
  213.             return null;
  214.         Dot dot = null;
  215.         int maxGain = 0;
  216.         for(int r = 1; r < borderSize - 1; r++)
  217.         {
  218.             for(int c = 1; c < borderSize - 1; c++)
  219.                 if(stones[r][c] == 0)
  220.                 {
  221.                     int cd[] = connectedIn8D(playerStone, r, c);
  222.                     int ed[] = expandedIn8D(playerStone, r, c);
  223.                     for(int i = 0; i < 4; i++)
  224.                         if(ed[i] > cd[i] && ed[i + 4] > cd[i + 4] && cd[i] + cd[i + 4] + 1 >= 4)
  225.                         {
  226.                             int gain = gainAt(r, c);
  227.                             if(gain > maxGain || gain > 0 && gain == maxGain && randomTrue())
  228.                             {
  229.                                 maxGain = gain;
  230.                                 dot = new Dot(r, c);
  231.                             }
  232.                         }
  234.                 }
  236.         }
  238.         return dot;
  239.     }
  241.     private Dot toSingle4S_3B_2N1B(int playerStone)
  242.     {
  243.         if(stoneCounter[playerStone] < 2)
  244.             return null;
  245.         Dot dot = null;
  246.         for(int r = 0; r < borderSize; r++)
  247.         {
  248.             for(int c = 0; c < borderSize; c++)
  249.             {
  250.                 if(stones[r][c] != 0 || find4S_3B_2N1BAt(r, c, playerStone, -1) == -1)
  251.                     continue;
  252.                 dot = new Dot(r, c);
  253.                 break;
  254.             }
  256.             if(dot != null)
  257.                 break;
  258.         }
  260.         return dot;
  261.     }
  263.     private Dot toDouble4S_3B_2N1B(int playerStone, boolean only4S)
  264.     {
  265.         if(stoneCounter[playerStone] < 4)
  266.             return null;
  267.         Dot dot = null;
  268.         for(int rTest = 0; rTest < borderSize; rTest++)
  269.         {
  270.             for(int cTest = 0; cTest < borderSize; cTest++)
  271.             {
  272.                 if(stones[rTest][cTest] != 0)
  273.                     continue;
  274.                 int cd[] = connectedIn8D(playerStone, rTest, cTest);
  275.                 if(cd[0] + cd[1] + cd[2] + cd[3] + cd[4] + cd[5] + cd[6] + cd[7] <= 0)
  276.                     continue;
  277.                 triedDot.setRowCol(rTest, cTest);
  278.                 stones[rTest][cTest] = playerStone;
  279.                 boolean found = false;
  280.                 int dFirst = find4S_3B_2N1B(playerStone, -1, rTest, cTest, only4S);
  281.                 if(dFirst != -1 && find4S_3B_2N1B(playerStone, dFirst, rTest, cTest, false) != -1)
  282.                     found = true;
  283.                 stones[rTest][cTest] = 0;
  284.                 triedDot.setRowCol(-1, -1);
  285.                 if(!found)
  286.                     continue;
  287.                 dot = new Dot(rTest, cTest);
  288.                 break;
  289.             }
  291.             if(dot != null)
  292.                 break;
  293.         }
  295.         return dot;
  296.     }
  298.     private int find4SAt(int row, int col, int playerStone, int exceptDirection)
  299.     {
  300.         int dFond = -1;
  301.         int cd[] = connectedIn8D(playerStone, row, col);
  302.         int ed[] = expandedIn8D(playerStone, row, col);
  303.         for(int d = 0; d < 4; d++)
  304.         {
  305.             if(d == exceptDirection || stones[row][col] != playerStone)
  306.                 continue;
  307.             int nConnect = cd[d] + cd[d + 4] + 1;
  308.             int nFree1 = ed[d] - cd[d];
  309.             int nFree2 = ed[d + 4] - cd[d + 4];
  310.             boolean b4S = nConnect >= 4 && (nFree1 >= 1 || nFree2 >= 1);
  311.             if(!b4S)
  312.                 continue;
  313.             dFond = d;
  314.             break;
  315.         }
  317.         return dFond;
  318.     }
  320.     private int find4S_3B_2N1BAt(int row, int col, int playerStone, int exceptDirection)
  321.     {
  322.         int dFond = -1;
  323.         int cd[] = connectedIn8D(playerStone, row, col);
  324.         int ed[] = expandedIn8D(playerStone, row, col);
  325.         for(int d = 0; d < 4; d++)
  326.         {
  327.             if(d == exceptDirection)
  328.                 continue;
  329.             if(stones[row][col] == playerStone)
  330.             {
  331.                 int nConnect = cd[d] + cd[d + 4] + 1;
  332.                 int nFree1 = ed[d] - cd[d];
  333.                 int nFree2 = ed[d + 4] - cd[d + 4];
  334.                 boolean b4S = nConnect >= 4 && (nFree1 >= 1 || nFree2 >= 1);
  335.                 boolean b3B = nConnect >= 3 && nFree1 >= 1 && nFree2 >= 1;
  336.                 if(b4S || b3B)
  337.                 {
  338.                     dFond = d;
  339.                     break;
  340.                 }
  341.             }
  342.             if(stones[row][col] != 0)
  343.                 continue;
  344.             int nFree1 = ed[d] - cd[d];
  345.             int nFree2 = ed[d + 4] - cd[d + 4];
  346.             boolean b2N1 = cd[d] >= 2 && cd[d + 4] >= 1 || cd[d] >= 1 && cd[d + 4] >= 2;
  347.             boolean bSFree = nFree1 >= 1 && nFree2 >= 1;
  348.             if(!b2N1 || !bSFree)
  349.                 continue;
  350.             dFond = d;
  351.             break;
  352.         }
  354.         return dFond;
  355.     }
  357.     private int find4S_3B_2N1B(int playerStone, int exceptDirection, int rTest, int cTest, boolean only4S)
  358.     {
  359.         int dFond = -1;
  360.         int rMin = rTest - 3;
  361.         if(rMin < 0)
  362.             rMin = 0;
  363.         int rMax = rTest + 3;
  364.         if(rMax > borderSize)
  365.             rMax = borderSize;
  366.         int cMin = cTest - 3;
  367.         if(cMin < 0)
  368.             cMin = 0;
  369.         int cMax = cTest + 3;
  370.         if(cMax > borderSize)
  371.             cMax = borderSize;
  372.         for(int r = rMin; r < rMax; r++)
  373.         {
  374.             for(int c = cMin; c < cMax; c++)
  375.             {
  376.                 if(stones[r][c] != playerStone && stones[r][c] != 0)
  377.                     continue;
  378.                 if(only4S)
  379.                     dFond = find4SAt(r, c, playerStone, exceptDirection);
  380.                 else
  381.                     dFond = find4S_3B_2N1BAt(r, c, playerStone, exceptDirection);
  382.                 if(dFond != -1)
  383.                     break;
  384.             }
  386.             if(dFond != -1)
  387.                 break;
  388.         }
  390.         return dFond;
  391.     }
  393.     private Dot thinkInNumber(int stonePlayer, int nl)
  394.     {
  395.         if(stoneCounter[stonePlayer] < nl - 1)
  396.             return null;
  397.         int maxGain = 0;
  398.         Dot dot = null;
  399.         for(int r = 0; r < borderSize; r++)
  400.         {
  401.             for(int c = 0; c < borderSize; c++)
  402.             {
  403.                 int gain = thinkInNumberAt(stonePlayer, r, c, nl);
  404.                 if(gain > maxGain || gain > 0 && gain == maxGain && randomTrue())
  405.                 {
  406.                     maxGain = gain;
  407.                     dot = new Dot(r, c);
  408.                 }
  409.             }
  411.         }
  413.         return dot;
  414.     }
  416.     private int thinkInNumberAt(int lineStone, int row, int col, int nl)
  417.     {
  418.         int lines = 0;
  419.         int otherGain = 0;
  420.         if(stones[row][col] == 0)
  421.         {
  422.             int cd[] = connectedIn8D(lineStone, row, col);
  423.             int ed[] = expandedIn8D(lineStone, row, col);
  424.             for(int i = 0; i < 4; i++)
  425.                 if(ed[i] + ed[i + 4] + 1 >= 5)
  426.                 {
  427.                     int l = cd[i] + cd[i + 4] + 1;
  428.                     if(l >= nl)
  429.                         lines++;
  430.                     else
  431.                         otherGain += 2 ^ l;
  432.                 }
  434.         }
  435.         return lines > 0 ? lines * 32 + otherGain : 0;
  436.     }
  438.     private int[] expandedIn8D(int stone, int row, int col)
  439.     {
  440.         int ed[] = new int[8];
  441.         for(int d = 0; d < 8; d++)
  442.             ed[d] = expandedIn1D(stone, row, col, d);
  444.         return ed;
  445.     }
  447.     private int expandedIn1D(int stone, int row, int col, int direction)
  448.     {
  449.         int n = 0;
  450.         int cn = 0;
  451.         Dot d = new Dot(row, col);
  452.         while(cn < 4) 
  453.         {
  454.             d.copyFrom(forwardOneStep(d, direction));
  455.             if(!d.inBorder(borderSize))
  456.                 break;
  457.             int st = stones[d.row][d.col];
  458.             if(st == 0)
  459.                 cn++;
  460.             if(st != stone && st != 0)
  461.                 break;
  462.             n++;
  463.         }
  464.         return n;
  465.     }
  467.     private Dot maxGainedDot()
  468.     {
  469.         Dot dotWithMaxGain = null;
  470.         int maxGain = 0;
  471.         for(int r = 0; r < borderSize; r++)
  472.         {
  473.             for(int c = 0; c < borderSize; c++)
  474.             {
  475.                 int gain = gainAt(r, c);
  476.                 if(gain > maxGain || gain > 0 && gain == maxGain && randomTrue())
  477.                 {
  478.                     maxGain = gain;
  479.                     dotWithMaxGain = new Dot(r, c);
  480.                 }
  481.             }
  483.         }
  485.         return dotWithMaxGain;
  486.     }
  488.     private int gainAt(int row, int col)
  489.     {
  490.         if(stones[row][col] == 0)
  491.         {
  492.             int gain = 0;
  493.             for(int d = 0; d < 8; d++)
  494.             {
  495.                 int gd = gainAtDirection(row, col, d);
  496.                 if(gd == 0)
  497.                     gain >>= 2;
  498.                 else
  499.                     gain += gd;
  500.             }
  502.             if(gain < 1)
  503.                 gain = 1;
  504.             return gain;
  505.         } else
  506.         {
  507.             return 0;
  508.         }
  509.     }
  511.     private int gainAtDirection(int row, int col, int direction)
  512.     {
  513.         int gain = 0;
  514.         Dot d = new Dot(row, col);
  515.         int step = 0;
  516.         do
  517.         {
  518.             d.copyFrom(forwardOneStep(d, direction));
  519.             step++;
  520.             if(!d.inBorder(borderSize))
  521.                 break;
  522.             int stone = stones[d.row][d.col];
  523.             if(stone == 2)
  524.                 break;
  525.             int gainByStone = stone == 1 ? 5 : 1;
  526.             gain += gainByStep(step) * gainByStone;
  527.         } while(true);
  528.         return gain;
  529.     }
  531.     private int gainByStep(int step)
  532.     {
  533.         int gain = (borderSize - step) / 2;
  534.         if(gain < 1)
  535.             gain = 1;
  536.         return gain;
  537.     }
  539.     private int exist2N1(int row, int col, int playerStone, int exceptDirection)
  540.     {
  541.         int cd[] = connectedIn8D(playerStone, row, col);
  542.         int ed[] = expandedIn8D(playerStone, row, col);
  543.         int existDirection = -1;
  544.         for(int i = 0; i < 4; i++)
  545.         {
  546.             if(i == exceptDirection || (cd[i] < 2 || cd[i + 4] < 1) && (cd[i] < 1 || cd[i + 4] < 2) || (ed[i] - cd[i]) + (ed[i + 4] - cd[i + 4]) <= 0)
  547.                 continue;
  548.             existDirection = i;
  549.             break;
  550.         }
  552.         return existDirection;
  553.     }
  555.     private int existNLineWithMinFree(int row, int col, int n, int minFree, int exceptDirection)
  556.     {
  557.         int stone = stones[row][col];
  558.         int cd[] = connectedIn8D(stone, row, col);
  559.         int ed[] = expandedIn8D(stone, row, col);
  560.         int existDirection = -1;
  561.         for(int i = 0; i < 4; i++)
  562.         {
  563.             if(i == exceptDirection || cd[i] + cd[i + 4] + 1 < n || (ed[i] - cd[i]) + (ed[i + 4] - cd[i + 4]) < minFree)
  564.                 continue;
  565.             existDirection = i;
  566.             break;
  567.         }
  569.         return existDirection;
  570.     }
  572.     private int[] connectedIn8D(int stone, int row, int col)
  573.     {
  574.         int cd[] = new int[8];
  575.         for(int d = 0; d < 8; d++)
  576.             cd[d] = connectedIn1D(stone, row, col, d);
  578.         return cd;
  579.     }
  581.     private int connectedIn1D(int stone, int row, int col, int direction)
  582.     {
  583.         int n = 0;
  584.         Dot d = new Dot(row, col);
  585.         do
  586.         {
  587.             d.copyFrom(forwardOneStep(d, direction));
  588.             if(d.inBorder(borderSize) && stones[d.row][d.col] == stone)
  589.                 n++;
  590.             else
  591.                 return n;
  592.         } while(true);
  593.     }
  595.     private Dot forwardOneStep(Dot d, int direction)
  596.     {
  597.         int r = d.row;
  598.         int c = d.col;
  599.         switch(direction)
  600.         {
  601.         case 0: // ''
  602.             c++;
  603.             break;
  605.         case 1: // '01'
  606.             r--;
  607.             c++;
  608.             break;
  610.         case 2: // '02'
  611.             r--;
  612.             break;
  614.         case 3: // '03'
  615.             r--;
  616.             c--;
  617.             break;
  619.         case 4: // '04'
  620.             c--;
  621.             break;
  623.         case 5: // '05'
  624.             r++;
  625.             c--;
  626.             break;
  628.         case 6: // '06'
  629.             r++;
  630.             break;
  632.         case 7: // '07'
  633.             r++;
  634.             c++;
  635.             break;
  636.         }
  637.         return new Dot(r, c);
  638.     }
  640.     private boolean randomTrue()
  641.     {
  642.         return rnd.nextInt() % 2 == 0;
  643.     }
  646. }