Membuat Game dengan Megaman-Inspired di Construct 2

() translation by (you can also view the original English article)

Saya akan memandu Anda melalui penciptaan game shooter / platformer yang terinspirasi dari Megaman. Kita akan lebih fokus pada aspek pemotretan gameplay daripada platformnya. Dalam tutorial ini saya akan menggunakan Construct 2 sebagai alat untuk membuat game, tapi saya akan menjelaskan logika menggunakan pseudocode sehingga Anda bisa mengikuti tutorial ini dalam bahasa atau mesin pilihan Anda.

Related Posts

Klik game untuk memberi fokus, lalu gunakan tombol panah untuk bergerak dan melompat, dan Z untuk menembak.

Agar fokus pada implementasi gameplay, saya tidak akan menjelaskan setiap fitur construct 2; Saya akan berasumsi bahwa Anda mengetahui dasar-dasar seperti memuat sprite, tabrakan dasar, atau pemutar suara. Dengan dasar-dasar ini, marilah mulai membuat game.

Siapkan Artwork

Hal pertama yang pertama, kita perlu memiliki sprite untuk game kita. Untungnya, opengameart telah menyelamatkan kita dengan seni game legal mereka yang snagat hebat. Kita membutuhkan empat set sprite; satu pahlawan, satu musuh, dan ubin untuk platform.

Hero (by Redshrike):
http://opengameart.org/content/xeon-ultimate-smash-friends
Enemy (also by Redshrike):
http://opengameart.org/content/fighting-robot-for-ultimate-smash-friends
Tiles (by robotality):
http://opengameart.org/content/prototyping-2d-pixelart-tilesets

Untuk menggunakannya di platform Construct 2, saya memangkas sprite pahlawan ke bingkai individu menggunakan GIMP.

Gerakan Dasar

Saya akan menggunakan perilaku platform Construct 2 untuk sisa tutorial sehingga saya dapat fokus pada bagian shooting dan AI dari game, yang menjadi fokus utama dari tutorial ini.

Construct 2s platform behaviour — Platform penampilan Construct 2's

Basic Movement Explained

Jika Anda menggunakan bahasa lain, atau ingin menerapkan platform dasar Anda dari pada menggunakan platform built-in. Anda hanya perlu menggunkan kode dalam tahapan ini jika Anda tidak ingin menggunakan platformConstruct 2's built-in.

Untuk memulianya, kita perlu untuk mempertimbangkan tiga cara untuk berpindah; berjalan ke arah kanan, berjalan ke arah kiri, ataupun melompat. Setiap frame akan diperbarui simulasi gamemya.

number moveSpeed = 50;

function update()
{
 moveHero();
}

Untuk memperbarui karakter pemain, kita menerapkan perpindahan dasar seperti

function moveHero()
{
 // player is pressing this key down
 if (keyDown(KEY_LEFT))
 {
 hero.x -= moveSpeed * deltaTime;
 hero.animate("walkLeft");
 }

if (keyDown(KEY_RIGHT))
 {
 hero.x += moveSpeed * deltaTime;
 hero.animate("walkRight");
 }

if (keyDown(KEY_UP))
 {
 hero.jump();
 hero.animate("jump");
 }

// a key that was just unpressed
 if (keyReleased(KEY_LEFT))
 {
 hero.animate("standLeft");
 }

if (keyReleased(KEY_RIGHT))
 {
 hero.animate("standRight");
 }
}

Saya menggunakan fungsi lain untuk melakukan lompatan karena melompat bukan hanya masalah mengubah nilai y tapi juga menghitung gravitasi. Kami juga akan memiliki fungsi yang akan merespon apakah sebuah kunci baru saja diluncurkan, untuk mengembalikan animasi pahlawan kita menjadi animasi bertahan.

Mari kita bicara tentang bagaimana membuat pemain melompat. Pahlawan itu perlu tahu apakah dia saat ini sedang melompat atau tidak, dan juga apakah dia saat ini jatuh atau tidak. Jadi kita akan mendeklarasikan dua variabel baru: isJumping danisFalling. Secara default, keduanya salah, yang berarti sang pahlawan berdiri di atas panggung.

Untuk melakukan lompatan kita harus terlebih dahulu mengecek apakah kedua nilai itu salah, dan kemudian membuat kode isjump menjadi benar.

Function jump()
{
 if (!isJumping && !isFalling)
 {
 isJumping = True
 }
}

