第三章 — 赋予生命

放置

现在我们在屏幕上有一个新的小行星，让我们设置它的原点。在我们的游戏中，小行星将来自屏幕的左侧、右侧或顶部 - 小行星从后面偷偷靠近是不公平的！

鉴于三个可能的原点，我们需要 Lua 生成一个介于 1 和 3 之间的随机整数。使用只有一个参数 3 的 math.random() 命令可以轻松完成此操作

    local newAsteroid = display.newImageRect( mainGroup, objectSheet, 1, 102, 85 )
    table.insert( asteroidsTable, newAsteroid )
    physics.addBody( newAsteroid, "dynamic", { radius=40, bounce=0.8 } )
    newAsteroid.myName = "asteroid"

    local whereFrom = math.random( 3 )
end

执行此命令后，局部变量 whereFrom 的值将为 1、2 或 3。使用它，我们可以实现一个条件if-then结构来处理这三种情况。在 Lua 中，该结构以这种基本形式开始

    local whereFrom = math.random( 3 )

    if ( whereFrom == 1 ) then

    end
end

让我们使用第一个条件，whereFrom == 1,将小行星放置在屏幕**左侧**边缘稍微偏离的位置。插入三行，使您的条件块如下所示

    if ( whereFrom == 1 ) then
        -- From the left
        newAsteroid.x = -60
        newAsteroid.y = math.random( 500 )
    end
end

由于这颗小行星将来自左侧，因此我们将其 x 属性设置为 -60。这应该足以确保在小行星首次创建时，即使是小行星的一部分对玩家也不可见（它完全在屏幕外）。至于 y 属性，我们再次使用 math.random() 在 1 和 500 之间随机选择一个值，有效地使小行星出现在内容区域顶部和向下大约一半距离之间的某个位置——毕竟，我们不希望任何小行星来自无法射击它们的地方！

移动

现在我们有了起点，我们需要告诉小行星它应该移动到哪里。这次我们将使用另一个物理命令：object:setLinearVelocity()。此命令类似于我们在上一个项目中使用的 object:applyLinearImpulse() 命令，但它不是对对象施加突然的“推力”，而是简单地设置对象以稳定、一致的方向移动。

在上一行之后直接添加突出显示的行

    if ( whereFrom == 1 ) then
        -- From the left
        newAsteroid.x = -60
        newAsteroid.y = math.random( 500 )
        newAsteroid:setLinearVelocity( math.random( 40,120 ), math.random( 20,60 ) )
    end
end

这可能看起来很复杂，但 object:setLinearVelocity() 只需要两个数字，分别表示**x** 和 **y** 方向上的速度。我们在这里使用的唯一技巧是 math.random() 来随机化这些值，以便每个小行星都以略微不同的方向移动。

如果我们决定现在调用/运行此函数，我们可能会看到一颗小行星从左侧缓慢地穿过屏幕，但也可能不会。为什么？因为我们还没有为屏幕的另外两侧添加条件情况！请记住，Lua 会在 1 和 3 之间随机选择一个数字，但目前我们只处理 1 的情况，因此我们当前的代码只有 ⅓ 的机会生成小行星。

以下两个条件将完成小行星可以起源的三个可能侧面。将多个条件添加到同一个if-then结构中时，第一个条件之后的条件应以 elseif 开头，而**不是**以 if 开头。观察这些添加

    if ( whereFrom == 1 ) then
        -- From the left
        newAsteroid.x = -60
        newAsteroid.y = math.random( 500 )
        newAsteroid:setLinearVelocity( math.random( 40,120 ), math.random( 20,60 ) )
    elseif ( whereFrom == 2 ) then
        -- From the top
        newAsteroid.x = math.random( display.contentWidth )
        newAsteroid.y = -60
        newAsteroid:setLinearVelocity( math.random( -40,40 ), math.random( 40,120 ) )
    elseif ( whereFrom == 3 ) then
        -- From the right
        newAsteroid.x = display.contentWidth + 60
        newAsteroid.y = math.random( 500 )
        newAsteroid:setLinearVelocity( math.random( -120,-40 ), math.random( 20,60 ) )
    end
