LuaとLÖVEでゲームを作成する-3

目次

• 記事1
  • パート1.ゲームサイクル
  • パート2.ライブラリ
  • パート3.部屋とエリア
  • パート4.演習
• セクション2
  • パート5.ゲームの基本
  • パート6.プレーヤークラスの基本
• セクション3
  • パート7.プレーヤーのパラメーターと攻撃
  • パート8.敵
• セクション4
  • パート9.ディレクターとゲームサイクル
  • パート10.コード作成のプラクティス
  • パート11.受動的スキル
• セクション5
  • パート12.その他の受動的スキル

13.スキルツリー

14.コンソール

15.最終

パート7：プレーヤーのオプションと攻撃

はじめに

この部分では、プレーヤーに関連するゲームプレイの部分に焦点を当てます。 まず、最も基本的なパラメーターである弾薬、加速、ヘルス（HP）、およびスキルポイントを追加します。 これらのパラメーターはゲーム全体で使用され、プレーヤーが使用可能なすべてのアクションを実行するために使用する主なパラメーターです。 その後、リソースオブジェクト、つまりプレーヤーが収集できるオブジェクトの作成に進みます。 これらには上記のパラメーターが含まれています。 そして最後に、攻撃システムといくつかの異なるプレイヤー攻撃を追加します。

描画順序

ゲームの主要部分に移る前に、私が見落としていたもう1つの重要な側面、つまり描画順序を考慮する必要があります。

描画順序は、上から描画するオブジェクトと下から描画するオブジェクトを決定します。 たとえば、特定のイベントが実行されると、いくつかのエフェクトがレンダリングされます。 プレーヤーの下など、他のオブジェクトの下にエフェクトが描画される場合、それらは表示されないか、正しく表示されません。 したがって、それらが常に他のすべての上に描画されるようにする必要があります。 これを行うには、描画オブジェクトの順序を設定する必要があります。

この問題を解決する方法はかなり簡単です。 GameObjectクラスでは、最初はすべてのエンティティに対して50であるdepth属性を定義し、その後、各クラスのコンストラクター定義で、オプションでオブジェクトの各クラスのdepth属性を個別に設定できます。 考えは、より深いオブジェクトは上に描画し、深さはより下に描画することです。 つまり、たとえば、他のすべての上にすべての効果を描画する場合、値75などのdepth属性に単純に割り当てることができます。

 function TickEffect:new(area, x, y, opts) TickEffect.super.new(self, area, x, y, opts) self.depth = 75 ... end 

内部では、次のように機能します。各フレームで、各オブジェクトのdepth属性でgame_objectsのリストをソートします。

 function Area:draw() table.sort(self.game_objects, function(a, b) return a.depth < b.depth end) for _, game_object in ipairs(self.game_objects) do game_object:draw() end end 

ここでは、レンダリングの前に、 table.sortを使用して、 depth属性でエンティティを並べ替えます。 深さが小さいエンティティはテーブルの前面に移動します。つまり、最初に（他のすべての下に）描画され、深さが大きいエンティティはテーブルの最後に移動し、最後に（上に）描画されます。 異なる種類のオブジェクトに異なる深さを設定しようとすると、これが機能することがわかります。

このアプローチでは、1つの小さな問題が発生します。一部のオブジェクトは同じ深さを持ち、これが発生すると、 game_objectsテーブルが絶えずソートされるときにgame_objectsが発生する場合がgame_objectsます。 オブジェクトの奥行きが同じ場合、あるフレームでは1つのオブジェクトが別のオブジェクトの上に表示されますが、次のフレームではその下に表示されるため、ちらつきが発生します。 これの可能性は小さいですが、これは起こる可能性があり、これを防ぐ必要があります。

これを解決する1つの方法は、オブジェクトの深さが同じ場合に別のソートパラメーターを定義することです。 私たちの場合、別のパラメーターとしてオブジェクト作成時間を選択しました。

 function Area:draw() table.sort(self.game_objects, function(a, b) if a.depth == b.depth then return a.creation_time < b.creation_time else return a.depth < b.depth end end) for _, game_object in ipairs(self.game_objects) do game_object:draw() end end 

つまり、深さが同じ場合、以前に作成されたオブジェクトが先に描画され、後で作成されます。 これは論理的な解決策であり、テストすると機能することがわかります。

描画順序の演習

93.オブジェクトの順序を変更して、奥のほうが奥に、奥の方が奥に描画されるようにします。 オブジェクトの深さが同じ場合は、作成時間順に並べ替える必要があります。 前に作成したオブジェクトを最後に描画し、後で作成したオブジェクトを最初に描画する必要があります。

94.以下に示すような上面の2.5Dゲームでは、エンティティを適切な順序でレンダリングする、つまり位置yでソートする必要があります。 y値が大きい（つまり、画面の下部に近い）エンティティを最後に描画し、y値が小さいエンティティを最初に描画する必要があります。 この場合、ソート機能はどのようになりますか？

主なパラメーター

次に、パラメーターの作成を開始します。 最初に確認するパラメーターはブーストです。 プレイヤーが「上」または「下」を押すと、船は押されたキーに応じて速度を変更します。 この基本機能に加えて、アクセラレーションを使用すると枯渇し、アクセラレーションを使用しないと徐々に復元されるリソースも必要です。 次の値とルールを適用します。

1. プレイヤーは最初に100単位の加速を持ちます
2. 加速度を使用すると、加速度が50単位減少します
3. 毎秒10個の加速単位が常に生成されます
4. 加速単位の数が0に達すると、このプロパティは「クールダウン」して再び使用できるようになるまで2秒かかります。
5. 加速は、「冷却」が無効で、加速ユニットのリソースが0より大きい場合にのみ実行できます

ルールは少し複雑に見えますが、本当に簡単です。 最初の3つは数値のタスクであり、最後の2つは無限の加速を防ぐために必要です。 リソースが0に達すると、常に1に回復します。これにより、プレーヤーが絶えず加速を使用する状況が発生する可能性があります。 この状況を防ぐには、「冷却」が必要です。

次に、これをコードに追加します。

 function Player:new(...) ... self.max_boost = 100 self.boost = self.max_boost end function Player:update(dt) ... self.boost = math.min(self.boost + 10*dt, self.max_boost) ... end 

これにより、ルール1および3を実装します。最初に、 boostの値はmax_boost 、つまり100であり、値max_boostまで、1秒あたり10を追加してboostします。 また、プレーヤーが加速するときに毎秒50ユニットを引くだけで、ルール2を実装できます。

 function Player:update(dt) ... if input:down('up') then self.boosting = true self.max_v = 1.5*self.base_max_v self.boost = self.boost - 50*dt end if input:down('down') then self.boosting = true self.max_v = 0.5*self.base_max_v self.boost = self.boost - 50*dt end ... end 

このコードの一部はすでにここにありました。つまり、追加された行はself.boost -= 50*dtでした。 ここで、ルール4を確認するには、 boostが0に達したときに冷却が2秒間開始されることを確認する必要があります。 ここではより多くの可動部品が使用されるため、これは少し複雑です。 コードは次のようになります。

 function Player:new(...) ... self.can_boost = true self.boost_timer = 0 self.boost_cooldown = 2 end 

まず、3つの変数を紹介します。 can_boostは、加速を実行できるタイミングを報告するために使用されます。 プレーヤーはゲームの開始時に加速できる必要があるため、デフォルトではtrueです。 boostが0に達するとfalseに設定され、 boost_cooldown秒後にtrueに設定されます。 boost_timer変数は、 boostが0になってから経過した時間をboost_cooldown 、この変数がboost_cooldownを超えると、 can_boostはtrueに設定されます。

 function Player:update(dt) ... self.boost = math.min(self.boost + 10*dt, self.max_boost) self.boost_timer = self.boost_timer + dt if self.boost_timer > self.boost_cooldown then self.can_boost = true end self.max_v = self.base_max_v self.boosting = false if input:down('up') and self.boost > 1 and self.can_boost then self.boosting = true self.max_v = 1.5*self.base_max_v self.boost = self.boost - 50*dt if self.boost <= 1 then self.boosting = false self.can_boost = false self.boost_timer = 0 end end if input:down('down') and self.boost > 1 and self.can_boost then self.boosting = true self.max_v = 0.5*self.base_max_v self.boost = self.boost - 50*dt if self.boost <= 1 then self.boosting = false self.can_boost = false self.boost_timer = 0 end end self.trail_color = skill_point_color if self.boosting then self.trail_color = boost_color end end 

それは複雑に思えますが、コードは私たちが達成したかったものを単に実装しています。 input:downでキーが押されたかどうかをチェックする代わりに、 boost 1より上（ルール5）であり、 can_boostがtrue（ルール5）であることもチェックします。 boostが0に達したら、 can_boostおよびcan_boost変数をfalseに設定し、 boost_timerを0にリセットしますboost_timerは各フレームでboost_timerに追加されるboost_timer 、2秒後にcan_boostをtrueに設定し、再び加速できます（ルール4）。