Agar sang pahlawan bisa melompat, kita butuh variabel yang disebut jumpPower dan gravity. Nilai default the jumpPower adalah -20 dan gravitasi adalah 1. Logikanya adalah menambahkan nilai daya loncat ke posisi Y pahlawan dan menambahkan gaya gravitasi untuk memberi nilai daya.

Kami melakukan ini setiap pada tahap. Mungkin ini bukan fisika gravitasi paling realistis yang ada, tapi game tidak perlu realistis, mereka hanya perlu dipercaya, karena itulah beberapa game memiliki lompatan manusia super dan lompatan ganda. Kode di bawah ini termasuk dalam fungsi pembaruan. Kode berikut termasuk dalam fungsi update.

If (isJumping || isFalling)
{
 hero.y += hero.jumpPower;
 hero.jumpPower += hero.gravity;
}

// eventually jump power will be greater than zero, and that means the hero is falling

if (hero.jumpPower >= 0)
{
 isJumping = False;
 isFalling = True;
}

// to make a stop to the fall, do something when the hero overlaps the platform

if (hero.isOverlapping(platform1))
{
 // platform1 is the platform that our hero can step on
 // resets the variable to their default value
 isJumping = False;
 isFalling = False;
 hero.jumpPower = -20;
}

// and then there's the free fall, when player falls over the edge of a platform
if (!hero.isOverlapping(platform1) && hero.jumpPower < 0 && !isJumping)
{
 // !hero.isOverlapping(platform1) checks whether or not our hero is standing on a platform
 // and if jumpPower is less than zero and the player is not currently jumping, then that means
 // he's falling

// setting these two values like this will make the player fall.
 hero.jumpPower = 0;
 isFalling = true;
}

Buatlah perilaku platform built-in 2 mereplikasi kode contoh di atas, yang hanya memberi bantuan kepada mereka yang bekerja dalam bahasa lain.

Menerapkan Penembakan

sampailah pada tahap penembakan dari sebuah game. Di seri Megaman ada tiga jenis tembakan: tembakan normal, tembakan bermuatan, dan tembakan energi tertingi.

tembakan normal cukup jelas. Charged shots adalah tembakan yang dibebankan terlebih dahulu sebelum dilepaskan, tembakan bermuatan ini datang dalam dua jenis: setengah diisi, dan terisi penuh. Serangan bermuatan ini lebih kuat dari tembakan normal, dengan terisi penuh maka ini menjadi yang terkuat.

Tembakan energi tinggi adalah tembakan dengan kekuatan yang diperoleh pemain setelah mengalahkan masing-masing atasan. Kerusakannya sama dengan tembakan normal tapi memiliki sifat khusus yang tidak dimiliki tembakan biasa.

Sekarang kita tahu tipe masing-masing tembakan, mari kita mulai untuk membuatnya. Pertama mari kita lihat logika di balik bagaimana kita menggunakan setiap tembakan. Di sini kita asumsikan bahwa tombol Z pada keyboard digunakan untuk menembakkan tembakan. Kami akan menerapkan dua perilaku yang berbeda:

Sekarang kita tahu tipe masing-masing tembakan, mari kita mulai untuk membuatnya. Pertama mari kita lihat logika di balik bagaimana kita menggunakan setiap tembakan. Di sini kita asumsikan bahwa tombol Z pada keyboard digunakan untuk menembakkan tembakan. Kami akan menerapkan dua perilaku yang berbeda:
Tembakan bermuatan: pemain menekan Z. Peluru normal pertama akan ditembak. Animasi akan berubah menjadi penembakan sebelum segera beralih ke animasi berdiri. Jika Z terus ditekan maka efek pengisian akan ditambahkan di atas animasi bermain (berdiri, berjalan). · Jika tombol Z dilepaskan dalam waktu kurang dari 5 detik sejak pengisian pertama, maka peluru yang setengah terisi akan ditembak. Jika tombol Z dilepaskan setelah 5 detik, peluru yang terisi penuh akan ditembak.
Tembakan energi tinggi: pahlawan kita pertama-tama harus melengkapi peluru yang dia dapatkan setelah mengalahkan atasan. Setelah melengkapi, pemain akan menekan tombol lain untuk menembakkan peluru ini. Perilaku peluru ini bervariasi, dan perlu dikodekan secara unik untuk setiap peluru.

Sekarang, mari kita mulai meng-kode. Karena pahlawan kita bisa menembak ke kiri dan kanan kita perlu tahu arah mana yang sedang dia hadapi. Mari kita nyatakan sebuah variabel baru yang disebut menghadap yang menyimpan nilai string apakah pahlawan itu menghadap ke kiri atau kanan.

