Category

Development Platform
Home > SourceCode/Document > Java Develop > View Code
Seven.java
Package: Java.rar　[view]
Upload User: liming9091
Upload Date: 2014-10-27
Package Size: 3376k
Code Size: 15k
Category:

Java Develop

Development Platform:

Java

Seven.java：Code Content
  1. package russiagame;
  3. public class Seven extends Root {
  4.     private GameTable gTable;
  5.     private int x, y;
  6.     private int direct = 1;
  7.     private int[] store;
  9.     public Seven() {
  10.         store = new int[15];
  11.     }
  13.     public boolean begin() {
  14.         if ( (gTable.myTable[ (gTable.x - 1) / 2][1] == 0) &&
  15.             (gTable.myTable[ (gTable.x - 1) / 2 + 1][0] == 0) &&
  16.             (gTable.myTable[ (gTable.x - 1) / 2 + 1][1] == 0) &&
  17.             (gTable.myTable[ (gTable.x - 1) / 2 + 2][1] == 0)) {
  18.             x = (gTable.x - 1) / 2;
  19.             y = 0;
  20.             gTable.myTable[x][y + 1] = 1;
  21.             gTable.myTable[x + 1][y] = 1;
  22.             gTable.myTable[x + 1][y + 1] = 1;
  23.             gTable.myTable[x + 2][y + 1] = 1;
  24.             return true;
  25.         }
  26.         else {
  27.             return false;
  28.         }
  29.     }
  31.     public boolean down() {
  32.         switch (direct) {
  33.             case 1:
  34.                 if (y <= gTable.y - 3) {
  35.                     store[0] = gTable.myTable[x][y + 2];
  36.                     store[1] = gTable.myTable[x + 1][y + 2];
  37.                     store[2] = gTable.myTable[x + 2][y + 2];
  38.                     if (isGo(3)) {
  39.                         gTable.myTable[x + 1][y] = 0;
  40.                         gTable.myTable[x][y + 1] = 0;
  41.                         gTable.myTable[x + 2][y + 1] = 0;
  42.                         gTable.myTable[x][y + 2] = 1;
  43.                         gTable.myTable[x + 1][y + 2] = 1;
  44.                         gTable.myTable[x + 2][y + 2] = 1;
  45.                         y += 1;
  46.                         return true;
  47.                     }
  48.                     else {
  49.                         return false;
  50.                     }
  51.                 }
  52.                 else {
  53.                     return false;
  54.                 }
  55.             case 2:
  56.                 if (y <= gTable.y - 4) {
  57.                     store[0] = gTable.myTable[x][y + 3];
  58.                     store[1] = gTable.myTable[x + 1][y + 2];
  59.                     if (isGo(2)) {
  60.                         gTable.myTable[x][y] = 0;
  61.                         gTable.myTable[x + 1][y + 1] = 0;
  62.                         gTable.myTable[x][y + 3] = 1;
  63.                         gTable.myTable[x + 1][y + 2] = 1;
  64.                         y += 1;
  65.                         return true;
  66.                     }
  67.                     else {
  68.                         return false;
  69.                     }
  70.                 }
  71.                 else {
  72.                     return false;
  73.                 }
  74.             case 3:
  75.                 if (y <= gTable.y - 3) {
  76.                     store[0] = gTable.myTable[x][y + 1];
  77.                     store[1] = gTable.myTable[x + 1][y + 2];
  78.                     store[2] = gTable.myTable[x + 2][y + 1];
  79.                     if (isGo(3)) {
  80.                         gTable.myTable[x][y] = 0;
  81.                         gTable.myTable[x + 1][y] = 0;
  82.                         gTable.myTable[x + 2][y] = 0;
  83.                         gTable.myTable[x][y + 1] = 1;
  84.                         gTable.myTable[x + 1][y + 2] = 1;
  85.                         gTable.myTable[x + 2][y + 1] = 1;
  86.                         y += 1;
  87.                         return true;
  88.                     }
  89.                     else {
  90.                         return false;
  91.                     }
  92.                 }
  93.                 else {
  94.                     return false;
  95.                 }
  96.             case 4:
  97.                 if (y <= gTable.y - 4) {
  98.                     store[0] = gTable.myTable[x][y + 2];
  99.                     store[1] = gTable.myTable[x + 1][y + 3];
  100.                     if (isGo(2)) {
  101.                         gTable.myTable[x + 1][y] = 0;
  102.                         gTable.myTable[x][y + 1] = 0;
  103.                         gTable.myTable[x][y + 2] = 1;
  104.                         gTable.myTable[x + 1][y + 3] = 1;
  105.                         y += 1;
  106.                         return true;
  107.                     }
  108.                     else {
  109.                         return false;
  110.                     }
  111.                 }
  112.                 else {
  113.                     return false;
  114.                 }
  115.             default:
  116.                 return false;
  117.         }
  118.     }
  120.     public boolean left() {
  121.         switch (direct) {
  122.             case 1:
  123.                 if (x >= 1) {
  124.                     store[0] = gTable.myTable[x][y];
  125.                     store[1] = gTable.myTable[x - 1][y + 1];
  126.                     if (isGo(2)) {
  127.                         gTable.myTable[x + 1][y] = 0;
  128.                         gTable.myTable[x + 2][y + 1] = 0;
  129.                         gTable.myTable[x][y] = 1;
  130.                         gTable.myTable[x - 1][y + 1] = 1;
  131.                         x -= 1;
  132.                         return true;
  133.                     }
  134.                     else {
  135.                         return false;
  136.                     }
  137.                 }
  138.                 else {
  139.                     return false;
  140.                 }
  141.             case 2:
  142.                 if (x >= 1) {
  143.                     store[0] = gTable.myTable[x - 1][y];
  144.                     store[1] = gTable.myTable[x - 1][y + 1];
  145.                     store[2] = gTable.myTable[x - 1][y + 2];
  146.                     if (isGo(3)) {
  147.                         gTable.myTable[x][y] = 0;
  148.                         gTable.myTable[x + 1][y + 1] = 0;
  149.                         gTable.myTable[x][y + 2] = 0;
  150.                         gTable.myTable[x - 1][y] = 1;
  151.                         gTable.myTable[x - 1][y + 1] = 1;
  152.                         gTable.myTable[x - 1][y + 2] = 1;
  153.                         x -= 1;
  154.                         return true;
  155.                     }
  156.                     else {
  157.                         return false;
  158.                     }
  159.                 }
  160.                 else {
  161.                     return false;
  162.                 }
  163.             case 3:
  164.                 if (x >= 1) {
  165.                     store[0] = gTable.myTable[x - 1][y];
  166.                     store[1] = gTable.myTable[x][y + 1];
  167.                     if (isGo(2)) {
  168.                         gTable.myTable[x + 2][y] = 0;
  169.                         gTable.myTable[x + 1][y + 1] = 0;
  170.                         gTable.myTable[x - 1][y] = 1;
  171.                         gTable.myTable[x][y + 1] = 1;
  172.                         x -= 1;
  173.                         return true;
  174.                     }
  175.                     else {
  176.                         return false;
  177.                     }
  178.                 }
  179.                 else {
  180.                     return false;
  181.                 }
  182.             case 4:
  183.                 if (x >= 1) {
  184.                     store[0] = gTable.myTable[x][y];
  185.                     store[1] = gTable.myTable[x - 1][y + 1];
  186.                     store[2] = gTable.myTable[x][y + 2];
  187.                     if (isGo(3)) {
  188.                         gTable.myTable[x + 1][y] = 0;
  189.                         gTable.myTable[x + 1][y + 1] = 0;
  190.                         gTable.myTable[x + 1][y + 2] = 0;
  191.                         gTable.myTable[x][y] = 1;
  192.                         gTable.myTable[x - 1][y + 1] = 1;
  193.                         gTable.myTable[x][y + 2] = 1;
  194.                         x -= 1;
  195.                         return true;
  196.                     }
  197.                     else {
  198.                         return false;
  199.                     }
  200.                 }
  201.                 else {
  202.                     return false;
  203.                 }
  204.             default:
  205.                 return false;
  206.         }
  207.     }
  209.     public boolean right() {
  210.         switch (direct) {
  211.             case 1:
  212.                 if (x <= gTable.x - 4) {
  213.                     store[0] = gTable.myTable[x + 2][y];
  214.                     store[1] = gTable.myTable[x + 3][y + 1];
  215.                     if (isGo(2)) {
  216.                         gTable.myTable[x + 1][y] = 0;
  217.                         gTable.myTable[x][y + 1] = 0;
  218.                         gTable.myTable[x + 2][y] = 1;
  219.                         gTable.myTable[x + 3][y + 1] = 1;
  220.                         x += 1;
  221.                         return true;
  222.                     }
  223.                     else {
  224.                         return false;
  225.                     }
  226.                 }
  227.                 else {
  228.                     return false;
  229.                 }
  230.             case 2:
  231.                 if (x <= gTable.x - 3) {
  232.                     store[0] = gTable.myTable[x + 1][y];
  233.                     store[1] = gTable.myTable[x + 2][y + 1];
  234.                     store[2] = gTable.myTable[x + 1][y + 2];
  235.                     if (isGo(3)) {
  236.                         gTable.myTable[x][y] = 0;
  237.                         gTable.myTable[x][y + 1] = 0;
  238.                         gTable.myTable[x][y + 2] = 0;
  239.                         gTable.myTable[x + 1][y] = 1;
  240.                         gTable.myTable[x + 2][y + 1] = 1;
  241.                         gTable.myTable[x + 1][y + 2] = 1;
  242.                         x += 1;
  243.                         return true;
  244.                     }
  245.                     else {
  246.                         return false;
  247.                     }
  248.                 }
  249.                 else {
  250.                     return false;
  251.                 }
  252.             case 3:
  253.                 if (x <= gTable.x - 4) {
  254.                     store[0] = gTable.myTable[x + 3][y];
  255.                     store[1] = gTable.myTable[x + 2][y + 1];
  256.                     if (isGo(2)) {
  257.                         gTable.myTable[x][y] = 0;
  258.                         gTable.myTable[x + 1][y + 1] = 0;
  259.                         gTable.myTable[x + 3][y] = 1;
  260.                         gTable.myTable[x + 2][y + 1] = 1;
  261.                         x += 1;
  262.                         return true;
  263.                     }
  264.                     else {
  265.                         return false;
  266.                     }
  267.                 }
  268.                 else {
  269.                     return false;
  270.                 }
  271.             case 4:
  272.                 if (x <= gTable.x - 3) {
  273.                     store[0] = gTable.myTable[x + 2][y];
  274.                     store[1] = gTable.myTable[x + 2][y + 1];
  275.                     store[2] = gTable.myTable[x + 2][y + 2];
  276.                     if (isGo(3)) {
  277.                         gTable.myTable[x][y + 1] = 0;
  278.                         gTable.myTable[x + 1][y] = 0;
  279.                         gTable.myTable[x + 1][y + 2] = 0;
  280.                         gTable.myTable[x + 2][y] = 1;
  281.                         gTable.myTable[x + 2][y + 1] = 1;
  282.                         gTable.myTable[x + 2][y + 2] = 1;
  283.                         x += 1;
  284.                         return true;
  285.                     }
  286.                     else {
  287.                         return false;
  288.                     }
  289.                 }
  290.                 else {
  291.                     return false;
  292.                 }
  293.             default:
  294.                 return false;
  295.         }
  296.     }
  298.     public boolean change() {
  299.         switch (direct) {
  300.             case 1:
  301.                 if (true) {
  302.                     store[0] = gTable.myTable[x][y];
  303.                     store[1] = gTable.myTable[x][y - 1];
  304.                     store[2] = gTable.myTable[x + 1][y - 1];
  305.                     if (isGo(3)) {
  306.                         gTable.myTable[x + 1][y + 1] = 0;
  307.                         gTable.myTable[x + 2][y + 1] = 0;
  308.                         gTable.myTable[x][y] = 1;
  309.                         gTable.myTable[x][y - 1] = 1;
  310.                         y -= 1;
  311.                         direct = 2;
  312.                         return true;
  313.                     }
  314.                     else {
  315.                         return false;
  316.                     }
  317.                 }
  318.                 else {
  319.                     return false;
  320.                 }
  321.             case 2:
  322.                 if (x <= gTable.x - 3) {
  323.                     store[0] = gTable.myTable[x + 1][y];
  324.                     store[1] = gTable.myTable[x + 2][y];
  325.                     store[2] = gTable.myTable[x + 2][y + 1];
  326.                     store[3] = gTable.myTable[x + 1][y + 2];
  327.                     if (isGo(4)) {
  328.                         gTable.myTable[x][y] = 0;
  329.                         gTable.myTable[x][y + 2] = 0;
  330.                         gTable.myTable[x + 2][y + 1] = 1;
  331.                         gTable.myTable[x + 1][y + 2] = 1;
  332.                         y += 1;
  333.                         direct = 3;
  334.                         return true;
  335.                     }
  336.                     else {
  337.                         return false;
  338.                     }
  339.                 }
  340.                 else {
  341.                     return false;
  342.                 }
  343.             case 3:
  344.                 if (true) {
  345.                     store[0] = gTable.myTable[x][y - 1];
  346.                     store[1] = gTable.myTable[x + 1][y - 1];
  347.                     store[2] = gTable.myTable[x + 2][y - 1];
  348.                     store[3] = gTable.myTable[x + 2][y + 1];
  349.                     if (isGo(4)) {
  350.                         gTable.myTable[x][y] = 0;
  351.                         gTable.myTable[x + 1][y + 1] = 0;
  352.                         gTable.myTable[x + 2][y - 1] = 1;
  353.                         gTable.myTable[x + 2][y + 1] = 1;
  354.                         x += 1;
  355.                         y -= 1;
  356.                         direct = 4;
  357.                         return true;
  358.                     }
  359.                     else {
  360.                         return false;
  361.                     }
  362.                 }
  363.                 else {
  364.                     return false;
  365.                 }
  366.             case 4:
  367.                 if (x <= gTable.x - 3) {
  368.                     store[0] = gTable.myTable[x + 2][y];
  369.                     store[1] = gTable.myTable[x + 2][y + 1];
  370.                     store[2] = gTable.myTable[x + 2][y + 2];
  371.                     store[3] = gTable.myTable[x][y + 2];
  372.                     if (isGo(4)) {
  373.                         gTable.myTable[x + 1][y] = 0;
  374.                         gTable.myTable[x][y + 1] = 0;
  375.                         gTable.myTable[x][y + 2] = 1;
  376.                         gTable.myTable[x + 2][y + 2] = 1;
  377.                         y += 1;
  378.                         direct = 1;
  379.                         return true;
  380.                     }
  381.                     else {
  382.                         return false;
  383.                     }
  384.                 }
  385.                 else {
  386.                     return false;
  387.                 }
  388.             default:
  389.                 return false;
  390.         }
  391.     }
  393.     public void downTo() {
  394.         boolean canDown = true;
  395.         while (canDown) {
  396.             canDown = down();
  397.         }
  398.     }
  400.     public boolean isGo(int n) {
  401.         for (int i = 0; i <= (n - 1); i++) {
  402.             if (store[i] != 0)
  403.                 return false;
  404.         }
  405.         return true;
  406.     }
  408.     public static void main(String args[]) {
  409.         new Seven();
  410.     }
  411. }