上記のコードは、完了状態の加速メカニズムです。 ここでは、このコードをい、無秩序で、悪い決定を組み合わせて呼び出すことができることに注意してください。 しかし、それはまさにゲームプレイの特定の側面を処理するコードのほとんどがどのように見えるかです。 ここでは、いくつかのルールに従うと同時にそれらに従う必要があります。 そのようなコードに慣れる必要があるように思えます。

すべての主要なパラメーターのうち、加速だけでも複雑なロジックを持っている可能性があります。 弾薬とHPの2つの重要なオプションがありますが、どちらもはるかに簡単です。 弾薬はプレイヤーの攻撃中に消費され、ゲーム中にリソースが収集されると復元され、プレイヤーがダメージを受けるとHPが減少し、リソースが収集されると復元されます。 これで、アクセラレーションで行ったように、それらをメインパラメータとして単純に追加できます。

 function Player:new(...) ... self.max_hp = 100 self.hp = self.max_hp self.max_ammo = 100 self.ammo = self.max_ammo end 

資源

私は、主要なパラメーターの1つに影響するリソースを小さなオブジェクトと呼びます。 ゲームには、このようなオブジェクトが5種類あり、次のように機能します。

• 弾薬リソースはプレイヤーの5個の弾薬を復元し、敵が死んだときに作成されます
• 加速リソースは、プレイヤーの25個の加速ユニットを復元し、ディレクターによってランダムに作成されます
• HPリソースは、プレーヤーから25 HPを復元し、ディレクターによってランダムに作成されます。
• SkillPointリソースは、プレーヤーに1つのスキルポイントを追加し、ディレクターによってランダムに作成されます。
• 攻撃リソースは、プレーヤーの現在の攻撃を変更し、ディレクターによってランダムに作成されます

ディレクター（ディレクター）-敵とリソースの作成を制御するコード。 他のゲーム（L4Dなど）でこのような名前が付けられており、適切だと思われたため、それを呼び出しました。 コードのこの部分で作業するつもりはないので、各リソースの作成をキーに関連付けて、作業を簡単にテストします。

弾薬リソース

弾薬から始めましょう。 最終結果は次のようになります。


小さな緑色の長方形は弾薬の資源です。 プレイヤーが彼に触れると、リソースが破壊され、プレイヤーは5ユニットの弾薬を受け取ります。 新しいAmmoクラスを作成し、定義から始めることができます。

 function Ammo:new(...) ... self.w, self.h = 8, 8 self.collider = self.area.world:newRectangleCollider(self.x, self.y, self.w, self.h) self.collider:setObject(self) self.collider:setFixedRotation(false) self.r = random(0, 2*math.pi) self.v = random(10, 20) self.collider:setLinearVelocity(self.v*math.cos(self.r), self.v*math.sin(self.r)) self.collider:applyAngularImpulse(random(-24, 24)) end function Ammo:draw() love.graphics.setColor(ammo_color) pushRotate(self.x, self.y, self.collider:getAngle()) draft:rhombus(self.x, self.y, self.w, self.h, 'line') love.graphics.pop() love.graphics.setColor(default_color) end 

弾薬リソースは、最初はsetLinearVelocityおよびapplyAngularImpulseによって設定された、ランダムな低速および回転で作成された物理的な長方形です。 さらに、このオブジェクトはdraftライブラリを使用してレンダリングされます。 これは、自分で行うよりも便利にあらゆる種類の図形を描画できる小さなライブラリです。 私たちの場合、単純に任意の長方形のようにリソースを描画できますが、この方法で行うことにしました。 ライブラリを自分でインストールし、ドキュメントを読み、その機能について学習していることを前提とします。 さらに、 getAngleの結果を使用して、物理オブジェクトの回転を考慮します。

これをすべてテストするために、これらのオブジェクトのいずれかの作成をキーにバインドできます。

 function Stage:new() ... input:bind('p', function() self.area:addGameObject('Ammo', random(0, gw), random(0, gh)) end) end 

ここでゲームを開始してPを数回押すと、オブジェクトの作成方法と移動/回転が表示されます。

次に作成する必要があるのは、プレーヤーとリソース間の衝突の相互作用です。 この相互作用はすべてのリソースに使用され、ほとんど常に同じです。 最初に行うことは、プレイヤーの物理オブジェクトと物理弾薬オブジェクトの衝突イベントをインターセプトすることです。 これを実装する最も簡単な方法は、 (collision classes)を使用する (collision classes)です。 まず、既存のオブジェクトの衝突の3つのクラスを定義できます：プレーヤー、発射物、およびリソース。

 function Stage:new() ... self.area = Area(self) self.area:addPhysicsWorld() self.area.world:addCollisionClass('Player') self.area.world:addCollisionClass('Projectile') self.area.world:addCollisionClass('Collectable') ... end 

そして、これらの各ファイル（Player、Projectile、Ammo）では、 setCollisionClassを使用して衝突型衝突クラスを設定できます（他のファイルでこのコードを繰り返します）。

 function Player:new(...) ... self.collider:setCollisionClass('Player') ... end 

それ自体は何も変更せず、物理オブジェクト間の衝突のイベントをインターセプトできる基盤を作成します。 たとえば、コリジョンクラスCollectableを変更してPlayer無視する場合：

 self.area.world:addCollisionClass('Collectable', {ignores = {'Player'}}) 

ゲームを開始すると、プレイヤーが弾薬リソースオブジェクトを物理的に無視することに気付くでしょう。 これは私たちが目指しているものではありませんが、衝突クラスでできることの良い例として役立ちます。 これら3つの衝突クラスは、次の規則に従う必要があります。

1. 発射物は発射物を無視します
2. CollectableはCollectableを無視します
3. 収集物は発射物を無視します
4. PlayerはCollectableで衝突イベントを生成します

ルール1、2、3は、 addCollisionClass呼び出しに小さな変更を加えることで実装できます。

 function Stage:new() ... self.area.world:addCollisionClass('Player') self.area.world:addCollisionClass('Projectile', {ignores = {'Projectile'}}) self.area.world:addCollisionClass('Collectable', {ignores = {'Collectable', 'Projectile'}}) ... end 

衝突クラスを宣言する順序が重要であることは注目に値します。 たとえば、ProjectileクラスとCollectableクラスの宣言を入れ替えると、Collectable衝突クラスがProjectile衝突クラスへのリンクを作成するため、Projectile衝突クラスがまだ定義されていないためエラーが発生します。

4番目のルールは、 enterを呼び出すことで実装できます。

 function Player:update(dt) ... if self.collider:enter('Collectable') then print(1) end end 

コードを実行すると、プレーヤーが弾薬リソースと衝突するたびに、コンソールに1が表示されます。

Ammoクラスに追加する必要のあるもう1つの要素は、プレーヤーへのオブジェクトのゆっくりした動きです。 これを行う最も簡単な方法は、 Seek Behavior動作を追加することです。 シーク動作の私のバージョンは、ExampleによるProgramming Game AIの書籍に基づいています。これには、一般的な制御動作の非常に優れた選択があります。 正直なところ、どのように動作するのか覚えていないので、動作の詳細は説明しません。したがって、興味がある場合は自分で理解してください：D

 function Ammo:update(dt) ... local target = current_room.player if target then local projectile_heading = Vector(self.collider:getLinearVelocity()):normalized() local angle = math.atan2(target.y - self.y, target.x - self.x) local to_target_heading = Vector(math.cos(angle), math.sin(angle)):normalized() local final_heading = (projectile_heading + 0.1*to_target_heading):normalized() self.collider:setLinearVelocity(self.v*final_heading.x, self.v*final_heading.y) else self.collider:setLinearVelocity(self.v*math.cos(self.r), self.v*math.sin(self.r)) end end 

ここで、弾薬リソースが存在する場合、 targetに向けられます。そうでない場合、リソースは最初に指定された方向に移動します。 targetは、次のようにStageで設定されるプレーヤーへのリンクが含まれます。

 function Stage:new() ... self.player = self.area:addGameObject('Player', gw/2, gh/2) end 

残っているのは、弾薬リソースが収集されたときに発生するアクションを処理することだけです。 上記のgifアニメーションでは、パーティクルで小さな効果が再現され（発射体が「死ぬ」ときの効果に似ています）、プレイヤーは+5の弾薬を受け取ります。

