pengantar
Sistem entitas-komponen adalah teknik arsitektur berorientasi objek.
Tidak ada konsensus universal tentang apa arti istilah tersebut, sama dengan pemrograman berorientasi objek. Namun, jelas bahwa sistem entitas-komponen secara khusus dimaksudkan sebagai alternatif arsitektur untuk warisan . Hirarki warisan alami untuk mengekspresikan apa objek yang , tetapi dalam jenis tertentu dari perangkat lunak (seperti game), Anda lebih suka mengungkapkan apa yang obyek tidak .
Ini adalah model objek yang berbeda dari "kelas dan warisan" yang Anda terbiasa bekerja di C ++ atau Java. Entitas sama ekspresifnya dengan kelas, seperti halnya prototipe seperti dalam JavaScript atau Self — semua sistem ini dapat diimplementasikan dalam hal satu sama lain.
Contohnya
Katakanlah Mari kita bahwa Playeradalah sebuah entitas dengan Position, Velocity, dan KeyboardControlledkomponen, yang melakukan hal-hal yang jelas.
entity Player:
Position
Velocity
KeyboardControlled
Kita tahu Positionharus dipengaruhi oleh Velocity, dan Velocityoleh KeyboardControlled. Pertanyaannya adalah bagaimana kita ingin memodelkan efek tersebut.
Entitas, Komponen, dan Sistem
Misalkan komponen tidak memiliki referensi satu sama lain; Physicssistem eksternal menelusuri semua Velocitykomponen dan memperbarui Positionentitas yang sesuai; suatu Inputsistem menelusuri semua KeyboardControlledkomponen dan memperbarui Velocity.
Player
+--------------------+
| Position | \
| | Physics
/ | Velocity | /
Input | |
\ | KeyboardControlled |
+--------------------+
Ini memenuhi kriteria:
Sistem sekarang bertanggung jawab untuk menangani peristiwa dan memberlakukan perilaku yang dijelaskan oleh komponen. Mereka juga bertanggung jawab untuk menangani interaksi antar entitas, seperti tabrakan.
Entitas dan Komponen
Namun, anggaplah bahwa komponen lakukan memiliki referensi satu sama lain. Sekarang entitas hanyalah sebuah konstruktor yang menciptakan beberapa komponen, mengikat mereka bersama, dan mengelola masa hidup mereka:
class Player:
construct():
this.p = Position()
this.v = Velocity(this.p)
this.c = KeyboardControlled(this.v)
Entitas sekarang dapat mengirimkan input dan memperbarui acara langsung ke komponennya. Velocityakan menanggapi pembaruan, dan KeyboardControlledakan menanggapi input. Ini masih memenuhi kriteria kami:
Di sini, interaksi komponen bersifat eksplisit, tidak dipaksakan dari luar oleh suatu sistem. Data yang menggambarkan perilaku (berapakah jumlah kecepatan?) Dan kode yang memberlakukannya (apa itu kecepatan?) Digabungkan, tetapi dengan cara alami. Data dapat dilihat sebagai parameter untuk perilaku. Dan beberapa komponen tidak bertindak sama sekali — a Positionadalah perilaku berada di suatu tempat .
Interaksi dapat ditangani pada tingkat entitas ("ketika Playerbertabrakan dengan Enemy...") atau pada tingkat komponen individu ("ketika entitas dengan Lifebertabrakan dengan entitas dengan Strength...").
Komponen
Apa alasan keberadaan entitas? Jika itu hanya sebuah konstruktor, maka kita dapat menggantinya dengan fungsi mengembalikan seperangkat komponen. Jika nanti kami ingin meminta entitas berdasarkan tipenya, kami juga dapat memiliki Tagkomponen yang memungkinkan kami melakukan hal itu:
function Player():
t = Tag("Player")
p = Position()
v = Velocity(p)
c = KeyboardControlled(v)
return {t, p, v, c}
Interaksi harus sekarang ditangani oleh query abstrak, benar-benar decoupling acara dari jenis entitas. Tidak ada lagi tipe entitas untuk di-query — Tagdata arbitrer mungkin lebih baik digunakan untuk debugging daripada logika game.
Kesimpulan
Entitas bukan fungsi, aturan, aktor, atau kombinator aliran data. Itu adalah kata benda yang mencontohkan fenomena konkret — dengan kata lain, itu adalah objek. Seperti yang dikatakan Wikipedia — sistem entitas-komponen adalah pola arsitektur perangkat lunak untuk memodelkan objek umum.