can not move the paddle in this program

[komaravolu raju]

Hello friends.

Now, I am trying to write a program for ball breaker game.
I have read some pages in after searching google.com and found, instead of using ball (round), we can also use the squares.
So, trying to write the code.
here is the code

Now, the issue is that I want to add some keyboard events to the paddle and make it move.
I tried to add the action Listeners to to it and the paddle is not working.

  

package com.room;

import java.awt.Color;
import java.awt.Event;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Timer;
import java.util.TimerTask;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class MyBall extends JPanel implements KeyListener
{
		public static MyBall panel = new MyBall(); 
		public Rectangle screenArea, bounds; // The screen area and boundary.
		public JFrame frame; // A JFrame to put the graphics into.
		public MyTimerTask myTask; // The TimerTask that runs the game.
		public PlayBall ball, ballx; // The game ball, a subclass of Rectangle.
		private Ball_Mould Obsticle; // A Obstacle for the ball to interact with.
		
		// This sets up the screen area, and creates instances of the JFrame, PlayBall, MyTimerTask, etc that we'll need. 
		
		public MyBall()
		{
		 super();
		 screenArea = new Rectangle(0, 0, 400, 400);// Frame bounds
		 bounds = new Rectangle(40, 40, 400, 400); // temporary values.
		 ball = new PlayBall();	// create ball
		 frame = new JFrame("Hi there");
		 myTask = new MyTimerTask();
		 Obsticle = new Ball_Mould();
		}

		class MyTimerTask extends TimerTask
		{
			 public void run()
			 {
			   ball.move();
			   frame.repaint();

			 }
		}

		class PlayBall extends Rectangle
		{
		private static final long serialVersionUID = -1297597992164082314L;
		int xVel, yVel; // The ball's velocity.
		 Color ballColor; // The color of the ball.
			 public PlayBall()
			 {
			   super(4000, 40, 20, 20);
			   xVel = width/4;
			   yVel = height/4;
			   ballColor=new Color(0, 0, 128);
			 }
		
		//move ball  
		 public void move()
		 {
		  
		   x+=xVel; // Move horizontally.
		   y+=yVel; // Move vertically.
		//System.out.println(bounds.getWidth());
		//System.out.println("---------"+bounds.width);
		   // Detect edges and bounce if necessary.
		   if (x > (bounds.width - width))
		   {
		     xVel = -xVel; // reverse movement.
		     x = bounds.width -  width; // Set location to screen edge.
		   }
		   
		   if (y > (bounds.height - height))
		   {
		     yVel = -yVel; // reverse movement.
		     y = bounds.height - height;
		   }
		   
		   if (x <= 0)
		   	{ 
			   xVel = -xVel;
			   x = 0;
		   	}
		   
		   if (y <= 0) 
		   	{ 
			   yVel = -yVel; 
			   y = 0; 
			}
		
		  // Detect Obstacle and bounce.
			   if (intersects(Obsticle)) 
			   {
			     // Get the intersection rectangle to find out which way to bounce.
			     Rectangle iRect = intersection(Obsticle);
			     // If we hit on the left side, go left (negative x velocity).
			     if ((x+(width/2))<(iRect.x+(iRect.width/2)))
			     	{
			    	 xVel=(0-Math.abs(xVel));
			    	}
			     // If we hit on the right side, go right (positive x velocity).
			     if ((x+(width/2))>(iRect.x+(iRect.width/2)))
			     		{
			    	 		xVel=Math.abs(xVel);
			    	 	}
			     // If we hit on the top, go up.
			     if ((y+(height/2))<(iRect.y+(iRect.height/2)))
			     		{
			    	 		yVel=(0-Math.abs(yVel));
			    	 	}
			  
			     // If we hit on the bottom, go down.
			     if ((y+(height/2))>(iRect.y+(iRect.height/2)))
			     		{
			    	 		yVel=Math.abs(yVel);
			     		}
			   } // if intersects
		 }
		
		/* Draw the ball into the provided graphics context. Preserves
		the context's drawing color setting. */
		
				 public void draw(Graphics g)
				 {
				 // the ball draws itself in the graphics context given.
				   Color gcColor = g.getColor(); // Preserve the present color.
				   g.setColor(ballColor); // Use the ball's color for the ball.
				   g.fillRect(x, y, width, height); // Draw the ball.
				   g.setColor(gcColor); // Restore prior color.
				 } // end draw()
		} // end of class PlayBall


		
		
		// paint 
			public void paintComponent(Graphics g)
			{
			 // Get the drawing area bounds for game logic.
//			 bounds = g.getClipBounds();
			 // Clear the drawing area.
			 g.clearRect(screenArea.x, screenArea.y, screenArea.width, screenArea.height);
			 // Draw the Obsticle.
			 g.setColor(Obsticle.getColor());
			 g.fillRect(Obsticle.x, Obsticle.y, Obsticle.width, Obsticle.height);
			 // Draw the ball.
			 ball.draw(g);
			}

/* Main program loop. */
	public static void main(String arg[])
	{
	
	 Timer timer = new Timer();  // Create a Timer object
	 
	 panel.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	 panel.frame.setSize(panel.screenArea.width, panel.screenArea.height);
	
	 panel.frame.setContentPane(panel); 
	 panel.frame.setAlwaysOnTop(true);
	 //panel.frame.setResizable(false);
	 panel.frame.setVisible(true);
	
	 // Set up the brick
	 
	 
	 panel.Obsticle.width = 80;
	 panel.Obsticle.height = 20;
	 
	 // add action listener
	
	 panel.Obsticle.y = 350;

		/* 	 
	 System.out.println(panel.screenArea.width);
	 panel.Obsticle.x = panel.screenArea.width/2;
	 panel.Obsticle.y = panel.screenArea.height/2;
	 panel.Obsticle.width = panel.screenArea.width/2;
	 panel.Obsticle.height = panel.screenArea.height/2;
	*/
	 
	 
	 // Set up a timer to do the myTask regularly.
	 timer.schedule(panel.myTask, 0, 33);
	 //System.out.println();
	}
		public void keyPressed(KeyEvent ke) 
	{
	        int kc = ke.getKeyCode();
	        if (kc == KeyEvent.VK_LEFT) 
	        {
	        	panel.Obsticle.x = 80-10;

	        }
	        if (kc == KeyEvent.VK_RIGHT) 
	        {
	        	panel.Obsticle.x = 80+10;
	        }
	    }
	public void keyReleased(KeyEvent arg0) 
	{}
	public void keyTyped(KeyEvent arg0) 
	{}
}

--------------------------


package com.room;
import java.awt.*;

public class Ball_Mould extends Rectangle
	{
	Color brickColor;

		public Ball_Mould(int newX, int newY, int newWidth, int newHeight)
		{
			
		super(newX, newY, newWidth, newHeight);
		brickColor = new Color(0, 128, 255);
		
		}

		public Ball_Mould(int newX, int newY)
		{
				this(newX, newY, 5, 5);
		}

		public Ball_Mould()
		{
		this(0,0,10,10);
		}

		public void setColor(Color newColor)
		{ 
			brickColor=newColor; 
		}
		
		
		
	public Color getColor()
	{ 
	return brickColor; 
	}

	
} // Ball_Mould




 

can any one help me how to do it???
More over when the ball touches the ground, the game should be over and

[Lester Burnham]

You're not adding a KeyListener anywhere. There should be an "addKeyListener(this)" statement in the MyBall constructor.

[komaravolu raju]

I am sorry. I did not notice it...
thanks for your help.
I did that.

But, after adding the action listener, I could move the paddle only 1 time in both left and right.
and please let me know how to approach for other questions.

thanks in advance.

[Lester Burnham]

But, after adding the action listener, I could move the paddle only 1 time in both left and right.

That's explained by this code:

            if (kc == KeyEvent.VK_LEFT)   
            {  
                panel.Obsticle.x = 80-10;  
  
            }  
            if (kc == KeyEvent.VK_RIGHT)   
            {  
                panel.Obsticle.x = 80+10;  
            }  

Hitting the left/right keys moves the paddle to an absolute position; what it should do is to move it to a position relative to the current one (which you would have to track in some variable).

[komaravolu raju]

Thanks for your support.
I got up to the movement of the paddle and displaying the bricks in the screen.

But, I could not manage to make the bricks vanish when they are each one is hit by the ball.

here is the code for that.

   


package com.room;

import java.util.*;
import java.util.Timer;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.*;
import java.lang.Math;