end

有了这些行，所有三个条件都得到了妥善处理。现在，当调用/运行此函数时，小行星将随机出现在三个指定区域之一中，并开始在屏幕上移动。

旋转

让我们用一个附加命令来结束 createAsteroid() 函数，以增加视觉趣味。为了使小行星在太空中移动时围绕其中心点缓慢旋转，我们可以应用随机量的扭矩（旋转力）。在if-then结构之后（在其结束 end 语句之后），添加以下突出显示的命令

    elseif ( whereFrom == 3 ) then
        -- From the right
        newAsteroid.x = display.contentWidth + 60
        newAsteroid.y = math.random( 500 )
        newAsteroid:setLinearVelocity( math.random( -120,-40 ), math.random( 20,60 ) )
    end

    newAsteroid:applyTorque( math.random( -6,6 ) )
end

放置

新的激光对象现已加载，但我们尚未正确定位它。在这种情况下，我们不能使用静态位置，因为飞船最终将通过玩家的控制左右移动。幸运的是，通过将其 x 和 y 值设置为飞船的 x 和 y 值，可以很容易地将新激光定位在与飞船完全相同的位置

local function fireLaser()

    local newLaser = display.newImageRect( mainGroup, objectSheet, 5, 14, 40 )
    physics.addBody( newLaser, "dynamic", { isSensor=true } )
    newLaser.isBullet = true
    newLaser.myName = "laser"

    newLaser.x = ship.x
    newLaser.y = ship.y
end

这将水平和垂直正确定位激光，但还有一个问题需要解决。因为此函数在飞船加载**之后**创建新的激光，并且两个对象都是 mainGroup 显示组的一部分，所以在分层方面，激光将在视觉上出现在飞船上方（前面）。显然这看起来很傻，所以让我们用以下突出显示的命令将它推到飞船后面

    newLaser.x = ship.x
    newLaser.y = ship.y
    newLaser:toBack()
end

移动

如前所述，我们将使用**过渡**将激光向上移动到屏幕上。大多数过渡都是使用 transition.to() 命令执行的。在其最简单的形式中，此命令接受一个对象引用（例如激光）和一个参数表，这些参数将在指定的时间内更改。

将以下突出显示的行添加到 fireLaser() 函数中

    newLaser.x = ship.x
    newLaser.y = ship.y
    newLaser:toBack()

    transition.to( newLaser, { y=-40, time=500, } )
end

如您所见，第一个参数是要进行过渡的对象 (newLaser)。对于第二个参数，我们包含一个表格，其中可以包含过渡的各种属性。这里，我们设置 y=-40，表示激光的垂直目标位置，略微超出屏幕的上边缘。我们还设置了一个自定义的 time 参数为 500。对于过渡，时间（持续时间）应始终以毫秒为单位指定 — 请记住 1 秒等于 1000 毫秒，因此此过渡将在 ½ 秒内完成。

清理

太好了！新的激光现在将正确地出现在与飞船相同的位置（视觉上也在其后面），并在屏幕上向上移动。只剩下最后一件事要实现了，而且这非常重要：清理。在任何应用程序中，从游戏中移除不再需要的对象至关重要。如果不这样做，应用程序最终会变得非常缓慢，耗尽内存并崩溃 — 这对玩家来说可不是什么好体验！

清理的方法有很多种，具体取决于情况。对于激光，我们将使用一种非常方便的方法，称为 onComplete 回调。作为 transition.to() 和其他几个命令中的一个选项，它告诉 Solar2D 您希望在某些事情“完成”时调用一个函数。这非常适合移除已完成过渡的激光，因此让我们扩展 transition.to() 命令以包含一个 onComplete 回调。

    newLaser.x = ship.x
    newLaser.y = ship.y
    newLaser:toBack()

    transition.to( newLaser, { y=-40, time=500,
        onComplete = function() display.remove( newLaser ) end
    } )
