Question

我在舞台上有两个mc，第一个叫做导弹，第二个叫做盒子。

因此，我把盒子装在mc和导弹mc中的盒子里。我的问题是如何检测任何导弹是否与箱子碰撞并对箱子造成损坏。

我使用的是简单有效的算法，但是当舞台上有许多导弹和盒子时它非常慢。我使用两个嵌套的“for”循环，这是一个不好的做法，但我目前没有其他想法。

这是代码

public function onEnterFrame(e:Event) {
        for(var i:int=0;i<ground_mc.boxesLayer_mc.numChildren;i++){
            mc1=ground_mc.boxesLayer_mc.getChildAt(i);
            for(var j:int=0;j<ground_mc.bmLayer_mc.numChildren;j++){
                mc2=ground_mc.bmLayer_mc.getChildAt(j);
                if(mc1.hitTestObject(mc2)){
                    se=new SmallExplosion();
                    se.x=mc1.x+randNumber(-20,20);
                    se.y=mc1.y+randNumber(-20,20);
                    ground_mc.addChild(se);
                    mc1.decreaseHealth(mc2.getDamage());
                }
            }
        }

    }

boxesLayer_mc - box movieclip

bmLayer_mc - missiles movieclip

是否有其他技术可以解决此问题。我已经尝试在每个导弹中添加检测代码，但“for”也很慢。

也许树或哈希映射搜索我不知道？或者可能是图表：）

任何想法都会有所帮助

Answer 1

对于类似的任务（2D），我所做的是创建一个简单的四叉树构造，其中每个节点可以包含其他子节点或用于冲突检测的显示对象列表。请注意，如果对象（在您的情况下为方框）移动很多，这将不会有效，因为您需要在每次移动时将它们移动到正确的节点。

一个简单的示例类是：

public class WorldPartitionNode {
  private var minX : Number;
  private var minY : Number;
  private var maxX : Number;
  private var maxY : Number;
  private var width : Number;
  private var height : Number;

  private var _children : Vector.<WorldPartitionNode>;
  private var _objects : Vector.<GameObject>;

  public function WorldPartitionNode(x : Number, y : Number, 
        w : Number, h : Number, childLevels : int)
  {
    minX = x;
    minY = y;
    maxX = x + w;
    maxY = y + h;
    width = h;
    height = h;

    if (childLevels == 0) {
      // This node should have no children, so instead it should
      // contain display objects
      _objects = new Vector.<GameObject>;
    }
    else {
      _children = new Vector.<WorldPartitionNode>(4,true);
     _children[0] = new WorldPartitionTreeNode(minX, minY, width/2, height/2, childLevels-1);
     _children[1] = new WorldPartitionTreeNode(minX+width/2, minY, width/2, height/2, childLevels-1);
     _children[2] = new WorldPartitionTreeNode(minX, minY+height/2, width/2, height/2, childLevels-1);
     _children[3] = new WorldPartitionTreeNode(minX+width/2, minY+height/2, width/2, height/2, childLevels-1);
    }
  }


  public function addObject(obj : GameObject) : void
  {
    if (_children) {
      // This is not a leaf node, so add it to that of the child
      // nodes in which it belongs.
      var i : uint;
      for (i=0; i<4; i++) {
        var c : WorldPartitionNode = _children[i];
        if (obj.x > c.minX && obj.y > c.minY && obj.x < c.maxX && obj.y < c.maxY) {
          c.addObject(obj);
          return; // Found node, so bail
        }
      }
    }
    else {
      // This is a leaf node, so just add to the internal objects vector
      _objects.push(obj);
    }
  }

  public function checkCollisions(x : Number, y : Number) : GameObject
  {
    if (_children) {
       // This node has children, so delegate to the right child
      var i : uint;
      for (i=0; i<4; i++) {
        var c : WorldPartitionNode = _children[i];
        if (x > c.minX && y > c.minY && x < c.maxX && y < c.maxY) {
          return c.checkCollisions(x, y);
        }
      }           
    }
    else {
      // This is a leaf node (with objects directly in it) so loop through
      // them all and check collision
      var obj : GameObject;
      for each (obj in _objects) {
         if (obj.collidesWith(x, y))
            return obj;
      }

      return null; //None if reached
    }
  }
}

如果childLevels > 0，此类的实例将自身划分为四个矩形部分（两行，两列），并为每个节点创建相同类的实例。这些节点将依次以相同的方式划分它们的空间，直到总共有childLevels个级别。

您可以创建一个三级四叉树（具有64个分区叶节点），其中每个节点的大小仅为原始空间的1/64。当您使用addObject()添加对象时，对象将被添加到分区节点，该节点对应于它所在的方块。

执行checkCollision()时，它将递归childLevels次，直到找到正确的分区，然后仅为该分区中的对象执行常规的碰撞检测循环。

创建一个三层树，覆盖1024x1024像素的空间：

var treeRoot : WorldPartitionNode = new WorldPartitionNode(0, 0, 1024, 1024, 3);

检查导弹与树中物体之间的碰撞：

var missile : GameObject;
for each (missile in _missiles) {
  var obj : GameObject = treeRoot.checkCollisions(missile.x, missile.y);
  if (obj != null)
    obj.kill(); // Was hit by missile
}

这可能会显着加快碰撞检测，但依赖于静态（或很少移动）的框，因为如果它们移动它们将不再在正确的分区节点中，如果它们不是树将失败找到它们之间的碰撞。

毫无疑问，更智能的分区系统，但在我需要在大空间中分散拾取器（硬币等）以及玩家飞来飞去收集它们的项目中，这对我来说非常有效。。然后每个框架让树检查静态拾取器和播放器之间的碰撞。

Answer 2

最佳解决方案是使用一些物理引擎（如box2d）。使用游戏引擎（如pushButtonEngine）进行游戏开发更好:) 虽然，如果你想自己做，R-tree类似的结构是你的选择：）

Answer 3

每个使用一个更简洁的代码和更少的分配

同时将onEnterFrame更改为计时器事件，如果需要，可以减慢计时器事件的速度。

public function onEnterFrame(e:Event) {
  for each( var box:MovieClip in ground_mc.boxesLayer_mc ){
    for each(var missle:MovieClip in <ground_mc.bmLayer_mc ){
      if( box.hitTestObject(missle)){
        se=new SmallExplosion();
        se.x=box.x+randNumber(-20,20);
        se.y=box.y+randNumber(-20,20);
        ground_mc.addChild(se);
        box.decreaseHealth(missle.getDamage());
      }
    }
  }
}

优化AS3中的碰撞检测代码

3 个答案: