To fill in the board square covered by a piece, it
would be helpful to have a method similar to the one above that copies
the non-zero entries from the given array into the corresponding board
squares.

I need to implement this now, but I have the following questions:

where do I put the contents array? I don't see a board array in the program

do
i need to put the contents array inside the board once it was laid down
or once it appears? and how do i know a piece was laid down? what if
statement should i use for that?

Code:

import java.awt.*;

public class Board extends Grid {
    public static final int COLUMNS = 16;
    public static final int ROWS = 32;
    public static final Color BLUE = new Color(0,0,128,40);
    
    public Board() {
        super(new int[ROWS][COLUMNS]);
        setSize(COLUMNS*Tetris.SQUARE_SIZE,
                ROWS*Tetris.SQUARE_SIZE);
    }
    
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.setColor(BLUE);
        paintStripes(g);
    }
    
    void paintStripes(Graphics g) {
        for (int i = 0; i < COLUMNS; i += 4) {
            g.fillRect(i*Tetris.SQUARE_SIZE,0,
                Tetris.SQUARE_SIZE*2,Tetris.SQUARE_SIZE*ROWS);
        }
    }
    

}

 

Code:

public class PieceFactory {

    public static final int[][] L1 =
        {{1,1,0,0},
         {0,1,0,0},
         {0,1,0,0},
         {0,0,0,0},
        };

    public static final int[][] L2 =
        {{0,1,0,0},
         {0,1,0,0},
         {1,1,0,0},
         {0,0,0,0},
        };

    public static final int[][] T =
        {{0,1,0,0},
         {1,1,0,0},
         {0,1,0,0},
         {0,0,0,0},
        };

    public static final int[][] BOX =
        {{1,1,0,0},
         {1,1,0,0},
         {0,0,0,0},
         {0,0,0,0},
        };

    public static final int[][] BAR =
        {{1,1,1,1},
         {0,0,0,0},
         {0,0,0,0},
         {0,0,0,0},
        };

    public static final int[][] STEP1 =
        {{1,0,0,0},
         {1,1,0,0},
         {0,1,0,0},
         {0,0,0,0},
        };

    public static final int[][] STEP2 =
        {{0,1,0,0},
         {1,1,0,0},
         {1,0,0,0},
         {0,0,0,0},
        };

    public static final int[][][] SHAPES = {L1,L2,T,BOX,BAR,STEP1,STEP2};

    public static Piece createPiece() {
        int[][] s = SHAPES[(int) (Math.random()*SHAPES.length)];
        switch ((int) (Math.random()*10)) {
            case 0:
            case 1:
            case 2:
            case 3:
            default: return new Piece(s);
        }


    }




}

 

