402 lines
11 KiB
C++
402 lines
11 KiB
C++
#pragma once
|
|
|
|
#include "Entity.hpp"
|
|
#include "GameContext.hpp"
|
|
|
|
#include "raylib.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <functional>
|
|
#include <vector>
|
|
|
|
struct TransformComponent : public Component {
|
|
float x = 0.0f;
|
|
float y = 0.0f;
|
|
void Setup() override {}
|
|
void Update(float) override {}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct PhysicsComponent : public Component {
|
|
float vx = 0.0f;
|
|
float vy = 0.0f;
|
|
float speedCap = 400.0f;
|
|
void Setup() override {}
|
|
void Update(float dt) override {
|
|
auto transform = entity->GetComponent<TransformComponent>();
|
|
if (!transform) {
|
|
return;
|
|
}
|
|
|
|
const float speed = std::sqrt(vx * vx + vy * vy);
|
|
if (speed > speedCap && speed > 0.0f) {
|
|
const float scale = speedCap / speed;
|
|
vx *= scale;
|
|
vy *= scale;
|
|
}
|
|
|
|
transform->get().x += vx * dt;
|
|
transform->get().y += vy * dt;
|
|
}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct GravityWellComponent : public Component {
|
|
float mass = 150000.0f;
|
|
float minDist = 30.0f;
|
|
bool active = false;
|
|
float followLerp = 12.0f;
|
|
void Setup() override {}
|
|
void Update(float dt) override {
|
|
auto transform = entity->GetComponent<TransformComponent>();
|
|
if (!transform) {
|
|
return;
|
|
}
|
|
|
|
active = IsMouseButtonDown(MOUSE_BUTTON_LEFT);
|
|
|
|
const Vector2 mouse = GetMousePosition();
|
|
auto &t = transform->get();
|
|
const float blend = std::clamp(followLerp * dt, 0.0f, 1.0f);
|
|
t.x += (mouse.x - t.x) * blend;
|
|
t.y += (mouse.y - t.y) * blend;
|
|
}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct ScrollComponent : public Component {
|
|
float scrollX = 0.0f;
|
|
float speed = 2.0f;
|
|
float accel = 0.018f;
|
|
void Setup() override {}
|
|
void Update(float dt) override {
|
|
speed += accel * dt;
|
|
scrollX += speed * dt * 60.0f;
|
|
if (context) {
|
|
context->scrollX = scrollX;
|
|
}
|
|
}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct MeterComponent : public Component {
|
|
float value = 60.0f;
|
|
float maxValue = 100.0f;
|
|
float drainRate = 14.0f;
|
|
float gainPerStar = 28.0f;
|
|
void Setup() override {}
|
|
|
|
void SetValue(float newValue) {
|
|
const float oldValue = value;
|
|
value = newValue;
|
|
if (context && oldValue != value) {
|
|
context->EmitMeterChanged(oldValue, value);
|
|
}
|
|
}
|
|
|
|
void AddValue(float delta) { SetValue(std::clamp(value + delta, 0.0f, maxValue)); }
|
|
|
|
void Drain(float amount) { AddValue(-amount); }
|
|
|
|
void Update(float) override {}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct NullZoneComponent : public Component {
|
|
float width = 70.0f;
|
|
void Setup() override {}
|
|
void Update(float) override {}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct ColliderComponent : public Component {
|
|
float radius = 8.0f;
|
|
bool monitoring = false;
|
|
bool monitorable = true;
|
|
std::vector<std::function<void(Entity &)>> onCollision;
|
|
void Setup() override {}
|
|
|
|
void EmitCollision(Entity &other) {
|
|
for (auto &callback : onCollision) {
|
|
callback(other);
|
|
}
|
|
}
|
|
|
|
void AddCollisionListener(std::function<void(Entity &)> callback) {
|
|
onCollision.push_back(std::move(callback));
|
|
}
|
|
|
|
void Update(float) override {
|
|
if (!monitoring || !context || !context->entities || entity->queuedForFree) {
|
|
return;
|
|
}
|
|
|
|
auto selfTransform = entity->GetComponent<TransformComponent>();
|
|
if (!selfTransform) {
|
|
return;
|
|
}
|
|
|
|
for (auto &other : *context->entities) {
|
|
if (!other || other.get() == entity || other->queuedForFree) {
|
|
continue;
|
|
}
|
|
|
|
auto otherCollider = other->GetComponent<ColliderComponent>();
|
|
auto otherTransform = other->GetComponent<TransformComponent>();
|
|
if (!otherCollider || !otherTransform || !otherCollider->get().monitorable) {
|
|
continue;
|
|
}
|
|
|
|
const float dx = selfTransform->get().x - otherTransform->get().x;
|
|
const float dy = selfTransform->get().y - otherTransform->get().y;
|
|
const float r = radius + otherCollider->get().radius;
|
|
if ((dx * dx + dy * dy) <= (r * r)) {
|
|
EmitCollision(*other);
|
|
}
|
|
}
|
|
}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct ScrollableComponent : public Component {
|
|
float worldX = 0.0f;
|
|
void Setup() override {}
|
|
void Update(float) override {
|
|
if (!context) {
|
|
return;
|
|
}
|
|
|
|
auto transform = entity->GetComponent<TransformComponent>();
|
|
if (!transform) {
|
|
return;
|
|
}
|
|
|
|
transform->get().x = worldX - context->scrollX;
|
|
}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct SpawnComponent : public Component {
|
|
float cursorWX = 0.0f;
|
|
void Setup() override {}
|
|
void Update(float) override {}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct TrailComponent : public Component {
|
|
void Setup() override {}
|
|
void Update(float) override {}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct ProjectionComponent : public Component {
|
|
void Setup() override {}
|
|
void Update(float) override {}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct LifetimeComponent : public Component {
|
|
float remaining = 0.0f;
|
|
void Setup() override {}
|
|
void Update(float dt) override {
|
|
remaining -= dt;
|
|
if (remaining <= 0.0f) {
|
|
entity->QueueFree();
|
|
}
|
|
}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct CollectibleComponent : public Component {
|
|
void Setup() override {
|
|
auto selfCollider = entity->GetComponent<ColliderComponent>();
|
|
if (!selfCollider) {
|
|
return;
|
|
}
|
|
|
|
selfCollider->get().monitoring = true;
|
|
|
|
selfCollider->get().AddCollisionListener([this](Entity &other) {
|
|
if (entity->queuedForFree || !context || !context->probeEntity ||
|
|
&other != context->probeEntity) {
|
|
return;
|
|
}
|
|
|
|
context->EmitCollectiblePicked(*entity);
|
|
entity->QueueFree();
|
|
|
|
if (!context->hudEntity) {
|
|
return;
|
|
}
|
|
|
|
auto meter = context->hudEntity->GetComponent<MeterComponent>();
|
|
if (!meter) {
|
|
return;
|
|
}
|
|
|
|
meter->get().AddValue(meter->get().gainPerStar);
|
|
});
|
|
}
|
|
|
|
void Update(float) override {}
|
|
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct HazardComponent : public Component {
|
|
void Setup() override {
|
|
auto selfCollider = entity->GetComponent<ColliderComponent>();
|
|
if (!selfCollider) {
|
|
return;
|
|
}
|
|
|
|
selfCollider->get().monitoring = true;
|
|
|
|
selfCollider->get().AddCollisionListener([this](Entity &other) {
|
|
if (!context || !context->probeEntity || &other != context->probeEntity) {
|
|
return;
|
|
}
|
|
|
|
if (context->onPlayerDeath) {
|
|
context->onPlayerDeath();
|
|
}
|
|
});
|
|
}
|
|
void Update(float) override {}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct GravityReceiverComponent : public Component {
|
|
Entity *well = nullptr;
|
|
bool inVoid = false;
|
|
void Setup() override {}
|
|
void Update(float dt) override {
|
|
if (!context || !context->probeEntity || entity != context->probeEntity) {
|
|
return;
|
|
}
|
|
|
|
if (!well && context->wellEntity) {
|
|
well = context->wellEntity;
|
|
}
|
|
if (!well) {
|
|
return;
|
|
}
|
|
|
|
auto myTransform = entity->GetComponent<TransformComponent>();
|
|
auto physics = entity->GetComponent<PhysicsComponent>();
|
|
auto wellTransform = well->GetComponent<TransformComponent>();
|
|
auto wellGravity = well->GetComponent<GravityWellComponent>();
|
|
if (!myTransform || !physics || !wellTransform || !wellGravity) {
|
|
return;
|
|
}
|
|
|
|
MeterComponent *meterPtr = nullptr;
|
|
if (context->hudEntity) {
|
|
auto meter = context->hudEntity->GetComponent<MeterComponent>();
|
|
if (meter) {
|
|
meterPtr = &meter->get();
|
|
}
|
|
}
|
|
|
|
if (!wellGravity->get().active) {
|
|
return;
|
|
}
|
|
if (meterPtr && meterPtr->value <= 0.0f) {
|
|
return;
|
|
}
|
|
|
|
inVoid = false;
|
|
if (context->entities) {
|
|
for (auto &other : *context->entities) {
|
|
if (!other || other.get() == entity) {
|
|
continue;
|
|
}
|
|
|
|
auto zone = other->GetComponent<NullZoneComponent>();
|
|
auto zoneTransform = other->GetComponent<TransformComponent>();
|
|
if (!zone || !zoneTransform) {
|
|
continue;
|
|
}
|
|
|
|
const float left = zoneTransform->get().x;
|
|
const float right = left + zone->get().width;
|
|
if (myTransform->get().x >= left && myTransform->get().x <= right) {
|
|
inVoid = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (inVoid) {
|
|
return;
|
|
}
|
|
|
|
const float dx = wellTransform->get().x - myTransform->get().x;
|
|
const float dy = wellTransform->get().y - myTransform->get().y;
|
|
const float dist = std::sqrt(dx * dx + dy * dy);
|
|
if (dist <= 0.0001f) {
|
|
return;
|
|
}
|
|
|
|
const float clampedDist = std::max(dist, wellGravity->get().minDist);
|
|
const float force = wellGravity->get().mass / (clampedDist * clampedDist);
|
|
const float nx = dx / dist;
|
|
const float ny = dy / dist;
|
|
|
|
physics->get().vx += nx * force * dt;
|
|
physics->get().vy += ny * force * dt;
|
|
|
|
if (meterPtr) {
|
|
meterPtr->Drain(meterPtr->drainRate * dt);
|
|
}
|
|
}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct ProbeStateComponent : public Component {
|
|
float spawnX = 96.0f;
|
|
float spawnY = 230.0f;
|
|
float spawnVx = 165.0f;
|
|
float spawnVy = 0.0f;
|
|
void Setup() override {}
|
|
void Update(float) override {
|
|
if (!context || !context->probeEntity || entity != context->probeEntity) {
|
|
return;
|
|
}
|
|
|
|
auto transform = entity->GetComponent<TransformComponent>();
|
|
if (!transform) {
|
|
return;
|
|
}
|
|
|
|
if (transform->get().y < -20.0f ||
|
|
transform->get().y > static_cast<float>(GetScreenHeight() + 20) ||
|
|
transform->get().x < -20.0f) {
|
|
if (context->onPlayerDeath) {
|
|
context->onPlayerDeath();
|
|
}
|
|
}
|
|
}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct HudComponent : public Component {
|
|
void Setup() override {}
|
|
void Update(float) override {}
|
|
void Cleanup() override {}
|
|
};
|
|
|
|
struct RenderComponent : public Component {
|
|
std::function<void()> draw;
|
|
|
|
virtual void Draw() {
|
|
if (draw) {
|
|
draw();
|
|
}
|
|
}
|
|
|
|
void Setup() override {}
|
|
void Update(float) override {}
|
|
void Cleanup() override {}
|
|
};
|