String facing = "right"; // which direction the hero is currently facing
function moveHero()
{
 // player is pressing this key down
 if (keyDown(KEY_LEFT))
 {
 hero.x -= moveSpeed * deltaTime;
 hero.animate("walkLeft");

 facing = "left";
 }

if (keyDown(KEY_RIGHT))
 {
 hero.x += moveSpeed * deltaTime;
 hero.animate("walkRight");

facing = "right";
 }

// ... the continuation of moveHero() function goes here
}

function update()
{
 // ...the update code that we previously wrote goes here...

// player press this key once
 if (keyPressed(KEY_Z))
 {
 if (facing == "right")
 {
 hero.animate("Shoot");

// we will add shooting function here later
 }
 else if (facing == "left")
 {
 hero.animate("Shoot");
 hero.mirrorSprite(); // this function flips the sprite horizontally
 }
 }

if (keyReleased(KEY_Z))
 {
 if (facing == "right")
 {
 hero.animate("standRight");
 }
 else if (facing == "left")
 {
 hero.animate("standLeft");
 hero.mirrorSprite(); // we need to call this again because the sprite was mirrored
 // if we don't mirror the sprite again, standLeft will look like standRight
 }
 }
}

move events in construct 2 — Pindahkan adegan di Construct 2

Sebelum kita menembak peluru, kita perlu melihat properti yang dimiliki peluru tersebut:

Kekuasaan: kekuatan serangan peluru, kerusakan yang akan ditanggungnya terhadap musuh
Kecepatan: seberapa cepat peluru pergi
Sudut: sudut penembakan, menentukan arah peluru.

Properti ini akan berbeda untuk setiap peluru. Secara khusus, properti energi akan berbeda. Sudut properti biasanya hanya satu dari dua nilai; apakah peluru itu ditembak ke kanan atau kiri, kecuali jika itu adalah peluru energi tinggi yang mungkin tertembak pada sudut yang unik.

Variasi penembakan akan dibahas nanti jadi sekarang saya hanya akan menyelesaikan penembakna dasar. Berikut ini adalah potongan kode yang dapat menembakkan peluru.

// first, we create a function that creates a new bullet
Function shoot(string pathToSprite, number bulletPower, number bulletSpeed, number bulletAngle)
{
 myBullet = new Bullet(pathToSprite);
 myBullet.power = bulletPower;

// the bullet class or object has two private variables that moves it according to its angle
 // more explanation to these two lines need more math, so I choose not to explain
 // I assume your engine of choice have a way to move an object according to its angle
 ySpeed = Math.sin(bulletAngle) * bulletSpeed;
 xSpeed = Math.cos(bulletAngle) * bulletSpeed;
}

// this is Bullet class' function that's called every frame, this moves the bullet according to its angle
function moveBullet()
{
 x += xSpeed * deltaTime;
 y += ySpeed * deltaTime;
}

// and this is the modification to our previous update() function
function update()
{
 // ...the update code that we previously wrote goes here...

// player press this key once
 if (keyPressed(KEY_Z))
 {
 if (facing == "right")
 {
 hero.animate("Shoot");
 hero.shoot("path/to/sprite.png", 10, 400, 0);

}
 else if (facing == "left")
 {
 hero.animate("Shoot");
 hero.mirrorSprite(); // this function flips the sprite horizontally
 hero.shoot("path/to/sprite.png", 10, 400, 180); // the angle is 180 so that the bullet goes left
 }
 }

// .. the continuation of update code goes here...
}

add bullet behaviour to the bullets — Tambahkan perilaku peluru pada peluru sprites

shooting code spawn new bullet object — Kode pemotretan dimana kita menelurkan sebuah peluru baru

Penembakan Bermuatan

Beberapa peluru bisa lebih bertenaga dibanding yang lain. Untuk membuat tembakan bermuatan, kami memerlukan variabel bernama chargedTime, yang akan bertambah setiap detik jika pemain menahan Z turun, dan akan kembali ke nol saat peluru ditembakkkan. Perubahan pada kode pembaruan adalah sebagai berikut:

