J2SE饿罗斯方块

最新推荐文章于 2023-04-23 11:39:35 发布
最新推荐文章于 2023-04-23 11:39:35 发布
阅读量2.4k 收藏
点赞数
分类专栏： 酷爱Java 文章标签： j2se byte random timer null class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baillluu/article/details/6751918
版权
 

/***这是我自已无聊时做的，看到别人有发，我也发出来看一下，呵呵，不过，我是搞web开发，做的不怎么好，颜色这块没搞好，方块变换也做的不怎么好，数学没学好，模块有点乱***/
/**有木有顶贴的啊！**/

 


import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Random;
import javax.swing.JButton;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.IOException;
import javax.swing.JFrame;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
public class Main extends JFrame {
 public Main(String str) throws IOException {
  EffectParts parts=new EffectParts();
  add(parts);
  setSize(400,480);
  setTitle(str);
  setVisible(true);
  setResizable(false);//是否可以调整大小；
  setLocationRelativeTo(null);//窗口显示的位置；
  //添加一个事件，退出程序事件；
  addWindowListener(new WindowAdapter() {
   @Override
   public void windowClosing(WindowEvent arg0) {
    System.exit(0);
   }
  });
 }

 public static void main(String[] args)throws IOException {
  Main main= new Main("俄罗斯方块1.0   bean number one game");
 }
}


class EffectParts extends JPanel implements KeyListener, MouseListener {
 FileOutputStream file;
 FileInputStream fileinput;
 int speedstrat = 1000;
 JButton start = new JButton("开始");
 JButton exit = new JButton("退出");
 JButton suspend = new JButton("暂停");
 JButton save = new JButton("存储游戏");
 JButton entry = new JButton("载入戏");
 private int speed = 1;
 boolean boo = false;
 private int score = 0;
 Random ran = new Random();
 SuperAdapter adapter = new SuperAdapter();
 DiamondTable diamond;
 Act[] act = new Act[4];
 Act[] actTwo = new Act[4];
 int[][] vesselState;
 Timer timer;
 TimerListener list = null;
 String url = "gamesave.txt";
 boolean fileboolean = true;
 boolean b = false;