end

简单地说，此添加会在过渡完成时运行一个函数。在函数内部，我们唯一需要的命令是 display.remove( newLaser )，它会从舞台上移除激光对象。除此之外，Lua 的内置的垃圾收集过程将自动释放分配给该对象的内存。

点击监听器

我们快完成射击机制了 — 让我们通过为飞船分配一个 "tap" 事件监听器来结束，这样玩家就可以实际发射激光了。在 fireLaser() 函数之后（在其结束 end 语句之后），添加以下命令：

    transition.to( newLaser, { y=-40, time=500,
        onComplete = function() display.remove( newLaser ) end
    } )
end

ship:addEventListener( "tap", fireLaser )

触摸事件

触摸事件与点击事件不同，它根据用户触摸的状态有四个不同的阶段：

• "began" — 表示触摸已在对象上开始（屏幕上的初始触摸）。
• "moved" — 表示触摸位置已在对象上移动。
• "ended" — 表示触摸已在对象上结束（从屏幕上抬起触摸）。
• "cancelled" — 表示系统取消了对触摸的跟踪（不要与 "ended" 混淆）。

为了方便起见，让我们在本地设置触摸事件的阶段 (event.phase)：

local function dragShip( event )

    local ship = event.target
    local phase = event.phase
end

通过在本地设置阶段，我们可以使用if-then结构来检查实际触摸事件处于哪个阶段。如果它刚刚开始（飞船上的初始触摸），则 "began" 阶段将分派给我们的函数。在这种条件下，我们将触摸焦点设置在飞船上 — 本质上，这意味着飞船对象将在整个持续时间内“拥有”触摸事件。当焦点在飞船上时，游戏中的其他对象将不会检测到来自此特定触摸的事件。

local function dragShip( event )

    local ship = event.target
    local phase = event.phase

    if ( "began" == phase ) then
        -- Set touch focus on the ship
        display.currentStage:setFocus( ship )
    end
end

紧接着，让我们存储触摸相对于飞船的起始“偏移”位置。从概念上讲，如此处所示，触摸可以发生在对象边界内的各个位置。在我们的代码中，event.x - ship.x为我们提供了屏幕上确切触摸点 (event.x) 与飞船x 位置 (ship.x) 之间的水平偏移量。我们将其设置为飞船的一个属性 (touchOffsetX)，以便在下一阶段使用。

    if ( "began" == phase ) then
        -- Set touch focus on the ship
        display.currentStage:setFocus( ship )
        -- Store initial offset position
        ship.touchOffsetX = event.x - ship.x
    end
end

对于 "moved" 阶段（您可以猜到），我们移动飞船！这只需设置飞船的x 位置即可完成，但请仔细观察 — 这就是我们的 touchOffsetX 属性发挥作用的地方。如果我们忽略此偏移量并简单地将飞船的x 位置设置为 event.x，则其中轴将跳到屏幕上的确切触摸点，并且如上图所示，飞船边界内的触摸点可能不完全位于中心。幸运的是，将偏移值考虑在内将产生平滑、一致的拖动效果。

    if ( "began" == phase ) then
        -- Set touch focus on the ship
        display.currentStage:setFocus( ship )
        -- Store initial offset position
        ship.touchOffsetX = event.x - ship.x

    elseif ( "moved" == phase ) then
        -- Move the ship to the new touch position
        ship.x = event.x - ship.touchOffsetX
    end
end

-- Store initial offset position
ship.touchOffsetX = event.x - ship.x
ship.touchOffsetY = event.y - ship.y

-- Move the ship to the new touch position
ship.x = event.x - ship.touchOffsetX
ship.y = event.y - ship.touchOffsetY