Code:

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Tetris extends JFrame implements KeyListener {
    public static final int SQUARE_SIZE = 10; // 10 by 10 pixels

    static Board board;
    static Tetris game;

    JPanel mainPanel;
    public Piece currentPiece;
    int score = 0;
    JButton scoreButton;

    public Tetris() {
        super("Tetris");
        game = this;
        Container pane = getContentPane();
        pane.setLayout(new BorderLayout());

        scoreButton = new JButton("0");
        scoreButton.setEnabled(false);
        pane.add(scoreButton,BorderLayout.NORTH);

        board = new Board();
        mainPanel = new JPanel();
        mainPanel.setLayout(null);
        mainPanel.add(board);
        mainPanel.setPreferredSize
            (new Dimension(Board.COLUMNS*SQUARE_SIZE,
                           Board.ROWS*SQUARE_SIZE));
        pane.add(mainPanel);

        addKeyListener(this);
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent we) {
                System.exit(0);
            }
        });
        pack();
        show();
        setResizable(false);
    }


    public void addToScore(int v) {
        score += v;
        scoreButton.setText(""+score);
    }

    public int getScore() {
        return score;
    }

    static Board getBoard() {
        return board;
    }

    static Tetris getGame() {
        return game;
    }

    static void sleep(int milliseconds) {
        try {
            Thread.sleep(milliseconds);
        } catch (InterruptedException ie) {
        }
    }

    public static void main(String[] args) {
        Tetris game = new Tetris();
        while (true) {
            game.dropPiece();
        }
    }

    void dropPiece() {
        currentPiece = PieceFactory.createPiece();
        mainPanel.add(currentPiece);
        currentPiece.repaint();
        currentPiece.fall();
        //mainPanel.remove(currentPiece);
        board.repaint();
        addToScore(1);
    }

    public void keyPressed(KeyEvent event) {
        int key = event.getKeyCode();
        switch (key) {
        case KeyEvent.VK_UP:  // up arrow
        case KeyEvent.VK_KP_UP:
            currentPiece.rotateCounterclockwise();
            break;
        case KeyEvent.VK_DOWN:  // down arrow
        case KeyEvent.VK_KP_DOWN:
            currentPiece.rotateClockwise();
            break;
        case KeyEvent.VK_LEFT:  // left arrow
        case KeyEvent.VK_KP_LEFT:
            currentPiece.moveLeft();
            break;
        case KeyEvent.VK_RIGHT:  // right arrow
        case KeyEvent.VK_KP_RIGHT:
            currentPiece.moveRight();
            break;
        case KeyEvent.VK_SPACE:  //  space bar
            currentPiece.drop();
        }
    }

    public void keyReleased(KeyEvent arg0) {
    }

    public void keyTyped(KeyEvent arg0) {
    }


}
 

Code:

public class Piece extends Grid {
    int currentX;     // current X location on the board
    double currentY;  // current Y location on the board


    public Piece(int shape[][]) {
        super(shape);
        currentX = 7;
        currentY = 2;
        updateLocation();
    }

    public Piece(int shape[][], currentX, currentY) {
        super(shape);
        this.currentX = currentX;
        this.currentY = currentY;
        updateLocation()
    }



    void updateSize() {
        setSize(Tetris.SQUARE_SIZE*getColumns(),
                Tetris.SQUARE_SIZE*getRows());
    }

    void updateLocation() {
        setLocation(Tetris.SQUARE_SIZE*currentX,
                    (int) (Tetris.SQUARE_SIZE*currentY));
    }

    synchronized void moveDown() {

    }

    synchronized void moveLeft() {
        currentX--;
        updateLocation();
    }

    synchronized void moveRight() {
        currentX++;
        updateLocation();
    }

    synchronized void rotateClockwise() {
        int x = currentX;
        int y = currentY;

        currentPiece = new Piece(s, x, y);

        updateLocation();
    }




    synchronized void rotateCounterclockwise() {
    }

    void fall() {
        // replace the following by your code
        Tetris.sleep(2000);
    }

    synchronized void drop() {
        currentY++;
        updateLocation();
    }

  public static int [][] multiplyMatrix(int [][] m1)
  {
          int [][] m2 =
        {{0,0,0,1},
         {0,0,1,0},
         {0,1,0,0},
         {1,0,0,0},
        };


    int[][] result = new int[4][4];

    // multiply
    for (int i=0; i<4; i++)
      for (int j=0; j<4; j++)
        for (int k=0; k<4; k++)
        if (m1[i][k] * m2[k][j] > 0)
        {
            result[i][j] = 1;
        }
        else
        {
            result[i][j] = 0;
        }


    return result;
  }

    }
 

Yup, but the problem is I didn't write the code, so I too have difficulty parsing it. As far as I know contents = the pieces that falls from the top and the constructor in Grid prints it.

1. Study the provided code to get a feel for what it does. Some
   of the graphics details (for example, how graphics components are
   created, added to containers, and painted) haven't been covered in
   CSE131, but go ahead and read through the files Tetris.java,
   Grid.java, Board.java, Piece.java, and
   PieceFactory.java to understand the way the implementation
   is organized. Notice that the Tetris class provides some static
   methods for getting references to the board and the tetris game
   itself so that other objects can call methods on them, for example
   to check if a board position would be legal, or to add points to
   the score.
