#include "Creature.hpp"
#include "../app/Assets.hpp"
+#include "../ui/string.hpp"
#include "../world/Planet.hpp"
#include "../world/Resource.hpp"
#include "../world/Simulation.hpp"
void BlobBackgroundTask::Tick(double dt) {
if (breathing) {
// TODO: derive breathing ability
- double amount = GetCreature().GetStats().Breath().gain * -(1.5 + 0.5 * GetCreature().ExhaustionFactor());
+ int gas = Assets().data.resources["air"].id;
+ // TODO: check if in compatible atmosphere
+ double amount = GetCreature().GetStats().Breath().gain * -(1.0 + GetCreature().ExhaustionFactor());
GetCreature().GetStats().Breath().Add(amount * dt);
+ // maintain ~1% gas composition
+ double gas_amount = GetCreature().GetComposition().Get(gas);
+ if (gas_amount < GetCreature().GetComposition().TotalMass() * 0.01) {
+ double add = std::min(GetCreature().GetComposition().TotalMass() * 0.025 - gas_amount, -amount * dt);
+ GetCreature().Ingest(gas, add);
+ }
if (GetCreature().GetStats().Breath().Empty()) {
breathing = false;
}
void BlobBackgroundTask::CheckSplit() {
if (GetCreature().Mass() > GetCreature().OffspringMass() * 2.0
&& GetCreature().OffspringChance() > Assets().random.UNorm()) {
- std::cout << "[" << int(GetCreature().GetSimulation().Time())
- << "s] " << GetCreature().Name() << " split" << std::endl;
+ GetCreature().GetSimulation().Log() << GetCreature().Name() << " split" << std::endl;
Split(GetCreature());
return;
}
// check for random property mutation
if (GetCreature().MutateChance() > Assets().random.UNorm()) {
double amount = 1.0 + (Assets().random.SNorm() * 0.05);
- math::Distribution &d = GetCreature().GetGenome().properties.props[(int(Assets().random.UNorm() * 8.0) % 8)];
+ math::Distribution &d = GetCreature().GetGenome().properties.props[Assets().random.UInt(9)];
if (Assets().random.UNorm() < 0.5) {
d.Mean(d.Mean() * amount);
} else {
}
bool IngestGoal::OnSuitableTile() {
- if (!GetSituation().OnTile()) {
+ if (!GetSituation().OnSurface()) {
return false;
}
const world::TileType &t = GetSituation().GetTileType();
, accept()
, found(false)
, target_pos(0.0)
-, target_srf(0)
-, target_tile(0)
, searching(false)
, reevaluate(0.0) {
}
GetSteering().GoTo(target_pos);
}
}
- } else if (OnTargetTile()) {
+ } else if (NearTarget()) {
GetSteering().Halt();
if (!GetSituation().Moving()) {
SetComplete();
}
void LocateResourceGoal::LocateResource() {
- if (GetSituation().OnTile()) {
+ if (GetSituation().OnSurface()) {
const world::TileType &t = GetSituation().GetTileType();
auto yield = t.FindBestResource(accept);
if (yield != t.resources.cend()) {
found = true;
searching = false;
target_pos = GetSituation().Position();
- target_srf = GetSituation().Surface();
- target_tile = GetSituation().GetPlanet().SurfacePosition(target_srf, target_pos);
} else {
// go find somewhere else
SearchVicinity();
}
} else {
// well, what now?
+ found = false;
+ searching = false;
}
}
void LocateResourceGoal::SearchVicinity() {
const world::Planet &planet = GetSituation().GetPlanet();
- int srf = GetSituation().Surface();
const glm::dvec3 &pos = GetSituation().Position();
+ const glm::dvec3 normal(planet.NormalAt(pos));
+ const glm::dvec3 step_x(normalize(cross(normal, glm::dvec3(normal.z, normal.x, normal.y))));
+ const glm::dvec3 step_y(normalize(cross(step_x, normal)));
- glm::ivec2 loc = planet.SurfacePosition(srf, pos);
- glm::ivec2 seek_radius(2);
- glm::ivec2 begin(glm::max(glm::ivec2(0), loc - seek_radius));
- glm::ivec2 end(glm::min(glm::ivec2(planet.SideLength()), loc + seek_radius + glm::ivec2(1)));
-
- double rating[end.y - begin.y][end.x - begin.x];
- std::memset(rating, 0, sizeof(double) * (end.y - begin.y) * (end.x - begin.x));
+ constexpr int search_radius = 2;
+ double rating[2 * search_radius + 1][2 * search_radius + 1] = {0};
// find close and rich field
- for (int y = begin.y; y < end.y; ++y) {
- for (int x = begin.x; x < end.x; ++x) {
- const world::TileType &type = planet.TypeAt(srf, x, y);
+ for (int y = -search_radius; y < search_radius + 1; ++y) {
+ for (int x = -search_radius; x < search_radius + 1; ++x) {
+ const glm::dvec3 tpos(pos + (double(x) * step_x) + (double(y) * step_y));
+ if (!GetCreature().PerceptionTest(tpos)) continue;
+ const world::TileType &type = planet.TileTypeAt(tpos);
auto yield = type.FindBestResource(accept);
if (yield != type.resources.cend()) {
// TODO: subtract minimum yield
- rating[y - begin.y][x - begin.x] = yield->ubiquity * accept.Get(yield->resource);
- double dist = std::max(0.125, 0.25 * glm::length(planet.TileCenter(srf, x, y) - pos));
- rating[y - begin.y][x - begin.x] /= dist;
+ rating[y + search_radius][x + search_radius] = yield->ubiquity * accept.Get(yield->resource);
+ // penalize distance
+ double dist = std::max(0.125, 0.25 * glm::length(tpos - pos));
+ rating[y + search_radius][x + search_radius] /= dist;
}
}
}
- // demote crowded tiles
+ // penalize crowding
for (auto &c : planet.Creatures()) {
if (&*c == &GetCreature()) continue;
- if (c->GetSituation().Surface() != srf) continue;
- glm::ivec2 coords(c->GetSituation().SurfacePosition());
- if (coords.x < begin.x || coords.x >= end.x) continue;
- if (coords.y < begin.y || coords.y >= end.y) continue;
- rating[coords.y - begin.y][coords.x - begin.x] *= 0.9;
+ for (int y = -search_radius; y < search_radius + 1; ++y) {
+ for (int x = -search_radius; x < search_radius + 1; ++x) {
+ const glm::dvec3 tpos(pos + (double(x) * step_x) + (double(y) * step_y));
+ if (length2(tpos - c->GetSituation().Position()) < 1.0) {
+ rating[y + search_radius][x + search_radius] *= 0.8;
+ }
+ }
+ }
}
glm::ivec2 best_pos(0);
double best_rating = -1.0;
- for (int y = begin.y; y < end.y; ++y) {
- for (int x = begin.x; x < end.x; ++x) {
- if (rating[y - begin.y][x - begin.x] > best_rating) {
+ for (int y = -search_radius; y < search_radius + 1; ++y) {
+ for (int x = -search_radius; x < search_radius + 1; ++x) {
+ if (rating[y + search_radius][x + search_radius] > best_rating) {
best_pos = glm::ivec2(x, y);
- best_rating = rating[y - begin.y][x - begin.x];
+ best_rating = rating[y + search_radius][x + search_radius];
}
}
}
if (best_rating) {
found = true;
searching = false;
- target_pos = planet.TileCenter(srf, best_pos.x, best_pos.y);
- target_srf = srf;
- target_tile = best_pos;
+ target_pos = normalize(pos + (double(best_pos.x) * step_x) + (double(best_pos.y) * step_y)) * planet.Radius();
GetSteering().GoTo(target_pos);
} else if (!searching) {
found = false;
searching = true;
target_pos = GetSituation().Position();
- target_pos[(srf + 0) % 3] += Assets().random.SNorm();
- target_pos[(srf + 1) % 3] += Assets().random.SNorm();
- // bias towards current direction
- target_pos += glm::normalize(GetSituation().Velocity()) * 0.5;
- target_pos = clamp(target_pos, -planet.Radius(), planet.Radius());
+ target_pos += Assets().random.SNorm() * step_x;
+ target_pos += Assets().random.SNorm() * step_y;
+ // bias towards current heading
+ target_pos += GetSituation().Heading() * 0.5;
+ target_pos = normalize(target_pos) * planet.Radius();
GetSteering().GoTo(target_pos);
}
}
-bool LocateResourceGoal::OnTargetTile() const noexcept {
+bool LocateResourceGoal::NearTarget() const noexcept {
const Situation &s = GetSituation();
- return s.OnSurface()
- && s.Surface() == target_srf
- && s.OnTile()
- && s.SurfacePosition() == target_tile;
+ return s.OnSurface() && length2(s.Position() - target_pos) < 0.5;
}
}
projects / blobs.git / blobdiff