model.java

The game tetris on java with using concurrent lib

package homeTask_14_tetris;

import java.awt.Color;
import java.awt.Point;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;



public class Model {

	private State state;
	private int countRotation;
	
	private List<ModelListener> modelListeners = new ArrayList<ModelListener>();
	
	public void addListener(ModelListener listener) {
		modelListeners.add(listener);
	}
	
	public void removeListener(ModelListener listener) {
		modelListeners.remove(listener);
	}
	
	private void fireUpdate() {
		for (ModelListener listener: modelListeners) {
			listener.update(getStateCopy());
		}
	}
	
	public void init() {
		state = new State();
	}
	
	private State getStateCopy() {
		return (State) state.clone(); 

	}

	public void moveLeft() {
		Point figurePosition = state.getFigurePosition();
		Point[] currentFigure = state.getFigure();
		removeFigure(currentFigure);
		state.setFigurePosition(new Point(figurePosition.x-1, figurePosition.y));
		
		
		if (isConformTo(currentFigure)) {
			addFigure(currentFigure);
			fireUpdate();
		} else
		{
			state.setFigurePosition(new Point(figurePosition.x++, figurePosition.y));	
			addFigure(currentFigure);
		}
		
	}
	

	public void moveRight() {
		Point figurePosition = state.getFigurePosition();
		Point[] currentFigure = state.getFigure();
		removeFigure(currentFigure);
		state.setFigurePosition(new Point(figurePosition.x+1, figurePosition.y));
		if (isConformTo(currentFigure)) {
			addFigure(currentFigure);
			fireUpdate();
		} 
		else
		{
			state.setFigurePosition(new Point(figurePosition.x--, figurePosition.y));	
			addFigure(currentFigure);
		}
		
	}
	

	public void moveDown() {
		Point figurePosition = state.getFigurePosition();
		Point[] currentFigure = state.getFigure();
		    removeFigure(currentFigure);

		state.setFigurePosition(new Point(figurePosition.x, figurePosition.y+1));
		if (isConformTo(currentFigure)) {
			addFigure(currentFigure);
			
			fireUpdate();
		} 
		else
		{
			
			state.setFigurePosition(new Point(figurePosition.x, figurePosition.y--));	
			addFigure(currentFigure);
		}
			
	}
	
	
	
	public void dropDown() {
        boolean flag = true;
		while(flag){
			Point figurePosition = state.getFigurePosition();
			Point[] currentFigure = state.getFigure();

			removeFigure(currentFigure);
            state.setFigurePosition(new Point(figurePosition.x,figurePosition.y+1));

		if (isConformTo(currentFigure)) {
			addFigure(currentFigure);
			fireUpdate();
		}
		else
		{
			state.setFigurePosition(new Point(figurePosition.x,figurePosition.y--));
			addFigure(currentFigure);
			flag=false;
		}
	            }
	}
	
	
	public void addFigure(Point[] figure){
	        if (figure != null)
	        {
	            final Point   centrePoint = state.getFigurePosition();
                int [][] newField = state.getField();
	        	for (int i = 0; i < 4; i++) 
	        	{
	        	    int coordOnField_x = centrePoint.x + figure[i].x;
	        	    int coordOnField_y = centrePoint.y + figure[i].y;
	        
	        	    newField[coordOnField_x][coordOnField_y]=state.getFigureType();
	        	}
	        	    state.setField(newField);
	         }
	    }
	
	 
	public void removeFigure(Point[] figure){
	        if (figure != null)	
	        {
	            final Point   centrePoint =state.getFigurePosition() ;
	            int [][] newField = state.getField();

	            for (int i = 0; i < 4; i++) 
	        	{
	        	    int coordOnField_x = centrePoint.x + figure[i].x;
	        	    int coordOnField_y = centrePoint.y + figure[i].y;
	            

	        	    newField[coordOnField_x][coordOnField_y]= 0;
	        	}
	            state.setField(newField);

	        }
	    }
	  
	 

	  
	  public boolean isConformTo(Point[] figure){
		  
	        boolean isConform = true;
            if (figure != null)
	        {
	            final Point   centrePoint =state.getFigurePosition() ;
                int countCols_Field = State.WIDTH;
	            int countRows_Field = State.HEIGHT; 
	        	
	            for (int i = 0; i < 4 && isConform == true; i++) 
	        	{ 
	           int coordOnField_x = centrePoint.x + figure[i].x;
        	   int coordOnField_y = centrePoint.y + figure[i].y;
//        	   checking that coordinates on field
	        if (coordOnField_y < 0 || coordOnField_y >= countRows_Field ||coordOnField_x < 0 || coordOnField_x >= countCols_Field )
	        	isConform = false;
//	           checking that coordinates in empty position       
	        if (isConform && state.getField()[coordOnField_x][coordOnField_y] != 0) 
	        	isConform = false;
	        	}
	        }
               return isConform;
	    }
	  

	
	
	  
	  public void rotate_cw() {
		// rotate figure on 90 degree
		Point[] currentFigure = state.getFigure();
        int cc;
		for (int i = 0; i < 4; i++) {
			// change coordinates of each part of figure
			 cc = currentFigure[i].x;
		     currentFigure[i].x = -currentFigure[i].y;
		     currentFigure[i].y = cc;
		     
		}
       state.setFigure(currentFigure);

	}
	

