我正在用java制作一个简单的基于物理的游戏,我一直在实现碰撞检测方法。我有几个类,它们继承自一个comman基类形状。我将所有可见对象存储在形状类的数组列表中。我为物体的每一次可能的碰撞创建了几种碰撞检测方法。当我开始实现这些方法时,我得到了这样的代码:
private void collision_detector(Shape s1,Shape s2){
if(s1.getClass()==Ball.class)
if(s2.getClass() == Block.class) collision_detector((Ball)s1,(Block)s2);
else collision_detector((Ball)s1,(Ball)s2);
else if(s1.getClass()==Block.class)
if(s2.getClass()==Block.class) collision_detector((Block)s1,(Block)s2);
else collision_detector((Ball)s2,(Block)s1);
}
这感觉不是实现碰撞检测的正确方法,因为每次添加三角形或六边形等新形状时,我都必须更新这个方法来检查每一个可能的组合。我对访客模式有点了解。但是有更好的方法吗?
如果您不介意将碰撞检测代码放入对象本身,您可以通过执行以下操作来消除检查的一侧:
public abstract class Shape {
public abstract boolean collidesWith (Shape s);
}
public class Ball extends Shape {
@Override public boolean collidesWith (Shape s) {
if (s instanceof Block)
return Collision.blockBall((Block)s, this);
else if (s instanceof Ball)
return Collision.ballBall(this, (Ball)s);
else
return false;
}
}
public class Block extends Shape {
@Override public boolean collidesWith (Shape s) {
if (s instanceof Block)
return Collision.blockBlock(this, (Block)s);
else if (s instanceof Ball)
return Collision.blockBall(this, (Ball)s);
else
return false;
}
}
public class Collision {
public static boolean blockBlock (Block a, Block b) { ... }
public static boolean blockBall (Block a, Ball b) { ... }
public static boolean ballBall (Ball a, Ball b) { ... }
}
这也让你可以在必要时为形状本身中的某些形状组合实现碰撞算法——你甚至可以消除碰撞,只需制作例如Block.collideWithBall、Block.colliedWithBlock和Ball.collideWithBlock,并酌情调用它们,例如:
public abstract class Shape {
public abstract boolean collidesWith (Shape s);
}
public class Ball extends Shape {
@Override public boolean collidesWith (Shape s) {
if (s instanceof Block)
return collidesWithBlock((Block)s);
else if (s instanceof Ball)
return collidesWithBall((Ball)s);
else
return false;
}
public boolean collidesWithBall (Ball b) {
...
}
public boolean collidesWithBlock (Block b) {
...
}
}
public class Block extends Shape {
@Override public boolean collidesWith (Shape s) {
if (s instanceof Block)
return collidesWithBlock((Block)s);
else if (s instanceof Ball)
return ((Ball)s).collidesWithBlock(this);
else
return false;
}
public boolean collidesWithBlock (Block b) {
...
}
}
就我个人而言,我更喜欢后者,因为它将冲突代码包含在相关的类中。请注意,Block.collidesWithBall是不必要的,因为可以使用Ball.collidesWithBlock。
每次添加新形状时,仍然需要更新以上代码。如果性能不是问题,你也可以这样做:
public abstract class CollisionAlgorithm {
public abstract boolean canCollide (Class<? extends Shape> a, Class<? extends Shape> b);
public abstract boolean collide (Shape a, Shape b);
}
public class Collider {
private static final List<CollisionAlgorithm> algorithms;
public static void registerAlgorithm (CollisionAlgorithm a) {
algorithms.append(a);
}
public static CollisionAlgorithm findAlgorithm (Class<? extends Shape> a, Class<? extends Shape> b) {
for (CollisionAlgorithm algo : algorithms)
if (algo.canCollide(a, b))
return algo;
return null;
}
public static boolean collide (Shape a, Shape b) {
if (a == null || b == null)
return false;
CollisionAlgorithm algo = findAlgorithm(a.getClass(), b.getClass());
if (algo != null)
return algo.collide(a, b);
algo = findAlgorithm(b.getClass(), a.getClass()); // try swapped order
if (algo != null)
return algo.collide(b, a);
return false;
}
}
// usage: first register algorithms
Collider.registerAlgorithm(new BallBallAlgorithm());
Collider.registerAlgorithm(new BallBlockAlgorithm());
Collider.registerAlgorithm(new BlockBlockAlgorithm());
// then
Shape myShape1 = ...;
Shape myShape2 = ...;
boolean collide = Collider.collide(myShape1, myShape2);
请注意:我很快在这里输入了这个,它旨在说明一个概念——可以进行许多改进例如,映射可以与两个Shape类一起使用,作为提高性能的关键,或者可以为CollisionAlgorithm提供通用参数,以消除铸造Shapes的需要。不过,请记住,每次需要执行碰撞测试时,这种方法都需要在算法容器中进行查找。