// player just released z key
if (keyReleased(KEY_Z))
{
 if (chargedTime > 0 && chargedTime <= 5)
 {
 if (facing == "right")
 {
 hero.animate("Shoot");
 hero.shoot("path/to/halfChargedBullet.png", 20, 400, 0);
 chargedTime = 0;

}
 else if (facing == "left")
 {
 hero.animate("Shoot");
 hero.mirrorSprite(); // this function flips the sprite horizontally
 hero.shoot("path/to/halfChargedBullet.png", 20, 400, 180);
 chargedTime = 0;

}
 }
 else if (chargedTime > 5)
 {
 if (facing == "right")
 {
 hero.animate("Shoot");
 hero.shoot("path/to/fullChargedBullet.png", 40, 400, 0);
 chargedTime = 0;

}
 else if (facing == "left")
 {
 hero.animate("Shoot");
 hero.mirrorSprite(); // this function flips the sprite horizontally
 hero.shoot("path/to/fullChargedBullet.png", 40, 400, 180);
 chargedTime = 0;

}
 }

if (facing == "right")
 {
 hero.animate("standRight");
 }
 else if (facing == "left")
 {
 hero.animate("standLeft");
 hero.mirrorSprite(); // we need to call this again because the sprite was mirrored
 // if we don't mirror the sprite again, standLeft will look like standRight
 }
}

// player is pressing this key down
if (keyDown(KEY_Z))
{
 // this is the function that adds the value of chargedTime every second
 // this keyDown block of code will be run every frame, which is less than a second
 // your engine of choice should have a way to tell whether a second has passed or not
 addChargedTime();
}

Tokoh pahlawan baru kita bergerak ke kiri, kanan, dan melompat sesuai masukan kita, dan juga menembakkan peluru, apakah normal, setengah diisi, atau terisi penuh.

Menerapkan Musuh

Kita sekarang telah mengendalikan pahlawan. Mari kita menyebutnya Xeon demi kesederhanaan. Dia bisa melakukan beberapa gerakan dasar seperti berjalan, melompat, dan menembak. Itu hebat! Tapi apa gunanya kemampuan menembak tanpa ada yang bisa ditembak kan? Itulah mengapa kali ini kita akan membuat musuh pertama kita.

Mari desain atribut musuh kita sebelum kita mulai mengkodenya.

Kesehatan: seberapa sehat musuh kita tentukan berapa banyak tembakan (dan jenisnya) yang dibutuhkan untuk menghancurkannya.
Kekuatan: Kekuatan serangan musuh, berapa banyak kerusakan yang terjadi pada pemain kita.
ShotAngle: ke arah mana musuh menembak peluru, bisa dibiarkan atau di kanan atau di mana saja yang kita inginkan.

Ada banyak hal yang kita butuhkan untuk musuh kita, sekarang mari kita buat kelas / objek musuh.

Kelas / objek musuh dengan kelas pemain / objek, kecuali musuh tidak mendengarkan masukan pemain. Karena itu kita perlu mengganti bagian mana pahlawan kita mendengarkan masukan pemain, untuk musuh AI / logika.

Serangan AI Musuh

Sebagai permulaan, mari kita tangani tembakan dasar AI dari musuh. Musuh akan menembak pemain saat melihat pemain.

Untuk menentukan apakah musuh "melihat 'pemain, kita perlu mendefinisikan sebuah variabel untuk objek musuh yang disebut menghadap yang merupakan string yang menyimpan satu dari dua nilai," kiri "atau" kanan ".

Musuh juga membutuhkan semacam penglihatan, itulah sebabnya mengapa kita akan membuat variabel lain yang disebut jangkauan. Jika pemain berada dalam kisaran ini maka itu berarti musuh "melihat" pemain. The pseudocode adalah sebagai berikut:

function boolean checkSees()
{
 if (facing == "left" && hero.x >= enemy.x -- range)
 {
 return true;
 }

if (facing == "right" && hero.x <= enemy.x + range)
 {
 return true;
 }

return false;
}

fungsi checkSees ()

Mungkin Anda telah melihat sesuatu dalam pseudocode ini: yaitu tidak mempertimbangkan posisi pahlawan, jadi musuh tetap akan menembaki pahlawan bahkan jika mereka berada di panggung dengan ketinggian yang berbeda.

Untuk saat ini ini sudah cukup, karena membuat algoritma garis pandang ada diluar lingkup tutorial ini. Dalam permainan Anda sendiri, Anda mungkin ingin menambahkan toleransi Y pada fungsi di atas yang akan memeriksa apakah posisi pahlawan berada di antara dua titik yang menentukan ketinggian musuh.

Membuat Musuh Menembak

Pseudocode untuk penembakan yang dilakukan musuh adalah sebagai berikut:

// can be in update() or somewhere else that's executed every frame
function update()
{
 if (checkSees())
 {
 shoot("path/to/bulletSprite.png", enemyPower, 400, shotAngle);
 }
}

Seperti yang bisa Anda lihat, fungsi shoot () musuh sama dengan pemain. Dibutuhkan jalur sprite, kekuatan serangan, kecepatan peluru, dan sudut penembakan sebagai parameter.