エフェクトから始めましょう。 このエフェクトは、 ProjectileDeathEffectオブジェクトと同じロジックを使用します。小さな白い閃光が発生し、エフェクトの実際の色が表示されます。 ここでの唯一の違いは、正方形を描画する代わりに、菱形、つまり、弾薬リソース自体を描画するために使用したのと同じ図を描画することです。 この新しいAmmoEffectオブジェクトに名前をAmmoEffectます。 ProjectileDeathEffect似ているため、詳細に検討しません。 ただし、次のように呼び出します。

 function Ammo:die() self.dead = true self.area:addGameObject('AmmoEffect', self.x, self.y, {color = ammo_color, w = self.w, h = self.h}) for i = 1, love.math.random(4, 8) do self.area:addGameObject('ExplodeParticle', self.x, self.y, {s = 3, color = ammo_color}) end end 

ここでは、1つのAmmoEffectオブジェクトを作成してから、 AmmoEffect個のAmmoEffectオブジェクトを作成します。これらは、Playerのデスエフェクトで既に使用しています。 Ammoオブジェクトのdie関数は、Playerと衝突したときに呼び出されます：

 function Player:update(dt) ... if self.collider:enter('Collectable') then local collision_data = self.collider:getEnterCollisionData('Collectable') local object = collision_data.collider:getObject() if object:is(Ammo) then object:die() end end end 

ここでは、まずgetEnterCollisionDataを使用して、指定したラベルの最後のエンターコリジョンイベントによって生成されたコリジョンデータを取得します。 次に、 getObjectを使用して、Collisibleイベントに参加するコライダーにアタッチされたオブジェクトへのアクセスを取得しますgetObjectイベントには、Collectable衝突クラスの任意のオブジェクトを指定できます。 私たちの場合、Ammoオブジェクトしかありませんが、他のものがある場合は、それらを区別するコードが配置される場所です。 そして、これがまさに私たちがやっていることですgetObjectから受け取ったオブジェクトがAmmoクラスかどうかを確認するために、クラシックライブラリのis関数を使用します。 これが実際に弾薬クラスのオブジェクトである場合、そのdie関数を呼び出します。 次のようになります。


最後に忘れたのは、弾薬リソースを収集するときにプレイヤーに弾薬+5を追加することです。 これを行うには、 addAmmo関数を定義します。この関数は、特定の値を単純にammo変数に追加し、 max_ammo超えないことをmax_ammoます。

 function Player:addAmmo(amount) self.ammo = math.min(self.ammo + amount, self.max_ammo) end 

そして、この関数をobject:die()後に追加します。

加速リソース（ブースト）

それでは、速度について説明しましょう。 最終結果は次のようになります。


ご覧のとおり、アイデアは弾薬リソースとほぼ同じで、ブーストリソースの動きがわずかに異なり、見た目が少し異なり、リソースが収集されるときに再現される視覚効果が異なります。

主なものから始めましょう。 弾薬を除くすべてのリソースは、画面の左側または右側に作成され、ゆっくりと反対側に直線的に移動します。 同じことが敵にも当てはまります。 これにより、プレーヤーはリソースに移動し、必要に応じてリソースを収集するのに十分な時間を確保できます。

Boostクラスのメインの初期コードはAmmoクラスとほぼ同じです。 次のようになります。

 function Boost:new(...) ... local direction = table.random({-1, 1}) self.x = gw/2 + direction*(gw/2 + 48) self.y = random(48, gh - 48) self.w, self.h = 12, 12 self.collider = self.area.world:newRectangleCollider(self.x, self.y, self.w, self.h) self.collider:setObject(self) self.collider:setCollisionClass('Collectable') self.collider:setFixedRotation(false) self.v = -direction*random(20, 40) self.collider:setLinearVelocity(self.v, 0) self.collider:applyAngularImpulse(random(-24, 24)) end function Boost:update(dt) ... self.collider:setLinearVelocity(self.v, 0) end 