	public void rotateFigureCW(){
         if (state.getcountFigureRotate() > 1) {
//        	  if current figure is not square then rotate
			countRotation++;
	   if (state.getcountFigureRotate() == 2 && countRotation == 2) 
	      {
	               
		   for (int i = 0; i < 3; i++) {
//	 if rotation of figure is 2 and it was twice rotation then back it on initial position
			   rotate_cw() ;
			     }
	       }
	     else rotate_cw() ;
	        }
         
         countRotation = countRotation % state.getcountFigureRotate();
    }
	
	
	
	public void rotate(){
		Point[] currentFigure = state.getFigure();
		removeFigure(currentFigure);
		rotateFigureCW();
		Point[] newFigure = state.getFigure();
		// if new figure is conform to field then add it and notify listeners
		if (isConformTo(newFigure)){
			addFigure(newFigure);
			fireUpdate();
		}else{
//			 rotate it back
			 for (int i = 0; i < 3; i++) {
				  rotateFigureCW();
				}
			Point[] initialFigure = state.getFigure();
//			add old figure
			addFigure(initialFigure);
		}
		
	}
	
	public void checkAndRemoveRows(){
		// counter for rows;
		int completeRows = 0;
		
        for (int row = State.HEIGHT - 1; row >= 0; row--) 
        {
            boolean isComplete = true;

            for (int col = 0; col < State.WIDTH; col++) 
            {
                if (state.getField()[col][row] == 0) 
                    isComplete = false;
            }

            if (isComplete) 
            {
//                remove complete row;
                int [][] newField = state.getField();
            	
                for (int myRow = row; myRow > 0; myRow--) 
           	{
           	    for (int myCol = 0; myCol < State.WIDTH; myCol++) 
           	    {
           		    newField[myCol][myRow] = newField[myCol][myRow - 1];
           	    }
           	}
               // initialize first row
           	for (int myCol = 0; myCol <State.WIDTH ; myCol++) 
           	{
           	    newField[myCol][0] = 0;
           	}
                state.setField(newField);

                row++;
//          increase  counter for points
                completeRows++;
                state.setWholeRemoveRows(state.getWholeRemoveRows()+1);
//          initialize current level
               
                if (state.getWholeRemoveRows()== 10) 
                	state.setLevel(1);
                if (state.getWholeRemoveRows() == 20) 
                	state.setLevel(2);
                if (state.getWholeRemoveRows() == 30) 
                	state.setLevel(3);
                if (state.getWholeRemoveRows() == 40) 
                	state.setLevel(4);

            }
        }

//        	initialize points
         state.setPoints(state.getPoints()+completeRows * 50);

	}
	
	
	
	
	
	
	
	
	public void ClearResults(){
//		Cleaning results for new Game
		int Cols_Field = State.WIDTH;
        int Rows_Field = State.HEIGHT; 
        int [][] newField  = new int[Cols_Field][Rows_Field];
       	 
        for (int cols = 0; cols < Cols_Field; cols++) 
    	    for (int rows = 0; rows <Rows_Field; rows++) 
    	    	newField[cols][rows] = 0;
       	
        state.setField(newField);
       	
        state.setLevel(0);
       	
        state.setPoints(0);
       	
        state.setWholeRemoveRows(0);
       
        state.setStateOfGame(0);
	}
	
	 
	public  void setRandomFigure(){
		state.setFigurePosition(new Point(State.WIDTH / 2, 0));
        state.setFigureType(new Random().nextInt(7) + 11) ; 
	    }
	
	
	
	public  void sendNextAndCheck(){
		 int CurrFigType = state.getFigureType();
		 // Send first figure in current game
		 
		if (CurrFigType ==0){
			setRandomFigure();

			Point[]currentFigure = state.getFigure();
		
			addFigure(currentFigure);
			fireUpdate();
			return;
		}
		
		// Send next figure
		Point figurePosition = state.getFigurePosition();
		Point [] currentFigure  = state.getFigure();
		removeFigure(currentFigure);
//        checking location of current figure
	    state.setFigurePosition(new Point(figurePosition.x, figurePosition.y+1));
		if ( isConformTo(currentFigure)){

			state.setFigurePosition(new Point(figurePosition.x, figurePosition.y--));
			addFigure(currentFigure);
//			if current figure still can move then do nothing
			return;
		}
//		if current figure was stop  send new figure and check state of game
		     if( isConformTo(currentFigure)==false  && state.getStateOfGame()==0){
		
		    	 state.setFigurePosition(new Point(figurePosition.x, figurePosition.y--)); 
		         addFigure(currentFigure);
		
		         checkAndRemoveRows();
		
		         setRandomFigure();

		Point[]currentFigNext = state.getFigure();
		if(isConformTo(currentFigNext))
		  {
		addFigure(currentFigNext);
		   }
		else{
//		initialize game over
			state.setStateOfGame(1);
		    }
		fireUpdate();
		 }    
	}
	

	 public Color setFigureColor(int typeFigure)
     {
     	Color colorFigure = null ;
     	switch (typeFigure) 
     	{
         	case State.L_CORNER :  
         		colorFigure = new Color(20, 200, 100);  
         	    break;
         	case State.R_CORNER :  
         		colorFigure = new Color(41, 50, 160);  
                break;
         	case State.LOG : 
         		colorFigure = new Color(120, 140, 16);
         	     break;
         	case State.L_ZIGZAG :  
         		colorFigure = new Color(120, 0, 0);
         	     break;
         	case State.R_ZIGZAG :  
         		colorFigure = new Color(32, 154, 170);  
         	    break;
         	case State.SQUARE :  
         		colorFigure = new Color(100, 90, 50); 
         	    break;
         	case State.AWNING : 
                colorFigure = new Color(9, 142, 8); 
         	    break;
     	}
     
     	return colorFigure;
     }

	

	
	 
	
}