Gerakan AI Musuh

Kapan musuh beralih dari menghadap ke kiri untuk menghadap ke kanan? Bagi pahlawan kita, kita menggunakan input pemain untuk mengubah arah wajah pahlawan kita. Bagi musuh kita, kita memiliki dua pilihan: gunakan beberapa jenis timer untuk beralih menghadap ke arah setiap beberapa detik sambil membiarkan musuh berdiri diam, atau mintalah musuh untuk berjalan ke tempat tertentu dan kemudian beralih menghadap ke arahnya dan kemudian berjalan ke tempat lain. untuk beralih menghadap ke arahnya lagi.

Metode kedua ini bisa digunakan sebagai patroli AI. Tentu saja, kita bisa membuat musuh berjalan dalam satu arah dan tidak pernah kembali.

Metode pseudocode untuk metode pertama adalah sebagai berikut:

function switchingAI()
{
 // elapsedTime() is a function that counts how many seconds has passed since its value is reset
 // I assume your engine of choice have this kind of functionality
 if (elapsedTime() > 4.0)
 {
 if (facing == "left")
 {
 facing = "right";
 shotAngle = 0;
 }

if (facing == "right")
 {
 facing = "left";
 shotAngle = 180;
 }

enemy.mirrorSprite(); // also flip the sprite horizontally
 resetTime(); // resets the time that counts in elapsedTime()
 }
}

switching AI function — Fungsi beralih AI

Musuh Berpatroli AI

Untuk membuat AI yang patroli, kita perlu membuat dua benda tak terlihat yang berada di ujung kedua rute patroli musuh, dan membuat musuh bergerak ke arah lain jika bertabrakan dengan mereka.

this is how it looks in Construct 2 — Patroli AI

Sekarang mari kita tulis pseudocode untuk AI patroli musuh:

function patrollingAI()
{
 if (facing == "right")
 {
 walkRight(); // the same as the one in player object / class

if (collidesWith(rightPatrolBorder))
 {
 facing = "left";
 enemy.mirrorSprite();
 }
 }

 if (facing == "left")
 {
 walkLeft();

if (collidesWith(leftPatrolBorder))
 {
 facing = "right";
 enemy.mirrorSprite();
 }
 }
}

Setelah ini, musuh akan berpatroli di antara dua titik seperti yang kita inginkan.

Untuk mengatur AI yang digunakan musuh, kita akan menambahkan satu variabel lagi dengan tipe string untuk musuh kita: AI musuh. Ini akan menentukan apa yang AI gunakan setiap frame, seperti:

if (enemyAI == "switching")
{
 switchingAI();
}
else if (enemyAI == "patrolling")
{
 patrollingAI();
}

Tentu Anda bisa menambahkan lebih banyak jenis AI musuh jika Anda mau.

Variasi Penembakan

Mari kita lanjutkan tentang bagaimana kita bisa membuat variasi tembakan untuk pemain dan musuh. Kami membuat variasi tembakan dengan mengubah dua hal: sudut pengambilan gambar, dan jumlah tembakan peluru.

Dengan cara ini kita bisa melakukan tembakan peluru yang sederhana, atau tembakan peluru tiga arah. Sebelum kita melakukan ini kita akan membuat variabel lain ke objek musuh / kelas bernama shotAI, yaitu sebuah string. Kami akan menggunakan ini di checkSees kami () memeriksa apakah blok, di mana musuh akan menembak. Perubahan pada blok kode akan menjadi seperti ini:

// can be in update() or somewhere else that's executed every frame
function update()
{
 if (checkSees())
 {
 if (shotAI == "simple")
 {
 shoot("path/to/bulletSprite.png", enemyPower, 400, shotAngle);
 }

if (shotAI == "threeBullets")
 {
 shootThreeBullets();
 }
 }
}

Tentu saja, nama AI dan jenis tembakan yang akan ditembak musuh terserah Anda, ini hanyalah sebuah contoh.

Sekarang, mari pelajari lebih dalam apa yang ada di dalam fungsi shootThreeBullets ().

Function shootThreeBullets()
{
 if (facing == "right")
 {
 shoot("path/to/bulletSprite.png", enemyPower, 400, 0); // this bullet goes straight to the right
 shoot("path/to/bulletSprite.png", enemyPower, 400, 330); // this goes up by 30 degrees
 shoot("path/to/bulletSprite.png", enemyPower, 400, 30); // this goes down by 30 degrees
 }

if (facing == "left")
 {
 shoot("path/to/bulletSprite.png", enemyPower, 400, 180); // this bullet goes straight to the left
 shoot("path/to/bulletSprite.png", enemyPower, 400, 210); // this goes up by 30 degrees
 shoot("path/to/bulletSprite.png", enemyPower, 400, 150); // this goes down by 30 degrees
 }
}