最终的条件情况包括 "ended" 和 "cancelled" 阶段。"ended" 阶段表示用户释放了对对象的触摸，而 "cancelled" 阶段表示系统取消/终止了触摸事件。通常，这两个阶段都可以在同一个条件块中处理。对于这个游戏，我们只需释放飞船上的触摸焦点：

    elseif ( "moved" == phase ) then
        -- Move the ship to the new touch position
        ship.x = event.x - ship.touchOffsetX

    elseif ( "ended" == phase or "cancelled" == phase ) then
        -- Release touch focus on the ship
        display.currentStage:setFocus( nil )
    end
end

让我们用另一个命令完成 dragShip() 触摸监听器函数：

    elseif ( "ended" == phase or "cancelled" == phase ) then
        -- Release touch focus on the ship
        display.currentStage:setFocus( nil )
    end

    return true  -- Prevents touch propagation to underlying objects
end

正如注释所示，这个简短但重要的命令告诉 Solar2D 触摸事件应该在此对象上“停止”并且不传播到底层对象。这在您可能有多个具有触摸事件检测的重叠对象的更复杂的应用程序中至关重要。添加return true在触摸侦听器函数的末尾可以防止潜在的（通常是不可取的）触摸传播。

触摸监听器

我们快完成移动机制了 — 让我们为飞船分配一个 "touch" 事件监听器，以便玩家可以左右触摸/拖动它。在 dragShip() 函数之后（在其结束 end 语句之后），添加以下命令：

    return true  -- Prevents touch propagation to underlying objects
end

ship:addEventListener( "touch", dragShip )

小行星清理

对于此游戏，让我们通过循环遍历 asteroidsTable 表格来移除已经漂移到屏幕外的小行星。还记得我们何时将此表格声明为存储每个小行星的引用的地方吗？当时它可能看起来不相关，但现在它完全发挥作用了！

要循环遍历表格，我们将使用 Lua for 循环。本质上，for 循环允许我们使用索引变量从起始数字到结束数字向上或向下计数。

将以下突出显示的命令添加到您的 gameLoop() 函数中：

local function gameLoop()

    -- Create new asteroid
    createAsteroid()

    -- Remove asteroids which have drifted off screen
    for i = #asteroidsTable, 1, -1 do

    end
end

在这种情况下，我们需要从 asteroidsTable 表格中的小行星数量开始倒计时（递减），但有一个小问题：随着新小行星的创建和玩家摧毁其他小行星，数量会不断变化.幸运的是，Lua 提供了一种方便的方法来计算表格中元素的数量，只需在表格名称前面加上 # 即可完成：

#asteroidsTable

如您所见，我们在 for 循环中使用了这种方法，它采用指示的形式 — 基本上，Lua 使用索引 i，从 #asteroidsTable 开始，在 1 停止，并且以 -1 计数（递减）。

在 for 循环内部，我们必须包含每次循环迭代时都应处理的代码。如果表格中有十个小行星，则循环将迭代十次。如果表格中只有一个小行星，它将迭代一次.

将以下突出显示的行添加到 for 循环内部：

    -- Remove asteroids which have drifted off screen
    for i = #asteroidsTable, 1, -1 do
        local thisAsteroid = asteroidsTable[i]

        if ( thisAsteroid.x < -100 or
             thisAsteroid.x > display.contentWidth + 100 or
             thisAsteroid.y < -100 or
             thisAsteroid.y > display.contentHeight + 100 )
        then
            display.remove( thisAsteroid )
            table.remove( asteroidsTable, i )
        end
    end
end

让我们更详细地研究这些命令：

• 对于循环的每次迭代，我们首先声明对循环在该特定迭代中引用的一个小行星的局部引用：

local thisAsteroid = asteroidsTable[i]

• 下一个块是一个多条件语句，用于检查在循环迭代期间引用的 小行星的位置。基本上，使用此语句，我们通过检查其 x 和 y 属性来检查小行星是否已大幅偏离屏幕的任何边缘：

