Collision Detection between two images in Java

前端 未结 9 1893
情歌与酒
情歌与酒 2020-11-27 06:53

I have two characters displayed in a game I am writing, the player and the enemy. defined as such:

public void player(Graphics g) {
    g.drawImage(plimg, x,         


        
相关标签:
9条回答
  • 2020-11-27 07:29

    Since Java doesn't have an intersect function (really!?) you can do collision detection by simply comparying the X and Y, Width and Height values of the bounding boxes (rectangle) for each of the objects that could potentially collide.

    So... in the base object of each colliding object... i.e. if your player and enemy have a common base you can put a simple Rectangle object called something like BoundingBox. If the common base is a built in Java class then you'll need to create a class that extends the build in class and have the player and enemy objects extend your new class or are instances of that class.

    At creation (and each tick or update) you'll need to set the BoundingBox paremeters for both your player and enemy. I don't have the Rectangle class infront of me but its most likely something like X, Y, Width and finally Height. X and Y are that objects location in your game world. The width and height are self explanatory I think. They'll most likely come out from the right of the players location though so, if the X and Y were bothe at 0 and your Width and Height were both at 256 you wouldn't see anything because the character would be at the top left outside of the screen.

    Anyways... to detect a collision, you'll want to compare the attributes of the player and enemy BoundingBoxes. So something like this...

     if( Player.BoundingBox.X = Enemy.BoundingBox.X && If( Player.BoundingBox.Y = Enemy.BoundingBox.Y )
     {
          //Oh noes!  The enemy and player are on top of eachother.
     }
    

    The logic can get sort of complicated but you'll need to compare the distances between each BoundingBox and compare locations.

    0 讨论(0)
  • 2020-11-27 07:30

    Here's the main class from my collision detection program.
    You can see it run at: http://www.youtube.com/watch?v=JIXhCvXgjsQ

    /**
     *
     * @author Tyler Griffin
     */
    import java.awt.*;
    import javax.swing.*;
    import java.awt.event.*;
    import java.awt.GraphicsDevice.*;
    import java.util.ArrayList;
    import java.awt.Graphics;
    import java.awt.geom.Line2D;
    
    
    public class collision extends JFrame implements KeyListener, MouseMotionListener, MouseListener
    {
        ArrayList everything=new ArrayList<tile>();
    
        int time=0, x, y, width, height, up=0, down=0, left=0, right=0, mouse1=0, mouse2=0;
        int mouseX, mouseY;
    
        GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
        GraphicsDevice screen = environment.getDefaultScreenDevice();
        DisplayMode displayMode = screen.getDisplayMode();
    
        //private BufferStrategy strategy;
    
        JLayeredPane pane = new JLayeredPane();
    
         tile Tile;
         circle Circle;
         rectangle Rectangle;
    
             textPane text;
    
        public collision()
        {
            setUndecorated(screen.isFullScreenSupported());
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setVisible(true);
            setLayout(null);
            setResizable(false);
            screen.setFullScreenWindow(this);
    
    
            width=displayMode.getWidth();
            height=displayMode.getHeight();
    
    
              Circle=new circle(-(int)Math.round((double)height/7*2),-(int)Math.round((double)height/7*2),(int)Math.round((double)height/7*.85),this);
              Rectangle=new rectangle(-(int)Math.round((double)height/7*1.5),-(int)Math.round((double)height/7*1.5),(int)Math.round((double)height/7*1.5),(int)Math.round((double)height/7*1.5),this);
              Tile=Circle;
              Tile.move(mouseX-Tile.width/2, mouseY-Tile.height/2);
                      text=new textPane(0,0,width,height,this);
    
              everything.add(new circle((int)Math.round((double)width/100*75),(int)Math.round((double)height/100*15),(int)Math.round((double)width/100*10),this));
                      everything.add(new rectangle((int)Math.round((double)width/100*70),(int)Math.round((double)height/100*60),(int)Math.round((double)width/100*20),(int)Math.round((double)height/100*20),this));
                      //everything.add(new line(750,250,750,750,this));
                      /*everything.add(new line(width/700*419,height/700*68,width/700*495,height/700*345,this));
                      everything.add(new line(width/700*495,height/700*345,width/700*749,height/700*350,this));
                      everything.add(new line(width/700*749,height/700*350,width/700*549,height/700*519,this));
                      everything.add(new line(width/700*549,height/700*519,width/700*624,height/700*800,this));
                      everything.add(new line(width/700*624,height/700*800,width/700*419,height/700*638,this));
                      everything.add(new line(width/700*419,height/700*638,width/700*203,height/700*800,this));
                      everything.add(new line(width/700*203,height/700*800,width/700*279,height/700*519,this));
                      everything.add(new line(width/700*279,height/700*519,width/700*76,height/700*350,this));
                      everything.add(new line(width/700*76,height/700*350,width/700*333,height/700*345,this));
                      everything.add(new line(width/700*333,height/700*345,width/700*419,height/700*68,this));
    
                      everything.add(new line(width/950*419,height/700*68,width/950*624,height/700*800,this));
                      everything.add(new line(width/950*419,height/700*68,width/950*203,height/700*800,this));
                      everything.add(new line(width/950*76,height/700*350,width/950*624,height/700*800,this));
                      everything.add(new line(width/950*203,height/700*800,width/950*749,height/700*350,this));
                      everything.add(new rectangle(width/950*76,height/700*350,width/950*673,1,this));*/
    
                      everything.add(new line((int)Math.round((double)width/1350*419),(int)Math.round((double)height/1000*68),(int)Math.round((double)width/1350*624),(int)Math.round((double)height/1000*800),this));
                      everything.add(new line((int)Math.round((double)width/1350*419),(int)Math.round((double)height/1000*68),(int)Math.round((double)width/1350*203),(int)Math.round((double)height/1000*800),this));
                      everything.add(new line((int)Math.round((double)width/1350*76),(int)Math.round((double)height/1000*350),(int)Math.round((double)width/1350*624),(int)Math.round((double)height/1000*800),this));
                      everything.add(new line((int)Math.round((double)width/1350*203),(int)Math.round((double)height/1000*800),(int)Math.round((double)width/1350*749),(int)Math.round((double)height/1000*350),this));
                      everything.add(new rectangle((int)Math.round((double)width/1350*76),(int)Math.round((double)height/1000*350),(int)Math.round((double)width/1350*673),1,this));
    
    
            addKeyListener(this);
            addMouseMotionListener(this);
            addMouseListener(this);
        }
    
        public void keyReleased(KeyEvent e)
        {
            Object source=e.getSource();
    
            int released=e.getKeyCode();
    
            if (released==KeyEvent.VK_A){left=0;}
            if (released==KeyEvent.VK_W){up=0;}
            if (released==KeyEvent.VK_D){right=0;}
            if (released==KeyEvent.VK_S){down=0;}
        }//end keyReleased
    
    
        public void keyPressed(KeyEvent e)
        {
            Object source=e.getSource();
    
            int pressed=e.getKeyCode();
    
            if (pressed==KeyEvent.VK_A){left=1;}
            if (pressed==KeyEvent.VK_W){up=1;}
            if (pressed==KeyEvent.VK_D){right=1;}
            if (pressed==KeyEvent.VK_S){down=1;}
    
            if (pressed==KeyEvent.VK_PAUSE&&pressed==KeyEvent.VK_P)
            {
                //if (paused==0){paused=1;}
                //else paused=0;
            }
        }//end keyPressed
    
        public void keyTyped(KeyEvent e){}
    
    //***********************************************************************************************
    
        public void mouseDragged(MouseEvent e)
        {
            mouseX=(e.getX());
            mouseY=(e.getY());
    
              //run();
        }
    
        public void mouseMoved(MouseEvent e)
        {
            mouseX=(e.getX());
            mouseY=(e.getY());
    
              //run();
        }
    
    //***********************************************************************************************
    
        public void mousePressed(MouseEvent e)
        {
            if(e.getX()==0 && e.getY()==0){System.exit(0);}
    
        mouseX=(e.getX()+x);
            mouseY=(e.getY()+y);
    
            if(Tile instanceof circle)
            {
                    Circle.move(0-Circle.width, 0-Circle.height);
                    Circle.setBounds(Circle.x, Circle.y, Circle.width, Circle.height);
                    Tile=Rectangle;
            }
            else
            {
                    Rectangle.move(0-Rectangle.width, 0-Rectangle.height);
                    Rectangle.setBounds(Rectangle.x, Rectangle.y, Rectangle.width, Rectangle.height);
                    Tile=Circle;
            }
    
            Tile.move(mouseX-Tile.width/2, mouseY-Tile.height/2);
        }
    
        public void mouseReleased(MouseEvent e)
        {
             //run();
        }
    
        public void mouseEntered(MouseEvent e){}
        public void mouseExited(MouseEvent e){}
    
        public void mouseClicked(MouseEvent e){}
    
    //***********************************************************************************************
    
        public void run()//run collision detection
        {
            while (this == this)
            {
                Tile.move(Tile.x + ((mouseX - (Tile.x + (Tile.width / 2))) / 10), Tile.y + ((mouseY - (Tile.y + (Tile.height / 2))) / 10));
                //Tile.move((mouseX - Tile.width / 2), mouseY - (Tile.height / 2));
    
                for (int i = 0; i < everything.size(); i++)
                {
                    tile Temp = (tile) everything.get(i);
    
                    if (Temp.x < (Tile.x + Tile.width) && (Temp.x + Temp.width) > Tile.x && Temp.y < (Tile.y + Tile.height) && (Temp.y + Temp.height) > Tile.y)//rectangles collided
                    {
                        if (Temp instanceof rectangle)
                        {
                            if (Tile instanceof rectangle){rectangleRectangle(Temp);}
                            else {circleRectangle(Temp);}//Tile instanceof circle
                        }
                        else
                        {
                            if (Temp instanceof circle)
                            {
                                if (Tile instanceof rectangle) {rectangleCircle(Temp);}
                                else {circleCircle(Temp);}
                            }
                            else//line
                            {
                                if (Tile instanceof rectangle){rectangleLine(Temp);}
                                else{circleLine(Temp);}
                            }
                        }
                    }//end if
                }//end for
    
                try {Thread.sleep(16L);}
                catch (Exception e) {}
    
                Tile.setBounds(Tile.x, Tile.y, Tile.width, Tile.height);
                //Rectangle.setBounds(x, y, width, height);
                //Circle.setBounds(x, y, width, height);
                repaint();
    
                text.out=" ";
            }//end while loop
        }//end run
    
    //***************************************special collision detection/handling functions************************************************
    
        void rectangleRectangle(tile Temp)
        {
            int lapTop, lapBot, lapLeft, lapRight, small, scootX=0, scootY=0;
    
            lapTop=(Temp.y+Temp.height)-Tile.y;
            lapBot=(Tile.y+Tile.height)-Temp.y;
            lapLeft=(Temp.x+Temp.width)-Tile.x;
            lapRight=(Tile.x+Tile.width)-Temp.x;
    
            small=999999999;
    
            if (lapTop<small){small=lapTop; scootX=0; scootY=lapTop;}
            if (lapBot<small){small=lapBot; scootX=0; scootY=lapBot*-1;}
                    if (lapLeft<small){small=lapLeft; scootX=lapLeft; scootY=0;}
                    if (lapRight<small){small=lapRight; scootX=lapRight*-1; scootY=0;}
    
            Tile.move(Tile.x+scootX, Tile.y+scootY);text.out="collision detected!";
        }
    
    
    
        void circleRectangle(tile Temp)
        {
            if((Tile.x+Tile.width/2<=Temp.x+Temp.width && Tile.x+Tile.width/2>=Temp.x)||(Tile.y+Tile.height/2>=Temp.y && Tile.y+Tile.height/2<=Temp.y+Temp.height))
            {
                rectangleRectangle(Temp);
            }
            else//push from nearest corner
            {
                int x,y;
                if(Tile.x+Tile.width/2>Temp.x+Temp.width && Tile.y+Tile.height/2<Temp.y){x=Temp.x+Temp.width; y=Temp.y;}
                else if(Tile.x+Tile.width/2<Temp.x && Tile.y+Tile.height/2<Temp.y){x=Temp.x; y=Temp.y;}
                else if(Tile.x+Tile.width/2>Temp.x+Temp.width && Tile.y+Tile.height/2>Temp.y+Temp.height){x=Temp.x+Temp.width; y=Temp.y+Temp.height;}
                else {x=Temp.x; y=Temp.y+Temp.height;}
    
                double distance = Math.sqrt(Math.pow(Tile.x+(Tile.width/2) - x, 2) + Math.pow(Tile.y+(Tile.height/2) - y, 2));
    
                if((int)Math.round(distance)<Tile.height/2)
                {
                                 double normY = ((Tile.y+(Tile.height/2) - y) / distance);
                                 double normX = ((Tile.x+(Tile.width/2) - x) / distance);
    
                                Tile.move(x-Tile.width/2+(int)Math.round(normX*((Tile.width/2))) , y-Tile.height/2+(int)Math.round(normY*((Tile.height/2))));text.out="collision detected!";
                }
            }
        }
    
    
    
        void rectangleCircle(tile Temp)
        {
            if((Temp.x+Temp.width/2<=Tile.x+Tile.width && Temp.x+Temp.width/2>=Tile.x)||(Temp.y+Temp.height/2>=Tile.y && Temp.y+Temp.height/2<=Tile.y+Tile.height))
            {
                rectangleRectangle(Temp);
            }
            else//push from nearest corner
            {
                int x,y;
                if(Temp.x+Temp.width/2>Tile.x+Tile.width && Temp.y+Temp.height/2<Tile.y){x=Tile.x+Tile.width; y=Tile.y;}
                else if(Temp.x+Temp.width/2<Tile.x && Temp.y+Temp.height/2<Tile.y){x=Tile.x; y=Tile.y;}
                else if(Temp.x+Temp.width/2>Tile.x+Tile.width && Temp.y+Temp.height/2>Tile.y+Tile.height){x=Tile.x+Tile.width; y=Tile.y+Tile.height;}
                else {x=Tile.x; y=Tile.y+Tile.height;}
    
                double distance = Math.sqrt(Math.pow(Temp.x+(Temp.width/2) - x, 2) + Math.pow(Temp.y+(Temp.height/2) - y, 2));
    
                if((int)Math.round(distance)<Temp.height/2)
                {
                 double normY = ((Temp.y+(Temp.height/2) - y) / distance);
                 double normX = ((Temp.x+(Temp.width/2) - x) / distance);
    
                 if(Temp.x+Temp.width/2>Tile.x+Tile.width && Temp.y+Temp.height/2<Tile.y){Tile.move((Temp.x+Temp.width/2)-(int)Math.round(normX*((Temp.width/2)))-Tile.width,(Temp.y+Temp.height/2)-(int)Math.round(normY*((Temp.height/2))));text.out="collision detected!";}
                    else if(Temp.x+Temp.width/2<Tile.x && Temp.y+Temp.height/2<Tile.y){Tile.move((Temp.x+Temp.width/2)-(int)Math.round(normX*((Temp.width/2))),(Temp.y+Temp.height/2)-(int)Math.round(normY*((Temp.height/2))));text.out="collision detected!";}
                    else if(Temp.x+Temp.width/2>Tile.x+Tile.width && Temp.y+Temp.height/2>Tile.y+Tile.height){Tile.move((Temp.x+Temp.width/2)-(int)Math.round(normX*((Temp.width/2)))-Tile.width,(Temp.y+Temp.height/2)-(int)Math.round(normY*((Temp.height/2)))-Tile.height);text.out="collision detected!";}
                    else {Tile.move((Temp.x+Temp.width/2)-(int)Math.round(normX*((Temp.width/2))),(Temp.y+Temp.height/2)-(int)Math.round(normY*((Temp.height/2)))-Tile.height);text.out="collision detected!";}
                }
            }
        }
    
    
    
    
        void circleCircle(tile Temp)
        {
            double distance = Math.sqrt(Math.pow((Tile.x+(Tile.width/2)) - (Temp.x+(Temp.width/2)),2) + Math.pow((Tile.y+(Tile.height/2)) - (Temp.y+(Temp.height/2)), 2));
    
            if((int)distance<(Tile.width/2+Temp.width/2))
            {
                            double normX = ((Tile.x+(Tile.width/2)) - (Temp.x+(Temp.width/2))) / distance;
                            double normY = ((Tile.y+(Tile.height/2)) - (Temp.y+(Temp.height/2))) / distance;
    
                Tile.move((Temp.x+(Temp.width/2))+(int)Math.round(normX*(Tile.width/2+Temp.width/2))-(Tile.width/2) , (Temp.y+(Temp.height/2))+(int)Math.round(normY*(Tile.height/2+Temp.height/2))-(Tile.height/2));text.out="collision detected!";
            }
        }
    
    
    
        void circleLine(tile Temp)
        {
                line Line=(line)Temp;
    
                if (Line.x1 < (Tile.x + Tile.width) && (Line.x1) > Tile.x && Line.y1 < (Tile.y + Tile.height) && Line.y1 > Tile.y)//circle may be hitting one of the end points
                {
                    rectangle rec=new rectangle(Line.x1, Line.y1, 1, 1, this);
                    circleRectangle(rec);
                    remove(rec);
                }
    
                if (Line.x2 < (Tile.x + Tile.width) && (Line.x2) > Tile.x && Line.y2 < (Tile.y + Tile.height) && Line.y2 > Tile.y)//circle may be hitting one of the end points
                {
                    rectangle rec=new rectangle(Line.x2, Line.y2, 1, 1, this);
                    circleRectangle(rec);
                    remove(rec);
                }
    
    
                int x1=0, y1=0, x2=Tile.x+(Tile.width/2), y2=Tile.y+(Tile.height/2);
    
                x1=Tile.x+(Tile.width/2)-Line.height;//(int)Math.round(Line.xNorm*1000);
                x2=Tile.x+(Tile.width/2)+Line.height;
                if(Line.posSlope)
                {
                    y1=Tile.y+(Tile.height/2)-Line.width;
                    y2=Tile.y+(Tile.height/2)+Line.width;
                }
                else
                {
                    y1=Tile.y+(Tile.height/2)+Line.width;
                    y2=Tile.y+(Tile.height/2)-Line.width;
                }
    
                Point point=intersection((double)x1,(double)y1,(double)x2,(double)y2,(double)Line.x1,(double)Line.y1,(double)Line.x2,(double)Line.y2);//find intersection
    
                if (point.x < (Line.x + Line.width) && point.x > Line.x && point.y < (Line.y + Line.height) && point.y > Line.y)//line intersects within line segment
                {
                    //if(point!=null){System.out.println(point.x+","+point.y);}
                    double distance = Math.sqrt(Math.pow((Tile.x+(Tile.width/2)) - point.x,2) + Math.pow((Tile.y+(Tile.width/2)) - point.y, 2));
    
                    if((int)distance<Tile.width/2)
                    {
                        //System.out.println("hit");
                        double normX = ((Tile.x+(Tile.width/2)) - point.x) / distance;
                        double normY = ((Tile.y+(Tile.height/2)) - point.y) / distance;
    
                        Tile.move((point.x)+(int)Math.round(normX*(Tile.width/2))-(Tile.width/2) , (point.y)+(int)Math.round(normY*(Tile.height/2))-(Tile.height/2));text.out="collision detected!";
                        //System.out.println(point.x+","+point.y);
                    }
                }
    
                //new bullet(this, (int)Math.round(tryX), (int)Math.round(tryY));
        }
    
            void rectangleLine(tile Temp)
        {
                line Line=(line)Temp;
                if(new Line2D.Double(Line.x1,Line.y1,Line.x2,Line.y2).intersects(new Rectangle(Tile.x,Tile.y,Tile.width,Tile.height)))
                {
                    if (Line.x1 < (Tile.x + Tile.width) && (Line.x1) > Tile.x && Line.y1 < (Tile.y + Tile.height) && Line.y1 > Tile.y)//circle may be hitting one of the end points
                    {
                        rectangle rec=new rectangle(Line.x1, Line.y1, 1, 1, this);
                        rectangleRectangle(rec);
                        remove(rec);
                    }
    
                    if (Line.x2 < (Tile.x + Tile.width) && (Line.x2) > Tile.x && Line.y2 < (Tile.y + Tile.height) && Line.y2 > Tile.y)//circle may be hitting one of the end points
                    {
                        rectangle rec=new rectangle(Line.x2, Line.y2, 1, 1, this);
                        rectangleRectangle(rec);
                        remove(rec);
                    }
    
                    if(Line.posSlope)//positive sloped line
                    {
                        //first we'll do the top left corner
                        int x1=Tile.x-Line.height;
                        int x2=Tile.x+Line.height;
                        int y1=Tile.y-Line.width;
                        int y2=Tile.y+Line.width;
                        Point topPoint=new Point(-99,-99), botPoint=new Point(-99,-99);
                        double topDistance=0, botDistance=0;
    
                        topPoint=intersection((double)x1,(double)y1,(double)x2,(double)y2,(double)Line.x1,(double)Line.y1,(double)Line.x2,(double)Line.y2);//find intersection
    
                        topDistance = Math.sqrt(Math.pow(Tile.x - topPoint.x,2) + Math.pow(Tile.y - topPoint.y, 2));
    
                        //new let's do the bottom right corner
                        x1=Tile.x+Tile.width-Line.height;
                        x2=Tile.x+Tile.width+Line.height;
                        y1=Tile.y+Tile.height-Line.width;
                        y2=Tile.y+Tile.height+Line.width;
    
                        botPoint=intersection((double)x1,(double)y1,(double)x2,(double)y2,(double)Line.x1,(double)Line.y1,(double)Line.x2,(double)Line.y2);//find intersection
    
                        botDistance = Math.sqrt(Math.pow((Tile.x+Tile.width) - botPoint.x,2) + Math.pow((Tile.y+Tile.height) - botPoint.y, 2));
    
    
                        if(topDistance<botDistance)
                        {
                            if(new Rectangle(Tile.x,Tile.y,Tile.width,Tile.height).contains(topPoint) && new Rectangle(Line.x,Line.y,Line.width,Line.height).contains(topPoint))
                            {
                                Tile.move(topPoint.x,topPoint.y);text.out="collision detected!";
                            }
                        }
                        else
                        {
                            if(new Rectangle(Tile.x,Tile.y,Tile.width,Tile.height).contains(botPoint) && new Rectangle(Line.x,Line.y,Line.width,Line.height).contains(botPoint))
                            {
                                Tile.move(botPoint.x-Tile.width,botPoint.y-Tile.height);text.out="collision detected!";
                            }
                        }
                    }
                    else//negative sloped lne
                    {
                        //first we'll do the top right corner
                        int x1=Tile.x+Tile.width-Line.height;
                        int x2=Tile.x+Tile.width+Line.height;
                        int y1=Tile.y+Line.width;
                        int y2=Tile.y-Line.width;
                        Point topPoint=new Point(-99,-99), botPoint=new Point(-99,-99);
                        double topDistance=0, botDistance=0;
    
                        topPoint=intersection((double)x1,(double)y1,(double)x2,(double)y2,(double)Line.x1,(double)Line.y1,(double)Line.x2,(double)Line.y2);//find intersection
    
                        topDistance = Math.sqrt(Math.pow(Tile.x + Tile.width - topPoint.x,2) + Math.pow(Tile.y - topPoint.y, 2));
    
                        //new let's do the bottom left corner
                        x1=Tile.x-Line.height;
                        x2=Tile.x+Line.height;
                        y1=Tile.y+Tile.height+Line.width;
                        y2=Tile.y+Tile.height-Line.width;
    
                        botPoint=intersection((double)x1,(double)y1,(double)x2,(double)y2,(double)Line.x1,(double)Line.y1,(double)Line.x2,(double)Line.y2);//find intersection
    
                        botDistance = Math.sqrt(Math.pow(Tile.x - botPoint.x,2) + Math.pow((Tile.y+Tile.height) - botPoint.y, 2));
    
    
                        if(topDistance<botDistance)
                        {
                            if(new Rectangle(Tile.x,Tile.y,Tile.width,Tile.height).contains(topPoint) && new Rectangle(Line.x,Line.y,Line.width,Line.height).contains(topPoint))
                            {
                                Tile.move(topPoint.x-Tile.width,topPoint.y);text.out="collision detected!";
                            }
                        }
                        else
                        {
                            if(new Rectangle(Tile.x,Tile.y,Tile.width,Tile.height).contains(botPoint) && new Rectangle(Line.x,Line.y,Line.width,Line.height).contains(botPoint))
                            {
                                Tile.move(botPoint.x,botPoint.y-Tile.height);text.out="collision detected!";
                            }
                        }
                    }
                }
        }
    
           public Point intersection(double x1, double y1, double x2, double y2,double x3, double y3, double x4, double y4)//I didn't write this. got it from http://www.ahristov.com/tutorial/geometry-games/intersection-lines.html (I altered it)
           {
                double d = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
    
                double xi = ((x3 - x4) * (x1 * y2 - y1 * x2) - (x1 - x2) * (x3 * y4 - y3 * x4)) / d;
                double yi = ((y3 - y4) * (x1 * y2 - y1 * x2) - (y1 - y2) * (x3 * y4 - y3 * x4)) / d;
    
                int x=(int)Math.round(xi);
                int y=(int)Math.round(yi);
    
                return new Point(x, y);
            }
    
    //***************************************************************************************
    
        public static void main(String[] args)
        {
            final collision Collision=new collision();
              Collision.run();
        }//end main
    }//end class
    
    0 讨论(0)
  • 2020-11-27 07:33

    You don't want to have the collision check code inside the painting code. The painting needs to be fast. Collision can go in the game loop. Therefore you need an internal representation of the objects independent of their sprites.

    0 讨论(0)
  • 2020-11-27 07:34

    Here's a useful of an open source game that uses a lot of collisions: http://robocode.sourceforge.net/

    You may take a look at the code and complement with the answers written here.

    0 讨论(0)
  • 2020-11-27 07:38

    I think your problem is that you are not using good OO design for your player and enemies. Create two classes:

    public class Player
    {
        int X;
        int Y;
        int Width;
        int Height;
    
        // Getters and Setters
    }
    
    public class Enemy
    {
        int X;
        int Y;
        int Width;
        int Height;
    
        // Getters and Setters
    }
    

    Your Player should have X,Y,Width,and Height variables.

    Your enemies should as well.

    In your game loop, do something like this (C#):

    foreach (Enemy e in EnemyCollection)
    {
        Rectangle r = new Rectangle(e.X,e.Y,e.Width,e.Height);
        Rectangle p = new Rectangle(player.X,player.Y,player.Width,player.Height);
    
        // Assuming there is an intersect method, otherwise just handcompare the values
        if (r.Intersects(p))
        {
           // A Collision!
           // we know which enemy (e), so we can call e.DoCollision();
           e.DoCollision();
        }
    }
    

    To speed things up, don't bother checking if the enemies coords are offscreen.

    0 讨论(0)
  • 2020-11-27 07:41

    No need to use rectangles ... compare the coordinates of 2 players constantly.

    like if(x1===x&&y1==y) remember to increase the range of x when ur comparing.

    if ur rectangle width is 30 take as if (x1>x&&x2>x+30)..likewise y

    0 讨论(0)
提交回复
热议问题