 // 构造方法
 public EffectParts() {
  
  list = new TimerListener();
  add(suspend);
  add(entry);
  add(save, -1);
  exit.addMouseListener(adapter.getMouseClose());
  start.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent arg0) {
    getMouseStart();
    requestFocus(true);
   }
  });
  suspend.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent arg0) {

    Suspend();
    requestFocus(true);
   }

  });
  save.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent arg0) {
    try {
     Save();
    } catch (IOException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
   }
  });
  entry.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent arg0) {
    try {
     entry();
    } catch (IOException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
   }
  });
  setVisible(true);
  setLayout(new FlowLayout(FlowLayout.RIGHT));
  add(start);
  add(exit);

  // 实例化方块；
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  // 增加键盘监听器;
  this.addKeyListener(this);
  this.addMouseListener(this);
  vesselState = new int[10][20];
  for (int i = 0; i < vesselState.length; i++) {
   for (int k = 0; k < vesselState[i].length; k++) {
    vesselState[i][k] = 0;
   }
  }
 }

 // 重写方法，作用：在面版上绘画
 @Override
 protected void paintComponent(Graphics arg0) {
  super.paintComponent(arg0);
  arg0.drawString("分数: " + this.score, 270, 60);
  arg0.drawLine(260, 63, 380, 63);
  arg0.drawString("速度: " + this.speed, 270, 95);
  arg0.drawLine(260, 98, 380, 98);
  arg0.drawString("下一个方块", 270, 135);
  arg0.drawRect(8, 35, 201, 401);
  arg0.drawString("俄罗斯方块1.1", 260, 370);
  arg0.drawString("作者:Game石头", 260, 390);
  // 生成方块体
  if (boo) {
   for (int i = 0; i < 4; i++) {
    int key = ran.nextInt(4);
    // 这里用一个SWITCH来生成不同的四个颜色;
    switch (key) {
    case 0:
     arg0.setColor(Color.BLUE);
     break;
    case 1:
     arg0.setColor(Color.BLACK);
     break;
    case 2:
     arg0.setColor(Color.GRAY);
     break;
    case 3:
     arg0.setColor(Color.PINK);
     break;

    default:
     break;
    }
    arg0.fillRect(9 + act[i].getX() * 20, 36 + act[i].getY() * 20,
      20, 20);
   }
   // 这里将以出现的方块记录在一个二维数组内；
   for (int i = 0; i < vesselState.length; i++) {
    for (int k = 0; k < vesselState[i].length; k++) {
     if (vesselState[i][k] == 1) {
      arg0.fillRect(9 + i * 20, 36 + k * 20, 20, 20);
     }
    }
   }
   // 这里显示下一个方块体;
   for (int i = 0; i < 4; i++) {
    arg0.fillRect(200 + actTwo[i].getX() * 20,
      160 + actTwo[i].getY() * 20, 20, 20);
   }
  }
 }
 // 这个方法用于载入游戏；
 void entry() throws IOException {
  File fi=new File(url);
  if(!fi.isFile())
  {
   this.requestFocus(true);
   return;
  }
  fileinput = new FileInputStream(url);
  byte[] b = new byte[20];
  byte[] bx=new byte[4];
  byte[] by=new byte[4];
  fileinput.read(bx, 0, bx.length);
  fileinput.read(by, 0, by.length);
  for(int i=0;i<this.act.length;i++)
  {
   act[i].setY(by[i]);
   act[i].setX(bx[i]);
  }
  
  for (int i = 0; i < vesselState.length; i++) {
   try {
    fileinput.read(b, 0, b.length);
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   for(int g=0;g<b.length;g++)
   {
    vesselState[i][g]=b[g];
   }
  }
  try {
   fileinput.close();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  this.boo=true;
  nextDiamond();
  this.requestFocus(true);
  repaint();

 }

 // 这个方法用来存储游戏；
 void Save() throws IOException {
  File f=new File(url);
  
  if (!this.boo) {
   this.requestFocus(true);
   return;
  }
  if(f.isFile())
  {
   f.delete();
  }
  this.Suspend();
  file = new FileOutputStream(url, fileboolean);
  byte[] b;
  byte[] b1=new byte[4];
  byte[] b2=new byte[4];
  for(int i=0;i<this.act.length;i++)
  {
   b1[i]=(byte)act[i].getX();
   b2[i]=(byte)act[i].getY();
  }
  try {
   file.write(b1);
   file.write(b2);
  } catch (IOException e1) {
   // TODO Auto-generated catch block
   e1.printStackTrace();
  }
  
  for (int i = 0; i < this.vesselState.length; i++) {
   b = new byte[20];
   for (int k = 9; k < this.vesselState[i].length; k++) {
    b[k] = (byte) vesselState[i][k];
   }
   try {
    file.write(b);
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  try {
   file.close();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  requestFocus(true);

 }

 // 这里是一个暂停方法
 void Suspend() {
  if (this.boo) {
   if (this.timer != null) {
    if (this.timer.isRunning()) {
     this.timer.stop();
    }
   }
   this.boo = false;
   this.suspend.setText("继续");
  } else {
   if (this.timer != null) {
    this.timer.start();
   }
   this.boo = true;
   this.suspend.setText("暂停");
  }
  this.requestFocus(true);
 }

 // 游戏开始调用这个方法；
 public boolean newAct() {
  if (this.boo) {

   // 随机取方块体样式
   int key = ran.nextInt(7) + 1;
   // 完成方块生成的数据;
   if (actTwo[0] == null) {
    diamond = new DiamondTable();
    act = diamond.getDiamond(key);
   } else {
    act = actTwo;
   }
   this.nextDiamond();
   if (!MinMaxShift(0, 1)) {
    return false;
   }
   b = true;
   return true;
  } else {
   return false;
  }
 }

 // 点击开始时事件触发的方法
 public void getMouseStart() {
  // 清空存储变量的值;
  for (int i = 0; i < vesselState.length; i++) {
   for (int k = 0; k < vesselState[i].length; k++) {
    vesselState[i][k] = 0;
   }
  }
  this.boo = true;
  this.score = 0;
  this.speed = 1;
  this.speedstrat = 1000;
  if (timer != null) {
   timer.stop();
  }
  timer = new Timer(speedstrat, list);
  // 清空存储方块体样式变量的值;
  for (int i = 0; i < 4; i++) {
   actTwo[i] = null;
  }
  if (timer.isRepeats()) {
   timer.stop();
  }
  this.suspend.setText("暂停");
  if (start.getText() == "开始") {
   start.setText("重置");
  }
  if (newAct()) {
   repaint();

  } else {
   return;
  }
  if (boo) {
   timer.start();
  }
 }

 // 控制方块不出容量；
 private boolean MinMaxShift(int x, int y) {
  for (int i = 0; i < 4; i++) {
   if ((act[i].getX() + x) < 0 || (act[i].getX() + x) >= 10
     || act[i].getY() + y < 0 || act[i].getY() + y > 19) {
    return false;
   }
   if (vesselState[act[i].getX() + x][act[i].getY() + y] == 1) {
    return false;
   }
  }

  return true;
 }

 // 改变方块的摆放方向
 // 改变方块摆放方向
 private void changeType() {
  Act[] actsan = new Act[4];
  for (int i = 0; i < actsan.length; i++) {
   actsan[i] = new Act();
   actsan[i].setX(act[i].getX());
   actsan[i].setY(act[i].getY());
  }
  for (int i = 0; i < actsan.length; i++) {
   if (actsan[i].getX() < 0 || actsan[i].getX() > 9
     || actsan[i].getY() < 0 || actsan[i].getY() > 19) {
    if (vesselState[act[i].getX() + 1][act[i].getY()] == 1
      || vesselState[act[i].getX() - 1][act[i].getY()] == 1) {
     return;
    }
   }
  }
  if ((actsan[2].getX() - actsan[0].getX()) == 1
    && (actsan[3].getX() - actsan[1].getX()) == 1
    && actsan[2].getY() - actsan[0].getY() == 0
    && (actsan[3].getY() - actsan[2].getY() == 1)
    && (actsan[3].getY() - actsan[0].getY() == 1)) {
   return;
  }
  int xx = (actsan[0].getX() + actsan[1].getX() + actsan[2].getX() + actsan[3]
    .getX()) / 4;
  int yy = (actsan[0].getY() + actsan[1].getY() + actsan[2].getY() + actsan[3]
    .getY()) / 4;
  for (int i = 0; i < actsan.length; i++) {
   actsan[i].setX(xx + yy - act[i].getY());
   actsan[i].setY(yy - xx + act[i].getX());
  }
  for (int i = 0; i < actsan.length; i++) {
   if (actsan[i].getX() < 0 || actsan[i].getX() > 9
     || actsan[i].getY() <= 0 || actsan[i].getY() > 19)
    return;
   else if (vesselState[actsan[i].getX()][actsan[i].getY()] == 1) {
    return;
   }
  }
  for (int i = 0; i < actsan.length; i++) {
   act[i].setX(actsan[i].getX());
   act[i].setY(actsan[i].getY());
  }
  repaint(9, 36, 201, 401);
 }

 // 方块移动方法实现；
 // 让方块体向左向右方法;
 private void Shift(int x, int y) {

  if (MinMaxShift(x, y) == false) {
   return;
  }
  if (boo) {
   for (int i = 0; i < 4; i++) {
    act[i].setX(act[i].getX() + x);
    act[i].setY(act[i].getY() + y);
    this.repaint(9, 36, 240, 400);
   }
  }
 }

 // 向下移动的方法；
 // 生成下一个方块体;
 private void nextDiamond() {
  int key = ran.nextInt(7) + 1;
  diamond = new DiamondTable();
  actTwo = diamond.getDiamond(key);
 }

 // 让方块体向下落的方法;
 private void down() {
  if (!boo) {
   return;
  }
  if (MinMaxShift(0, 1)) {
   for (int i = 0; i < 4; i++) {
    act[i].setY(act[i].getY() + 1);
   }
   repaint(9, 36, 240, 400);
  } else {
   for (int i = 0; i < 4; i++) {
    vesselState[act[i].getX()][act[i].getY()] = 1;
   }
   boolean lean = newAct();
   // 这里如果反回的是true；就查看容器中有没有增实，如果有，让他消失；
   // 同时让上面的方块落下来；并且加上分;
   if (lean) {
    boolean iftrue = false;
    int index = 19;
    int[] count = new int[20];
    int value = 0;
    for (int i = vesselState[0].length - 1; i >= 0; i--) {

     for (int k = vesselState.length - 1; k >= 0; k--) {
      value += vesselState[k][i];
      if (value == 10) {
       count[index] = i;
       index--;
      }
     }
     if (value == 0) {
      break;
     }
     value = 0;

    }
    int val = 0;
    // 这个盾环让完整的一行消掉;
    for (int i = vesselState[0].length - 1; i >= 0; i--) {
     for (int k = vesselState.length - 1; k >= 0; k--) {
      if (count[i] > 0) {
       vesselState[k][count[i]] = 0;
       val += 1;
      }
     }

    }
    // 加分方法
    if (val != 0) {
     if (val / 10 == 1)
      this.score += (val);
     else if (val / 10 == 2) {
      this.score += (val + 10);
     } else if (val / 10 == 3) {
      this.score += (val + 20);
     } else if (val / 10 == 4) {
      this.score += (val * 2);
     }
     val = 0;
    }
    // 加速度的给显示判断
    if (this.score > 2000) {

     if (this.score / 2000 <= 9
       && (this.score / 2000) != this.speed) {
      this.speed = this.score / 2000;
      this.speedstrat = (1000 - this.speed * 100);
      if (boo) {
       this.timer.stop();
       timer = new Timer(speedstrat, list);
       timer.start();
      }
     }
    }

    // 让整个面容器中的方块体随消失的方块体往下充实；
    for (int g = 0; g < 20; g++) {
     for (int i = vesselState[0].length - 1; i > 0; i--) {

      for (int k = vesselState.length - 1; k >= 0; k--) {
       value += vesselState[k][i];

      }
      for (int k = vesselState.length - 1; k >= 0; k--) {
       if (value == 0) {
        iftrue = true;
       }
       if (iftrue) {
        vesselState[k][i] = vesselState[k][i - 1];
       }
      }
      value = 0;
     }
     iftrue = false;
    }
   }

   repaint();
   // 这里如果反回来的是false,就让时间监听器停止，游戏也停止;
   if (!lean) {

    JOptionPane.showMessageDialog(null, "游戏结束！\n game over!", "提示",
      1);
    boo = false;
    timer.stop();
   }
  }
 }

 // 键盘事件
 @Override
 public void keyPressed(KeyEvent arg0) {
  if (boo) {
   switch (arg0.getKeyCode()) {
   case 65:
    this.Shift(-1, 0);
    break;
   case 37:
    this.Shift(-1, 0);
    break;
   case 38:
    this.changeType();
    break;
   case 87:
    this.Shift(0, -1);
    break;
   case 39:
    this.Shift(1, 0);
    break;
   case 68:
    this.Shift(1, 0);
    break;
   case 40:
    this.down();
    break;
   case 83:
    this.down();
    break;
   default:
    break;
   }
  }
  // 按下空格键，将调用暂停的方法
  if (32 == arg0.getKeyCode()) {
   this.Suspend();
  }
 }

 @Override
 public void keyReleased(KeyEvent arg0) {
 }

 @Override
 public void keyTyped(KeyEvent arg0) {
 }

 @Override
 public void mouseClicked(MouseEvent arg0) {
  // TODO Auto-generated method stub

 }

 @Override
 public void mouseEntered(MouseEvent arg0) {
  // TODO Auto-generated method stub

 }

 @Override
 public void mouseExited(MouseEvent arg0) {
  // TODO Auto-generated method stub

 }

 // 点击面版得到焦点；
 @Override
 public void mousePressed(MouseEvent arg0) {
  int x = arg0.getX();
  int y = arg0.getY();
  if (x >= 9 && x <= 209 && y >= 10 && y <= 410) {
   this.requestFocus();
  }
 }

 @Override
 public void mouseReleased(MouseEvent arg0) {
  // TODO Auto-generated method stub

 }

 public class TimerListener implements ActionListener {

  @Override
  public void actionPerformed(ActionEvent arg0) {
   down();

  }

 }
}

/**
 *
 * @author Administrator 一个超级适配器事件处理；
 */
class SuperAdapter {

 // 鼠标点击退出或开始事件
 public MouseListener getMouseClose() {
  return new MouseAdapter() {

   @Override
   public void mousePressed(MouseEvent arg0) {
    int values = JOptionPane.showConfirmDialog(null, "确定退出序程？",
      "提示", 2);

    if (0 == values) {
     System.exit(0);
    } else {
     return;
    }
   }
  };
 }

}
class DiamondTable {
 // 这个集合用于存放各中方块模具；
 private Map<Integer, Act[]> diamondVessel = null;
 private Map<Integer, Map<Integer, Act[]>> diamondMin = new HashMap<Integer, Map<Integer, Act[]>>();
 private Act[] act = new Act[4];

 // 构造一共19个方块体的样式;
 public DiamondTable() {
  diamondVessel = new HashMap<Integer, Act[]>();
  Act[] act = new Act[4];
  // 从这里开始生一种方块样式
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  // 第一种方块的第一个样式；这是个正方体只有一个样式;
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(4);
  act[1].setY(1);
  act[2].setX(5);
  act[2].setY(0);
  act[3].setX(5);
  act[3].setY(1);
  // 这里存进集合中
  diamondVessel.put(1, act);
  diamondMin.put(1, diamondVessel);

  // //
  // 第二种方块的各种样式
  diamondVessel = new HashMap<Integer, Act[]>();
  // （1）
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(3);
  act[0].setY(0);
  act[1].setX(4);
  act[1].setY(0);
  act[2].setX(5);
  act[2].setY(0);
  act[3].setX(6);
  act[3].setY(0);
  diamondVessel.put(1, act);
  // （2）
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(4);
  act[1].setY(1);
  act[2].setX(4);
  act[2].setY(2);
  act[3].setX(4);
  act[3].setY(3);
  diamondVessel.put(2, act);

  diamondMin.put(2, diamondVessel);

  // //
  // 第三种方块的各种样式
  diamondVessel = new HashMap<Integer, Act[]>();
  // (1)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(4);
  act[1].setY(1);
  act[2].setX(4);
  act[2].setY(2);
  act[3].setX(5);
  act[3].setY(2);
  diamondVessel.put(1, act);
  // (2)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(4);
  act[1].setY(1);
  act[2].setX(5);
  act[2].setY(0);
  act[3].setX(6);
  act[3].setY(0);
  diamondVessel.put(2, act);
  // (3)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(5);
  act[1].setY(0);
  act[2].setX(5);
  act[2].setY(1);
  act[3].setX(5);
  act[3].setY(2);
  diamondVessel.put(3, act);
  // (4)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(1);
  act[1].setX(5);
  act[1].setY(1);
  act[2].setX(6);
  act[2].setY(0);
  act[3].setX(6);
  act[3].setY(1);
  diamondVessel.put(4, act);
  diamondMin.put(3, diamondVessel);

  // //
  // 第四种方块的各种样式
  diamondVessel = new HashMap<Integer, Act[]>();
  // //
  // (1)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(5);
  act[0].setY(0);
  act[1].setX(5);
  act[1].setY(1);
  act[2].setX(5);
  act[2].setY(2);
  act[3].setX(4);
  act[3].setY(2);
  diamondVessel.put(1, act);
  // (2)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(4);
  act[1].setY(1);
  act[2].setX(5);
  act[2].setY(1);
  act[3].setX(6);
  act[3].setY(1);
  diamondVessel.put(2, act);
  // (3)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(4);
  act[1].setY(1);
  act[2].setX(4);
  act[2].setY(2);
  act[3].setX(5);
  act[3].setY(0);
  diamondVessel.put(3, act);
  // (4)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(5);
  act[1].setY(0);
  act[2].setX(6);
  act[2].setY(0);
  act[3].setX(6);
  act[3].setY(1);
  diamondVessel.put(4, act);
  diamondMin.put(4, diamondVessel);

  // //
  // 第五种方块的各种样式
  diamondVessel = new HashMap<Integer, Act[]>();
  // //
  // (1)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(4);
  act[1].setY(1);
  act[2].setX(5);
  act[2].setY(1);
  act[3].setX(5);
  act[3].setY(2);
  diamondVessel.put(1, act);
  // (2)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(1);
  act[1].setX(5);
  act[1].setY(0);
  act[2].setX(5);
  act[2].setY(1);
  act[3].setX(6);
  act[3].setY(0);
  diamondVessel.put(2, act);
  diamondMin.put(5, diamondVessel);

  // //
  // 第六种方块的各种样式
  diamondVessel = new HashMap<Integer, Act[]>();
  // //
  // (1)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(5);
  act[0].setY(0);
  act[1].setX(5);
  act[1].setY(1);
  act[2].setX(4);
  act[2].setY(1);
  act[3].setX(4);
  act[3].setY(2);
  diamondVessel.put(1, act);
  // (2)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(5);
  act[1].setY(0);
  act[2].setX(5);
  act[2].setY(1);
  act[3].setX(6);
  act[3].setY(1);
  diamondVessel.put(2, act);
  diamondMin.put(6, diamondVessel);

  // //
  // 第七种方块的各种样式
  diamondVessel = new HashMap<Integer, Act[]>();
  // //
  // (1)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(4);
  act[1].setY(1);
  act[2].setX(4);
  act[2].setY(2);
  act[3].setX(5);
  act[3].setY(1);
  diamondVessel.put(1, act);
  // (2)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(0);
  act[1].setX(5);
  act[1].setY(0);
  act[2].setX(6);
  act[2].setY(0);
  act[3].setX(5);
  act[3].setY(1);
  diamondVessel.put(2, act);
  // (3)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(5);
  act[0].setY(0);
  act[1].setX(5);
  act[1].setY(1);
  act[2].setX(5);
  act[2].setY(2);
  act[3].setX(4);
  act[3].setY(1);
  diamondVessel.put(3, act);
  // (4)
  act = new Act[4];
  for (int i = 0; i < act.length; i++) {
   act[i] = new Act();
  }
  act[0].setX(4);
  act[0].setY(1);
  act[1].setX(5);
  act[1].setY(0);
  act[2].setX(5);
  act[2].setY(1);
  act[3].setX(6);
  act[3].setY(1);
  diamondVessel.put(4, act);
  diamondMin.put(7, diamondVessel);
 }

 int b = 0;
 private Random ran = new Random();

 // 得到一个方块体样式
 public Act[] getDiamond(int i) {
  diamondVessel = diamondMin.get(i);
  b = diamondVessel.size();
  b = ran.nextInt(b) + 1;
  act = diamondVessel.get(b);
  return act;

 }

}
class Act {
 int x;
 int y;
 public int getX() {
  return x;
 }
 public void setX(int x) {
  this.x = x;
 }
 public int getY() {
  return y;
 }
 public void setY(int y) {
  this.y = y;
 }
}

baillluu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
xxx.rar_comxxx_xxx网_俄罗斯 XXX_俄罗斯XXX视频_俄罗斯免费xxx
09-23
使用vs2008编写的俄罗斯方块，每一步头文件跟关键函数的添加都有详细描写
Javascript
qq_43910862的博客
07-17 1556
javascript概述，基本语法，常用函数，正则表达式，以及用js写的一个俄罗斯方块案例...
XXX.rar_39xxx俄罗斯_JAVA俄罗斯方块_XXX俄罗斯_俄罗斯xxx_俄罗斯xxx动漫
09-24
俄罗斯方块游戏，用Java编，可在ECLIPSE环境下运行
java Adapter模式
热门推荐
a1192529545的专栏
06-01 14万+
通常，客户类（clients of class）通过类的接口访问它提供的服务。有时，现有的类（existing class）可以提供客户类的功能需要，但是它所提供的接口不一定是客户类所期望的。这是由于现有的接口太详细或者缺乏详细或接口的名称与客户类所查找的不同等诸多不同原因导致的。 　　在这种情况下，现有的接口需要转化（convert）为客户类期望的接口，这样保证了对现有类的重用。如果不
J2SE 俄罗斯方块
11-22
《J2SE 俄罗斯方块》是一款基于Java平台（J2SE）开发的经典游戏，它展示了Java编程在游戏开发中的应用。J2SE，全称为Java 2 Platform, Standard Edition，是Java技术的核心部分，提供了编写桌面应用程序所需的所有...
j2SE俄罗斯方块源代码
01-08
《j2SE俄罗斯方块源代码解析》 在IT领域，源代码是程序的灵魂，它揭示了软件运行的内在逻辑。本篇文章将深入探讨“j2SE俄罗斯方块源代码”，这是一个经典的游戏项目，利用Java的j2SE（Java 2 Platform, Standard ...
基于j2se的俄罗斯方块
03-01
《基于J2SE的俄罗斯方块游戏开发详解》 在编程世界中，经典的游戏总是能够吸引程序员的兴趣，其中，俄罗斯方块无疑是极具挑战性的项目之一。本教程将深入讲解如何利用Java的J2SE（Java Standard Edition）平台，...
j2se_俄罗斯方块源代码
12-04
《J2SE版俄罗斯方块源代码解析》 在编程世界中，俄罗斯方块是一款经典的休闲游戏，它的简单规则和无限挑战性使其成为初学者学习游戏编程的理想选择。本篇将详细解读基于J2SE（Java 2 Standard Edition）编写的...
j2se的简易版俄罗斯方块
12-13
【标题】"j2se的简易版俄罗斯方块"是一个基于Java 2 Standard Edition (J2SE) 平台开发的简单游戏项目。这个程序旨在实现经典的俄罗斯方块游戏，尽管其图形用户界面可能并不美观，但核心的游戏逻辑和基本功能得以...
微服务gateway 获取共享session
04-23 1827
之前搞这个会话共享花了也有5-6个小时，因为gateway根本不能使用EnableRedisHttpSession，spring cloud gateway是基于webflux，是非阻塞的，zuul和我们的web服务都是基于servlet的，gateway中需要将EnableRedisHttpSession注解换成EnableRedisWebSession，我替换了好像也没什么用，但是我也没管它，网上有些还说如果用gateway网关是没办法用spring session，都建议用Tokens。
Apache JK集群环境session丢失问题
07-02 1705
这两天在搞集群，遇到一个写问题 项目描述：公司现有一个系统，页面的数据的布局都是ajax请求后台，得到html标签加载的，系统有权限控制，也就是session中会存放当前用户是否登录。通过以个过滤器进行监听，如果用户在请求后台数据时，发现session中没有当前用户的登录数据，就重定向到登录的页面，所以这里session中的数据一定要复制共享，否则用户登录信息会丢失。 问题描述：通过网上以些例
下面是我自已的思路做的一个计算器，有点复杂!
09-06 645
import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import java.awt.event.WindowEvent; import java.awt.event.WindowLis
读取excel表(限于至2003版，包含2003版)
10-27 454
package com; import java.io.FileInputStream; import java.io.InputStream; /**  * 注意:使用前请导入相关的jar包("poi-3.7-20101029.jar");  * ISNULL带表当前的单元格是空的  */ import org.apache.poi.hssf.usermodel.HSSFCell;
JAVA读取xml文件(DOM)
11-30 430
package ext.elead.peixun.reader; import java.io.File; import java.io.IOException; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parse
eclipse本地的jar包配置Junit环境
最新发布
07-23
用于在eclipse中导入本地的jar包配置Junit环境，版本应该是JUnit4， 配置详情可参照我的博文：http://t.csdnimg.cn/GaqTZ
龙飞嵌入式POS餐饮应用方案介绍.doc
07-23
嵌入式
Struts 2.0 Java归档库文件包
07-23
Struts2.0是Java Web开发中非常重要的一个框架，它是Apache软件基金会的Jakarta项目下的一个产品。这个框架主要用于构建MVC（Model-View-Controller）架构的应用程序，为开发者提供了一种组织应用程序结构、处理HTTP请求以及展示数据的方式。在本压缩包中，包含的是一些Struts2.0的核心jar包、源代码和实例，这些内容对于学习和理解Struts2.0的工作原理和实际应用是非常有帮助的。 我们来详细解析一下Struts2.0的关键知识点： 1. **MVC模式**：Struts2.0基于MVC设计模式，它将应用程序的逻辑分为三个部分——模型（Model）、视图（View）和控制器（Controller）。模型负责业务逻辑，视图负责数据显示，控制器负责接收用户请求并调用相应的模型方法，更新视图。 2. **Action类**：在Struts2中，Action类是处理业务逻辑的核心组件。开发者需要创建Action类，并实现execute()方法，该方法会响应用户的请求，执行相应的业务操作。 3. **配置文件**：Struts2使用XML配
分拣设备_包括零件图_机械3D图可修改打包下载.zip
07-23
分拣设备_包括零件图_机械3D图可修改打包下载.zip
JavaGui开发俄罗斯方块游戏的毕业论文
通过以俄罗斯方块游戏为例，详细描述了借助J2SE的类库开发电脑小游戏的步骤。 论文首先介绍了J2SE及其体系结构，为读者提供了对Java开发环境的基本了解。然后，通过在J2SE平台上开发俄罗斯方块游戏的实例，详细阐述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值