if ( thisAsteroid.x < -100 or
    thisAsteroid.x > display.contentWidth + 100 or
    thisAsteroid.y < -100 or
    thisAsteroid.y > display.contentHeight + 100 )
then

• 如果满足以下四个条件中的任何一个，我们将执行两个重要操作

display.remove( thisAsteroid )

table.remove( asteroidsTable, i )

这样就完成了我们的小行星清理工作！基本上，在游戏循环的每次迭代中，我们使用 for 循环检查已经大幅漂移到屏幕边界之外的小行星。然后，将每个“失效”的小行星从屏幕**和** asteroidsTable 存储表中移除，从而保持小行星总数和内存使用量较低。

循环计时器

尽管您可能将游戏循环想象成在应用程序运行时的每一帧（高达每秒 60 次）更新的代码/功能，但这对每个应用程序来说并不一定都是正确的。因为我们的游戏循环是一个标准函数，所以我们可以完全控制它运行的频率和时间。

有几种不同的方法可以重复运行游戏循环函数。在这个游戏中，我们显然不想每秒生成 60 个新的小行星，而且也不需要经常执行清理任务。因此，我们将实现一个**重复计时器**。

紧跟在 gameLoop() 函数之后（在其结束 end 语句之后），添加以下命令

            display.remove( thisAsteroid )
            table.remove( asteroidsTable, i )
        end
    end
end

gameLoopTimer = timer.performWithDelay( 500, gameLoop, 0 )

让我们剖析一下这一行

1. 首先，我们声明 gameLoopTimer 占位符变量（先前已声明）将与我们的计时器关联。这允许我们在以后需要时使用该变量作为暂停或取消计时器的引用/句柄。

2. 接下来，我们调用 timer.performWithDelay()。这个便捷的命令告诉 Solar2D 在指定的毫秒数后执行某些操作。计时器对各种游戏功能都很有用，所以请熟悉它们！

3. 在括号内，我们首先输入计时器触发之前要等待的毫秒数（延迟）。这里我们使用 500，这恰好是半秒，但您可以尝试其他值。像 250 这样的较低数字会使小行星生成更快并增加游戏的难度，但不要将此值设置得太低，否则小行星会生成太快并挤满屏幕。

4. 下一个参数是计时器触发时将被调用/运行的函数。显然，我们在这里指定 gameLoop。

5. 最后，我们包含可选的**迭代次数**参数，其值为 0。如果省略此参数，计时器将只触发一次然后停止。如果您包含此参数，计时器将重复该迭代次数，但不要被这种情况下的 0 所迷惑——我们**不是**告诉计时器“运行零次”而是永远重复。基本上，传递 0 或 -1 将导致计时器无限期地重复（除非我们告诉它暂停/停止）。

恢复飞船

在我们进入碰撞处理之前，我们需要一个函数，可以在飞船与小行星碰撞后调用该函数来恢复飞船。在我们的游戏中，我们将模仿经典的街机游戏，在新飞船淡入视野时，它会暂时无敌——毕竟，让玩家在没有机会躲避 incoming 小行星的情况下连续死亡是不公平的！

在您已经编写的代码之后，添加以下突出显示的函数

gameLoopTimer = timer.performWithDelay( 500, gameLoop, 0 )


local function restoreShip()

    ship.isBodyActive = false
    ship.x = display.contentCenterX
    ship.y = display.contentHeight - 100

    -- Fade in the ship
    transition.to( ship, { alpha=1, time=4000,
        onComplete = function()
            ship.isBodyActive = true
            died = false
        end
    } )
end

让我们检查一下这个函数的内容

1. 第一个命令，ship.isBodyActive = false，有效地将飞船从物理模拟中移除，使其停止与其他物体交互。我们这样做（暂时）是为了让飞船在淡回视野时，碰撞的小行星不会触发另一个碰撞响应。

2. 接下来的两行只是将飞船重新定位在底部中心屏幕。