ただし、いくつかの違いがあります。コンストラクターの最初の3行は、オブジェクトの開始位置を取得します。関数は次のようにtable.random定義さutils.luaれます。

 function table.random(t) return t[love.math.random(1, #t)] end 

ご覧のとおり、彼女はテーブルからランダムなアイテムを選択するだけです。この場合、-1または1を選択するだけで、オブジェクトを作成する側を示します。値-1が選択されている場合、オブジェクトは画面の左側に作成され、1の場合は右側に作成されます。この選択された位置の特定の位置は-48またはgw+48に等しくなります。つまり、オブジェクトは画面の外側に作成されますが、その端に十分近くなります。

次に、速度のいくつかの違いを除いて、弾薬とほぼ同じ方法でオブジェクトを定義します。オブジェクトが右側に作成された場合は、左側に移動し、左側にある場合は右側に移動する必要があります。したがって、速度には20〜40のランダムな値が割り当てられ、次にが乗算され-directionます。これは、オブジェクトが右側にある場合、direction1に等しい;左側に移動したいので、速度は負になります（反対側の場合はその逆）。 x軸に沿ったオブジェクトの速度のコンポーネントには常に属性値が割り当てられ、vy 軸に沿ったコンポーネントは0に設定されます。オブジェクトを水平線に沿って移動するため、yに沿った速度を0に設定します

。最後の主な違いは描画方法です。

 function Boost:draw() love.graphics.setColor(boost_color) pushRotate(self.x, self.y, self.collider:getAngle()) draft:rhombus(self.x, self.y, 1.5*self.w, 1.5*self.h, 'line') draft:rhombus(self.x, self.y, 0.5*self.w, 0.5*self.h, 'fill') love.graphics.pop() love.graphics.setColor(default_color) end 

単一の菱形を描画する代わりに、内部と外部を1つずつ描画します。これは一種のアウトラインになります。もちろん、好きなようにオブジェクトを描画できますが、私はこの方法を個人的に選択しました。

それでは、エフェクトに移りましょう。ここでは2つのオブジェクトが使用されます。1つはAmmoEffect（ただし、もう少し複雑です）に似ています。2つ目はtextに使用されます+BOOST。 AmmoEffectに似たものから始めて、名前を付けBoostEffectます。

この効果は2つの部分で構成されています。白いフラッシュのある中央と、消えた後のフリッカー効果です。センターは同じようAmmoEffectに機能しますが、唯一の違いは各フェーズの実行時間です。最初のフェーズでは0.1〜0.2、2番目のフェーズでは0.15〜0.35です。

 function BoostEffect:new(...) ... self.current_color = default_color self.timer:after(0.2, function() self.current_color = self.color self.timer:after(0.35, function() self.dead = true end) end) end 

効果の2番目の部分は、彼の死の前のちらつきです。フリッカーは、変数を作成することで実現できますvisible。trueの場合、効果が描画され、falseの場合、描画されません。この変数の値を変更することにより、目的の効果が得られます。

 function BoostEffect:new(...) ... self.visible = true self.timer:after(0.2, function() self.timer:every(0.05, function() self.visible = not self.visible end, 6) self.timer:after(0.35, function() self.visible = true end) end) end 

ここでは、可視性と非可視性を切り替えるために、every0.05秒の間隔で6回呼び出しを使用し、完了後、最後にエフェクトを表示します。エフェクトは0.55秒後に「死ぬ」ため（dead現在の色を設定するときに0.55後に値をtrueに設定するため）、最後に見えるようにすることはそれほど重要ではありません。これで、次のように描画できます。

 function BoostEffect:draw() if not self.visible then return end love.graphics.setColor(self.current_color) draft:rhombus(self.x, self.y, 1.34*self.w, 1.34*self.h, 'fill') draft:rhombus(self.x, self.y, 2*self.w, 2*self.h, 'line') love.graphics.setColor(default_color) end 

単純に異なるサイズの内側と外側のひし形を描画します。特定の値（1.34、2）は、主に試行錯誤によって導き出されます。

この効果のために最後に行う必要があるのは、オブジェクトの存続期間中に外部のアウトライン菱形を増やすことです。次のようにできます。

 function BoostEffect:new(...) ... self.sx, self.sy = 1, 1 self.timer:tween(0.35, self, {sx = 2, sy = 2}, 'in-out-cubic') end 

次に、描画関数を次のように変更します。

 function BoostEffect:draw() ... draft:rhombus(self.x, self.y, self.sx*2*self.w, self.sy*2*self.h, 'line') ... end 

この変数のおかげでsxとsy0.35秒の二重のために、あまりにも、0.35である秒、回路用の2に増加されます。最終的に、結果は次のようになります（die弾薬リソースで行ったように、このオブジェクトの機能をPlayerの衝突イベントに既にリンクしていると仮定します）。

---

それでは、エフェクトの他の部分、クレイジーテキストについて見てみましょう。このテキスト効果はゲームのほぼすべての場所で使用されるため、正しく実装する必要があります。もう一度、どのように見えるかを示します。


まず、エフェクトをいくつかの部分に分けましょう。最初に気付くのは、画面に最初に描かれる線だけですが、最後に向かってオブジェクトのようにちらつき始めますBoostEffect。 FlickerはBoostEffectと同じロジックを使用します。つまり、既に調べました。

また、文字列の文字は他の文字にランダムに変化し始め、各文字の背景もランダムに色が変化します。これは、このエフェクトが各キャラクターを個別に処理し、行全体で動作しないことを示しています。つまり、すべてのキャラクターをテーブルに保存し、charactersこのテーブルを処理してから、すべての変更とエフェクトを使用して画面上のテーブルから各キャラクターを描画する必要があります。

これらすべてを考慮して、classの基底を決定できInfoTextます。次のように呼び出します。

 function Boost:die() ... self.area:addGameObject('InfoText', self.x, self.y, {text = '+BOOST', color = boost_color}) end 

つまり、文字列は属性に保存されますtext。その場合、クラスの基底の定義は次のようになります。

 function InfoText:new(...) ... self.depth = 80 self.characters = {} for i = 1, #self.text do table.insert(self.characters, self.text:utf8sub(i, i)) end end 

そのため、オブジェクトの深さは80（他のすべてのオブジェクトよりも高い、つまりすべての上に描画される）であると判断し、元の文字列をテーブル文字に分割します。このために、ライブラリを使用しますutf8。一般に、すべての種類の文字をサポートするライブラリを使用して文字列を操作することをお勧めします。これは、後で説明するように、オブジェクトにとって特に重要です。

また、これらのキャラクターのレンダリングも個別に行う必要があります。これは、前述のとおり、各キャラクターには独自の背景があり、ランダムに変化するためです。

各文字を個別にレンダリングするロジックは、文字テーブルを調べて、位置xに各文字を描画することです。位置xは、その前にあるすべての文字の合計です。つまり、たとえば、最初のO行内+BOOSTは位置でのレンダリングを意味しますinitial_x_position + widthOf('+B')。この場合、幅を取得する際の問題+Bは、関数を使用するが、Font:getWidthまだフォントを設定していないため、使用するフォントに依存することです。ただし、この問題は簡単に解決できます！

このために、私たちは、フォントを使用m5x7ダニエルLinssenを。このフォントをフォルダーに入れてresources/fontsからダウンロードできます。フォルダーからクラス定義をロードするために使用されるコードobjects（演習14）に似ているため、ダウンロードに必要なコードは演習として残しておきます。このダウンロードプロセスの終了までに、ダウンロードしたfontsすべてのフォントを次の形式で含むグローバルテーブルが作成されます。fontname_fontsize。この例では、次を使用しますm5x7_16。

 function InfoText:new(...) ... self.font = fonts.m5x7_16 ... end 

そして、レンダリングコードは次のようになります。

 function InfoText:draw() love.graphics.setFont(self.font) for i = 1, #self.characters do local width = 0 if i > 1 then for j = 1, i-1 do width = width + self.font:getWidth(self.characters[j]) end end love.graphics.setColor(self.color) love.graphics.print(self.characters[i], self.x + width, self.y, 0, 1, 1, 0, self.font:getHeight()/2) end love.graphics.setColor(default_color) end 

まず、これlove.graphics.setFontを使用して、次のレンダリング操作で使用するフォントを指定します。次に、各シンボルを調べて、それらを描画する必要があります。しかし、最初に、xで位置を計算する必要があります。これは、その前のすべての文字の幅の合計です。変数を蓄積する内側のループwidthはまさにそれを行います。 1（行の先頭）からi-1（現在の行の前の文字）で始まり、各文字の幅をtotal width、つまりすべての合計に加算します。次に、love.graphics.printそれぞれのキャラクターを対応する位置に描画します。また、各文字をフォントの高さの半分だけシフトします（したがって、設定したy位置に対して文字が中央に配置されます）。

これらすべてをテストすると、次の結果が得られます。


まさに必要なもの！

これで、消える前に点滅するテキストに進むことができます。この効果は、BoostEffectオブジェクトと同じロジックを使用します。つまり、単純にコピーできます。

 function InfoText:new(...) ... self.visible = true self.timer:after(0.70, function() self.timer:every(0.05, function() self.visible = not self.visible end, 6) self.timer:after(0.35, function() self.visible = true end) end) self.timer:after(1.10, function() self.dead = true end) end 

これを実行すると、テキストがしばらくの間正常のままであり、ちらつき始めて消えることがわかります。

そして今、最も難しいのは、各キャラクターをランダムに変更することです。メインと背景の色についても同じことを行います。これらの変更は、シンボルがちらつき始めるのとほぼ同時に開始されるため、after上記で定義した0.7秒間、コードのこの部分を呼び出し内に配置します。これを行います-0.035秒ごとに、キャラクターを別のランダムなキャラクターに変更する機会のある手順を開始します。次のようになります。

 self.timer:after(0.70, function() ... self.timer:every(0.035, function() for i, character in ipairs(self.characters) do if love.math.random(1, 20) <= 1 then -- change character else -- leave character as it is end end end) end) 

つまり、0.035秒ごとに、各キャラクターは何か他のものに変わる確率が5％です。これを終了するには、変数を追加しますrandom_characters。これは、文字を変更できるすべての文字を含む文字列です。キャラクターを変更する必要がある場合、この行からランダムにキャラクターを選択します。

 self.timer:after(0.70, function() ... self.timer:every(0.035, function() local random_characters = '0123456789!@#$%¨&*()-=+[]^~/;?><.,|abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYXZ' for i, character in ipairs(self.characters) do if love.math.random(1, 20) <= 1 then local r = love.math.random(1, #random_characters) self.characters[i] = random_characters:utf8sub(r, r) else self.characters[i] = character end end end) end) 

コードを実行すると、次のようになります。


同じロジックを使用して、シンボルの前景色と背景色を変更できます。これを行うために、我々は2つのテーブルを定義し、background_colorsそしてforeground_colors。各テーブルのサイズはtableと同じでcharacters、各文字の背景色と前景色のみが含まれます。一部のキャラクターでこの表の色が指定されていない場合、デフォルトではメインの色（boost_color）と透明な背景が使用されます。

 function InfoText:new(...) ... self.background_colors = {} self.foreground_colors = {} end function InfoText:draw() ... for i = 1, #self.characters do ... if self.background_colors[i] then love.graphics.setColor(self.background_colors[i]) love.graphics.rectangle('fill', self.x + width, self.y - self.font:getHeight()/2, self.font:getWidth(self.characters[i]), self.font:getHeight()) end love.graphics.setColor(self.foreground_colors[i] or self.color or default_color) love.graphics.print(self.characters[i], self.x + width, self.y, 0, 1, 1, 0, self.font:getHeight()/2) end end 

定義されている場合background_colors[i]（現在の文字の背景色）、背景色については、現在の文字の適切な位置とサイズに長方形を描画するだけです。を使用しsetColorて現在のシンボルのレンダリング色を設定するだけで、原色を変更します。foreground_colors[i]定義されていない場合、デフォルトではequal self.colorになります。これはboost_color、Boostオブジェクトから呼び出されたときに正確に転送されるため、このオブジェクトでは常にequal です。ただし、self.color定義されていない場合は、デフォルトで白（default_color）になります。テーブルbackground_colorsとの中に値を定義していないため、このコード自体は何もしませんforeground_colors。

これを行うには、文字をランダムに変更するために使用したのと同じロジックを使用できます。

 self.timer:after(0.70, function() ... self.timer:every(0.035, function() for i, character in ipairs(self.characters) do ... if love.math.random(1, 10) <= 1 then -- change background color else -- set background color to transparent end if love.math.random(1, 10) <= 2 then -- change foreground color else -- set foreground color to boost_color end end end) end) 

色を置き換えるコードは、色のリストから選択する必要があります。6色のグローバルグループを定義したので、それらすべてをリストに入れて、それを使用してそのうちの1つをランダムに選択できますtable.random。さらに、これに加えて、6つのソースのネガとなる6色をさらに定義します。つまり、元の色がある232, 48, 192場合、そのネガはとして定義できます255-232, 255-48, 255-192。

 function InfoText:new(...) ... local default_colors = {default_color, hp_color, ammo_color, boost_color, skill_point_color} local negative_colors = { {255-default_color[1], 255-default_color[2], 255-default_color[3]}, {255-hp_color[1], 255-hp_color[2], 255-hp_color[3]}, {255-ammo_color[1], 255-ammo_color[2], 255-ammo_color[3]}, {255-boost_color[1], 255-boost_color[2], 255-boost_color[3]}, {255-skill_point_color[1], 255-skill_point_color[2], 255-skill_point_color[3]} } self.all_colors = fn.append(default_colors, negative_colors) ... end 

ここでは、各色の対応する値を含む2つのテーブルを定義し、関数appendを使用してそれらを結合します。次に、このようなことをしてtable.random(self.all_colors)、この表で定義されている10個からランダムな色を1つ取得します。つまり、次のことができます。

 self.timer:after(0.70, function() ... self.timer:every(0.035, function() for i, character in ipairs(self.characters) do ... if love.math.random(1, 10) <= 1 then self.background_colors[i] = table.random(self.all_colors) else self.background_colors[i] = nil end if love.math.random(1, 10) <= 2 then self.foreground_colors[i] = table.random(self.all_colors) else self.background_colors[i] = nil end end end) end) 

ゲームを実行すると、次のように表示されます。


以上です。後でこの効果を改善します（演習を含む）が、今のところこれで十分です。最後に行う必要があるのは、加速リソースを収集するときにプレイヤーに+25のブーストを追加することです。これは弾薬リソースとまったく同じように機能するため、コードはスキップします。

リソース演習

95. Projectile衝突クラスがPlayer衝突クラスを無視するようにします。

96.関数を変更してaddAmmo、負の値の追加をサポートし、属性ammoが0を下回らないようにします。関数addBoostおよびaddHPHPリソースの追加も同様に行います（別の演習のタスクになります）。

97.前の演習から判断すると、正の値と負の値を1つの関数で処理するか、関数addResourceと関数に分割する方がよいremoveResourceでしょうか？

98.オブジェクトInfoTextで、シンボルが20％変化する確率、メインカラーが5％変化する確率、および背景色が30％変化する確率を変更します。

99.テーブルを定義するdefault_colors、negative_colorsそしてall_colorsにおけるInfoText非ローカルおよびグローバル。

100は、オブジェクトの位置をランダム化しInfoText、それが間に作成されるように-self.wし、self.w成分xの、間-self.hおよびself.h成分Yに。属性wとは、h対象ブーストされ、情報テキストを作成しました。

101.次の機能があるとします。

 function Area:getAllGameObjectsThat(filter) local out = {} for _, game_object in pairs(self.game_objects) do if filter(game_object) then table.insert(out, game_object) end end return out end 

フィルター関数が渡すArea内のすべてのゲームオブジェクトを返します。また、InfoTextコンストラクターで次のように呼び出されるとします。

 function InfoText:new(...) ... local all_info_texts = self.area:getAllGameObjectsThat(function(o) if o:is(InfoText) and o.id ~= self.id then return true end end) end 

これは、現在ではないすべての既存および現在のInfoTextオブジェクトを返します。 InfoTextオブジェクトが他のInfoTextオブジェクトと視覚的に重複しないようにしてください。つまり、画面上の同じスペースを占有せず、テキストが読めなくなることはありません。これはあなたにとって都合の良い方法で行うことができます。主なことは、タスクを実行することです。

102.（コンテンツ）すべての機能と視覚効果を備えたHPリソースを追加します。 Boostリソースとまったく同じロジックを使用しますが、+ 25 HPを追加します。リソースと効果は次のようになります。


103.（コンテンツ）すべての機能と視覚効果を備えたSPリソースを追加します。リソースと同じロジックを使用しますが、+ 1 SPを追加します。さらに、SPリソースは、Playerオブジェクトの内部変数としてではなく、グローバル変数として定義する必要があります。リソースと効果は次のようになります。

攻撃

さて、攻撃に移りましょう。まず、シェルのレンダリング方法を変更します。今ではそれらは円として描かれていますが、それらを線にしたいのです。これは次のように実装できます。

 function Projectile:draw() love.graphics.setColor(default_color) pushRotate(self.x, self.y, Vector(self.collider:getLinearVelocity()):angle()) love.graphics.setLineWidth(self.s - self.s/4) love.graphics.line(self.x - 2*self.s, self.y, self.x, self.y) love.graphics.line(self.x, self.y, self.x + 2*self.s, self.y) love.graphics.setLineWidth(1) love.graphics.pop() end 

この関数でpushRotateは、発射体の速度を使用するため、発射体が動く角度に応じて発射体を回転させることができます。次に、内部でlove.graphics.setLineWidth、属性にほぼ比例する値を使用して設定しますがs、それよりわずかに小さくします。これは、s全体が大きいシェルが厚くなることを意味します。次に、でシェルを描画しますlove.graphics.line。また-2*self.s、中心から1本の線を引き、次に中心からに別の線を引くことも重要です2*self.s。各攻撃には独自の色があり、これらの線の1つの色を変更しますが、2番目の線の色は変更しないため、これを行います。たとえば、これを行う場合：

 function Projectile:draw() love.graphics.setColor(default_color) pushRotate(self.x, self.y, Vector(self.collider:getLinearVelocity()):angle()) love.graphics.setLineWidth(self.s - self.s/4) love.graphics.line(self.x - 2*self.s, self.y, self.x, self.y) love.graphics.setColor(hp_color) -- change half the projectile line to another color love.graphics.line(self.x, self.y, self.x + 2*self.s, self.y) love.graphics.setLineWidth(1) love.graphics.pop() end 

次に、このようになります：


したがって、各攻撃に異なる色を割り当て、プレイヤーが画面上で何が起こっているかをよりよく理解できるようにすることができます。

---

完成したゲームには16の攻撃がありますが、ここではそのうちの一部のみを検討します。攻撃システムは非常にシンプルで、次のルールに基づいています。

1. 攻撃（中立を除く）は、各ショットで弾薬を消費します。
2. 弾薬が0になると、現在の攻撃は中立に変わります。
3. ランダムに生成されたリソースを使用して、新しい攻撃を取得できます。
4. 新しい攻撃が受信されると、現在の攻撃が置き換えられ、弾薬が完全に復元されます。
5. 各攻撃は独自の量の弾薬を使用し、独自の特性を持っています。

最初に行うことは、各攻撃についての情報を含むテーブルを定義することです：それらの「冷却」の時間、弾薬と色の消費。テーブルを定義しますがglobals.lua、今のところは次のようになります。

 attacks = { ['Neutral'] = {cooldown = 0.24, ammo = 0, abbreviation = 'N', color = default_color}, } 

定義済みの標準的な攻撃はと呼ばれNeutralます。彼女は、ゲームで既に持っている攻撃のパラメーターを使用します。これでsetAttack、ある攻撃を別の攻撃に置き換える関数を定義し、次の攻撃のグローバルテーブルを使用できます。

 function Player:setAttack(attack) self.attack = attack self.shoot_cooldown = attacks[attack].cooldown self.ammo = self.max_ammo end 

次のように呼び出すことができます。

 function Player:new(...) ... self:setAttack('Neutral') ... end 

ここではattack、現在の攻撃の名前を含む属性を変更するだけです。この属性はshoot、現在アクティブな攻撃を確認し、シェルを作成する方法を決定するために、関数で使用されます。

属性を変更することもできますshoot_cooldown。この属性はまだ作成していませんが、boost_timerand 属性に似ていますboost_cooldown。これは、アクション（この場合は攻撃）が発生する頻度を制御するために使用されます。この行を削除します。

 function Player:new(...) ... self.timer:every(0.24, function() self:shoot() end) ... end 

そして、攻撃のタイミングを手動で設定します。

 function Player:new(...) ... self.shoot_timer = 0 self.shoot_cooldown = 0.24 ... end function Player:update(dt) ... self.shoot_timer = self.shoot_timer + dt if self.shoot_timer > self.shoot_cooldown then self.shoot_timer = 0 self:shoot() end ... end 

機能の最後に、弾薬の量も復元します。そこで、ルール4を実装します。次にできることはshoot、さまざまな攻撃の存在を考慮に入れるように関数を少し変更することです。

 function Player:shoot() local d = 1.2*self.w self.area:addGameObject('ShootEffect', self.x + d*math.cos(self.r), self.y + d*math.sin(self.r), {player = self, d = d}) if self.attack == 'Neutral' then self.area:addGameObject('Projectile', self.x + 1.5*d*math.cos(self.r), self.y + 1.5*d*math.sin(self.r), {r = self.r}) end end 

発射物を発射する前に、条件付き設計を使用してif self.attack == 'Neutral'現在の攻撃を確認します。16個の攻撃すべてをチェックする必要があるため、この機能は徐々に大きな条件チェーンに成長します。

---

1つの攻撃を追加して、どのように見えるかを見てみましょう。追加する攻撃はと呼ばれDoubleます。次のようになります。


ご覧のとおり、彼女は1つではなく2つのシェルで斜めに撃ちます。最初に、攻撃の説明をグローバル攻撃テーブルに追加する必要があります。この攻撃の冷却時間は0.32秒で、弾薬2個を消費し、その色は次のようになりますammo_color（これらの値は試行錯誤で取得しました）。

 attacks = { ... ['Double'] = {cooldown = 0.32, ammo = 2, abbreviation = '2', color = ammo_color}, } 

これを関数に追加できますshoot：

 function Player:shoot() ... elseif self.attack == 'Double' then self.ammo = self.ammo - attacks[self.attack].ammo self.area:addGameObject('Projectile', self.x + 1.5*d*math.cos(self.r + math.pi/12), self.y + 1.5*d*math.sin(self.r + math.pi/12), {r = self.r + math.pi/12, attack = self.attack}) self.area:addGameObject('Projectile', self.x + 1.5*d*math.cos(self.r - math.pi/12), self.y + 1.5*d*math.sin(self.r - math.pi/12), {r = self.r - math.pi/12, attack = self.attack}) end end 

ここでは、1つではなく2つのシェルを作成しています。それぞれのシェルは、math.pi / 12ラジアンまたは15度の角度に向けられています。また、シェルに攻撃の名前として属性を取得させましたattack。発射物がどのタイプの攻撃に属しているかを判断するのに役立つため、発射物のタイプごとにこれを行います。これは、適切な色を設定したり、必要に応じて動作を変更したりするのに役立ちます。Projectileオブジェクトは次のようになります。

 function Projectile:new(...) ... self.color = attacks[self.attack].color ... end function Projectile:draw() pushRotate(self.x, self.y, Vector(self.collider:getLinearVelocity()):angle()) love.graphics.setLineWidth(self.s - self.s/4) love.graphics.setColor(self.color) love.graphics.line(self.x - 2*self.s, self.y, self.x, self.y) love.graphics.setColor(default_color) love.graphics.line(self.x, self.y, self.x + 2*self.s, self.y) love.graphics.setLineWidth(1) love.graphics.pop() end 

コンストラクターではcolor、この攻撃に対してグローバルテーブルで定義された色を設定しますattacks。そして、描画関数では、属性colorであるこの色で線の一部を描画し、もう一方である線を描画しますdefault_color。ほとんどのタイプのシェルでは、パターンは同じです。

最後に忘れてしまったのは、この攻撃をルール1に準拠させることです。つまり、適切な量の弾薬を消費させるコードを追加するのを忘れました。これはかなり簡単に修正できます。

 function Player:shoot() ... elseif self.attack == 'Double' then self.ammo = self.ammo - attacks[self.attack].ammo ... end end 

これにより、ルール1が実行されます（ダブル攻撃の場合）。ルール2を実装するコードを追加することもできますammo。0 になったら、現在の攻撃をNeutral次のように変更します。

 function Player:shoot() ... if self.ammo <= 0 then self:setAttack('Neutral') self.ammo = self.max_ammo end end 

shoot弾薬の量が0になった後、プレーヤーに撃たせたくないので、関数の最後に移動する必要があり

ます。これを実行してプログラムを実行しようとすると、次のようになります。

攻撃演習

104.（CONTENT）攻撃を実装しTripleます。攻撃テーブルでの定義は次のとおりです。

 attacks['Triple'] = {cooldown = 0.32, ammo = 3, abbreviation = '3', color = boost_color} 

そして、攻撃自体は次のようになります。


シェルの角度はinとまったく同じDoubleですが、中央に（攻撃シェルと同じ角度で）追加の​​シェルが作成されていNeutralます。ダブル攻撃と同じ手順に従って、この攻撃を作成します。

105.（CONTENT）攻撃を実装しRapidます。攻撃テーブルでの定義は次のようになります。

 attacks['Rapid'] = {cooldown = 0.12, ammo = 1, abbreviation = 'R', color = default_color} 

そして、攻撃自体は次のようになります。


106.（CONTENT）攻撃を実装しSpreadます。攻撃の表におけるその定義：

 attacks['Spread'] = {cooldown = 0.16, ammo = 1, abbreviation = 'RS', color = default_color} 

そして、攻撃自体は次のようになります。


ショットに使用される角度は、-math.pi / 8〜+ math.pi / 8のランダムな値です。この攻撃のシェルの色も少し異なります。色を1つだけにするのではなく、各フレームで色をリストの1つにall_colors（または気分に応じてフレーム全体で）ランダムに変更します。

107.（CONTENT）攻撃を実装しBackます。攻撃テーブルでの定義は次のようになります。

 attacks['Back'] = {cooldown = 0.32, ammo = 2, abbreviation = 'Ba', color = skill_point_color} 

そして、攻撃自体は次のようになります。


108.（CONTENT）攻撃を実装しSideます。攻撃の表におけるその定義：

 attacks['Side'] = {cooldown = 0.32, ammo = 2, abbreviation = 'Si', color = boost_color} 

攻撃自体：


109.（CONTENT）リソースを実装しAttackます。以下のようBoostでSkillPoint、攻撃のリソースは、画面の左端または右端に作成した後、非常にゆっくりと内側に移動されます。プレーヤーが攻撃リソースと対話すると、関数を使用setAttackした攻撃は、リソースに含まれる攻撃に変わります。

Attackリソースは、BoostおよびSkillPointリソースと外観がわずかに異なりますが、彼自身と彼の効果の原理はほとんど同じです。各リソースに使用される色はシェルと同じであり、識別子名はabbreviation表で名前を付けたものattacksです。それらは次のようになります。


プレーヤーによる新しい攻撃を拾うときは、InfoTextオブジェクトを作成することを忘れないでください！

---

パート8：敵

はじめに

このパートでは、いくつかの敵の作成と、EnemyProjectileクラス、つまり、一部の敵がプレイヤーを撃つことができるシェルを検討します。この部分は他の部分よりも少し短くなります。これは、すべての敵の作成について詳細に説明するのではなく、すべての敵についてほぼ同じである一般的な動作についてのみ説明するためです。

敵

このゲームの敵は、前のパートで作成したリソースとほぼ同じように動作します。画面の左または右の境界付近にランダムな位置yで作成され、その後ゆっくり内側に移動します。それらの動作のコードは、リソースに実装したものとほぼ同じです。

最初に命名しRockた敵から始めます。次のようになります。


このオブジェクトのコンストラクタコードは、コードと非常に似ていますBoostが、わずかな違いがあります。

 function Rock:new(area, x, y, opts) Rock.super.new(self, area, x, y, opts) local direction = table.random({-1, 1}) self.x = gw/2 + direction*(gw/2 + 48) self.y = random(16, gh - 16) self.w, self.h = 8, 8 self.collider = self.area.world:newPolygonCollider(createIrregularPolygon(8)) self.collider:setPosition(self.x, self.y) self.collider:setObject(self) self.collider:setCollisionClass('Enemy') self.collider:setFixedRotation(false) self.v = -direction*random(20, 40) self.collider:setLinearVelocity(self.v, 0) self.collider:applyAngularImpulse(random(-100, 100)) end 

ここでは、RectangleColliderの代わりに、オブジェクトはPolygonColliderを使用します。createIrregularPolygonで定義される関数を使用して、このポリゴンの頂点を作成しutils.luaます。この関数は、不規則な長方形を構成する頂点のリストを返す必要があります。不規則な長方形とは、円のように見えるものを意味しますが、その各頂点は中心からわずかに近くまたは遠くにあり、各頂点間の角度もわずかにランダムになります。

関数の定義を開始するには、2つの引数を受け取ると言うことができます：sizeとpoint_amount。 1つ目は円の半径を示し、2つ目はポリゴン（ポリゴン）を構成するポイントの数を示します。

 function createIrregularPolygon(size, point_amount) local point_amount = point_amount or 8 end 

ここでpoint_amount、定義されていない場合のデフォルトは8であると言うこともできます

。次にできることは、すべてのポイントを定義することです。これは、1〜のサイクルで実行できます。point_amount各サイクルで、角度の間隔に基づいて次の頂点を決定します。たとえば、2番目の点の位置を決定するために、その角度はinterval 2*angle_intervalにあるangle_intervalと言えます2*math.pi/point_amount。ここではvalue です。つまり、この場合、約90度になります。このコードを記述する方が論理的です。したがって、

 function createIrregularPolygon(size, point_amount) local point_amount = point_amount or 8 local points = {} for i = 1, point_amount do local angle_interval = 2*math.pi/point_amount local distance = size + random(-size/4, size/4) local angle = (i-1)*angle_interval + random(-angle_interval/4, angle_interval/4) table.insert(points, distance*math.cos(angle)) table.insert(points, distance*math.sin(angle)) end return points end 

ここでangle_interval、上で説明したようにを定義しますdistanceが、円の半径内のどこかで、からのランダムオフセットで定義-size/4し+size/4ます。これは、各頂点が円の円周上ではなく、近くのどこかにあることを意味します。また、角度の範囲を少しランダム化して、同じ効果を作成します。最後に、xおよびyコンポーネントを返されたポイントのリストに追加します。ポリゴンはローカル空間に作成されることに注意してください（中心が0、0であると仮定）。つまり、ポリゴンを使用してオブジェクトを正しい場所に配置する必要がありますsetPosition。

このオブジェクトのコンストラクターのもう1つの違いは、衝突クラスを使用することEnemyです。他のすべての衝突クラスと同様に、このクラスも使用前に定義する必要があります。

 function Stage:new() ... self.area.world:addCollisionClass('Enemy') ... end 

一般に、相互に異なる衝突動作を持つオブジェクトのタイプには、新しい衝突クラスを追加する必要があります。例えば、敵はプレイヤーを物理的に無視しますが、シェルは無視しません。他の種類のオブジェクトはこの動作を使用しないため、新しい衝突クラスを作成する必要があります。発射物の衝突クラスがプレーヤーのみを無視し、他のシェルを無視しない場合、発射物の衝突クラスは敵にも使用できます。

Rockオブジェクトで最後に行うことは、それをレンダリングすることです。これは単なるポリゴンであるため、次のようにして単純にポイントを描画できますlove.graphics.polygon。

 function Rock:draw() love.graphics.setColor(hp_color) local points = {self.collider:getWorldPoints(self.collider.shapes.main:getPoints())} love.graphics.polygon('line', points) love.graphics.setColor(default_color) end 

最初にこれらのポイントを取得しPolygonShape:getPointsます。ポイントはローカル座標で返されますが、グローバル座標が必要なのでBody:getWorldPoints、ローカル座標をグローバル座標に変換するためにそれらを使用する必要があります。その後、ポリゴンを描くことができ、期待どおりに動作します。コライダーから直接ポイントを取得し、コライダーが回転するポリゴンpushRotateであるため、結果のポイントはすでにオブジェクトの回転を考慮しているため、Boostオブジェクトのようにオブジェクトを使用して回転させる必要はありません。

これをすべて行うと、ゲームは次のようになります。

敵の演習

110.次のタスクを実行します。

• hp開始値が100の属性をRockクラスに追加します。
• Rock hit . :
  
  
  • damage , , 100
  • damage hp , hp 0 , Rock «»
  • hp 0 , hit_flash true, 0,2 — false. hit_flash true, default_color , hp_color .

111.新しいクラスを作成しますEnemyDeathEffect。この効果は、敵が死んでオブジェクトProjectileDeathEffectとまったく同じように振る舞うときに作成されますが、それだけが大きく、Rockオブジェクトのサイズに対応します。このオブジェクトは、hpRockオブジェクト属性が0以下になったときに作成する必要があります。

112.発射物衝突クラスオブジェクトと敵衝突クラスオブジェクト間の衝突イベントを実装します。この場合、Projectileクラスの更新関数に実装する必要があります。シェルがEnemyクラスのオブジェクトにヒットすると、シェルhitによって引き起こされたダメージの量で敵の関数を呼び出す必要があります（デフォルトでは、シェルの属性damageは最初は100になります）。ヒットした場合、発射物は独自の関数も呼び出す必要がありますdie。

113。Playerクラスに関数を追加しますhit。この関数は次のことを行う必要があります。

• 引数を受け取る必要があり、damage定義されていない場合、デフォルト値は10です。
• この関数は、属性invincibleをtrueに設定する以外は何もしません。
• 4〜8個のオブジェクトを作成する必要があります ExplodeParticle
• 関数addHP（またはremoveHP、追加することを決定した場合）は、属性damageを受け取り、それを使用してPlayerオブジェクトのHPを下げる必要があります。関数addHP（またはremoveHP）の内部で、hp0以下になりプレーヤーが死んだ場合の状況を処理する方法を実装する必要があります。

さらに、次の条件付き取引は公正でなければなりません。

• 30, invincible true, — false. , 0,2 6, , 0,5 0,25. , invisible true false 0,04 , invincible true. invisible true, Player .
• 30, 0,1 6, , 0,25 0,75.

この関数hitは、プレーヤーが敵と衝突したときに呼び出す必要があります。敵と衝突した場合、プレイヤーに30のダメージを与える必要があります。

---

これらの4つの演習を完了すると、プレーヤー、投射物、敵の岩の間の相互作用に必要なものがすべて揃うはずです。これらの相互作用は他の敵に適用されます。すべて次のようになります。

敵の発射物

これで、敵との作業の別の部分-砲弾を発射する敵の作成に集中できます。そのような機会は一部の敵が利用できるようになるので、Projectileに似ているが敵が使用するオブジェクトを作成する必要があります。これを行うには、オブジェクトを作成しますEnemyProjectile。

コードをコピーして少し変更するだけで、最初にこのオブジェクトを作成できますProjectile。これらのオブジェクトの両方には多くの共通点があります。共通の振る舞いをする共通の発射物オブジェクトに抽象化できますが、実際にはゲームには2種類のシェルしかないため、これは必要ありません。コピー後、次の変更を行う必要があります。

 function EnemyProjectile:new(...) ... self.collider:setCollisionClass('EnemyProjectile') end 

EnemyProjectile衝突クラスもEnemyProjectileでなければなりません。EnemyProjectileオブジェクトが他のEnemyProjectile、Projectile、およびPlayerを無視するようにします。したがって、この目標に対応する衝突クラスを追加します。

 function Stage:new() ... self.area.world:addCollisionClass('EnemyProjectile', {ignores = {'EnemyProjectile', 'Projectile', 'Enemy'}}) end 

変更する必要がある別の重要な側面は損傷です。プレイヤーが発射した通常の発射物は100ダメージを与え、敵の砲弾は10ダメージを与えます。

 function EnemyProjectile:new(...) ... self.damage = 10 end 

また、Playerと競合するが、他の敵と競合しないためには、敵が発射したシェルが必要です。したがって、Projectileオブジェクトで使用される衝突コードを取得し、Player自体にラップします。

 function EnemyProjectile:update(dt) ... if self.collider:enter('Player') then local collision_data = self.collider:getEnterCollisionData('Player') ... end 

最後に、このオブジェクトを赤白ではなく完全に赤にすることで、プレーヤーが自分のシェルを敵のものと区別できるようにします。

 function EnemyProjectile:draw() love.graphics.setColor(hp_color) ... love.graphics.setColor(default_color) end 

これらの小さな変更をすべて行ったので、EnemyProjectileオブジェクトを作成できました。次に、それを使用する敵を作成する必要があります！

敵を撃つ

敵のシューターは次のようになります。


ご覧のとおり、最初は小さな効果が再現され、次に砲弾が発射されます。発射物はプレーヤーと同じように見えますが、完全に赤いだけです。

Rockオブジェクトからコードをコピーすることで、この敵の作成を​​開始できます。この敵（そして実際すべての敵）は、画面の左または右に現れてからゆっくりと内側に移動するという共通の特性を持ちます。Rockオブジェクトにはすでにこのコードが含まれているため、これから始めます。コードをコピーした後、小さな変更を加える必要があります。

 function Shooter:new(...) ... self.w, self.h = 12, 6 self.collider = self.area.world:newPolygonCollider( {self.w, 0, -self.w/2, self.h, -self.w, 0, -self.w/2, -self.h}) end 

敵のシューターの幅、高さ、上部の値は、ロックとは異なります。石では、単純に不規則な多角形を作成しましたが、プレイヤーが自分がどこに移動するかを本能的に理解できるように、この敵にははっきりと区別できる尖った形状を与える必要があります。ここでのピークの設定は、船の設計プロセスに似ています。したがって、必要に応じて、敵の外観を変更して、より急峻にすることができます。

 function Shooter:new(...) ... self.collider:setFixedRotation(false) self.collider:setAngle(direction == 1 and 0 or math.pi) self.collider:setFixedRotation(true) end 

また、以下を変更する必要があります。石とは異なり、オブジェクトの速度を設定するだけでは十分ではありません。また、物理コライダーが正しい方向を向くように角度を設定する必要があります。これを行うには、最初に一定の回転を無効にし（それ以外の場合、角度の設定は機能しません）、角度を変更してから、一定の回転を再び真にする必要があります。何かが衝突したときにコライダーを回転させたくないため、回転を再び永続化します。動きの方向に向けておく必要があります。

文字列direction == 1 and math.pi or 0は、Luaの三項演算子の実装です。他の言語では、次のようになり(direction == 1) ? math.pi : 0ます。第2部と第4部の演習では、それらを詳細に検討できたと思います。本質的に、ここでは次のことが起こります。direction1に等しい（敵が右側に表示され、左側に向けられる）場合、最初の条件付き構文はtrueに解析されます。つまり、が取得されtrue and math.pi or 0ます。注文の執行のためにand、そしてor最初の意志true and math.pi結果として、我々は持っているだろう、で、math.pi or 0両方の要素が真であるとき、そしてので、そのリターンにMath.PIをor最初のものを返します。一方、direction-1の場合、最初の条件付き構文はfalseに解析されfalse and math.pi or 0、成功します。つまりfalse or 00になりorます。最初の要素がfalseの場合、2番目の要素が返されるためです。

これらすべてを念頭に置いて、ゲーム内でShooterオブジェクトの作成を開始できます。これらは次のようになります。


次に、攻撃前の効果を作成する必要があります。通常、ほとんどのゲームでは、敵が攻撃しようとすると、何かがプレイヤーに通知されます。ほとんどの場合、これはアニメーションですが、エフェクトでもあります。この場合、単純な「チャージング」エフェクトを使用します。このエフェクトでは、発射物が飛ぶ点まで多くの粒子が吸収されます。

高レベルでの実装方法は次のとおりです。

 function Player:new(...) ... self.timer:every(random(3, 5), function() -- spawn PreAttackEffect object with duration of 1 second self.timer:after(1, function() -- spawn EnemyProjectile end) end) end 

これは、3〜5秒の間隔で、各敵の射手が新しい発射物を発射することを意味します。これは、エフェクトPreAttackEffectが1秒間完了した後に発生します。

同様の効果は、粒子で次のように機能します。排気トレースの場合、各フレームまたはフレームを通して、特定のタイプの粒子が作成され、この効果が構成されます。この場合、パーティクルはの名前で作成されTargetParticleます。これらのパーティクルは、ターゲットとして定義したポイントまで移動し、しばらくしてから、または目標に到達したときに消滅します。

 function TargetParticle:new(area, x, y, opts) TargetParticle.super.new(self, area, x, y, opts) self.r = opts.r or random(2, 3) self.timer:tween(opts.d or random(0.1, 0.3), self, {r = 0, x = self.target_x, y = self.target_y}, 'out-cubic', function() self.dead = true end) end function TargetParticle:draw() love.graphics.setColor(self.color) draft:rhombus(self.x, self.y, 2*self.r, 2*self.r, 'fill') love.graphics.setColor(default_color) end 

ここでは、各パーティクルについて、時間の経過とともにd（または0.1〜0.3秒のランダムな値）、トゥイーンはに移行しtarget_x, target_y、パーティクルがこの位置に到達すると消滅します。パーティクルは菱形としても描画されます（以前に作成したエフェクトの1つとして）が、非常に小さく、時間とともにさらに小さくなるため、円または正方形として描画することもできます。

これらのオブジェクトPreAttackEffectを次のように作成します。

 function PreAttackEffect:new(...) ... self.timer:every(0.02, function() self.area:addGameObject('TargetParticle', self.x + random(-20, 20), self.y + random(-20, 20), {target_x = self.x, target_y = self.y, color = self.color}) end) end 

そのため、ここでは、位置の周りのランダムな場所に0.02秒ごとに（ほぼすべてのフレームで）1つのパーティクルを作成しtarget_x, target_y、エフェクト自体（つまり、船の船首）の位置値に属性を設定します。次のように我々はPreAttackEffectを作成します。

Shooter

 function Shooter:new(...) ... self.timer:every(random(3, 5), function() self.area:addGameObject('PreAttackEffect', self.x + 1.4*self.w*math.cos(self.collider:getAngle()), self.y + 1.4*self.w*math.sin(self.collider:getAngle()), {shooter = self, color = hp_color, duration = 1}) self.timer:after(1, function() end) end) end 

設定する初期位置は、Shooterオブジェクトの鼻の上にある必要があります。そのため、既に適用したmath.cosとmath.sinで通常のパターンを使用し、可能な両方の角度（0とmath.pi）を考慮することができます。durationPreAttackEffectの有効期間を制御する属性を渡すこともできます。ここでは次のことができます。

 function PreAttackEffect:new(...) ... self.timer:after(self.duration - self.duration/4, function() self.dead = true end) end 

私はduration自分自身を「コントローラーオブジェクト」と呼ぶオブジェクトなので、使用しません。たとえば、描画関数には何もありません。つまり、ゲームでは表示されません。TargetParticle彼が作成するように注文したオブジェクトのみが表示されます。これらのオブジェクトは、0.1秒から0.3秒までのランダムな寿命を持ちます。つまり、発射物で撃ったときに最後のパーティクルをすぐに終わらせたい場合、このオブジェクトはその持続時間より0.1-0.3秒遅れて死にます。 1秒で。 0.75（期間-期間/ 4）に等しくすることにしましたが、代わりに0.9秒に近い別の数値を使用できます。

ここでゲームを実行すると、次のようになります。


そして、すべてが非常にうまく機能します。しかし、よく見ると、ターゲットパーティクルの位置（PreAttackEffectオブジェクトの位置）が固定されたままであり、シューターに従わないことがわかります。これは、プレーヤーのShootEffectオブジェクトを修正したのと同じ方法で修正できます。shooterPreAttackEffectオブジェクトを作成したShooterオブジェクトを指す属性が既にあるため、この親オブジェクトの位置に基づいてPreAttackEffectの位置を更新するだけshooterです。

 function PreAttackEffect:update(dt) ... if self.shooter and not self.shooter.dead then self.x = self.shooter.x + 1.4*self.shooter.w*math.cos(self.shooter.collider:getAngle()) self.y = self.shooter.y + 1.4*self.shooter.w*math.sin(self.shooter.collider:getAngle()) end end 

ここでは、各フレームをこのオブジェクトの位置を更新して、オブジェクトを作成したShooterオブジェクトの鼻の上に配置します。ゲームを実行すると、次のようになります。


更新コードの重要な側面はその部分not self.shooter.deadです。このように相互に内部のオブジェクトを参照する場合、一方のオブジェクトが消滅しても、もう一方のオブジェクトがそのオブジェクトへのリンクを保存することがあります。たとえば、PreAttackEffectオブジェクトの有効期間は0.75秒ですが、作成から消滅までの間、作成したShooterオブジェクトはプレイヤーによって殺される可能性があります。これが発生すると、問題が発生する可能性があります。

私たちの場合、問題はcollider、Shooterオブジェクトの属性にアクセスできることです。この属性は、Shooterオブジェクトが消滅すると破棄されます。そして、このオブジェクトが破壊された場合、それはもう存在しないため、何もできません。実行しようとするとgetAngleその後、ゲームは落ちます。このような問題を解決する共通のシステムを開発することはできますが、実際には必要だとは思いません。今のところ、この方法でオブジェクトを参照するときは、すでに死んでいる可能性のあるオブジェクトにアクセスしようとしないように注意するだけで十分です。

そして最後に、EnemyProjectileオブジェクトを作成する最後の部分です。これを非常に簡単に操作して作成しますが、通常どおり、他のオブジェクトを作成しますが、独自の属性を使用します。

 function Shooter:new(...) ... self.timer:every(random(3, 5), function() ... self.timer:after(1, function() self.area:addGameObject('EnemyProjectile', self.x + 1.4*self.w*math.cos(self.collider:getAngle()), self.y + 1.4*self.w*math.sin(self.collider:getAngle()), {r = math.atan2(current_room.player.y - self.y, current_room.player.x - self.x), v = random(80, 100), s = 3.5}) end) end) end 

ここでは、PreAttackEffectを作成したのと同じ位置に発射物を作成し、その速度に80と100のランダムな値を割り当てます。また、デフォルト値に対してサイズをわずかに大きくします。最も重要な部分は、その角度（r属性）がプレーヤーの方向を指していることです。我々はの角度を取得したいとき、一般的なケースでは、sourceアップをするためにtarget、我々は次のことを行う必要があります。

 angle = math.atan2(target.y - source.y, target.x - source.x) 

だからそうする。オブジェクトを作成した後、それはプレーヤーに向けられ、彼に向かって動き始めます。次のようになります。


このアニメーションをチュートリアルのこの部分の最初のアニメーションと比較すると、わずかな違いがわかります。シェルは、プレイヤーに直接飛行するのではなく、プレイヤーに向かってゆっくりと回っている期間があります。これは、パッシブホーミングスキルと同じコードフラグメントを使用します。これは、時間の経過とともに追加されるので、後で使用します。

徐々に、EnemyProjectileオブジェクトにさまざまな機能を追加して、多くの異なる敵に適用できるようにします。ただし、このすべての機能は、プレーヤーのパッシブスキルとして機能するため、Projectileオブジェクトに最初に実装されます。たとえば、シェルをプレイヤーの周りに回す受動的なスキルがあります。実装したら、コードをEnemyProjectileオブジェクトにコピーし、関数を使用して敵を実装できます。彼は砲弾を撃ちません-彼らは彼の周りを旋回します。このようにして、多くの敵を作成します。そのため、プレイヤーに受動的なスキルを作成するときは、この部分を演習として残します。

2人の敵（ロックとシューター）で停止している間、EnemyProjectileをそのままにして、他の側面に進みます。ただし、後でゲームに機能を追加すると、新しい敵を作成するために戻ります。

EnemyProjectile / Shooterの練習

114. ProjectileとEnemyProjectile間の衝突イベントを実装します。EnemyProjectileクラスで、Projectileクラスのオブジェクトに入ると、die両方のオブジェクトの関数が呼び出され、両方が破棄されることを確認してください。

115.direction Shooterクラスの属性名は混乱しますか？もしそうなら、どのように名前を変更する必要がありますか？そうでない場合、なぜですか？