java j'ai essayé de casser un simple bloc

introduction

Je posterai sur Qiita pour la première fois aujourd'hui. Pour être honnête, je suis confus car je ne sais pas quoi faire ci-dessous, mais pour le moment, j'aimerais publier le plus possible chaque jour pour améliorer mes compétences en langage de programmation. Je vous remercie

Pourquoi avez-vous décidé de publier sur Qiita?

Pour être honnête, je veux l'ajouter comme un point attrayant dans la recherche d'emploi. Même si on me disait que je voulais être ingénieur sans pouvoir faire quoi que ce soit comme ça, je savais que ça tomberait, alors au moins je voulais le poster sur Qiita et révéler à quel point je suis capable. Désormais, je souhaite continuer à poster afin que des progrès ne puissent être réalisés que dans les domaines de mon intérêt.

Pourquoi avez-vous décidé de faire un disjoncteur de bloc

Je voulais publier ici les jeux que j'ai faits dans le passé parce que je voulais les faire librement comme une tâche scolaire. J'adore aussi le blocage des blocs, Tetris et Puyopuyo, alors je voulais faire un jeu rétro.

Bloquer les règles de rupture

Quiconque a fait une cassure de bloc le saura, mais il est nécessaire de concevoir une balle pour qu'elle ne retombe pas au bas de l'écran avec une raquette ou une barre. Lorsque vous frappez en arrière, vous frappez la balle contre le bloc et effacez tous les blocs, ou lorsque vous effacez le bloc, vous ajoutez des points. C'est un jeu très simple, mais très difficile à réaliser. breakout.png Comme le montre l'image, ceci est un exemple de rupture de bloc. J'ai changé la taille, la vitesse et le nombre de balles parce que c'est ennuyeux avec une seule. Cela s'écarte à ce stade, mais pour le moment, c'est comme ça. Le bloc est également fait disparaître du nombre de fois que la balle frappe. Si c'est comme indiqué sur l'image, le jaune sera 3 fois, le bleu 1 fois et le vert 2 fois. Le noir ne disparaîtra pas, quel que soit le nombre de coups. Cependant, en raison de la date limite de soumission des devoirs, j'aurais dû compter le nombre de blocs après la limite de temps pour le jeu, mais je n'ai pas pu arriver à temps et le résultat était à mi-chemin. Il était toujours affiché comme étant clair du jeu et la condition de défaillance ne pouvait pas être établie. Par conséquent, je le posterai plusieurs fois pour l'améliorer.

Site de référence

http://aidiary.hatenablog.com/entry/20040918/1251373370 Ce site a fait un disjoncteur de bloc. Veuillez vous référer ici pour l'algorithme de base. Certains sont à peu près les mêmes, mais très simples. Merci beaucoup.

environnement java

java version "12.0.1" 2019-04-16 Java(TM) SE Runtime Environment (build 12.0.1+12) Java HotSpot(TM) 64-Bit Server VM (build 12.0.1+12, mixed mode, sharing)

Code programme

Maintenant que nous avons près de 900 lignes, je voudrais expliquer les articles séparément. Je ne pense pas que je m'en lasserai ...


import javax.swing.Timer;
import java.awt.Color;
import javax.swing.*;
import java.awt.*;
import java.text.ParseException;


public class TimerTest1 extends JFrame {
 static int x=855;
static int y=800;
    private Timer timer;
    private int countdown_sec = 5;
    private CardLayout card = new CardLayout(0, 0);