2. The class Grid is the parent of both the Board and Piece classes.
   Study its implementation. Notice that a Grid object is created by
   passing it an array of rows, where each row is an array of integers
   representing the squares in the columns of that row. If an array
   entry is 0, the corresponding square is considered to be empty.
   Look at the paint method to see how a grid paints itself based on
   its array.
   
   
   • Add a method to the Grid class that takes in a row number
     as a parameter and returns true exactly when the given row is
     full (has no zero entries). This will be useful for determining
     when to remove a row from the board.
   • Similarly, add a method to the Grid class that returns true
     when a given row is entirely empty. This will be useful for
     determining when the game is over. (Because the game continues
     as long as the top row of the board is empty.)
   
   
   

3. The Board class extends Grid. It will be helpful to add the
   following methods:
   
   
   • Write a method in the Board class that takes a row and
     column index and a two-dimensional array as parameters, and
     checks to see that the non-zero entries of the given array
     correspond to empty positions on the grid, assuming that the
     given array's upper left were positioned at the given row and
     column. You'll use this to determine if a piece can move into
     a given position.
   • To fill in the board square covered by a piece, it would be
     helpful to have a method similar to the one above that copies
     the non-zero entries from the given array into the corresponding
     board squares.
   • Finally, when it's necessary to remove a row, it would be
     nice to have a method on the board that would take that row
     out, move all the others down, and then replace the top row
     with an empty one. For effect, you may want to first clear
     the row being removed, sleep one second, and then bump down
     the other rows. Remember that since the grid is represented
     as an array of rows, it is not necessary to copy all the values
     in the arrays. Just move the rows themselves.
   
   
   

4. The Piece class also extends Grid. Notice that its currentX
   (column) position is represented as an int, but its currentY (row)
   position is represented as a double. This is so you can drop the
   piece gradually, probably 1/5 of a square at a time. To determine
   the next whole row number, the method Math.ceil may help
   you.
   
   
   • In the Piece class, you'll want methods for moving the
     piece down, moving it left and right by one column, and for
     rotating the piece clockwise and counterclockwise 90 degrees.
     (You want these methods to be synchronized so that two
     modifications of the piece aren't attempted concurrently.)
     When a piece is rotated, the array changes shape (somewhat
     similar, but not exactly like, the transpose algorithm we did
     in class). Note: Each time you move a piece, call its
     updateLocation method so that it gets painted properly on the
     board. Similarly, each time you change the shape of a piece,
     call its updateSize method. You should only move or rotate a
     piece if it would be legal to do so. (The methods of the Board
     will be helpful for determining legality of a board position.)
   • You'll need to write a method that is responsible for making
     the piece fall from the top of the board until it's supposed to
     stop, at which time it should fill in the board as appropriate.
     Call the static sleep method in the Tetris class to
     control the animation speed. Remember, though, that when the
     space bar is pressed, the piece should fall without delay.

Maybe this will help you.

If you have questions, don't hesitate I will try to answer them.

http://mathcs.slu.edu/~fritts/cse131/labs/lab9/index.html

not a homework

i just googled the tutorial

I have a question:

there are 2 classes that extends Grid, which has a int [] [] contents attribute. do both classes have their own copy and if so how can I access them individually?

I have a question: how can i put the pieces inside the board?

Do I have to do it after it lands or as soon as it appears?

And what if statement would I use? I don't understand how I could implement this...

What would the condition be then? And how do you access the shape variable from the Board class? Earlier, for Piece, I simpy wrote shapes = a (a = int[][]array), but the method call was currentPiece.moveDown() (currentPiece is an instance of Piece). If the method call was simpy method(), how would I assign the shape variable of the Board class a value (both Piece and Board inherit shapes attribute from the parent class).