Open source Star Ruler 2 source code!

source/game/design/projectiles.cpp

@@ -0,0 +1,749 @@
+#include "projectiles.h"
+#include "line3d.h"
+#include "main/references.h"
+#include "processing.h"
+#include "physics/physics_world.h"
+#include "obj/object.h"
+#include "empire.h"
+#include "design/effector.h"
+#include "threads.h"
+#include "scene/node.h"
+#include "scene/particle_system.h"
+#include "memory/AllocOnlyPool.h"
+#include "threads.h"
+#include "obj/lock.h"
+#include "scene/animation/anim_projectile.h"
+#include "util/save_file.h"
+#include "design/design.h"
+#include "obj/blueprint.h"
+#include "network/network_manager.h"
+#include "ISound.h"
+#include "ISoundDevice.h"
+#include <climits>
+#include <algorithm>
+
+memory::AllocOnlyPool<Projectile,threads::Mutex> projPool(8192);
+
+void initNewThread();
+void cleanupThread();
+
+struct ProjEffect : public ObjectMessage {
+	Object* source;
+	const Effector* effector;
+	vec3d relImpact;
+	float effectiveness;
+	float partiality;
+	float delay;
+
+	ProjEffect(const Effector* fctr, Object* target, Object* src, vec3d relImpactPt, float eff, float part, float del) : ObjectMessage(target), source(src), effector(fctr), relImpact(relImpactPt), effectiveness(eff), partiality(part), delay(del) {
+		source->grab();
+		effector->grab();
+	}
+
+	~ProjEffect() {
+		object->drop();
+		source->drop();
+		effector->drop();
+	}
+
+	void process() override {
+		effector->triggerEffect(source, object, relImpact, effectiveness, partiality, delay);
+	}
+};
+
+struct ProjImpactEffect : public scene::NodeEvent {
+	const scene::ParticleSystemDesc* system;
+	vec3d from, vel;
+	float scale;
+	float delay;
+
+	ProjImpactEffect(scene::Node* parentNode, const scene::ParticleSystemDesc* sys, const vec3d& From, const vec3d& Vel, float Scale, float Delay) : NodeEvent(parentNode), system(sys), from(From), vel(Vel), scale(Scale), delay(Delay) {
+	}
+
+	void process() override {
+		vec3d pos;
+		quaterniond rot;
+		if(node) {
+			vec3d d = (from - node->abs_position).normalized();
+			pos = (from - node->abs_position);
+			rot = quaterniond::fromImpliedTransform(vec3d::front(), d);
+		}
+		else {
+			pos = from;
+		}
+		auto* pSys = scene::playParticleSystem(system, node, pos, rot,  vel, scale, delay);
+		if(pSys)
+			pSys->drop();
+	}
+
+	~ProjImpactEffect() {
+	}
+};
+
+double clamp(double v, double low, double high) {
+	if(v <= low)
+		return low;
+	else if(v >= high)
+		return high;
+	else
+		return v;
+}
+
+static inline double sqr(double x) {
+	return x * x;
+}
+
+//Look for a new objec hostile to the owner
+Object* findTarget(Empire* owner, const vec3d& position, double radius, const void* ofType = nullptr) {
+	if(!owner)
+		return nullptr;
+
+	Object* obj = nullptr;
+
+	devices.physics->findInBox(AABBoxd::fromCircle(position, radius), [&obj,owner,&position,radius,ofType](const PhysicsItem& item) {
+		if(obj)
+			return;
+		if(item.type == PIT_Object) {
+			Object* target = item.object;
+			if(!target->isVisibleTo(owner) || !target->isValid())
+				return;
+			if(ofType && target->type != ofType)
+				return;
+			if(position.distanceToSQ(target->position) > (radius + target->radius) * (radius + target->radius))
+				return;
+
+			obj = target;
+			obj->grab();
+		}
+	}, owner->hostileMask);
+
+	return obj;
+}
+
+bool Projectile::tick(double time) {
+	//Rotate to track the target
+	if(type == PT_Missile) {
+		if(target && target->isValid()) {
+			if(recover <= 0.f) {
+				vec3d dir = (target->position - position).normalized();
+				vec3d projImpact = target->position + dir;
+				if(target->type->blueprintOffset != 0) {
+					auto* blueprint = (Blueprint*)(((size_t)target) + target->type->blueprintOffset);
+					const Design* dsg = blueprint->design;
+
+					if(dsg != nullptr) {
+						vec3d impactOffset = target->rotation.inverted() * dir;
+						projImpact = target->rotation * dsg->hull->getImpact(impactOffset, target->radius, true) + target->position;
+					}
+				}
+
+				dir = (projImpact - position).normalized();
+				double speed = velocity.getLength();
+				vec3d vdir = velocity / speed;
+
+				double angle = acos(clamp(vdir.dot(dir),-1,1)), rot = tracking * time;
+				if(angle < rot) {
+					velocity = dir * speed;
+				}
+				else if(angle >= pi * 0.9) {
+					quaterniond dirq = quaterniond::fromImpliedTransform(vec3d::front(), dir);
+					quaterniond vdirq = quaterniond::fromImpliedTransform(vec3d::front(), vdir);
+					quaterniond result = vdirq.slerp(dirq, rot / angle);
+					velocity = (result * vec3d::front()).normalized(speed);
+				}
+				else {//if(angle < 0.05) {
+					//Lerp is a good enough approximation
+					//   -- It really is not :( stupid missiles can't even turn 180 degrees
+					velocity = vdir.interpolate(dir, rot / angle).normalized(speed);
+				}
+
+				if(graphics) {
+					auto* anim = (scene::ProjectileAnim*)graphics->animator.ptr;
+					anim->velocity = velocity;
+				}
+			}
+		}
+		else if(source && source->isValid()) {
+			if(target) {
+				auto* prevTarget = target;
+				target = findTarget(source->owner, target->position, 50.0, target->type);
+				prevTarget->drop();
+			}
+			else {
+				target = findTarget(source->owner, position, 50.0);
+			}
+
+			//If we didn't quickly find a target, we die twice as fast
+			if(target == 0 && !effector->type.pierces)
+				lifetime *= 0.5f;
+		}
+		else {
+			//Become a dummy when the target is already dead
+			//Also live only half the remaining time
+			lifetime *= 0.5f;
+			if(target) {
+				target->drop();
+				target = 0;
+			}
+		}
+	}
+	else if(type == PT_Beam) {
+		//Beams can't fire when the source is dead
+		if(!source->isValid())
+			return true;
+
+		if(target) {
+			if(target->isValid()) {
+				if(tracking > 0) {
+					vec3d targDir = (target->position - (source->position + position)).normalize();
+					double range = velocity.getLength();
+
+					vec3d curDir = velocity / range;
+
+					double dot = std::max(std::min(targDir.dot(curDir), 1.0), -1.0);
+					double angDiff = acos(dot);
+					double track = tracking * time;
+
+					if(angDiff <= track)
+						velocity = targDir * range;
+					else
+						velocity = curDir.slerp(targDir,track/angDiff) * range;
+				}
+			}
+			else {
+				//Our current target is dead, find a new one
+				auto* prevTarget = target;
+				if(source)
+					target = findTarget(source->owner, target->position, 50.0, target->type);
+				else
+					target = 0;
+				prevTarget->drop();
+			}
+		}
+	}
+
+	line3dd line(position, vec3d());
+
+	if(type != PT_Beam) {
+		line.end = position + velocity * time;
+	}
+	else {
+		line.start += source->position;
+		line.end = line.start + velocity;
+	}
+
+	Object* other = 0;
+	vec3d impactPt;
+
+	double prevDistSQ = 0;
+	double projScale = scale;
+
+	//If our line still collides with our last impacted object, we can check for only intervening objects
+	if(lastImpact && lastImpact->isValid()) {
+		vec3d closePt = line.getClosestPoint(lastImpact->position,false);
+		double distSQ = closePt.distanceToSQ(lastImpact->position);
+		double width = lastImpact->radius + scale;
+		if(distSQ <= width * width) {
+			other = lastImpact;
+			other->grab();
+			impactPt = closePt - line.getDirection() * sqrt(width*width - distSQ);
+			if(!effector || !effector->type.pierces)
+				line.end = impactPt;
+			prevDistSQ = closePt.distanceToSQ(line.start);
+		}
+	}
+
+	if(mode != PM_OnlyHitsTarget) {
+		if(mode == PM_PassthroughInvalid) {
+			const Effector* eff = effector;
+			Object* src = source;
+			devices.physics->findInBox(AABBoxd(line, scale), [&other,&line,&prevDistSQ,&impactPt,projScale,eff,src](const PhysicsItem& item) {
+				//if(item.type != PIT_Object)
+				//	return;
+				Object* obj = item.object;
+				vec3d closePt = line.getClosestPoint(obj->position,false);
+				double distSQ = closePt.distanceToSQ(obj->position);
+				double width = obj->radius + projScale;
+				if(distSQ <= width * width && (!eff || eff->canTarget(src, obj))) {
+					double objDistSQ = closePt.distanceToSQ(line.start);
+					if(!other || objDistSQ < prevDistSQ) {
+						if(other)
+							other->drop();
+						other = obj;
+						other->grab();
+						prevDistSQ = objDistSQ;
+						impactPt = closePt - line.getDirection() * sqrt(width*width - distSQ);
+					}
+				}
+			}, source->owner ? (source->owner->hostileMask | 0x1) : ~0x0);
+		}
+		else {
+			devices.physics->findInBox(AABBoxd(line, scale), [&other,&line,&prevDistSQ,&impactPt,projScale](const PhysicsItem& item) {
+				//if(item.type != PIT_Object)
+				//	return;
+				Object* obj = item.object;
+				vec3d closePt = line.getClosestPoint(obj->position,false);
+				double distSQ = closePt.distanceToSQ(obj->position);
+				double width = obj->radius + projScale;
+				if(distSQ <= width * width) {
+					double objDistSQ = closePt.distanceToSQ(line.start);
+					if(!other || objDistSQ < prevDistSQ) {
+						if(other)
+							other->drop();
+						other = obj;
+						other->grab();
+						prevDistSQ = objDistSQ;
+						impactPt = closePt - line.getDirection() * sqrt(width*width - distSQ);
+					}
+				}
+			}, source->owner ? (source->owner->hostileMask | 0x1) : ~0x0);
+		}
+	}
+	else if(target && target->isValid()){
+		vec3d closePt = line.getClosestPoint(target->position,false);
+		double distSQ = closePt.distanceToSQ(target->position);
+		double width = target->radius + projScale;
+		if(distSQ <= width * width) {
+			if(other)
+				other->drop();
+			other = target;
+			other->grab();
+			impactPt = closePt - line.getDirection() * sqrt(width*width - distSQ);
+		}
+	}
+
+	if(other != nullptr && other->type->blueprintOffset != 0) {
+		auto* blueprint = (Blueprint*)(((size_t)other) + other->type->blueprintOffset);
+		const Design* dsg = blueprint->design;
+
+		if(dsg != nullptr) {
+			vec3d impactOffset = impactPt - other->position;
+			impactOffset = other->rotation.inverted() * impactOffset;
+			impactPt = other->rotation * dsg->hull->getImpact(impactOffset, other->radius, type == PT_Beam) + other->position;
+		}
+	}
+
+	if(recover > 0.f) {
+		if(other && other == lastImpact) {
+			other->drop();
+			other = nullptr;
+		}
+		recover -= time;
+		if(recover <= 0.f)
+			recover = 0.f;
+	}
+
+	if(other) {
+		if(impact)
+			*impact = impactPt;
+		if(type == PT_Beam || effector->type.pierces) {
+			other->grab();
+			if(lastImpact)
+				lastImpact->drop();
+			lastImpact = other;
+		}
+
+		auto* player = Empire::getPlayerEmpire();
+
+		if(effector) {
+			if(player && other->isVisibleTo(player)) {
+				if(auto* sfx = effector->type.skins[effector->skinIndex].impact_sound) {
+					if(sfx->loaded && !audio::disableSFX) {
+						auto* sound = devices.sound->play3D(sfx->source, snd_vec(other->position), false, true);
+						if(sound) {
+							if(source)
+								sound->setVolume((float)((scale + 1.0) / (scale + 7.0)));
+							sound->setPitch((float)randomd(0.95,1.05));
+							float dist = other->position.distanceTo(devices.render->cam_pos);
+							float lo = dist / (dist + scale * 500.0);
+							if(lo > 0.05)
+								sound->setLowPass(lo);
+							sound->resume();
+						}
+					}
+				}
+			}
+		}
+
+		LockGroup* lockGroup = other->lockGroup;
+		float delay = 0.f;
+		if(effector && lockGroup) {
+			if(type == PT_Missile && missileData) {
+				double speed = velocity.getLength();
+				delay = impactPt.distanceTo(position) / speed * 1.5f;
+			}
+
+			if(effector->type.skins[effector->skinIndex].impact && (!player || other->isVisibleTo(player)))
+				scene::queueNodeEvent(new ProjImpactEffect(other->node, effector->type.skins[effector->skinIndex].impact, impactPt, other->velocity, (float)sqrt(effector->relativeSize * (source ? source->radius : 1.0)), delay));
+			if(!devices.network->isClient)
+				lockGroup->addMessage(new ProjEffect(effector, other, source, impactPt - other->position, efficiency, type == PT_Beam ? (float)time : 1.f, delay));
+			else
+				other->drop();
+		}
+		else {
+			other->drop();
+		}
+
+		if(type != PT_Beam) {
+			if(effector && effector->type.pierces) {
+				recover = effector->type.recoverTime;
+				if(target && other == target) {
+					target->drop();
+					target = nullptr;
+				}
+			}
+			else {
+				if(type == PT_Missile && missileData) {
+					auto& data = **missileData;
+					double gameTime = devices.driver->getGameTime();
+					double speed = velocity.getLength();
+
+					data.lastUpdate = gameTime;
+					data.aliveUntil = gameTime + delay;
+					data.pos = impactPt;
+					data.vel = vec3f((impactPt - position).normalized(speed));
+				}
+				return true;
+			}
+		}
+	}
+	else if(impact) {
+		*impact = line.end;
+	}
+
+	if(type != PT_Beam) {
+		position = line.end;
+		if(type == PT_Missile && missileData) {
+			auto& data = **missileData;
+			data.lastUpdate = devices.driver->getGameTime();
+			data.pos = position;
+			data.vel = vec3f(velocity);
+		}
+	}
+	lifetime -= (float)time;
+	return lifetime <= 0;
+}
+
+void* Projectile::operator new(size_t size) {
+	return projPool.alloc();
+}
+
+void Projectile::operator delete(void* p) {
+	return projPool.dealloc((Projectile*)p);
+}
+
+Projectile::Projectile(ProjType Type) : lastTick(devices.driver->getGameTime()), source(0), target(0), lastImpact(0), graphics(0), type(Type), impact(0), efficiency(1.f), endNotice(0), mode(PM_Normal), recover(0.f) {
+}
+
+Projectile::~Projectile() {
+	if(graphics) {
+		graphics->markForDeletion();
+		graphics->drop();
+	}
+
+	if(type != PT_Missile) {
+		if(endNotice) {
+			**endNotice = true;
+			endNotice->drop();
+		}
+	}
+	else {
+		if(missileData) {
+			if((*missileData)->aliveUntil < 0)
+				(*missileData)->aliveUntil = 0;
+			missileData->drop();
+		}
+	}
+	
+	if(source)
+		source->drop();
+	if(target)
+		target->drop();
+	if(lastImpact)
+		lastImpact->drop();
+	if(effector)
+		effector->drop();
+}
+
+extern double frameTime_s;
+Projectile* Projectile::load(SaveFile& file) {
+	const Effector* efftr = nullptr;
+
+	unsigned char empID;
+	int dsgId;
+	unsigned subsysIndex, effectorIndex, effId;
+	if((bool)file) {
+		empID = file;
+		if(empID == INVALID_EMPIRE)
+			return 0;
+
+		dsgId = file;
+		subsysIndex = file;
+		effectorIndex = file;
+
+		Empire* dsgOwner = Empire::getEmpireByID(empID);
+		const Design* dsg = dsgOwner->getDesign(dsgId);
+		if(dsg == nullptr || subsysIndex >= dsg->subsystems.size() || effectorIndex >= dsg->subsystems[subsysIndex].type->effectors.size()) {
+			//throw "Invalid projectile effector.";
+			// Just cancel the projectile later so we can continue the load.
+		}
+		else {
+			efftr = &dsg->subsystems[subsysIndex].effectors[effectorIndex]; //No refcounting on design effectors
+		}
+	}
+	else {
+		effId = file;
+		efftr = getEffector(effId); //Reference is transfered to projectile
+	}
+
+	//Find effector
+	Projectile* proj = new Projectile((ProjType)file.read<unsigned char>());
+	proj->effector = efftr;
+
+	//Load data
+	file >> proj->lastTick;
+	file >> proj->lifetime;
+	proj->source = file.readExistingObject();
+	proj->target = file.readExistingObject();
+	file >> proj->position;
+	file >> proj->velocity;
+	file >> proj->scale;
+	file >> proj->tracking;
+	file >> proj->efficiency;
+
+	//Actually screw this, these things cause nothing but problems
+	delete proj;
+	return 0;
+
+	if(!proj->source || !proj->effector) {
+		//This can happen if the object that fired the projectile
+		//was already destroyed when the save occured. We have no way
+		//of instantiating these or their effects at the moment, because
+		//we know absolutely nothing about the source.
+
+		//TODO: Preserve these in some way, they can still impact and matter
+		//quite a bit.
+		delete proj;
+		return 0;
+	}
+
+	//TODO: The effects are non-trivial, figure out how to restore them
+	//Create graphics
+	/*proj->graphics = proj->effector->type.createGraphics(proj->effector, proj->scale);
+	if(!proj->graphics) {
+		delete proj;
+		throw "Invalid projectile effector graphics.";
+	}
+
+	proj->graphics->position = proj->position;
+	proj->graphics->rebuildTransformation();
+	proj->graphics->animator = new scene::ProjectileAnim(proj->velocity, 1.f);
+
+	registerProjectile(proj);
+	proj->graphics->queueReparent(devices.scene);
+	return proj;*/
+	registerProjectile(proj);
+	return proj;
+}
+
+void Projectile::save(SaveFile& file) {
+	if(effector && effector->effectorId != 0) {
+		file << false;
+		file << effector->effectorId;
+	}
+	else {
+		file << true;
+		if(!effector || !effector->inDesign || !effector->inDesign->owner) {
+			file << INVALID_EMPIRE;
+			return;
+		}
+
+		file << effector->inDesign->owner->id;
+		file << effector->inDesign->id;
+		file << effector->subsysIndex;
+		file << effector->effectorIndex;
+	}
+
+	file << (unsigned char)type;
+	file << lastTick;
+	file << lifetime;
+	file << source;
+	file << target;
+	file << position;
+	file << velocity;
+	file << scale;
+	file << tracking;
+	file << efficiency;
+}
+
+threads::Mutex projAddLock, projfillLock;
+threads::Signal activeProjThreads;
+threads::atomic_int pull_index, push_index, processed_count;
+std::vector<double> projThreadTimes;
+
+std::vector<Projectile*>* source = new std::vector<Projectile*>, *dest = new std::vector<Projectile*>;
+std::vector<Projectile*> queuedProjs;
+
+static void fillProjectiles() {
+	dest->resize(push_index);
+
+	if(!queuedProjs.empty()) {
+		projAddLock.lock();
+		dest->insert(dest->end(), queuedProjs.begin(), queuedProjs.end());
+		queuedProjs.clear();
+		projAddLock.release();
+	}
+
+	std::swap(source, dest);
+	dest->resize(source->size());
+
+	processed_count = 0;
+	push_index = 0;
+	pull_index = 0;
+}
+
+volatile bool ProjectilesActive = false;
+volatile bool EndProjectiles = false;
+volatile bool PauseProjectiles = false;
+volatile bool ProjectilesPaused = false;
+class ProcessProjectiles : public processing::Action {
+	bool host, active;
+public:
+	ProcessProjectiles(bool Host) : host(Host), active(true) {
+	}
+
+	~ProcessProjectiles() {
+		//This happens when the game is ending. We may not complete an entire cycle at the right time.
+		if(host)
+			ProjectilesActive = false;
+		else if(active)
+			activeProjThreads.signalDown();
+	}
+
+	bool run() {
+		if(host && activeProjThreads.check(0)) {
+			if(EndProjectiles)
+				return true;
+			ProjectilesActive = true;
+
+			if(PauseProjectiles) {
+				ProjectilesActive = false;
+				ProjectilesPaused = true;
+				return false;
+			}
+			else if(ProjectilesPaused) {
+				ProjectilesPaused = false;
+			}
+			else {
+				fillProjectiles();
+			}
+
+			if(!source->empty()) {
+				activeProjThreads.signal(4);
+				for(unsigned i = 0; i < 4; ++i)
+					processing::queueAction(new ProcessProjectiles(false));
+			}
+			else {
+				ProjectilesActive = false;
+				return false;
+			}
+		}
+
+		double curTime = devices.driver->getGameTime();
+		unsigned tickMax = 1000;
+		while(tickMax--) {
+			int index = pull_index++;
+			if(index >= (int)source->size()) {
+				if(host) {
+					ProjectilesActive = false;
+					return false;
+				}
+				else {
+					active = false;
+					activeProjThreads.signalDown();
+					return true;
+				}
+			}
+
+			//Take the next projectile, tick it, and put it on the output stack (unless it needs deleted)
+			Projectile* proj = source->at(index);
+			double t = curTime - proj->lastTick;
+
+			if(t < 0.125) {
+				int outIndex = push_index++;
+				dest->at(outIndex) = proj;
+			}
+			else {
+				if(!proj->tick(t)) {
+					proj->lastTick = curTime;
+					int outIndex = push_index++;
+					dest->at(outIndex) = proj;
+				}
+				else {
+					delete proj;
+				}
+			}
+		}
+
+		return false;
+	}
+};
+
+void registerProjectile(Projectile* proj) {
+	projAddLock.lock();
+	queuedProjs.push_back(proj);
+	projAddLock.release();
+}
+
+void initProjectiles() {
+	EndProjectiles = false;
+	PauseProjectiles = false;
+	processing::queueAction(new ProcessProjectiles(true));
+}
+
+void stopProjectiles() {
+	EndProjectiles = true;
+	while(ProjectilesActive)
+		threads::sleep(1);
+	activeProjThreads.wait(0);
+	source->clear(); source->shrink_to_fit();
+	dest->clear(); dest->shrink_to_fit();
+	for(auto i = queuedProjs.begin(), end = queuedProjs.end(); i != end; ++i)
+		delete *i;
+	queuedProjs.clear();
+	pull_index = 0;
+	push_index = 0;
+	processed_count = 0;
+}
+
+void saveProjectiles(SaveFile& file) {
+	unsigned cnt = (unsigned)(queuedProjs.size() + push_index);
+	file << cnt;
+
+	cnt = (unsigned)queuedProjs.size();
+	for(unsigned i = 0; i < cnt; ++i)
+		queuedProjs[i]->save(file);
+
+	cnt = (unsigned)push_index;
+	for(unsigned i = 0; i < cnt; ++i)
+		(*dest)[i]->save(file);
+}
+
+void loadProjectiles(SaveFile& file) {
+	unsigned cnt = file;
+	for(unsigned i = 0; i < cnt; ++i)
+		Projectile::load(file);
+}
+
+void pauseProjectiles() {
+	PauseProjectiles = true;
+	if(!ProjectilesActive)
+		return;
+	activeProjThreads.wait(0);
+	while(!ProjectilesPaused && ProjectilesActive)
+		threads::sleep(1);
+}
+
+void resumeProjectiles() {
+	PauseProjectiles = false;
+}