3. 最后一个命令现在可能没有完全理解，但在我们进一步添加“死亡”功能后就会理解。本质上，这个 transition.to() 命令会在四秒钟内将飞船淡回到完全不透明度 (alpha=1)。它还包括对匿名函数的 onComplete 回调。此函数将飞船恢复为活动的物理体，并将 died 变量重置为 false。

碰撞函数

接下来，让我们编写碰撞函数的基础

        end
    } )
end


local function onCollision( event )

    if ( event.phase == "began" ) then

        local obj1 = event.object1
        local obj2 = event.object2
    end
end

这相对简单，您应该能从前面的一些基本概念中认出它

1. 与触摸事件类似，碰撞也有不同的**阶段**，在本例中是 "began" 和 "ended"。"began" 碰撞阶段是您需要处理的最常见的阶段，但在某些情况下，检测 "ended" 阶段也很重要。现在不用太担心这个——在这里，我们只是通过将我们的功能包装在一个条件子句中来隔离 "began" 阶段。

2. 为了简化整个函数，我们使用局部变量 obj1 和 obj2 来引用碰撞中涉及的两个对象。使用全局方法检测碰撞时，这些对象由 event.object1 和 event.object2 引用。

激光与小行星

让我们处理我们的第一个碰撞条件：激光和小行星。还记得我们在创建每个对象时如何为其分配一个 myName 属性吗？此属性现在成为检测哪两种对象类型发生碰撞的关键。这里，开头的条件子句检查 obj1 和 obj2 的 myName 属性。如果这些值是 "laser" 和 "asteroid"，我们就知道哪两种对象类型发生了碰撞，我们可以继续处理结果。

    if ( event.phase == "began" ) then

        local obj1 = event.object1
        local obj2 = event.object2

        if ( ( obj1.myName == "laser" and obj2.myName == "asteroid" ) or
             ( obj1.myName == "asteroid" and obj2.myName == "laser" ) )
        then

        end
    end
end

在条件子句内，让我们首先简单地通过 display.remove() 移除这两个对象。虽然一个花哨的爆炸效果会很棒，但这个项目只是展示了如何处理碰撞——你以后如何扩展它取决于你的想象力！

        if ( ( obj1.myName == "laser" and obj2.myName == "asteroid" ) or
             ( obj1.myName == "asteroid" and obj2.myName == "laser" ) )
        then
            -- Remove both the laser and asteroid
            display.remove( obj1 )
            display.remove( obj2 )
        end
    end
end

接下来，让我们从 asteroidsTable 表中移除被摧毁的小行星，这样游戏循环就不需要再担心它了。为此，我们使用另一个 for 循环来迭代 asteroidsTable，找到小行星的实例并将其移除

        if ( ( obj1.myName == "laser" and obj2.myName == "asteroid" ) or
             ( obj1.myName == "asteroid" and obj2.myName == "laser" ) )
        then
            -- Remove both the laser and asteroid
            display.remove( obj1 )
            display.remove( obj2 )

            for i = #asteroidsTable, 1, -1 do
                if ( asteroidsTable[i] == obj1 or asteroidsTable[i] == obj2 ) then
                    table.remove( asteroidsTable, i )
                    break
                end
            end
        end
    end
end

最后，为了奖励玩家摧毁小行星，我们将 score 变量增加 100 并更新 scoreText 文本对象以反映新的值

        if ( ( obj1.myName == "laser" and obj2.myName == "asteroid" ) or
             ( obj1.myName == "asteroid" and obj2.myName == "laser" ) )
        then
            -- Remove both the laser and asteroid
            display.remove( obj1 )
            display.remove( obj2 )

            for i = #asteroidsTable, 1, -1 do
                if ( asteroidsTable[i] == obj1 or asteroidsTable[i] == obj2 ) then
                    table.remove( asteroidsTable, i )
                    break
                end
            end

            -- Increase score
            score = score + 100
            scoreText.text = "Score: " .. score
        end
    end
