我正在编写一个 2d 物理引擎来娱乐。
我为不同的形状编写了不同的类,BoxObject
是一个矩形,BallObject
是一个圆形,LineObject
是一条直线。所有这些都实现了PhysicsObject
接口(interface)。
正在模拟的所有对象都驻留在一个列表中。
public static List<PhysicsObject> objects = new ArrayList<PhysicsObject>();
所有这些对象都需要检查是否相互碰撞。
Collision
类包含名为 penetrationData
的方法,用于获取所有可能类型对的穿透数据,例如penetrationData(BoxObject a, BallObject b)
和 penetrationData(BallObject a, LineObject b)
等。如下所示。
package com.optimus.game.physics;
public class Collision {
// Default - no collision
public static float[] penetrationData(PhysicsObject a, PhysicsObject b) {
return null;
}
// Line vs Circle
public static float[] penetrationData(LineObject line, BallObject ball) {
float distance = line.distance(ball.x, ball.y);
if (Math.abs(distance) > ball.radius) {
return null;
}
float penetration = ball.radius - Math.abs(distance);
float normalX = line.perpendicularX();
float normalY = line.perpendicularY();
return new float[] {normalX, normalY, penetration};
}
// Circle vs Line
public static float[] penetrationData(BallObject ball, LineObject line) {
float[] data = penetrationData(line, ball);
// reverse the normal
if (data != null) {
data[0] = -data[0];
data[1] = -data[1];
}
return data;
}
// Circle vs Circle
public static float[] penetrationData(BallObject a, BallObject b) {
// Vector from A to B
float normalX = b.x - a.x;
float normalY = b.y - a.y;
float penetration = 0;
// calculate the penetration and normal direction
// ...
// ... (code skipped)
return new float[] {normalX, normalY, penetration};
}
// Rect vs Rect
public static float[] penetrationData(BoxObject a, BoxObject b) {
// Vector from A to B
float normalX = b.x - a.x;
float normalY = b.y - a.y;
float penetration = 0;
// calculate the penetration and normal direction
// ...
// ... (code skipped)
return new float[] {normalX, normalY, penetration};
}
// Rect vs Circle
public static float[] penetrationData(BoxObject box, BallObject ball) {
// Vector from A to B
float normalX = ball.x - (box.x + box.width / 2f);
float normalY = ball.y - (box.y + box.height / 2f);
float penetration = 0;
// calculate the penetration and normal direction
// ...
// ... (code skipped)
return new float[] {normalX, normalY, penetration};
}
// Circle vs Rect
public static float[] penetrationData(BallObject ball, BoxObject box) {
float[] data = penetrationData(box, ball);
// reverse the normal
if (data != null) {
data[0] = -data[0];
data[1] = -data[1];
}
return data;
}
}
我会检查碰撞情况,例如...
public static void checkAndResolveCollisions(List<PhysicsObject> objects) {
// check collision between all objects in a list
// list of objects can contain BallObject, LineObject and
// BoxObject all of which implement PhysicsObject
// loop over all possible pairs
for (int i = 0; i < objects.size(); i++) {
for (int j = i + 1; j < objects.size(); j++) {
// here I want that apt function is called based on type
// but objects.get(int i) always returns a PhysicsObject
float[] data = Collision.penetrationData(objects.get(i), objects.get(j));
// data = null implies no overlap
if (data == null) {
continue;
}
// Calculate relative velocity in terms of the normal direction
float normalX = data[0];
float normalY = data[1];
float penetration = data[2];
// Resolve the collision along the normal
// ...
// ... (code skipped)
}
}
}
但是它不起作用,penetrationData
每次都返回 null
...
如果我得到这样的渗透数据,那么有效的是,但是这段代码很糟糕,我只要看看它就可以知道......
// here is what works, but I know is bad java code
float[] data = getAptPenetrationData(objects.get(i), objects.get(j));
其中getAptPenetrationData
是一个通用函数,它进行类型转换然后调用apt函数
// generic function that calls others
public static float[] getAptPenetrationData(PhysicsObject a, PhysicsObject b) {
// bad java code...
boolean aIsBall = a instanceof BallObject;
boolean aIsBox = a instanceof BoxObject;
boolean aIsLine = a instanceof LineObject;
boolean bIsBall = b instanceof BallObject;
boolean bIsBox = b instanceof BoxObject;
boolean bIsLine = b instanceof LineObject;
float[] data = null;
// circle vs circle
if (aIsBall && bIsBall) {
data = Collision.penetrationData((BallObject)a, (BallObject)b);
// box vs box
} else if (aIsBox && bIsBox) {
data = Collision.penetrationData((BoxObject)a, (BoxObject)b);
// box vs circle
} else if (aIsBox && bIsBall) {
data = Collision.penetrationData((BoxObject)a, (BallObject)b);
// circle vs box
} else if (aIsBall && bIsBox) {
data = Collision.penetrationData((BallObject)a, (BoxObject)b);
// circle vs line
} else if (aIsBall && bIsLine) {
data = Collision.penetrationData((BallObject)a, (LineObject)b);
// line vs circle
} else if (aIsLine && bIsBall) {
data = Collision.penetrationData((LineObject)a, (BallObject)b);
}
return data;
}
我一定错过了一些东西,并且一定有更好的方法来完成我想做的事情。任何帮助表示赞赏。谢谢。
编辑:
根据Zim-Zam的建议,现在碰撞是这样解决的...
public static void checkAndResolveCollisions(List<PhysicsObject> objects) {
// check collision between all objects in a list
// list of objects can contain BallObject, LineObject and
// BoxObject all of which implement PhysicsObject
// loop over all possible pairs
for (int i = 0; i < objects.size(); i++) {
for (int j = i + 1; j < objects.size(); j++) {
// does not work, goes into infinite recursion
// still calls PhysicsObject.penetrationData(PhysicsObject)
float[] data = objects.get(i).penetrationData(objects.get(j));
// data = null implies no overlap
if (data == null) {
continue;
}
// Calculate relative velocity in terms of the normal direction
float normalX = data[0];
float normalY = data[1];
float penetration = data[2];
// Resolve the collision along the normal
// ...
// ... (code skipped)
}
}
}
但只有当我将以下方法签名添加到 PhysicsObject
接口(interface)时它才有效
public PenetrationData penetrationData(PhysicsObject other);
public PenetrationData penetrationData(BallObject other);
public PenetrationData penetrationData(BoxObject other);
public PenetrationData penetrationData(LineObject other);
这仍然不理想,因为每次我实现新的 PhysicsObject
时,我都必须更改接口(interface)。
PhysicsObject 实现(仅限 penetrationData
函数)-
BallObject.java
public class BallObject implements PhysicsObject {
@Override
public float[] penetrationData(PhysicsObject other) {
return other.penetrationData(this);
}
@Override
public float[] penetrationData(LineObject line) {
return Collision.penetrationData(this, line);
}
@Override
public float[] penetrationData(BoxObject box) {
return Collision.penetrationData(this, box);
}
@Override
public float[] penetrationData(BallObject ball) {
return Collision.penetrationData(this, ball);
}
// ... rest of the code
}
BoxObject.java
public class BoxObject implements PhysicsObject {
@Override
public float[] penetrationData(PhysicsObject other) {
return other.penetrationData(this);
}
@Override
public float[] penetrationData(LineObject line) {
return null; // not implemented
}
@Override
public float[] penetrationData(BoxObject box) {
return Collision.penetrationData(this, box);
}
@Override
public float[] penetrationData(BallObject ball) {
return Collision.penetrationData(this, ball);
}
// ... rest of the code
}
LineObject.java
public class LineObject implements PhysicsObject {
@Override
public float[] penetrationData(PhysicsObject other) {
return other.penetrationData(this);
}
@Override
public float[] penetrationData(LineObject line) {
return null; // not implemented
}
@Override
public float[] penetrationData(BoxObject box) {
return null; // not implemented
}
@Override
public float[] penetrationData(BallObject ball) {
return Collision.penetrationData(this, ball);
}
// ... rest of the code
}
最佳答案
正如已经指出的,您需要双重调度。但是,我不建议使用重量级且充满样板的访问者模式。您应该用 Java 实现您自己的调度系统。例如,构建从对象对到渗透数据计算器的映射。然后,您将拥有大量的 map.put()
,而不是大量的 instanceof
。您甚至可以通过使用 varargs 方法来避免重复 put
,该方法可用于伪造 map 文字:
static Map<ObjPair, CollisionCalc> map(Object... kvs) {
final Map<ObjPair, CollisionCalc> ret = new HashMap<>();
for (int i = 0;;i < kvs.length)
ret.put((ObjPair)kvs[i++], (CollisionCalc)kvs[i++]);
return ret;
}
在客户端,这应该如下所示:
public static float[] penetrationData(PhyObject o1, PhyObject o2) {
return map.get(new ObjPair(o1, o2)).penetrationData(o1, o2);
}
关于java - 根据对象的类型调用适当的函数,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/17262017/