    public static void main(String[] args) throws ParseException {
          TimerTest1 frame = new TimerTest1();
         
          frame.setSize(x,y);
          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          frame.getContentPane().setBackground(new Color(0, 0, 0));
          frame.setVisible(true);
  }
    TimerTest1() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("écran titre");
        setLayout(card);
        JPanel panel = new Draw();
        //JPanel labelPanel = new JPanel();
        //JLabel label = new JLabel();
        JPanel game_over = new breakout();
        game_over.setOpaque(false);
        add(panel,"Dessiner des personnages");
       // labelPanel.add(label);
       
      
        timer = new Timer(1000, (e) -> {
          
           
            if (countdown_sec ==0){
              add(game_over, "gameover_window");
                timer.stop();
              
                showPanel("gameover_window");
               
                return;
            }
            countdown_sec--;
        }); 
        timer.start();
    }
    
    public void showPanel(String name) {
        card.show(getContentPane(), name);
    }
    public static class Draw extends JPanel{
    public   void paintComponent(Graphics g){
draw(g);
    }
    public static  void draw(Graphics g){
      g.setFont(new Font("TimeRoman", Font.CENTER_BASELINE, 30));
      g.setColor(Color.red);
      g.drawString("Rupture de bloc",300 , 200);
      g.setColor(Color.red); 
      g.drawString("Il démarrera dans 5 secondes!", 250, 300); 
      g.drawString("Le délai est de 30 secondes", 250, 400); 
      g.setColor(Color.red);
      g.setColor(Color.red);
      g.drawString("Déplacez la souris sur le côté pour faire rebondir la balle", 125, 500);  
      g.setColor(Color.red);
      g.drawString("La pointe de la flèche ci-dessous correspond à la position initiale de la souris", 100, 600); 
      g.setColor(Color.red);
      g.drawString("↓",425 , 700);
    }
  }
  }

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.Timer;
import java.util.TimerTask;

   
   public class breakout extends JPanel implements MouseMotionListener{
       static int countball =15;
      
       
   Racket racket;
   Ball[] ball;
   Block[] block;
   Unbreakblock[] block1;
   Twobreakblock[] block2;
   Threebreakblock[] block3;

   double time;
   int remain=37;
   boolean gameover=false;
   static int x=855;
   static int y=800;
   static int size =15;
   static final int NUM_BLOCK_ROW = 4;
   //Nombre de colonnes dans le bloc
    static final int NUM_BLOCK_COL = 9;
   //Nombre de blocs
    static final int NUM_BLOCK = NUM_BLOCK_ROW * NUM_BLOCK_COL;
    static final int NUM_BLOCK_ROW1 = 8;

    static final int NUM_BLOCK_COL1 = 1;
    
    static final int NUM_BLOCK1 = NUM_BLOCK_ROW1 * NUM_BLOCK_COL1;
    static final int NUM_BLOCK_ROW2 = 8;

    static final int NUM_BLOCK_COL2 = 3;
    
    static final int NUM_BLOCK2 = NUM_BLOCK_ROW2 * NUM_BLOCK_COL2;
    static final int NUM_BLOCK_ROW3 = 8;

    static final int NUM_BLOCK_COL3 = 4;
    
    static final int NUM_BLOCK3 = NUM_BLOCK_ROW3 * NUM_BLOCK_COL3;
    static final int SumBlock=  NUM_BLOCK+NUM_BLOCK2+NUM_BLOCK3;
 
    //Créer une carte bidimensionnelle
      private char[][] map;
       private int MX = 20, MY = 18;
       private String[] map_str = {
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",
       "                   B",                        
                                 };
                                 
       public breakout(){
        time = System.currentTimeMillis() * 0.001 + remain; 
           addMouseMotionListener(this);
           racket =new Racket();
           ball =  new Ball[countball];
           Random rand = new Random();
           int n=countball;
            int num[] = new int [n];
      for(int i=0;i<n;i++){
            num[i]= 40+rand.nextInt(700);
           ball[0]=new Ball(num[0],250,5,-6,7);
           ball[1]=new Ball(num[1],260,-5,-3,10);
           ball[2]=new Ball(num[2],420,4,6,8);
           ball[3]=new Ball(num[3],480,-5,2,10);
           ball[4]=new Ball(num[4],590,5,-6,11);
           ball[5]=new Ball(num[5],550,-5,-3,12);
           ball[6]=new Ball(num[6],570,4,6,13);
           ball[7]=new Ball(num[7],480,-5,2,14);
           ball[8]=new Ball(num[8],490,5,-6,8);
           ball[9]=new Ball(num[9],400,-5,-3,8);
           ball[10]=new Ball(num[10], 350,4,6,9);
           ball[11]=new Ball(num[11],400,-5,2,10);
           ball[12]=new Ball(num[12],390,-5,-3,10);
           ball[13]=new Ball(num[13],500,4,6,10);
           ball[14]=new Ball(num[14],530,-5,2,7);
      }
           block = new Block[NUM_BLOCK];
           block1 = new Unbreakblock[NUM_BLOCK1];
          block2 = new Twobreakblock[NUM_BLOCK2];
           block3 =new Threebreakblock[NUM_BLOCK3];
          
           for (int i = 0; i < NUM_BLOCK_ROW; i++) {
               for (int j = 0; j < NUM_BLOCK_COL; j++) {
                   int x =2* j * Block.WIDTH + Block.WIDTH+50;
                   int y =2* i * Block.HEIGHT + Block.HEIGHT+600;
                   block[i * NUM_BLOCK_COL + j] = new Block(x, y);
               }
            }
           for ( int c = 0; c < NUM_BLOCK_ROW1; c++) {
               for (int d = 0; d < NUM_BLOCK_COL1; d++) {
                   int a = 2*c *  Unbreakblock.WIDTH1 +  Unbreakblock.WIDTH1+50;
                   int b = d *  Unbreakblock.HEIGHT1 +  Unbreakblock.HEIGHT1+450;
                   block1[d * NUM_BLOCK_COL1 + c] = new  Unbreakblock(a, b);
               }
            }
           for ( int c = 0; c < NUM_BLOCK_ROW2; c++) {
               for (int d = 0; d < NUM_BLOCK_COL2; d++) {
                   int a = 2*c *  Twobreakblock.WIDTH2 +  Twobreakblock.WIDTH2+50;
                   int b = 2*d *  Twobreakblock.HEIGHT2 +  Twobreakblock.HEIGHT2+300;
                   block2[c* NUM_BLOCK_COL2 + d] = new  Twobreakblock(a, b);
               }
           }
         for ( int c = 0; c < NUM_BLOCK_ROW3; c++) {
               for (int d = 0; d < NUM_BLOCK_COL3; d++) {
                   int a =2* c * Threebreakblock.WIDTH3 +  Threebreakblock.WIDTH3+50;
                   int b = 5*d * Threebreakblock.HEIGHT3 +  Threebreakblock.HEIGHT3+60;
                   block3[c * NUM_BLOCK_COL3 + d] = new  Threebreakblock(a, b);
               }
           } 
          TimeBomb timeBomb = new TimeBomb();
           Timer timer = new Timer();
           timer.schedule(timeBomb,  5000);
          
           map = new char[MY+2][MX+2];
           for (int x = 0; x <= MX+1; x++) {
             map[0][x] = 'B'; 
             map[MY+1][x] = 'B';
           }
           for (int y = 0; y <= MY+1; y++) {
             map[y][0] = 'B'; 
             map[y][MX+1] = 'B';
           }
           for (int y = 1; y <= MY; y++) {
               for (int x = 1; x <= MX; x++) {
                 map[y][x] = map_str[y-1].charAt(x-1);
               }
           }
        }
       public void displayTime(Graphics g) {
        if ( gameover ) {
       
          g.setFont(new Font("TimeRoman", Font.BOLD, 50));
          g.setColor(Color.YELLOW);
          g.drawString("GAME CLEAR", 250, 550); 
          for(int j=0;j<countball;j++){
            int ballsize =ball[j].Size();
          ball[j].Size();
                if(ballsize==0){
                return;
                }
          }
        } else {
         int dt = (int) (time - System.currentTimeMillis() * 0.001);
          g.setFont(new Font("TimeRoman", Font.BOLD, 50));
          g.setColor(Color.orange);
          g.drawString("Time: " + dt+"  ",300, 550);
                 if ( dt == 0 ) gameover = true;
        }
    }
  
      class TimeBomb extends TimerTask  {
       
       public void run(){
     
        while(true){
               for(int j=0;j<countball;j++){
               ball[j].move();
              
                  //Traitement des collisions entre la raquette et la balle
            int collidePos0 = racket.collideWith(ball[j]);
            
            //Si vous frappez la raquette
            if (collidePos0 != Racket.NO_COLLISION4) {
                //Changer la vitesse de la balle en fonction de la position où la balle frappe
                switch (collidePos0) {
                    case Racket.LEFT4:
                        //Je veux réfléchir vers la gauche quand il frappe le côté gauche de la raquette
                        //Si la balle se déplace vers la droite, retournez-la vers la gauche
                        //Si vous allez vers la gauche, laissez-le tel quel
                        if (ball[j].getVX() > 0) ball[j].boundX();
                        ball[j].boundY();
                        break;
                    case Racket.RIGHT4:
                        //Je veux réfléchir vers la droite quand il frappe le côté droit de la raquette
                        //Si la balle se déplace vers la gauche, retournez-la vers la droite
                        //Si vous allez vers la droite, laissez-le tel quel
                        if (ball[j].getVX() < 0) ball[j].boundX();
                        ball[j].boundY();
                        break;
                }
            }
               for (int i = 0; i < NUM_BLOCK; i++) {
                   //Ignorer les blocs qui ont déjà disparu
                   if (block[i].isDeleted())
                       continue;
                   //Calculez la position où le bloc a frappé
                   int collidePos = block[i].collideWith(ball[j]);
                   //Si vous touchez le bloc
                   if (collidePos != Block.NO_COLLISION) {
                       block[i].delete();
              
                       //Calculez la direction de réflexion de la balle à partir de la position où la balle frappe
                       switch (collidePos) {
                           case Block.DOWN :
                           case Block.UP :
                               ball[j].boundY();
                               break;
                           case Block.LEFT :
                           case Block.RIGHT :
                               ball[j].boundX();
                               break;
                           case Block.UP_LEFT :
                           case Block.UP_RIGHT :
                           case Block.DOWN_LEFT :
                           case Block.DOWN_RIGHT :
                               ball[j].boundXY();
                               break;
                       }
                       break; //Un seul bloc peut être brisé à la fois
                    }
                }
               for (int i = 0; i < NUM_BLOCK1; i++) {
                   int collidePos1 = block1[i].collideWith(ball[j]);
                   if ( collidePos1 !=Unbreakblock.NO_COLLISION1) {
                       block1[i].notdelete();
                       
                       switch (collidePos1) {
                           case Unbreakblock.DOWN1 :
                           case Unbreakblock.UP1 :
                               ball[j].boundY();
                               break;
                           case Unbreakblock.LEFT1 :
                           case Unbreakblock.RIGHT1 :
                               ball[j].boundX();
                               break;
                           case Unbreakblock.UP_LEFT1 :
                           case Unbreakblock.UP_RIGHT1 :
                           case Unbreakblock.DOWN_LEFT1 :
                           case Unbreakblock.DOWN_RIGHT1 :
                               ball[j].boundXY();
                               break;
                       }
                       break; 
                   }
                }
               for (int i = 0; i < NUM_BLOCK2; i++) {
                   if (block2[i].isDeleted()){
                       continue;
                    }
                   int collidePos2 = block2[i].collideWith(ball[j]);
                   if ( collidePos2 !=Twobreakblock.NO_COLLISION2) {
                      
                           block2[i].delete();
                      
                       switch (collidePos2) {
                         
                           case Twobreakblock.DOWN2 :
                           case Twobreakblock.UP2 :
                               ball[j].boundY();
                               break;
                          
                           case Twobreakblock.LEFT2 :
                           case Twobreakblock.RIGHT2 :
                               ball[j].boundX();
                               break;
                         
                           case Twobreakblock.UP_LEFT2 :
                           case Twobreakblock.UP_RIGHT2 :
                           case Twobreakblock.DOWN_LEFT2 :
                           case Twobreakblock.DOWN_RIGHT2 :

                               ball[j].boundXY();
                               break;
                       }
                       break; 
                   }
               }
               
              for (int i = 0; i < NUM_BLOCK3; i++) {
               if (block3[i].isDeleted()){
     
                   continue;
               }
                   int collidePos3 = block3[i].collideWith(ball[j]);
                   
                   if ( collidePos3 !=Threebreakblock.NO_COLLISION3) {
                       block3[i].delete();
                      
                       
                       switch (collidePos3) {
                         
                           case Threebreakblock.DOWN3 :
                           case Threebreakblock.UP3 :
                               ball[j].boundY();
                               break;
                          
                           case Threebreakblock.LEFT3 :
                           case Threebreakblock.RIGHT3 :
                               ball[j].boundX();
                               break;
                         
                           case Threebreakblock.UP_LEFT3 :
                           case Threebreakblock.UP_RIGHT3 :
                           case Threebreakblock.DOWN_LEFT3 :
                           case Threebreakblock.DOWN_RIGHT3 :
                               ball[j].boundXY();
                               break;
                       }
                       break; 
                    }
                }
               }
               repaint();
               try {
                   Thread.sleep(20);
               }catch(InterruptedException e){
                   e.printStackTrace();
                   
               }
            }
       }
      }
        
       public void paintComponent(Graphics g){
           racket.draw(g);
           displayTime(g);
           
           for(int i=0;i<countball;i++){
               ball[i].draw(g);
           }
           
           for (int i=0;i<NUM_BLOCK;i++){
               if(!block[i].isDeleted()){
                   block[i].draw(g);
               }
           }
           for (int i=0;i<NUM_BLOCK1;i++){
               if(!block1[i].isDeleted()){
                   block1[i].draw(g);
               }
           }
          
          for (int i=0;i<NUM_BLOCK2;i++){
               if(!block2[i].isDeleted()){
                   block2[i].draw(g);
               }
           }
           
           for (int i=0;i<NUM_BLOCK3;i++){
               if(!block3[i].isDeleted()){
                   block3[i].draw(g);
               }
           }
               for (int y = 0; y <= MY; y++) {
                 for (int x = 0; x <= MX; x++) {
                   int xx = 40*x, yy = 40*y;
                   switch ( map[y][x] ) {
                     //Blocs de dessin
             case 'B':  g.setColor(Color.green);
                        g.fillRect(xx, yy, 26, 10);
                        g.fillRect(xx+32, yy, 8, 10);
                        g.fillRect(xx, yy+15, 10, 10);
                        g.fillRect(xx+16, yy+15, 24, 10);
                        g.fillRect(xx, yy+30, 18, 10);
                        g.fillRect(xx+24, yy+30, 16, 10);
                        break;
                   }
                }
            } 
        }
       
       @Override
       public void mouseMoved(MouseEvent e){
          int x =e.getX();
         racket.move(x);
           repaint();
       }
       @Override
       public void mouseDragged(MouseEvent e){

       }
    }
        class Racket {
       public int width =120;
       public static  int height = 5;
       public static final int NO_COLLISION4 = 0;  //Non-collision
       public static final int LEFT4 = 1;
       public static final int RIGHT4 = 2;
                private int center;
   
        public Racket (){
       center = breakout.x/2;
   
        }       
        public int  collideWith(Ball ball) {
      //Jugement de collision de balle
        Rectangle racketRectLeft = new Rectangle(
               center - width / 2, breakout.y - height-90,
               width/2, height);
               Rectangle racketRectRight = new Rectangle(
                center, breakout.y - height-90,
                width / 2, height);
      
        Rectangle ballRect = new Rectangle(
               ball.getX(), ball.getY(),
               ball.getSize(), ball.getSize());
        if (racketRectLeft.intersects(ballRect)) {
           return LEFT4;
        }
        else if (racketRectRight.intersects(ballRect)) {
        return RIGHT4;
        }
       return NO_COLLISION4;
        }

        public  void draw (Graphics g){
        g.setColor(Color.WHITE);
        g.fillRect(center - width/2,breakout.y-height-90,width,height);
   
        }
        public void move (int x ){
      center =x;
       if (center<(width/2)+40)
       center =(width/2)+40;
       else if (center > breakout.x - (width / 2)-55) 
           center = breakout.x - (width / 2)-55;
   
        }
        }
     class Ball  {
       
      private   int x;
       private  int y;
       private  int vx;
       private  int vy;
       private int size;
       double time;
       int remain=37;
       boolean gameover=false;
       int dt = (int) (time - System.currentTimeMillis() * 0.001);
       Random rand ;
       public Ball(int  x,int y,int vx,int vy,int size ){
           
   this.x=x;
   this.y=y;
   this.vx=vx;
   this.vy=vy;
     this.size =size;    
     time = System.currentTimeMillis() * 0.001 + remain; 
       }
        public  void draw(Graphics g){
           
   g.setColor(Color.RED);
   g.fillOval(x,y,size,size);
  
       }
       
       public int   Size(){
  return size=size-3;
       } 
       public void move(){
         
           if ( gameover ) {
         x=0;
         y=0;
            } else {
            int dt = (int) (time - System.currentTimeMillis() * 0.001);
            x += vx;
            y += vy;
          
            if ( dt == 0 ) gameover = true;
         
            }
           if (x < 40 || x > breakout.x - size-60) {
             boundX();
           }
           if (y < 40  ) {
             boundY();
           }
        }
           public void boundX(){
            vx=-vx;
           }   
           public void boundY(){
            vy=-vy;
           }
       public int getX(){
           return x;
       }
       public void boundXY(){
           vx=-vx;
           vy=-vy;
       }
       public int getY(){
           return y;
       }
       public int getSize(){
           return size;
       }
       public int getVX(){
           return vx;
       }
       public int getVY(){
           return vy;
           
       }
    public void setVX(int v){
        vx=v;
       
    }
    public void setVY(int v){
         vy=v;
      
    }
}
       class Block {
           public static final int WIDTH = 40;
           public static final int HEIGHT = 16;
           public static final int NO_COLLISION = 0; //Non-collision
           public static final int DOWN = 1;
           public static final int LEFT = 2;
           public static final int RIGHT = 3;
           public static final int UP = 4;
           public static final int DOWN_LEFT = 5;
           public static final int DOWN_RIGHT = 6;
           public static final int UP_LEFT = 7;
           public static final int UP_RIGHT = 8;
       
       
           //Position (coordonnées du coin supérieur gauche)
           private int x, y;
    
           //La balle a-t-elle été frappée et effacée?
           private boolean isDeleted;
       
           public Block(int x, int y) {
               this.x = x;
               this.y = y;
               isDeleted = false;
           }
        
           public void draw(Graphics g) {
               g.setColor(Color.CYAN);
               g.fillRect(x, y, WIDTH, HEIGHT);
       
               //Dessinez une bordure
               g.setColor(Color.BLACK);
               g.drawRect(x, y, WIDTH, HEIGHT);
           }
           public int collideWith(Ball ball) {
               Rectangle blockRect = new Rectangle(x, y, WIDTH, HEIGHT);
       
               int ballX = ball.getX();
               int ballY = ball.getY();
               int ballSize = ball.getSize();
               if (blockRect.contains(ballX, ballY)
                   && blockRect.contains(ballX + ballSize, ballY)) {
                   //Collision sous le bloc = Les points en haut à gauche et en haut à droite de la balle sont à l'intérieur du bloc
                   return DOWN;
               } else if (blockRect.contains(ballX + ballSize, ballY)
                   && blockRect.contains(ballX + ballSize, ballY + ballSize)) {
                   //Collision depuis la gauche du bloc = Les points en haut à droite et en bas à droite de la balle sont à l'intérieur du bloc
                   return LEFT;
               } else if (blockRect.contains(ballX, ballY)
                   && blockRect.contains(ballX, ballY + ballSize)) {
                   //Collision du côté droit du bloc = Les points supérieur gauche et inférieur gauche de la balle sont à l'intérieur du bloc
                   return RIGHT;
               } else if (blockRect.contains(ballX, ballY + ballSize)
                   && blockRect.contains(ballX + ballSize, ballY + ballSize)) {
                   //Collision du haut du bloc = Les points inférieurs gauche et inférieur droit de la balle sont à l'intérieur du bloc
                   return UP;
               } else if (blockRect.contains(ballX + ballSize, ballY)) {
                   //Collision en bas à gauche du bloc = Le point en haut à droite de la balle est à l'intérieur du bloc
                   return DOWN_LEFT;
               } else if (blockRect.contains(ballX, ballY)) {
                   //Collision depuis le coin inférieur droit du bloc = le point supérieur gauche de la balle est à l'intérieur du bloc
                   return DOWN_RIGHT;
               } else if (blockRect.contains(ballX + ballSize, ballY + ballSize)) {
                   //Collision en haut à gauche du bloc = Le point en bas à droite de la balle est à l'intérieur du bloc
                   return UP_LEFT;
               } else if (blockRect.contains(ballX, ballY + ballSize)) {
                   //Collision depuis le coin supérieur droit du bloc = le point inférieur gauche de la balle est à l'intérieur du bloc
                   return UP_RIGHT;
               }
       
               return NO_COLLISION;
           }
           public void delete() {
              
       
               isDeleted = true;
           }
         
            public int getX(){
                return x;
            } 
            public int getY(){
               
               return y;
            }
            public boolean isDeleted(){
                return isDeleted;
            }
        }
     interface figure1 {
        public void draw(Graphics g);
        public int collideWith(Ball ball);
        public int getX();
        public int getY();
        public boolean isDeleted();
  
     }
