Java 小程序中的碰撞检测帮助

Question

我正在制作一个飞扬的小鸟游戏，并且我正在尝试做出一个声明，如果它接触到两个管道中的一个，小鸟就会死亡。

这是我在“运行”方法中运行的碰撞代码。

    int appletsize_x = 800;
    int appletsize_y = 500;

    int x_pos = appletsize_x / 2;
    int y_pos = appletsize_y / 2;

    int x_pos2 = 100;
    int y_pos2 = -50;

    int x_pos6 = 100;
    int y_pos6 = 350;

      public void run ()
    {

            if (x_pos >= x_pos2
                    || (x_pos <= x_pos6))
            {
                collision = true;
                if (collision = true)
                {
                    startgame = false;
                }
            }
}

当然还有更多，我只是想知道如何对鸟和管道进行碰撞检测。

Answer 1

如果这些管道是线形的并且您知道它们的线公式（或至少是端点的坐标），那么您可以使用“到线的垂直距离”计算来了解它是否足够接近。

已经回答了：here

如果管道需要是一个复杂的形状，并且如果你对粒子模拟没问题，这里有一个非常简单、低效但易于使用的示例，它在一组可碰撞对象上构建一个对象并检查单个对象的碰撞对象（鸟）：

import java.util.ArrayList;
import java.util.List;


public class FactoryClass {

    public class CollidableResult
    {
        public Collidable c;
        public boolean yesItIs;
    }

    public class Collidable
    {
        public float x;
        public float y;
        public static final float tolerance=600.001f; 
        public Collidable()
        {
            //just giving random starting coordinates for fun
            // so the object may not be a pipe with these. Please add some parameters
            // for your needs
            x=(float) (Math.random()*1000.0);
            y=(float) (Math.random()*1000.0);         
        }
        public CollidableResult isTooClose(Collidable c)
        {
            float deltax=(c.x - this.x);
            float deltay=(c.y - this.y);
            // checks if close enough
            if(Math.sqrt(deltax*deltax + deltay*deltay)<tolerance) 
            {
                CollidableResult cr=new CollidableResult();
                cr.yesItIs=true;
                cr.c=this;
                return cr;              
            }
            else
            {
                CollidableResult cr=new CollidableResult();
                cr.yesItIs=false;
                cr.c=null;
                return cr;   
            }
        }

        public List<Collidable> collide(List<Collidable> cl)
        {
            List<Collidable> c=new ArrayList<Collidable>();
            for(Collidable co:cl)
            {
                if(this.isTooClose(co).yesItIs)
                {
                    c.add(co);
                }
            }
            return c;       
        }
        public void die()
        {
            // AnimateDead();
            try {this.finalize();} catch (Throwable e) {e.printStackTrace();}
            System.gc();        
        }
        public void levelUp()
        { 
            System.out.println("Level Up! Hit points incremented by 12.");  
        }

    }

    public static void main(String[] args) {
        FactoryClass factory=new FactoryClass();
        List<Collidable> pointsOfAPipe = new ArrayList<Collidable>();
        pointsOfAPipe.add(factory.new Collidable(/*parameters for pipe */));
        pointsOfAPipe.add(factory.new Collidable(/*parameters for pipe */));
        pointsOfAPipe.add(factory.new Collidable(/*parameters for pipe */));
        //...
        // build your pipe object using many colllidable points (can build complex shapes with this)
        //...
        pointsOfAPipe.add(factory.new Collidable(/*parameters for pipe */));
        pointsOfAPipe.add(factory.new Collidable(/*parameters for pipe */));
        pointsOfAPipe.add(factory.new Collidable(/*parameters for pipe */));

        Collidable bird=factory.new Collidable();
        bird.x=100;
        bird.y=350;
        List<Collidable> collisionPoints = bird.collide(pointsOfAPipe);
        if(collisionPoints.size()>0)
        {
            System.out.println("Bird collides pipe on "+collisionPoints.size()+" different points and dies");
            bird.die();
        }
        else {System.out.println("Bird survived");bird.levelUp();}  
    }   
}

大多数时候，我的输出是：

Bird collides pipe on 4 different points and dies

您可以添加另一个集成不同集合的类，以制作更复杂的场景，例如安装在宇宙飞船上的旋转炮塔，发射光束以切割管道，甚至碰撞其他宇宙飞船和鸟类。