AI Toolkit adalah perpustakaan C ++ hanya header yang menyediakan alat untuk membangun otak NPC game Anda.
Itu menyediakan:
Mengapa proyek ini? Yah, saya menulis tentang itu di sini.
Tambahkan folder include
dari repositori ini ke jalur sertakan Anda.
Atau tambahkan sebagai submodule:
$ git submodule add https://github.com/linkdd/aitoolkit.git
$ g++ -std=c++23 -Iaitoolkit/include main.cpp -o mygame
NB: Perpustakaan ini kompatibel dengan C ++ 20.
Atau menggunakan Shipp, tambahkan ke dependensi Anda:
{
"name" : " myproject " ,
"version" : " 0.1.0 " ,
"dependencies" : [
{
"name" : " aitoolkit " ,
"url" : " https://github.com/linkdd/aitoolkit.git " ,
"version" : " v0.5.1 "
}
]
}
Pertama, sertakan header:
# include < aitoolkit/fsm.hpp >
using namespace aitoolkit ::fsm ;
Kemudian, buat jenis papan tulis Anda:
struct blackboard_type {
// ...
};
Kemudian, buat jenis negara untuk masing -masing negara bagian Anda:
class state_dummy final : public state<blackboard_type> {
public:
virtual void enter (blackboard_type& blackboard) override {
// ...
}
virtual void exit (blackboard_type& blackboard) override {
// ...
}
virtual void pause (blackboard_type& blackboard) override {
// ...
}
virtual void resume (blackboard_type& blackboard) override {
// ...
}
virtual void update (blackboard_type& blackboard) override {
// ...
}
};
Buat mesin negara bagian sederhana Anda:
auto simple_bb = blackboard_type{};
auto simple_fsm = simple_machine<blackboard_type>();
simple_fsm.set_state(state_dummy{}, simple_bb);
simple_fsm.pause(simple_bb);
simple_fsm.resume(simple_bb);
simple_fsm.update(simple_bb);
Atau dengan mesin status tumpukan:
auto stack_bb = blackboard_type{};
auto stack_fsm = stack_machine<blackboard_type>{};
stack_fsm.push_state(state_dummy{}, stack_bb);
stack_fsm.push_state(state_dummy{}, stack_bb);
stack_fsm.update(stack_bb);
stack_fsm.pop_state(stack_bb);
stack_fsm.pop_state(stack_bb);
Pertama, sertakan header:
# include < aitoolkit/behtree.hpp >
using namespace aitoolkit ::bt ;
Kemudian, buat jenis papan tulis Anda:
struct blackboard_type {
// ...
};
Lalu, buat pohon Anda:
auto tree = seq<blackboard_type>(
node_list<blackboard_type>(
check<blackboard_type>([]( const blackboard_type& bb) {
// check some condition
return true ;
}),
task<blackboard_type>([](blackboard_type& bb) {
// perform some action
return execution_state::success;
})
)
);
Akhirnya, evaluasinya:
auto blackboard = blackboard_type{
// ...
};
auto state = tree.evaluate(blackboard);
Untuk informasi lebih lanjut, konsultasikan dokumentasi.
Pertama, sertakan file header:
# include < aitoolkit/utility.hpp >
using namespace aitoolkit ::utility ;
Lalu, buat tipe papan tulis:
struct blackboard_type {
int food{ 0 };
int wood{ 0 };
int stone{ 0 };
int gold{ 0 };
};
Selanjutnya, buat kelas untuk setiap tindakan yang ingin Anda lakukan:
class collect_food final : public action<blackboard_type> {
public:
virtual float score ( const blackboard_type& blackboard) const override {
return 50 . 0f ;
}
virtual void apply (blackboard_type& blackboard) const override {
blackboard. food += 1 ;
}
};
class collect_wood final : public action<blackboard_type> {
public:
virtual float score ( const blackboard_type& blackboard) const override {
return 150 . 0f ;
}
virtual void apply (blackboard_type& blackboard) const override {
blackboard. wood += 1 ;
}
};
class collect_stone final : public action<blackboard_type> {
public:
virtual float score ( const blackboard_type& blackboard) const override {
return - 10 . 0f ;
}
virtual void apply (blackboard_type& blackboard) const override {
blackboard. stone += 1 ;
}
};
class collect_gold final : public action<blackboard_type> {
public:
virtual float score ( const blackboard_type& blackboard) const override {
return 75 . 0f ;
}
virtual void apply (blackboard_type& blackboard) const override {
blackboard. gold += 1 ;
}
};
Akhirnya, buat evaluator dan jalankan:
auto evaluator = evaluator<blackboard_type>(
action_list<blackboard_type>(
collect_food{},
collect_wood{},
collect_stone{},
collect_gold{}
)
);
auto blackboard = blackboard_type{};
evaluator.run(blackboard);
Pertama, sertakan file header:
# include < aitoolkit/goap.hpp >
using namespace aitoolkit ::goap ;
Kemudian, buat kelas Blackboard yang akan menahan keadaan perencana:
struct blackboard_type {
bool has_axe{ false };
int wood{ 0 };
};
NB: Papan tulis harus sebanding (
a == b
) dan hashable.
Selanjutnya, buat kelas untuk setiap tindakan yang ingin Anda lakukan:
class get_axe final : public action<blackboard_type> {
public:
virtual float cost ( const blackboard_type& blackboard) const override {
return 1 . 0f ;
}
virtual bool check_preconditions ( const blackboard_type& blackboard) const override {
return !blackboard. has_axe ;
}
virtual void apply_effects (blackboard_type& blackboard, bool dry_run) const override {
blackboard. has_axe = true ;
}
};
class chop_tree final : public action<blackboard_type> {
public:
virtual float cost ( const blackboard_type& blackboard) const override {
return 1 . 0f ;
}
virtual bool check_preconditions ( const blackboard_type& blackboard) const override {
return blackboard. has_axe ;
}
virtual void apply_effects (blackboard_type& blackboard, bool dry_run) const override {
blackboard. wood += 1 ;
}
};
Akhirnya, buat rencana dan jalankan:
auto initial = blackboard_type{};
auto goal = blackboard_type{
. has_axe = true ,
. wood = 3
};
auto p = planner<blackboard_type>(
action_list<blackboard_type>(
get_axe{},
chop_tree{}
),
initial,
goal
);
auto blackboard = initial;
while (p) {
p. run_next (blackboard); // will mutate the blackboard
}
Untuk informasi lebih lanjut, konsultasikan dengan dokumentasi.
Dokumentasi tersedia online di sini.
Anda dapat membangunnya secara lokal menggunakan Doxygen:
$ make docs
Perpustakaan ini dirilis berdasarkan ketentuan lisensi MIT.