src/ai/Spawner.cpp

   1 #include "Spawner.hpp"
   2
   3 #include "Chaser.hpp"
   4 #include "RandomWalk.hpp"
   5 #include "../model/Model.hpp"
   6 #include "../model/ModelRegistry.hpp"
   7 #include "../rand/GaloisLFSR.hpp"
   8 #include "../world/BlockLookup.hpp"
   9 #include "../world/BlockType.hpp"
  10 #include "../world/ChunkIndex.hpp"
  11 #include "../world/Entity.hpp"
  12 #include "../world/World.hpp"
  13
  14 #include <iostream>
  15
  16 using namespace std;
  17
  18
  19 namespace blank {
  20
  21 Spawner::Spawner(World &world, ModelRegistry &models, GaloisLFSR &rand)
  22 : world(world)
  23 , models(models)
  24 , controllers()
  25 , random(rand)
  26 , timer(64)
  27 , despawn_range(128 * 128)
  28 , spawn_distance(16 * 16)
  29 , max_entities(16)
  30 , chunk_range(4)
  31 , model_offset(0)
  32 , model_length(models.size()) {
  33         timer.Start();
  34 }
  35
  36 Spawner::~Spawner() {
  37         for (auto &ctrl : controllers) {
  38                 delete ctrl;
  39         }
  40 }
  41
  42
  43 void Spawner::LimitModels(size_t begin, size_t end) {
  44         if (begin >= models.size() || end > models.size() || begin >= end) {
  45                 cout << "warning, models limit out of bounds or invalid range given" << endl;
  46         } else {
  47                 model_offset = begin;
  48                 model_length = end - begin;
  49         }
  50 }
  51
  52 void Spawner::Update(int dt) {
  53         CheckDespawn();
  54         timer.Update(dt);
  55         if (timer.Hit()) {
  56                 TrySpawn();
  57         }
  58         for (auto &ctrl : controllers) {
  59                 ctrl->Update(dt);
  60         }
  61 }
  62
  63
  64 void Spawner::CheckDespawn() noexcept {
  65         const auto &refs = world.Players();
  66         for (auto iter = controllers.begin(), end = controllers.end(); iter != end;) {
  67                 Entity &e = (*iter)->Controlled();
  68                 if (e.Dead()) {
  69                         delete *iter;
  70                         iter = controllers.erase(iter);
  71                         end = controllers.end();
  72                         continue;
  73                 }
  74                 bool safe = false;
  75                 for (const Player &ref : refs) {
  76                         glm::vec3 diff(ref.GetEntity().AbsoluteDifference(e));
  77                         if (dot(diff, diff) < despawn_range) {
  78                                 safe = true;
  79                                 break;
  80                         }
  81                 }
  82                 if (!safe) {
  83                         e.Kill();
  84                         delete *iter;
  85                         iter = controllers.erase(iter);
  86                         end = controllers.end();
  87                 } else {
  88                         ++iter;
  89                 }
  90         }
  91 }
  92
  93 void Spawner::TrySpawn() {
  94         if (controllers.size() >= max_entities || model_length == 0) return;
  95
  96         // select random player to punish
  97         auto &players = world.Players();
  98         if (players.size() == 0) return;
  99         size_t player_num = random.Next<unsigned short>() % players.size();
 100         auto i = players.begin(), end = players.end();
 101         for (; player_num > 0 && i != end; ++i, --player_num) {
 102         }
 103         const Player &player = *i;
 104
 105         BlockLookup spawn_block(player.GetChunks().RandomBlock(random));
 106
 107         // distance check
 108         //glm::vec3 diff(glm::vec3(chunk * Chunk::Extent() - pos) + player.entity->Position());
 109         //float dist = dot(diff, diff);
 110         //if (dist > despawn_range || dist < spawn_distance) {
 111         //      return;
 112         //}
 113
 114         // check if the spawn block and the one above it are loaded and inhabitable
 115         if (!spawn_block || spawn_block.GetType().collide_block) {
 116                 return;
 117         }
 118
 119         BlockLookup head_block(spawn_block.Next(Block::FACE_UP));
 120         if (!head_block || head_block.GetType().collide_block) {
 121                 return;
 122         }
 123
 124         Spawn(player.GetEntity(), spawn_block.GetChunk().Position(), spawn_block.GetBlockCoords());
 125 }
 126
 127 void Spawner::Spawn(Entity &reference, const glm::ivec3 &chunk, const glm::vec3 &pos) {
 128         Entity &e = world.AddEntity();
 129         e.Position(chunk, pos);
 130         e.Bounds({ { -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f } });
 131         e.WorldCollidable(true);
 132         RandomModel().Instantiate(e.GetModel());
 133         Controller *ctrl;
 134         if (random()) {
 135                 ctrl = new RandomWalk(e, random.Next<std::uint64_t>());
 136                 e.Name("walker");
 137         } else {
 138                 ctrl = new Chaser(world, e, reference);
 139                 e.Name("chaser");
 140         }
 141         controllers.emplace_back(ctrl);
 142 }
 143
 144 Model &Spawner::RandomModel() noexcept {
 145         std::size_t offset = (random.Next<std::size_t>() % model_length) + model_offset;
 146         return models[offset];
 147 }
 148
 149 }