1

我使用以下函数将物理体附加到来自 SKTileMapNode 的图块上：

 static func addPhysicsBody(to tileMap: SKTileMapNode, and tileInfo: String){

    let tileSize = tileMap.tileSize
    let halfWidth = CGFloat(tileMap.numberOfColumns) / 2 * tileSize.width
    let halfHeight = CGFloat(tileMap.numberOfRows) / 2 * tileSize.height

    for row in 0..<tileMap.numberOfColumns{
        for column in 0..<tileMap.numberOfRows{
            let tileDefinition = tileMap.tileDefinition(atColumn: column, row: row)
            let isCorrectTile = tileDefinition?.userData?[tileInfo] as? Bool
            if isCorrectTile ?? false && tileInfo == "wall"{

                let x = CGFloat(column) * tileSize.width - halfWidth
                let y = CGFloat(row) * tileSize.height - halfHeight

                let tileNode = SKNode()
                tileNode.position = CGPoint(x: x, y: y)
                tileNode.physicsBody = SKPhysicsBody.init(rectangleOf: tileSize, center: CGPoint(x: tileSize.width / 2, y: tileSize.height / 2))
                tileNode.physicsBody!.isDynamic = false
                tileNode.physicsBody!.restitution = 0.0
                tileNode.physicsBody!.categoryBitMask = Constants.PhysicsCategories.wall
                tileNode.physicsBody!.collisionBitMask = Constants.PhysicsCategories.player | Constants.PhysicsCategories.npc | Constants.PhysicsCategories.enemy
                nodesForGraph.append(tileNode)
                tileMap.addChild(tileNode)
            }
        }
    }
}

但是，如果我使用它，我每个图块都有一个物理体。我想将物理体连接到更大的物理体以获得更好的性能。我知道这可以与init(bodies: [SKPhysicsBody]). 但我该怎么做呢？
我怎样才能找出哪个身体紧挨着另一个身体来对它们进行分组？
tileMap 中的物理体并非彼此相邻。有些是大块物理体，有些是单个物理体，旁边没有任何物体。所以我不能简单地将每个物理体放在一个数组中并将它们分组。
这是一张图片，显示了它目前的样子。

TileMap 物理

我希望解释足够清楚。如果没有，我会尝试更好地解释它。

有没有人这样做过并且可以指出我正确的方向？我将不胜感激任何帮助。

编辑：在我尝试这个之前： 

static var bodies = [SKPhysicsBody]()
static func addPhysicsBody(to tileMap: SKTileMapNode, and tileInfo: String){

    let tileSize = tileMap.tileSize
    let halfWidth = CGFloat(tileMap.numberOfColumns) / 2 * tileSize.width
    let halfHeight = CGFloat(tileMap.numberOfRows) / 2 * tileSize.height

    for column in 0..<tileMap.numberOfColumns{
        for row in 0..<tileMap.numberOfRows{
            let tileDefinition = tileMap.tileDefinition(atColumn: column, row: row)
            let isCorrectTile = tileDefinition?.userData?[tileInfo] as? Bool
            if isCorrectTile ?? false && tileInfo == "wall"{

                let x = CGFloat(column) * tileSize.width - halfWidth
                let y = CGFloat(row) * tileSize.height - halfHeight

                let tileNode = SKNode()
                tileNode.position = CGPoint(x: x, y: y)
                tileNode.physicsBody = SKPhysicsBody.init(rectangleOf: tileSize, center: CGPoint(x: tileSize.width / 2, y: tileSize.height / 2))
                tileNode.physicsBody!.isDynamic = false
                tileNode.physicsBody!.restitution = 0.0
                tileNode.physicsBody!.categoryBitMask = Constants.PhysicsCategories.wall
                tileNode.physicsBody!.collisionBitMask = Constants.PhysicsCategories.player | Constants.PhysicsCategories.npc | Constants.PhysicsCategories.enemy
                //nodesForGraph.append(tileNode)
                bodies.append(tileNode.physicsBody!)
                tileMap.addChild(tileNode)
            }
        }
    }
    tileMap.physicsBody = SKPhysicsBody(bodies: bodies)
}

但是当我这样做时，物理体完全搞砸了..

4

2 回答 2

3

我建议应用线扫描算法将图块合并在一起。

您可以分四个步骤完成此操作；

  1. 遍历 SKTileMap 中瓦片的位置。

  2. 找到彼此相邻的瓷砖。

  3. 对于每组相邻的瓷砖，收集：

    • 左下角坐标和
    • 一个直角坐标。

  4. 画一个正方形，然后移动到下一组瓷砖，直到你用完瓷砖坐标。

第一步：创建一个包含所有位置节点的数组。

func tilephysics() {

    let tilesize = tileMap.tileSize
    let halfwidth = CGFloat(tileMap.numberOfColumns) / 2.0 * tilesize.width
    let halfheight =  CGFloat(tileMap.numberOfRows) / 2.0 * tilesize.height

    for col in 0 ..< tileMap.numberOfColumns {

        for row in 0 ..< tileMap.numberOfRows {

            if (tileMap.tileDefinition(atColumn: col, row: row)?.userData?.value(forKey: "ground") != nil) {

                let tileDef = tileMap.tileDefinition(atColumn: col, row: row)!
                let tile = SKSpriteNode()

                let x = round(CGFloat(col) * tilesize.width - halfwidth + (tilesize.width / 2))
                let y = round(CGFloat(row) * tilesize.height - halfheight + (tilesize.height / 2))

                tile.position = CGPoint(x: x, y: y)
                tile.size = CGSize(width: tileDef.size.width, height: tileDef.size.height)

                tileArray.append(tile)
                tilePositionArray.append(tile.position)
            }
        }
    }
    algorithm()
}