class Unbreakblock implements figure1 {
   public static final int WIDTH1 = 40;
   public static final int HEIGHT1 = 16;
   public static final int NO_COLLISION1= 0; 
   public static final int DOWN1= 1;
   public static final int LEFT1 = 2;
   public static final int RIGHT1 = 3;
   public static final int UP1 = 4;
   public static final int DOWN_LEFT1 = 5;
   public static final int DOWN_RIGHT1 = 6;
   public static final int UP_LEFT1 = 7;
   public static final int UP_RIGHT1 = 8;
   private int a, b;
   private boolean isDeleted;
   public Unbreakblock(int a, int b) {
       this.a = a;
       this.b = b;
       isDeleted = false;
   }
   public void draw(Graphics g) {
       g.setColor(Color.GRAY);
       g.fillRect(a, b, WIDTH1, HEIGHT1);
       g.setColor(Color.BLACK);
       g.drawRect(a, b, WIDTH1, HEIGHT1);
   }
   public int collideWith(Ball ball) {
       Rectangle blockRect = new Rectangle(a, b, WIDTH1, HEIGHT1);
   
       int ballX = ball.getX();
       int ballY = ball.getY();
       int ballSize = ball.getSize();
       if (blockRect.contains(ballX, ballY)
           && blockRect.contains(ballX + ballSize, ballY)) {
          
           return DOWN1;
       } else if (blockRect.contains(ballX + ballSize, ballY)
           && blockRect.contains(ballX + ballSize, ballY + ballSize)) {
           
           return LEFT1;
       } else if (blockRect.contains(ballX, ballY)
           && blockRect.contains(ballX, ballY + ballSize)) {
          
           return RIGHT1;
       } else if (blockRect.contains(ballX, ballY + ballSize)
           && blockRect.contains(ballX + ballSize, ballY + ballSize)) {
          
           return UP1;
       } else if (blockRect.contains(ballX + ballSize, ballY)) {
           
           return DOWN_LEFT1;
       } else if (blockRect.contains(ballX, ballY)) {
          
           return DOWN_RIGHT1;
       } else if (blockRect.contains(ballX + ballSize, ballY + ballSize)) {
         
           return UP_LEFT1;
       } else if (blockRect.contains(ballX, ballY + ballSize)) {
         
           return UP_RIGHT1;
       }
   
       return NO_COLLISION1;
    }
   public void notdelete() {
       isDeleted = false ;
   }
    public int getX(){
        return a;
    } 
    public int getY(){
       
       return b;
    }
    public boolean isDeleted(){
        return isDeleted;
    }
}
   class Twobreakblock implements figure1 {
       public static final int WIDTH2 = 40;
       public static final int HEIGHT2 = 16;
       public static final int NO_COLLISION2= 0; 
       public static final int DOWN2= 21;
       public static final int LEFT2 = 22;
       public static final int RIGHT2 = 23;
       public static final int UP2 = 24;
       public static final int DOWN_LEFT2 = 25;
       public static final int DOWN_RIGHT2 = 26;
       public static final int UP_LEFT2 = 27;
       public static final int UP_RIGHT2 = 28;
    int a, b;
        int count =2;
       private boolean isDeleted;
       public Twobreakblock(int a, int b) {
           this.a = a;
           this.b = b;
           isDeleted = false;
       }
       public void draw(Graphics g) {
           g.setColor(Color.GREEN);
           g.fillRect(a, b, WIDTH2, HEIGHT2);
   
          
           g.setColor(Color.BLACK);
           g.drawRect(a, b, WIDTH2, HEIGHT2);
       }
       public int collideWith(Ball ball) {
           Rectangle blockRect = new Rectangle(a, b, WIDTH2, HEIGHT2);
   
           int ballX = ball.getX();
           int ballY = ball.getY();
           int ballSize = ball.getSize();
           if (blockRect.contains(ballX, ballY)
               && blockRect.contains(ballX + ballSize, ballY)) {
              
               return DOWN2;
           } else if (blockRect.contains(ballX + ballSize, ballY)
               && blockRect.contains(ballX + ballSize, ballY + ballSize)) {
              
               return LEFT2;
           } else if (blockRect.contains(ballX, ballY)
               && blockRect.contains(ballX, ballY + ballSize)) {
               
               return RIGHT2;
           } else if (blockRect.contains(ballX, ballY + ballSize)
               && blockRect.contains(ballX + ballSize, ballY + ballSize)) {
               
               return UP2;
           } else if (blockRect.contains(ballX + ballSize, ballY)) {
               
               return DOWN_LEFT2;
           } else if (blockRect.contains(ballX, ballY)) {
             
               return DOWN_RIGHT2;
           } else if (blockRect.contains(ballX + ballSize, ballY + ballSize)) {
              
               return UP_LEFT2;
           } else if (blockRect.contains(ballX, ballY + ballSize)) {
              
               return UP_RIGHT2;
           }
   
           return NO_COLLISION2;
       }
       public void delete() {
                if(isDeleted==false)
                count--;
                if(count==0)  
           
           isDeleted = true  ;
        } 
        public int getX(){
            return a;
        } 
        public int getY(){
           
           return b;
        }
        public boolean isDeleted(){
            return isDeleted;
        }
     }
     
     class Threebreakblock implements figure1{
       public static final int WIDTH3 = 40;
       public static final int HEIGHT3 = 16;
       public static final int NO_COLLISION3= 0; 
       public static final int DOWN3= 1;
       public static final int LEFT3 = 2;
       public static final int RIGHT3 = 3;
       public static final int UP3 = 4;
       public static final int DOWN_LEFT3 = 5;
       public static final int DOWN_RIGHT3 = 6;
       public static final int UP_LEFT3 = 7;
       public static final int UP_RIGHT3 = 8;
       private int a, b;
        int count =3;
       private boolean isDeleted;
       public Threebreakblock(int a, int b) {
           this.a = a;
           this.b = b;
           isDeleted = false;
       }
       public void draw(Graphics g) {
           g.setColor(Color.YELLOW);
           g.fillRect(a, b, WIDTH3, HEIGHT3);
   
          
           g.setColor(Color.BLACK);
           g.drawRect(a, b, WIDTH3, HEIGHT3);
       }
       public int collideWith(Ball ball) {
           Rectangle blockRect = new Rectangle(a, b, WIDTH3, HEIGHT3);
   
           int ballX = ball.getX();
           int ballY = ball.getY();
           int ballSize = ball.getSize();
           if (blockRect.contains(ballX, ballY)
               && blockRect.contains(ballX + ballSize, ballY)) {
              
               return DOWN3;
           } else if (blockRect.contains(ballX + ballSize, ballY)
               && blockRect.contains(ballX + ballSize, ballY + ballSize)) {
              
               return LEFT3;
           } else if (blockRect.contains(ballX, ballY)
               && blockRect.contains(ballX, ballY + ballSize)) {
               
               return RIGHT3;
           } else if (blockRect.contains(ballX, ballY + ballSize)
               && blockRect.contains(ballX + ballSize, ballY + ballSize)) {
               
               return UP3;
           } else if (blockRect.contains(ballX + ballSize, ballY)) {
               
               return DOWN_LEFT3;
           } else if (blockRect.contains(ballX, ballY)) {
             
               return DOWN_RIGHT3;
           } else if (blockRect.contains(ballX + ballSize, ballY + ballSize)) {
              
               return UP_LEFT3;
           } else if (blockRect.contains(ballX, ballY + ballSize)) {
              
               return UP_RIGHT3;
           }
   
           return NO_COLLISION3;
       }
       public void delete() {
                if(isDeleted==false)
                count--;
                if(count==0)  
           isDeleted = true  ;
        } 
      
        public int getX(){
            return a;
        } 
        public int getY(){
           
           return b;
        }
        public boolean isDeleted(){
            return isDeleted;
        }
     }

Le retrait est sale. .. .. Il décrit l'état dans lequel le devoir a été soumis. Chaque classe d'évasion stocke un bloc, une balle et une variable d'instance d'une raquette qui fait rebondir la balle. En outre, extend hérite des fonctionnalités de Jpanel et les implémentations peuvent gérer les événements de souris. La limite de temps est fixée à 30 secondes. Je dois attendre 5 secondes sur le premier écran de démarrage.Je l'ai réglé sur 35 secondes, écran titre compris, mais pour une raison quelconque, le jeu ne démarre que s'il est 37 secondes. Je ne connais pas la cause.

breakout03.png

Cela prendra énormément de temps pour expliquer le code ... Cette fois, j'ai écrit un article comprenant le code du niveau d'introduction. Si vous le regardez, il peut y avoir des parties qui peuvent être omises ... Par exemple, c'est très difficile à comprendre, par exemple, la fonction du bloc est dupliquée avec presque le même code ... C'est bien d'écrire, mais l'autre partie ne comprend pas Si vous ne pouvez pas le faire, cela n'a aucun sens. Je souhaite continuer à écrire du code facile à comprendre et à transmettre à l'autre partie pour qu'il ne se termine pas par l'auto-satisfaction. La prochaine fois, j'expliquerai le code en détail