public class MyBall extends JPanel implements KeyListener
{
        public Rectangle screenArea, bounds; // The screen area and boundary.
        public JFrame frame; // A JFrame for graphics
        public MyTimerTask myTask; // The TimerTask that runs the game.
        public PlayBall ball, ballx; // The game ball, a subclass of Rectangle.
        private Ball_Mould Obsticle; // A Obstacle for the ball to interact with.
        private Ball_Mould brk;// Bricks targeted by the ball 
        
        
        
        // This sets up the screen area, and creates instances of the JFrame, PlayBall, MyTimerTask, etc that we'll need. 
       
       
        public MyBall()
        {
         super();
         screenArea = new Rectangle(0, 0, 400, 400);// Frame bounds
         bounds = new Rectangle(40, 40, 400, 400); // temporary values.
         ball = new PlayBall();    // create ball
         frame = new JFrame("Hi there");
         myTask = new MyTimerTask();
         Obsticle = new Ball_Mould();
         brk = new Ball_Mould(); // create object to display bricks
        }

        class MyTimerTask extends TimerTask
        {
             public void run()
             {
               ball.move();
               frame.repaint();
             }
        }

        class PlayBall extends Rectangle
        {
         int xVel, yVel; // The ball's velocity.
         Color ballColor; // The color of the ball.
         
     
             public PlayBall()
             {
               super(1000, 20, 20, 20);
               //super(10, 40, 20, 20);
               xVel = width/4;
               yVel = height/4;
               ballColor=new Color(0, 0, 128);
             }
       
        //move ball 
         public void move()
         {
           x+=xVel; // Move horizontally.
           y+=yVel; // Move vertically.
           System.out.println(bounds.getWidth());
           System.out.println("---------"+bounds.width);
           // Detect edges and bounce if necessary.
           if (x > (bounds.width - width))
           {
             xVel = -xVel; // reverse movement.
             x = bounds.width -  width; // Set location to screen edge.
           }
          
           if (y > (bounds.height - height))
           {
             yVel = -yVel; // reverse movement.
             y = bounds.height - height;
           }
          
           if (x <= 0)
               {
               xVel = -xVel;
               x = 0;
               }
          
           if (y <= 0)
               {
               yVel = -yVel;
               y = 0;
            }
       
          // Detect Obstacle and bounce.
           if (intersects(Obsticle))
           {
             // Get the intersection rectangle to find out which way to bounce.
             Rectangle iRect = intersection(Obsticle);
             // If we hit on the left side, go left (negative x velocity).
             if ((x+(width/2))<(iRect.x+(iRect.width/2)))
                 {
                 xVel=(0-Math.abs(xVel));
                }
             // If we hit on the right side, go right (positive x velocity).
             if ((x+(width/2))>(iRect.x+(iRect.width/2)))
                     {
                         xVel=Math.abs(xVel);
                     }
             // If we hit on the top, go up.
             if ((y+(height/2))<(iRect.y+(iRect.height/2)))
                     {
                         yVel=(0-Math.abs(yVel));
                     }
         
             // If we hit on the bottom, go down.
             if ((y+(height/2))>(iRect.y+(iRect.height/2)))
                     {
                         yVel=Math.abs(yVel);
                     }

           } // if intersects
           
           ///// bricks leveling
           
           
           
           // Detect Obstacle and bounce with bricks
           if (intersects(brk))
           {
             // Get the intersection rectangle to find out which way to bounce.
             Rectangle iRect = intersection(brk);
             // If we hit on the left side, go left (negative x velocity).
             if ((x+(width/2))<(iRect.x+(iRect.width/2)))
                 {
                 xVel=(0-Math.abs(xVel));
                }
             // If we hit on the right side, go right (positive x velocity).
             if ((x+(width/2))>(iRect.x+(iRect.width/2)))
                     {
                         xVel=Math.abs(xVel);
                     }
             // If we hit on the top, go up.
             if ((y+(height/2))<(iRect.y+(iRect.height/2)))
                     {
                         yVel=(0-Math.abs(yVel));
                     }
         
             // If we hit on the bottom, go down.
             if ((y+(height/2))>(iRect.y+(iRect.height/2)))
                     {
                         yVel=Math.abs(yVel);
                     }

           } // if intersects brick
           
           
           

         }//  end move meth
       
        //* Draw the ball into the provided graphics context. Preserves the context's drawing color setting. 
       