Jika Anda tidak yakin mengapa 0 pergi ke kanan dan 180 pergi ke kiri, itu karena arah 0 derajat lurus ke sisi kanan layar, 90 derajat mengarah ke sisi bawah layar, dan seterusnya sampai ini menabrak 360 derajat. Begitu Anda tahu nilai apa yang muncul dan mengarah kemana, Anda bisa menciptakan variasi tembakan Anda sendiri.

Kita juga bisa membuat variabel shotAI untuk pemain, tapi saya lebih suka kita namai itu selectedShot, karena pemain kita akan memilih peluru bukan diprogram dari awal.

Logika di megaman adalah setiap saat megaman mengalahkan bos, dia mendapat kekuatan bos itu sebagai tembakan baru. Saya akan mencoba menciptakan logika itu. Untuk melakukan ini, kita membutuhkan sebuah array yang berisi tembakan pemain, termasuk tembakan normal. Pseudocode seperti ini:

var shotArr = ["normalShot", "boss1", "boss2"];
var shotIndex = 0;
var selectedShot = "normalShot";

function update()
{
 // this is the block of code in player's update function where the player shoots a bullet

// this function changes the bullet that the player shoots
 changeBullet();

// player press this key once
 if (keyPressed(KEY_Z))
 {
 if (facing == "right")
 {
 hero.animate("Shoot");
 if ( selectedShot == "normalShot")
 {
 hero.shoot("path/to/sprite.png", 10, 400, 0);
 }
 else if ( selectedShot == "boss1")
 {
 // add codes to shoot the kind of shot that the player received after defeating boss 1
 }
 }
 }
}

function changeBullet()
{
 // changes shotIndex based on button pressed
 if (keyPressed(KEY_E))
 {
 shotIndex += 1;
 }

if (keyPressed(KEY_Q))
 {
 shotIndex -= 1;
 }

// fix shotIndex if it's out of array's length
 if (shotIndex == shotArr.length)
 {
 shotIndex = 0;
 }

if (shotIndex < 0)
 {
 shotIndex = shotArr.length -- 1;
 }

selectedShot = shotArr[shotIndex];
}

Kita perlu melacak dua variabel baru:

how to add an array to construct 2 — Bagaimana cara menambahkan array pada Construct 2

Kami akan mendorong elemen baru untuk shotArr saat pemain tersebut mengalahkan bos.

Upgrade Peluru Pemain

Sama seperti shootThreeBullet musuh (), Anda bisa menjadi kreatif dan menciptakan variasi tembakan Anda sendiri. Karena ini adalah peluru pahlawan, mari kita berikan sesuatu yang spesial.

Mari kita membuat satu jenis tembakan agar efektif melawan bos tertentu, sehingga bisa mengatasi lebih banyak kerusakan. Untuk melakukan ini, kita akan membuat sebuah variabel untuk objek peluru yang bernama strongAgainst yaitu variabel tipe string lain yang berisi nama bos bahwa peluru ini efektif melawannya. Kami akan menambahkan penawaran ini lebih banyak fungsi kerusakan saat kita membahas bagian bos dari game.

Kesehatan dan Kematian

Di sinilah semua variasi tembakan yang kita buat benar-benar mulai menjadi masalah. Di sinilah pahlawan kita merusak dan membunuh musuh, dan sebaliknya.

Untuk memulai, mari kita membuat variabel untuk kedua pahlawan dan objek musuh, bernama kesehatan yang merupakan int, dan variabel lain untuk pahlawan yang disebut variable lives (kehidupan). Mari kita lihat pseudocode:

if (bullet.collidesWith(hero))
{
 hero.health -= bullet.power;
 createExplosion(); // for now we don't have an explosion sprite, so this will act as a reminder
}

// check if the hero is dead
if (hero.health <= 0)
{
 hero.lives -= 1; // decreases hero's total number of lives.
 destroyHero();
}

Kita akan membuat pseudocode yang sama untuk perusakan musuh, seperti:

if (bullet.collidesWith(enemy))
{
 enemy.health -= bullet.power;
 createExplosion();
}

if (enemy.health <= 0)
{
 destroyEnemy();
}

bullet collides with player and enemy — Menangani tabrakan peluru antara pemain dan musuh

GUI Bar Kesehatan