第二步和第三步：找到相邻的瓦片，收集两个角坐标，并将它们添加到一个数组中：

var dir = [String]()
var pLoc = [CGPoint]()
var adT = [CGPoint]()

func algorithm(){

    let width = tileMap.tileSize.width
    let height = tileMap.tileSize.height
    let rWidth = 0.5 * width
    let rHeight = 0.5 * height

    var ti:Int = 0
    var ti2:Int = 0
    var id:Int = 0
    var dl:CGPoint = CGPoint(x: 0, y: 0)

    var tLE = [CGPoint]()
    var tRE = [CGPoint]()

    for t in tilePositionArray {

        if (ti-1 < 0) || (tilePositionArray[ti-1].y != tilePositionArray[ti].y - height) {

            dl = CGPoint(x: t.x - rWidth, y: t.y - rHeight)

        }

        if (ti+1 > tilePositionArray.count-1) {
            tLE.append(dl)

            tRE.append(CGPoint(x: t.x + rWidth, y: t.y + rHeight))

        } else if (tilePositionArray[ti+1].y != tilePositionArray[ti].y + height) {

            if let _ = tRE.first(where: {

                if $0 == CGPoint(x: t.x + rWidth - width, y: t.y + rHeight) {id = tRE.index(of: $0)!}

                return $0 == CGPoint(x: t.x + rWidth - width, y: t.y + rHeight)}) {

                if tLE[id].y == dl.y {

                    tRE[id] = CGPoint(x: t.x + rWidth, y: t.y + rHeight)

                } else {

                    tLE.append(dl)

                    tRE.append(CGPoint(x: t.x + rWidth, y: t.y + rHeight))

                }

            } else {

                tLE.append(dl)

                tRE.append(CGPoint(x: t.x + rWidth, y: t.y + rHeight))

            }

        }

        ti+=1

    }

第四步：画一个矩形，继续下一个形状：

for t in tLE {

        let size = CGSize(width: abs(t.x - tRE[ti2].x), height: abs(t.y - tRE[ti2].y))
        let loadnode = SKNode()

        loadnode.physicsBody = SKPhysicsBody(rectangleOf: size)
        loadnode.physicsBody?.isDynamic = false
        loadnode.physicsBody?.affectedByGravity = false
        loadnode.physicsBody?.restitution = 0

        loadnode.physicsBody?.categoryBitMask = 2

        loadnode.position.x = t.x + size.width / 2
        loadnode.position.y = t.y + size.height / 2

        scene.addChild(loadnode)

        ti2 += 1

    }
}

正确应用这些步骤，您应该会看到您的图块以大正方形合并在一起；像这样：

没有用于比较的视觉效果的屏幕截图

没有显示物理体的视觉效果的屏幕截图

解决这个问题我很开心。如果我帮助了你，请告诉我。我最近才开始编码并且正在寻找新的挑战。如果您有挑战或我可能参与的项目，请与我联系。

于 2019-06-14T18:42:06.950 回答
1

正如 Knight0fDragon 指出的那样，没有办法完全按照您的要求进行操作。不幸的是，SpriteKit 中的瓦片地图还有很多不足之处。但是你可以尝试这种技术来减少物理物体的数量。

想法 #1 - 手动绘制你的物理实体

在编辑器中创建您的瓦片地图。只需将您的瓷砖纹理绘制到地图上即可；不要为它们分配任何物理实体。然后继续在编辑器中将颜色精灵 ( SKSpriteNodes) 拖到需要物理实体的地图部分上。对节点进行整形，为需要物理体的区域制作最大的矩形。这最适用于大而平坦的表面，如墙壁、地板、天花板、平台、板条箱等。这很乏味，但与像自动将物体分配给所有瓷砖一样，模拟中的物理物体数量要少得多。

想法 #2 - 不使用物理实体

这个想法可能需要更多的工作，但你可以完全避免使用物理体。首先，在编辑器中创建您的瓦片地图。分析您的地图以确定哪些图块标记了障碍物，玩家不应越过该障碍物。将用户数据标识符分配给该类型的磁贴。对于不同类型的障碍，您需要不同类别的标识符，并且您可能还需要设计您的艺术品以适应这种方法。

一旦你的屏障瓷砖被充分识别，编写代码来检查玩家精灵当前占据的瓷砖的用户数据值，并相应地限制精灵的移动。例如，如果玩家输入一个标有上限的标题，您的移动代码将不允许玩家精灵向上移动。同样，如果玩家进入标记最左侧边界的图块，您的移动代码将不会让玩家向左移动。

你可以查看这个相关的帖子，我基本上提出了相同的想法。不幸的是，SpriteKit 的瓦片地图对于这个问题没有完美的解决方案。

于 2018-03-20T23:22:01.100 回答