                 public void draw(Graphics g)
                 {
                 // the ball draws itself in the graphics context given.
                   Color gcColor = g.getColor(); // Preserve the present color.
                   g.setColor(ballColor); // Use the ball's color for the ball.
                   g.fillRect(x, y, width, height); // Draw the ball.
                   g.setColor(gcColor); // Restore prior color.
                 } // end draw()
                 
                 
       
                 
        } // end of class PlayBall

            public void paintComponent(Graphics g)
            {
             // Get the drawing area bounds for game logic.
             bounds = g.getClipBounds();
             // Clear the drawing area.
             g.clearRect(screenArea.x, screenArea.y, screenArea.width, screenArea.height);
             // Draw the Obsticle.
             g.setColor(Obsticle.getColor());
             g.fillRect(Obsticle.x, Obsticle.y, Obsticle.width, Obsticle.height);
             // Draw the ball.
             


           // draw brick
           // g.fillRect(brick.x, brick.y, brick.width, brick.height);
             g.fillRect(brk.x,  brk.y, brk.width, brk.height);

             
             ball.draw(g);
             
             
             
            }

/* Main program loop. */
    public static void main(String arg[])
    {
   
     Timer timer = new Timer();  // Create a Timer object
     MyBall ball = new MyBall();
     MyBall brk=new MyBall();
     ball.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     ball.frame.setSize(ball.screenArea.width, ball.screenArea.height);
   
     ball.frame.setContentPane(ball);
     ball.frame.setAlwaysOnTop(true);
//     ball.frame.setResizable(false);
     ball.frame.setVisible(true);
     brk.frame.setVisible(true);
     ball.frame.addKeyListener(ball); // add action listener to paddle
//     brk.frame.addKeyListener(brk); // add action listener to paddle
     
     // Set up the paddle.
     ball.Obsticle.x = 20;
     ball.Obsticle.y = 350;
     ball.Obsticle.width = 40;
     ball.Obsticle.height = 20;
     
     ball.brk.x=100;
//   ball.brick.x = 20;
   ball.brk.y = 100;
   ball.brk.width = 40;
   ball.brk.height = 20;
     
     
     
 /*    
     // set bricks to be hit by ball and paddle
     for(i=0;i<10;i++)
     {
          ball.brk.x=100;
//          ball.brick.x = 20;
          ball.brk.y = 100;
          ball.brk.width = 40;
          ball.brk.height = 20;
     }    
     
   */  
    /*
     System.out.println(ball.screenArea.width);
     ball.Obsticle.x = ball.screenArea.width/2;
     ball.Obsticle.y = ball.screenArea.height/2;
     ball.Obsticle.width = ball.screenArea.width/2;
     ball.Obsticle.height = ball.screenArea.height/2;
    */
     // Set up a timer to do the myTask regularly.
     timer.schedule(ball.myTask, 0, 33);
    }

	@Override
	public void keyPressed(KeyEvent ke) 
	{
		int key=ke.getKeyCode();
		System.out.println("key ---------"+key);
		if(key==KeyEvent.VK_LEFT)
		{
		    Obsticle.x=Obsticle.x-20;

		}
		System.out.println("key ---------"+key);
		if(key==KeyEvent.VK_RIGHT)
		{
			
		    Obsticle.x=Obsticle.x+20;

		}
	}

	@Override
	public void keyReleased(KeyEvent e) {
		
	}

	@Override
	public void keyTyped(KeyEvent e) 
	{
		
	}
/*
	public void setBrick(Ball_Mould brick) {
		this.brick = brick;
	}

	public Ball_Mould getBrick() {
		return brick;
	}
*/
}

------------------------


ball Mould class that enhirit rectangle calss




package com.room;


import java.awt.*;

public class Ball_Mould extends Rectangle
    {
    Color brickColor;

        public Ball_Mould(int newX, int newY, int newWidth, int newHeight)
        {
           
        super(newX, newY, newWidth, newHeight);
        brickColor = new Color(0, 128, 255);
       
        }

        public Ball_Mould(int newX, int newY)
        {
                this(newX, newY, 5, 5);
        }

        public Ball_Mould()
        {
        this(0,0,10,10);
        }

        public void setColor(Color newColor)
        {
            brickColor=newColor;
        }
       
       
       
    public Color getColor()
    {
    return brickColor;
    }

} // end Ball_Mould

 

can any one give me some suggestion......
That would be of great help...

[komaravolu raju]

oh..

finally I have done the game..
and from there, I have also done the target bouncer game also with the same concept...

thanks for your support..