Sekarang, jika saya berhenti begitu saja maka itu tidak akan menarik. Jadi saya akan membuat sprite persegi panjang di pojok kiri atas layar yang bertindak sebagai bar kesehatan pahlawan kita.

Panjang bar kesehatan ini akan berubah tergantung pada kesehatan pahlawan kita saat ini. Rumus untuk mengubah batas kesehatan bar adalah ini:

1	// this is in the update function
2	healthBar.width = (hero.health / hero.maxHealth) * 100;

Kita membutuhkan satu variabel lagi untuk pahlawan kita yang disebut maxHealth; nilai penuh kesehatan pahlawan kita. Untuk saat ini nilai ini tidak bisa diubah tapi mungkin di masa depan kita bisa membuat item yang meningkatkan jumlah maxHealth pahlawan.

Membuat Dunia Game

Sekarang kita telah menciptakan variasi pahlawan, musuh, dan tembakan kita, kita perlu membuat beberapa tingkatan dan bos.

Untuk memiliki beberapa tingkat berarti pada beberapa titik dalam permainan pemain akan mencapai satu atau lebih pos pemeriksaan yang mengalihkan permainan dari tingkat 1-1 ke tingkat 1-2 ke level 1-3 dan seterusnya sampai mereka mencapai bos.

Saat pemain mati di suatu tempat di level 1-2 dia tidak perlu memutar ulang semua permainan sejak awal dari level 1-1. Bagaimana saya melakukan ini? Pertama, kita akan membuat level, saya tidak akan menjelaskan banyak tentang perancangan level, tapi inilah contoh level dalam Build 2.

sample level design — Contoh desain level

Gambar pada bagian pojok kiri atas adalah lapisan HUD. Ini akan merambat, mengikuti pahlawan ketika game dimainkan.

Doors and Checkpoints

Satu sprite yang harus Anda perhatikan adalah sprite hijau di bagian kanan atas dari level. Ini adalah pos pemeriksaan di level ini saat pemain bertabrakan dengan itu kita akan mentransfer game ke level 1-2.

Untuk menangani beberapa tingkat, kita memerlukan tiga variabel: currentLevel, levelName, dan nextLevel.

Variabel currentLevel dibuat di objek pahlawan / kelas. LevelName dibuat di adegan game (tingkat) objek untuk setiap level. Variabel nextLevel dibuat pada objek sprite hijau.

Logikanya adalah sebagai berikut: ketika pahlawan bertabrakan dengan sprite hijau (saya menyebutnya greenDoor), kita akan mengubah level kita ke adegan game dimana variabel levelName sama dengan variabel nextLevel. Setelah kita mengubah level, kita akan mengubah nilai variabel currentreevel pahlawan menjadi sama dengan levelame pada adegan gameName. Inilah pseudocodenya:

// this is inside game's update function
if (hero.collidesWith(greenDoor))
{
 changeLevelTo(greenDoor.nextLevel);
}

change level when touches green door — Ubah level saat kita menyentuh pintu hijau

Menginisiasi Level Baru

Berikut adalah pseudocode untuk menangani saat level berikutnya dimuat dan siap dimainkan.

// this is the function that's triggered when the new level is loaded
function onStart()
{
 hero.currentLevel = scene.LevelName;
 hero.x = startPos.x;
 hero.y = startPos.y;
}

Posisi Awal Pemain

Sekarang setelah kita berubah ke level yang baru, saya akan menjelaskan sprite oranye di belakang tokoh kita di gambar desain tingkat di atas. Sprite oranye itu adalah objek yang saya sebut startPos. Ini digunakan untuk menandai posisi awal setiap level.

Kami mengacu pada objek ini saat sang pahlawan baru saja berubah level atau mati, sehingga kita tahu dimana harus menelurkannya.

Inilah pseudocode untuk penanganan saat sang pahlawan mati:

// the function that's triggered when the hero is destroyed
Function onDestroyed()
{
 // revives hero if the hero still have lives.
 If (hero.lives > 0)
 {
 var newHero = new Hero();
 newHero.x = startPos.x;
 newHero.y = startPos.y;
 }
}

Sekarang kita bisa memiliki banyak level dan kita juga bisa menelurkan ulang saat sang pahlawan telah meninggal.

Anda bisa menciptakan level sebanyak yang Anda mau, atau mungkin malah menciptakan dua objek greenDoor di level mana salah satunya kembali ke level 1-1 jika pemain memecahkan teka-teki dengan cara yang salah.

pertempuran Bos

Akhirnya saatnya menerapkanbos itu sendiri. Untuk membuat level bos sesederhana membuat level lain yang akan menelurkan bos yang bukan merupakan musuh biasa.

