fork(1) download
copy 
  1. import java.awt.*;
  2. import java.applet.*;
  3. import java.awt.event.*;
  4. import java.util.Vector;
  5. import java.awt.Rectangle;
  6.  
  7. public class Bounce2 extends Applet implements ActionListener, AdjustmentListener, MouseListener, MouseMotionListener, Runnable
  8. {
  9.   //runtime variables
  10.   boolean running = false;
  11.   boolean kill = false;
  12.  
  13.   //buttons
  14.   Button runbutton = new Button("Run");
  15.   Button pausebutton = new Button("Pause");
  16.   Button quitbutton = new Button("Quit");
  17.  
  18.   //text
  19.   Label speedlabel = new Label("Speed");
  20.   Label sizelabel = new Label("Size");
  21.  
  22.   Panel drawingpanel;
  23.  
  24.   //scrollbars
  25.   private final int barHeight = 20, SLIDER_WIDTH = 10, MAXSPEED = 110, MINSPEED = 0, MAX_SIZE = 110, MIN_SIZE = 10;
  26.   Scrollbar speedbar = new Scrollbar(Scrollbar.HORIZONTAL, MAXSPEED/2, SLIDER_WIDTH, MINSPEED, MAXSPEED);
  27.   Scrollbar sizebar = new Scrollbar(Scrollbar.HORIZONTAL, MAX_SIZE/2, SLIDER_WIDTH, MIN_SIZE, MAX_SIZE);
  28.  
  29.   //drawn objs
  30.   Ball ball;
  31.  
  32.   private Thread ballThread;
  33.  
  34.   //boundaries
  35.   static int boundx = 640;
  36.   static int boundy = 400;
  37.  
  38.   //speed
  39.   int speed = MAXSPEED/2;
  40.   int delay = MAXSPEED - speed;
  41.  
  42.   //initialize the applet and draw everything
  43.   public void init()
  44.   {
  45.     double colWeight[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};//15 cols
  46.     double rowWeight[] = {1,1,1,1,1,1,1,1,1,1}; //10 rows
  47.     int colWidth[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};//15 cols
  48.     int rowHeight[] = {1,1,1,1,1,1,1,1,1,1}; //10 rows
  49.     GridBagConstraints c = new GridBagConstraints();
  50.     GridBagLayout gbl = new GridBagLayout();
  51.     gbl.rowHeights = rowHeight;
  52.     gbl.rowWeights = rowWeight;
  53.     gbl.columnWeights = colWeight;
  54.     gbl.columnWidths = colWidth;
  55.     c.anchor = GridBagConstraints.CENTER;
  56.  
  57.     setBounds(0,0,480,640);
  58.     setLayout(new BorderLayout());
  59.     Panel controlpanel = new Panel();
  60.     controlpanel.setLayout(gbl);
  61.     controlpanel.setSize(640,80);
  62.  
  63.     drawingpanel = new Panel();
  64.     drawingpanel.setLayout(new BorderLayout(0,0));
  65.     drawingpanel.setSize(640,400);
  66.     ball = new Ball();
  67.     drawingpanel.add("Center",ball);
  68.     drawingpanel.setVisible(true);
  69.  
  70.     //speed scrollbar
  71.     c.weightx = 1;
  72.     c.weighty = 1;
  73.     c.gridwidth = 3;
  74.     c.gridheight = 1;
  75.     c.gridx = 1;
  76.     c.gridy = 7;
  77.     c.fill= GridBagConstraints.HORIZONTAL;
  78.     gbl.setConstraints(this.speedbar,c);
  79.  
  80.     //run button
  81.     c.weightx = 1;
  82.     c.weighty = 1;
  83.     c.gridwidth = 2;
  84.     c.gridheight = 1;
  85.     c.gridx = 5;
  86.     c.gridy = 7;
  87.     c.fill= GridBagConstraints.HORIZONTAL;
  88.     gbl.setConstraints(this.runbutton,c);
  89.  
  90.     //pause button
  91.     c.weightx = 1;
  92.     c.weighty = 1;
  93.     c.gridwidth = 2;
  94.     c.gridheight = 1;
  95.     c.gridx = 8;
  96.     c.gridy = 7;
  97.     c.fill= GridBagConstraints.HORIZONTAL;
  98.     gbl.setConstraints(this.pausebutton,c);
  99.  
  100.     //size scrollbar
  101.     c.weightx = 1;
  102.     c.weighty = 1;
  103.     c.gridwidth = 3;
  104.     c.gridheight = 1;
  105.     c.gridx = 11;
  106.     c.gridy = 7;
  107.     c.fill= GridBagConstraints.HORIZONTAL;
  108.     gbl.setConstraints(this.sizebar,c);
  109.  
  110.     //speed text label
  111.     c.weightx = 1;
  112.     c.weighty = 1;
  113.     c.gridwidth = 3;
  114.     c.gridheight = 1;
  115.     c.gridx = 1;
  116.     c.gridy = 8;
  117.     c.fill= GridBagConstraints.HORIZONTAL;
  118.     gbl.setConstraints(this.speedlabel,c);
  119.  
  120.     //size text label
  121.     c.weightx = 1;
  122.     c.weighty = 1;
  123.     c.gridwidth = 3;
  124.     c.gridheight = 1;
  125.     c.gridx = 11;
  126.     c.gridy = 8;
  127.     c.fill= GridBagConstraints.HORIZONTAL;
  128.     gbl.setConstraints(this.sizelabel,c);
  129.  
  130.     //quit button
  131.     c.weightx = 1;
  132.     c.weighty = 1;
  133.     c.gridwidth = 3;
  134.     c.gridheight = 1;
  135.     c.gridx = 6;
  136.     c.gridy = 9;
  137.     c.fill= GridBagConstraints.HORIZONTAL;
  138.     gbl.setConstraints(this.quitbutton,c);
  139.  
  140.     //add to the screen
  141.     controlpanel.add(this.speedbar);
  142.     controlpanel.add(this.runbutton);
  143.     controlpanel.add(this.pausebutton);
  144.     controlpanel.add(this.sizebar);
  145.     controlpanel.add(this.speedlabel);
  146.     controlpanel.add(this.sizelabel);
  147.     controlpanel.add(this.quitbutton);
  148.  
  149.     //add listners
  150.     speedbar.addAdjustmentListener(this);
  151.     runbutton.addActionListener(this);
  152.     pausebutton.addActionListener(this);
  153.     sizebar.addAdjustmentListener(this);
  154.     quitbutton.addActionListener(this);
  155.     ball.addMouseListener(this);
  156.     ball.addMouseMotionListener(this);
  157.  
  158.     //add the panels
  159.     add("South", controlpanel);
  160.     add("Center", drawingpanel);
  161.  
  162.  
  163.     //drawing paramaters
  164.     //loc = new Point(loc.x+dx, loc.y+dy);
  165.   }
  166.  
  167.   public void start()
  168.   {
  169.     if (ballThread == null)
  170.     {
  171.       ballThread = new Thread(this);
  172.       ballThread.start();
  173.     }
  174.   }
  175.  
  176.   public void run()
  177.   {
  178.     Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
  179.     while (!kill)
  180.     {
  181.       if (running)
  182.       {
  183.         ball.repaint();
  184.       }
  185.       try
  186.       {
  187.         Thread.sleep(delay);
  188.       }
  189.       catch(InterruptedException e){System.err.println("Interrupted.");}
  190.     }
  191.     stop();
  192.   }
  193.  
  194.   public void paint(Graphics g)
  195.   {
  196.     super.paint(g);
  197.   }
  198.  
  199. 	public void mouseClicked(MouseEvent m)
  200. 	{
  201. 		if (!ball.flag)
  202.     {
  203.       Point p;
  204.       p = new Point(m.getPoint());
  205.       Vector<Rectangle> v;
  206.       v = (Vector<Rectangle>)ball.r;
  207.       boolean done = false;
  208.       int i = 0;
  209.  
  210.       while (!done)
  211.       {
  212.         if(v.elementAt(i).contains(p))
  213.         {
  214.           v.removeElement(i);
  215.           System.err.print("Element removed");
  216.         }
  217.         i++;
  218.         if(i>=v.size())
  219.           done=true;
  220.       } 
  221.       ball.r = v;
  222.     }
  223. 	}
  224.  
  225. 	public void mousePressed(MouseEvent m)
  226. 	{
  227. 		ball.flag = true;
  228. 		ball.start = m.getPoint();
  229.     ball.end = ball.start;
  230.     ball.cur = ball.start;
  231. 	}
  232.  
  233. 	public void mouseDragged(MouseEvent m)
  234. 	{
  235. 		if (ball.flag == true)
  236. 		{
  237. 			ball.cur = m.getPoint();
  238. 		}
  239. 	}
  240.  
  241. 	public void mouseReleased(MouseEvent m)
  242. 	{
  243.     //add rect method in ball
  244.     ball.end = ball.cur;
  245.     if (ball.flag)
  246.     {
  247.       ball.addrect();
  248.     }
  249. 		ball.flag = false;
  250. 	} 
  251.  
  252. 	public void mouseEntered(MouseEvent m){}
  253. 	public void mouseExited(MouseEvent m){}
  254. 	public void mouseMoved(MouseEvent m){}
  255.  
  256.   public void actionPerformed(ActionEvent e)
  257.   {
  258.     Object source = e.getSource();
  259.     if (source == this.runbutton)
  260.     {
  261.       running = true;
  262.     }
  263.     else if (source == this.pausebutton)
  264.     {
  265.       running = false;
  266.     }
  267.     else if (source == this.quitbutton)
  268.     {
  269.       //kill processes
  270.       kill = true;
  271.       //remove listeners
  272.       stop();
  273.     }
  274.   }
  275.  
  276.   public void adjustmentValueChanged(AdjustmentEvent e)
  277.   {
  278.     Object source = e.getSource();
  279.     //set the new size.
  280.     if (source == sizebar)
  281.     {
  282.       //check for clipping
  283.       int newsize = sizebar.getValue();
  284.       newsize = ball.resize(newsize);
  285.       sizebar.setValue(newsize);
  286.     }
  287.     if (source == speedbar)
  288.     {
  289.       speed = speedbar.getValue();
  290.       delay = MAXSPEED - speed;
  291.     }
  292.   }
  293.  
  294.   public void stop()
  295.   {
  296.     this.speedbar.removeAdjustmentListener(this);
  297.     this.runbutton.removeActionListener(this);
  298.     this.pausebutton.removeActionListener(this);
  299.     this.sizebar.removeAdjustmentListener(this);
  300.     this.quitbutton.removeActionListener(this);
  301.     this.removeMouseListener(this);
  302.     this.removeMouseMotionListener(this);
  303.     Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
  304.   }
  305. }	
  306.  
  307. //class to handle animations
  308. class Ball extends Canvas
  309. {   
  310.   Rectangle temp;
  311.   static int size = 50;
  312.   private Graphics obj;
  313.   Image offscreen = null;
  314.   static Point loc = new Point(100,100); //location of the ball
  315.  
  316.   //boundaries
  317.   static int boundx = 640;
  318.   static int boundy = 400;
  319.  
  320.   //directions
  321.   int dx = 1; //1 = left, -1 = right
  322.   int dy = 1; //1 = up, -1 = down
  323.  
  324.   static boolean flag = false;
  325.  
  326.   //rectangle vector and associated things
  327.   Vector<Rectangle> r = new Vector<Rectangle>();
  328.   Point start, cur, end;
  329.  
  330.   public int resize(int newsize)
  331.   {
  332.     // x
  333.     if (loc.x+newsize >= boundx)
  334.     {
  335.       newsize = boundx - loc.x - 1;
  336.       return newsize;
  337.     }
  338.  
  339.     // y
  340.     if (loc.y+newsize >= boundy + 100)
  341.     {
  342.       newsize = boundy+100 - loc.y - 1;
  343.       return newsize;
  344.     }
  345.     size = newsize;
  346.     return newsize;
  347.   }
  348.  
  349.   public void move()
  350.   {
  351.     //if it will hit the right or left boundary, flip the x direction and set it
  352.     if (loc.x+size >= boundx || loc.x <= 0)
  353.     { dx *= -1; }
  354.     //if it will hit the top or bottom boundray, flip the y direction and set it
  355.     if (loc.y+size >= boundy || loc.y <= 0)
  356.     { dy *= -1; }
  357.  
  358.  
  359.     for (int i = 0; i < r.size(); i++)
  360.     {
  361.  
  362.       temp = new Rectangle(r.elementAt(i));
  363.       int rx = temp.x;
  364.       int ry = temp.y;
  365.       int rh = temp.height;
  366.       int rw = temp.width;
  367.       //If the ball hits either side of the rectangle, change the x direction
  368.       if((loc.x > rx && loc.x > ry && loc.x < (ry + rh))||(loc.x < (rx + rw) && loc.x > rx && loc.x <(ry + rh)))
  369.         {dx *= -1;}
  370.       //If the ball hits either the top or bottom, change the y direction
  371.       if((loc.y > ry && loc.y > rx && loc.y < (rx + rw))||(loc.y < (ry + rh) && loc.y > ry && loc.y <(rx + rw)))
  372.         {dy *= -1;}
  373.     }
  374.     //Increment or decrement the location of the ball based on the X and Y directions.
  375.     loc.x += dx;
  376.     loc.y += dy;
  377.   }
  378.  
  379.   public void addrect()
  380.   {
  381.     //What was wrong here is that for the final parameter, I had Math.abs(end.y-start.x). 
  382.     if (end.x > start.x && end.y > start.y)
  383.     r.add(new Rectangle(start.x,start.y, Math.abs(end.x-start.x),Math.abs(end.y-start.y)));
  384.     if (end.x > start.x && end.y < start.y)
  385.       r.add(new Rectangle(start.x,end.y, Math.abs(end.x-start.x),Math.abs(end.y-start.y)));  
  386.     if (end.x < start.x && end.y > start.y)
  387.       r.add(new Rectangle(end.x, start.y, Math.abs(end.x-start.x),Math.abs(end.y-start.y)));
  388.     if (end.x < start.x && end.y < start.y)
  389.       r.add(new Rectangle(end.x, end.y, Math.abs(end.x-start.x),Math.abs(end.y-start.y)));
  390.   }
  391.  
  392.   public void update(Graphics g)
  393.   {
  394.     //super.update(g);       //Getting rid of this fixed double buffering
  395.     // I looked at P-dawg's code and he didn't have it.
  396.     Graphics buffer;
  397.     if (offscreen == null)
  398.     {
  399.       offscreen = createImage(getWidth(), getHeight());
  400.     }
  401.     buffer = offscreen.getGraphics();
  402.     buffer.setColor(getBackground());
  403.     buffer.fillRect(0,0,640, 410);
  404.     mypaint(buffer);
  405.     g.drawImage(offscreen, 0, 0, this);
  406.   }
  407.  
  408.   public void mypaint(Graphics g)
  409.   {
  410.     //update loc
  411.     move();
  412.  
  413.     //draw
  414.     g.setColor(Color.RED);
  415.     for (int i = 0; i < r.size(); i++)
  416.     {
  417.       Rectangle t;
  418.       t = new Rectangle(r.elementAt(i));
  419.       g.fillRect(t.x,t.y,t.width,t.height);
  420.     }
  421.     g.setColor(Color.BLACK);
  422.     g.drawOval(loc.x, loc.y, size, size);
  423.     g.fillOval(loc.x, loc.y, size, size);
  424.  
  425.     if (flag)
  426.     {
  427.       if (!r.isEmpty())
  428.       {
  429.         for (int i = 0; i < r.size(); i++) 
  430.         {
  431.           if (cur.x > start.x && cur.y > start.y)
  432.           {
  433.             g.drawRect(start.x, start.y, Math.abs(cur.x - start.x), Math.abs(cur.y - start.y));
  434.             g.setColor(Color.gray);
  435.             g.fillRect(start.x, start.y, Math.abs(cur.x - start.x), Math.abs(cur.y - start.y));
  436.           }  
  437.           if (cur.x > start.x && cur.y < start.y)
  438.           {
  439.             g.drawRect(start.x, cur.y, Math.abs(cur.x - start.x), Math.abs(cur.y - start.y));
  440.             g.setColor(Color.gray);
  441.             g.fillRect(start.x, cur.y, Math.abs(cur.x - start.x), Math.abs(cur.y - start.y));              
  442.           }
  443.           if (cur.x < start.x && cur.y > start.y)
  444.           {
  445.             g.drawRect(cur.x, start.y, Math.abs(cur.x - start.x), Math.abs(cur.y - start.y));
  446.             g.setColor(Color.gray);
  447.             g.fillRect(cur.x, start.y, Math.abs(cur.x - start.x), Math.abs(cur.y - start.y)); 
  448.           }
  449.           if (cur.x < start.x && cur.y < start.y)
  450.           {
  451.             g.drawRect(cur.x, cur.y, Math.abs(cur.x - start.x), Math.abs(cur.y - start.y));
  452.             g.setColor(Color.gray);
  453.             g.fillRect(cur.x, cur.y, Math.abs(cur.x - start.x), Math.abs(cur.y - start.y));
  454.           }
  455.         }
  456.       }
  457.     }
  458.   }
  459. }
Not running #stdin #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/R1hpBx
language:
Java (HotSpot 12)
created:
11 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!