Question

This is a grade 12 object oriented programming project.

I have a class called Ball to construct my ball object.

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

public class Ball{
    private double xPos;
    private double yPos;
    private int direction;
    public Ball(int ixPos, int iyPos, int idirection){
        xPos = ixPos;
        yPos = iyPos;
        direction = idirection;
    }
    public int returnX(){
        return (int)xPos;
    }
    public int returnY(){
        return (int)yPos;
    }
    public int returnDirection(){
        return direction;
    }
    public void move(){
        xPos += 1*Math.cos(Math.toRadians(direction));
        yPos -= 1*Math.sin(Math.toRadians(direction));
    }
    public void collide(int collideWith){
        if(collideWith==1){//collide with left wall
            if(90<direction && direction<180){
                direction = 180-direction;
            }
            if(180<direction && direction<270){
                direction = 540-direction;
            }
        }
        if(collideWith==2){//collide with right wall
            if(0<direction && direction<90){
                direction = 180-direction;
            }
            if(270<direction && direction<360){
                direction = 540-direction;
            }
        }
        if(collideWith==3){//collide with up wall
            if(0<direction && direction<90){
                direction = 360-direction;
            }
            if(90<direction && direction<180){
                direction = 360-direction;
            }
        }
        if(collideWith==4){//collide with down wall
            direction = 360-direction;
        }
    }
    public void collidePaddle(int collidePos){
        if(collidePos!=50 && collidePos!=0){
            direction = (50-collidePos)*180/50;
        }
    }
}

As you can see in the “move” function, right now the ball is going at a very low speed. But i need the ball to go faster. If I change the 1 into something like, 5, there would be a problem. In my main class where it checks if the ball is hitting the wall or blocks to change direction, the ball would go into the wall or the blocks if the amount of pixels the ball can move each time is greater than 1.

To me it seems like there’s no way to solve this problem, no idea where I would start thinking, is there a better way of checking collide or something?

Thank you.

Answer 1

Instead of using absolute checks in your collidePaddle check, you should allow for ranges.

For example…

public void collidePaddle(int collidePos){
    if (collidePos >= 50) {
        direction = (50-collidePos)*180/50;
        // Correct the position of the ball to meet the minimum requirements
        // of the collision...
    } else if (collidePos <= 0) {
        direction = (50-collidePos)*180/50;
        // Correct the position of the ball to meet the minimum requirements
        // of the collision...
    }
}

(Sorry, I’m having fun working out your code ;))

This will allow the ball the “pass” beyond the these points within a virtual context, but if you correct the position to componsate, it should make no difference…when it’s rendered…

Updated

Here’s a REALLY SIMPLE example of what I’m talking about…

public class SimpleBouncyBall {

    public static void main(String[] args) {
        new SimpleBouncyBall();
    }

    public SimpleBouncyBall() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (Exception ex) {
                }

                JFrame frame = new JFrame("Test");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new CourtPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class CourtPane extends JPanel {

        private Ball ball;
        private int speed = 5;

        public CourtPane() {
            Timer timer = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    Rectangle bounds = new Rectangle(new Point(0, 0), getSize());
                    if (ball == null) {
                        ball = new Ball(bounds);
                    }
                    speed = ball.move(speed, bounds);
                    repaint();
                }
            });
            timer.setRepeats(true);
            timer.setCoalesce(true);
            timer.start();
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(100, 100);
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g); 
            if (ball != null) {
                Graphics2D g2d = (Graphics2D) g.create();
                g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                Point p = ball.getPoint();
                g2d.translate(p.x, p.y);
                ball.paint(g2d);
                g2d.dispose();
            }
        }

    }

    public class Ball {

        private Point p;
        private int radius = 12;

        public Ball(Rectangle bounds) {                
            p = new Point();
            p.x = 0;
            p.y = bounds.y + (bounds.height - radius) / 2;                
        }

        public Point getPoint() {
            return p;
        }

        public int move(int speed, Rectangle bounds) {                
            p.x += speed;
            if (p.x + radius >= (bounds.x + bounds.width)) {                    
                speed *= -1;
                p.x = ((bounds.x + bounds.width) - radius) + speed;                    
            } else if (p.x <= bounds.x) {
                speed *= -1;
                p.x = bounds.x + speed;                    
            }
            p.y = bounds.y + (bounds.height - radius) / 2;                
            return speed;                
        }

        public void paint(Graphics2D g) {
            g.setColor(Color.RED);
            g.fillOval(0, 0, radius, radius);
        }            
    }        
}

My move method doesn’t care if you’ve past the boundaries as it will reposition the ball back to sit within side those boundaries

public int move(int speed, Rectangle bounds) {                
    // Apply the delta
    p.x += speed;
    // Have we passed beyond the right side??
    if (p.x + radius >= (bounds.x + bounds.width)) {                    
        speed *= -1;
        p.x = ((bounds.x + bounds.width) - radius) + speed;                    
    // Have we past beyond the left side??
    } else if (p.x <= bounds.x) {
        speed *= -1;
        p.x = bounds.x + speed;                    
    }
    p.y = bounds.y + (bounds.height - radius) / 2;                
    return speed;                
}

Play around with the speed and see what you get 😉