Bagian yang sulit adalah menciptakan AI untuk bos karena masing-masing bos akan memiliki AI yang unik. Jadi untuk memudahkan untuk memahami dan menduplikat banyak bos, saya akan membuat AI bos yang bergantung pada waktu setelah mereka melahirkan. Yang berarti mereka akan melakukan A selama x detik, lalu ganti menjadi B selama beberapa detik kemudian lakukan C selama z detik sebelum kembali ke A. Pseudocode akan terlihat seperti ini:

// this code is inside the boss update function, so it's executed every frame
if (elapsedTime() > 2.0)
{
 // this if block is executed for 3 seconds, because the difference in time with the if block below
 // is three seconds.
 BossShot1(); // shot variation to be executed this time
}
else if (elapsedTime() > 5.0)
{
 bossShot2();
}
else if (elapsedTime() > 6.0)
{
 bossShot3();
}

if (elapsedTime() > 7.0)
{
 // reset the time so the boss executes the first action again
 resetsTime();
}

Definisi fungsi tembakan bos ada di bawah. Jangan ragu untuk mengubahnya agar sesuai dengan apa yang Anda inginkan untuk pertarungan bos:

function bossShot1()
{
 // a simple straight shot
 bossEnemy.shoot("path/to/bullet/sprite.png", bossPower, 400, shotAngle); // shotAngle is 180
}

function bossShot2()
{
 // a three direction bullets shot
 bossEnemy.shoot("path/to/bullet/sprite.png", bossPower, 400, shotAngle);
 bossEnemy.shoot("path/to/bullet/sprite.png", bossPower, 400, shotAngle + 30);
 bossEnemy.shoot("path/to/bullet/sprite.png", bossPower, 400, shotAngle - 30);
}

function bossShot3()
{
 // for this one, I'm going to make a circle shot, so the bullets will form a circle
 for (var i = 0; i <= 9; i++)
 {
 bossEnemy.shoot("path/to/bullet/sprite.png", bossPower, 400, 36 * i); // change the shotAngle
 }
}

Terserah Anda untuk menambahkan variasi tembakan ke rutinitas bos. Variabel yang digunakan oleh objek musuh bos sama dengan objek musuh, kecuali bos yang tidak menggunakan variabel enemyAI dan shotAI, karena keduanya akan ditangani jika blok di atas tergantung pada waktu yang telah berlalu.

Boss musuh juga memiliki variabel yang objek yang tidak dimiliki musuh. Ini disebut rewardShot, yang merupakan string. Variabel ini memegang nama bos yang ditembak pemain yang akan didapat setelah mengalahkan bos (yang ada dalam variabel array shotArr).

Ini akan memungkinkan pemain untuk "belajar" serangan bos seperti yang dijelaskan sebelumnya. Untuk menambahkan jenis tembakan ini ke tangkapan tangkapan pemain, kita perlu menambahkan kode berikut setelah musuh mati:

function bossShot1()
{
    // a simple straight shot
    bossEnemy.shoot("path/to/bullet/sprite.png", bossPower, 400, shotAngle); // shotAngle is 180
}

function bossShot2()
{
    // a three direction bullets shot
    bossEnemy.shoot("path/to/bullet/sprite.png", bossPower, 400, shotAngle);
    bossEnemy.shoot("path/to/bullet/sprite.png", bossPower, 400, shotAngle + 30);
    bossEnemy.shoot("path/to/bullet/sprite.png", bossPower, 400, shotAngle - 30);
}

function bossShot3()
{
    // for this one, I'm going to make a circle shot, so the bullets will form a circle
    for (var i = 0; i <= 9; i++)
    {
        bossEnemy.shoot("path/to/bullet/sprite.png", bossPower, 400, 36 * i); // change the shotAngle
    }
}

Untuk menerapkan jenis peluru tambahan agar pemain Anda dapat menikmatinya, yang perlu Anda lakukan adalah menambahkan kode yang sesuai untuk setiap hadiah. Buatlah penghargaan atas hasil yang Anda buat, seperti yang telah kami lakukan sebelumnya.

Selamat!

Anda telah menyelesaikan tutorial tentang cara membuat permainan platfor metroidvania Megaman di Contruct 2. Selanjutnya Anda hanya perlu membangun permainan Anda berdasarkan pada apa yang telah Anda pelajari di sini untuk membuatnya menjadi milik Anda sendiri. Tambahkan lebih banyak tipe musuh, level lebih, powerups dan lainnya. Semoga berhasil dan selamat bersenang - senang.