end

小行星与飞船

现在让我们处理第二个碰撞条件：小行星和飞船。在第一个条件之后将以下条件添加到if-then语句。请注意，我们使用 elseif 是因为我们正在向同一个语句添加另一个可能的条件

            -- Increase score
            score = score + 100
            scoreText.text = "Score: " .. score

        elseif ( ( obj1.myName == "ship" and obj2.myName == "asteroid" ) or
                 ( obj1.myName == "asteroid" and obj2.myName == "ship" ) )
        then

        end
    end
end

在这个条件子句中，让我们从一个额外的if-then检查

        elseif ( ( obj1.myName == "ship" and obj2.myName == "asteroid" ) or
                 ( obj1.myName == "asteroid" and obj2.myName == "ship" ) )
        then
            if ( died == false ) then

            end
        end
    end
end

开始

此条件检查可能看起来有点奇怪，但我们需要确认飞船尚未被摧毁。随着游戏的进行，或者小行星生成速度更快，飞船完全有可能几乎同时被两颗小行星击中。在这种情况下失去两条命显然是不公平的，因此我们检查 died 的值，只有当它是 false 时才继续。if-then子句中，让我们立即设置died = true因为玩家这次真的死了！

        elseif ( ( obj1.myName == "ship" and obj2.myName == "asteroid" ) or
                 ( obj1.myName == "asteroid" and obj2.myName == "ship" ) )
        then
            if ( died == false ) then
                died = true
            end
        end
    end
end

接下来，我们将从 lives 变量中减去一条命，并更新 livesText 文本对象以反映新的值

        elseif ( ( obj1.myName == "ship" and obj2.myName == "asteroid" ) or
                 ( obj1.myName == "asteroid" and obj2.myName == "ship" ) )
        then
            if ( died == false ) then
                died = true

                -- Update lives
                lives = lives - 1
                livesText.text = "Lives: " .. lives
            end
        end
    end
end

最后，让我们包含一个条件语句来检查玩家是否还有命

        elseif ( ( obj1.myName == "ship" and obj2.myName == "asteroid" ) or
                 ( obj1.myName == "asteroid" and obj2.myName == "ship" ) )
        then
            if ( died == false ) then
                died = true

                -- Update lives
                lives = lives - 1
                livesText.text = "Lives: " .. lives

                if ( lives == 0 ) then
                    display.remove( ship )
                else
                    ship.alpha = 0
                    timer.performWithDelay( 1000, restoreShip )
                end
            end
        end
    end
end

在这个语句的开头子句中，如果 lives 等于 0，我们 פשוט מסירים את הספינה לחלוטין. 这就是您可以显示“游戏结束”消息或执行其他操作的地方，但现在我们将保持各种可能性。

在默认的 else 子句中（玩家至少还有一条命），我们通过将其 alpha 属性设置为 0 来使飞船不可见。这与我们之前编写的 restoreShip() 函数相关联，在该函数中，当飞船淡回视野时，transition.to() 命令将飞船的 alpha 转换回 1。在那行之后，我们实际上在一秒钟的延迟后调用了 restoreShip() 函数——这会在飞船开始淡回视野之前产生轻微的延迟。

碰撞监听器

我们所有的碰撞逻辑现在都已到位，但除非我们将它连接起来，否则绝对不会发生任何事情！由于我们决定使用全局方法实现碰撞，因此只需一个命令即可告诉 Solar2D 它应该侦听应用程序的每个运行时帧中的新碰撞。

紧跟在 onCollision() 函数之后（在其结束 end 语句之后），添加以下命令

        end
    end
end

Runtime:addEventListener( "collision", onCollision )

此命令类似于之前的事件侦听器，我们在其中将 "tap" 或 "touch" 侦听器类型添加到特定对象。在这里，我们只是将 "collision" 侦听器类型添加到全局 Runtime 对象。