Recommended Posts

java j'ai essayé de casser un simple bloc
J'ai essayé de casser le bloc avec java (1)
J'ai essayé de créer une compétence Clova en Java
J'ai essayé de créer une fonction de connexion avec Java
J'ai essayé d'interagir avec Java
J'ai essayé de résumer l'apprentissage Java (1)
J'ai essayé de résumer Java 8 maintenant
J'ai essayé de moderniser une application Java EE avec OpenShift.
J'ai essayé de convertir une chaîne de caractères en un type LocalDate en Java
J'ai créé un client RESAS-API en Java
J'ai essayé de résumer les expressions Java lambda
J'ai essayé de créer une application cartographique simple dans Android Studio
J'ai essayé de créer une application simple en utilisant Dockder + Rails Scaffold
[Java] J'ai essayé de faire un labyrinthe par la méthode de creusage ♪
J'ai essayé de créer une simple application Android de reconnaissance faciale en utilisant OpenCV
J'ai essayé de faire une authentification de base avec Java
J'étais accro à un simple test de Jedis (bibliothèque Java-> Redis)
J'ai essayé de développer un outil de gestion des effectifs
Je l'ai fait en Java pour toujours rendre (a == 1 && a == 2 && a == 3) vrai
J'ai essayé de développer un site Web pour étudier DUO3.0.
J'ai essayé de frapper une méthode Java d'ABCL
Un débutant Java a essayé de créer une application Web simple à l'aide de Spring Boot
Je voulais que (a == 1 && a == 2 && a == 3) vrai en Java
J'ai essayé de créer une application de clonage LINE
J'ai essayé de sortir quatre-vingt-dix-neuf en Java
J'ai essayé de créer une application de conversation en Java à l'aide de l'IA «A3RT»
J'ai essayé de créer une compétence Alexa avec Java
J'ai essayé de développer un site Web pour enregistrer les dépenses.
J'ai essayé d'implémenter un serveur en utilisant Netty
J'ai essayé d'exécuter Java dans un terminal Mac
J'ai essayé de faire un jeu simple avec Javafx ① "Trouvons le jeu du bonheur" (inachevé)
[Java] J'ai essayé de me connecter en utilisant le pool de connexion avec Servlet (tomcat) & MySQL & Java
[Azure] J'ai essayé de créer une application Java pour la création d'applications Web gratuites - [Débutant]
[Petite histoire] J'ai essayé de rendre java ArrayList un peu plus pratique
J'ai fait un jeu de problèmes de calcul simple en Java
J'ai essayé d'implémenter TCP / IP + BIO avec JAVA
J'ai essayé de développer un site Web de partage de boutique de ramen.
[Java 11] J'ai essayé d'exécuter Java sans compiler avec javac
[Java] J'ai essayé de résoudre le problème de rang B de Paiza
J'ai essayé de faire fonctionner SQS en utilisant AWS Java SDK
# 2 [Note] J'ai essayé de calculer quatre-vingt-dix-neuf avec Java.
J'ai essayé d'utiliser Log4j2 sur un serveur Java EE
J'ai essayé OCR de traiter un fichier PDF avec Java
J'ai essayé d'implémenter Sterling Sort avec Java Collector
[Java] J'ai essayé de mettre en œuvre la recherche de produits de l'API Yahoo
J'ai essayé d'implémenter la méthode de division mutuelle d'Eugrid en Java
~ J'ai essayé d'apprendre la programmation fonctionnelle avec Java maintenant ~
J'ai essayé de gratter un graphique boursier en utilisant Java (Jsoup)
J'ai essayé de découvrir ce qui avait changé dans Java 9
J'ai essayé Drools (Java, InputStream)
[Java] Dessine un motif simple
J'ai essayé d'utiliser Java REPL
J'ai essayé de vérifier yum-cron
J'ai essayé la métaprogrammation avec Java
J'ai essayé de créer une fonction / écran d'administrateur de site commercial avec Java et Spring
J'ai essayé de faire un jeu simple avec Javafx ① "Trouvons le jeu du bonheur" (version inachevée ②)
[Azure] J'ai essayé de créer une application Java gratuitement ~ Se connecter avec FTP ~ [Débutant]
[Java] Je souhaite convertir un tableau d'octets en un nombre hexadécimal
J'ai essayé de résumer les bases de kotlin et java