import hooks;
import orbitals;
import generic_effects;
import traits;
from orbitals import OrbitalEffect;
import requirement_effects;
import consume_effects;

#section server-side
from regions.regions import getRegion;
#section all

#section server
import object_creation;
#section all

class AddParticleSystem : OrbitalEffect {
	Document doc("Adds a permanent particle system to the orbital.");
	Argument particle("Particle System", AT_Custom, doc="ID of the particle system to create.");
	Argument size("Size", AT_Decimal, "1.0", doc="Scale factor for the effect.");

#section server-side
	void onMakeGraphics(Orbital& obj, any@ data, OrbitalNode@ node) const override {
		auto@ gfx = PersistentGfx();
		gfx.establish(obj, arguments[0].str, arguments[1].decimal);
		gfx.rotate(obj.rotation);
	}
#section all
};

//AddArmor(<Amount> = 0, <Per Import> = 0)
// Add maximum armor to the orbital.
class AddArmor : OrbitalEffect {
	Document doc("Add maximum armor to the orbital.");
	Argument amt("Amount", AT_Decimal, "0.0", doc="Base armor to add.");
	Argument perImport("Per Import", AT_Decimal, "0.0", doc="Armor added per import.");

#section server
	double amount(Orbital& obj) {
		double amt = arguments[0].decimal;
		double per = arguments[1].decimal;
		if(per != 0)
			amt += per * double(obj.usableResourceCount);
		return amt;
	}

	void onEnable(Orbital& obj, any@ data) const override {
		double amt = amount(obj);
		data.store(amt);
		obj.modMaxArmor(amt);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		double amt = amount(obj);
		double prev = 0;
		data.retrieve(prev);
		if(amt != prev) {
			data.store(amt);
			obj.modMaxArmor(amt - prev);
		}
	}

	void onDisable(Orbital& obj, any@ data) const override {
		double amt = 0;
		data.retrieve(amt);
		obj.modMaxArmor(-amt);
	}

	void save(any@ data, SaveFile& file) const override {
		double amt = 0;
		data.retrieve(amt);
		file << amt;
	}

	void load(any@ data, SaveFile& file) const override {
		double amt = 0;
		file >> amt;
		data.store(amt);
	}
#section all
};

//AddHealth(<Amount> = 0, <Per Import> = 0)
// Add maximum health to the orbital.
class AddHealth : OrbitalEffect {
	Document doc("Add maximum health to the orbital.");
	Argument amt("Amount", AT_Decimal, "0.0", doc="Base health to add.");
	Argument perImport("Per Import", AT_Decimal, "0.0", doc="Health added per import.");

#section server
	double amount(Orbital& obj) {
		double amt = arguments[0].decimal;
		double per = arguments[1].decimal;
		if(per != 0)
			amt += per * double(obj.usableResourceCount);
		return amt;
	}

	void onEnable(Orbital& obj, any@ data) const override {
		double amt = amount(obj);
		data.store(amt);
		obj.modMaxHealth(amt);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		double amt = amount(obj);
		double prev = 0;
		data.retrieve(prev);
		if(amt != prev) {
			data.store(amt);
			obj.modMaxHealth(amt - prev);
		}
	}

	void onDisable(Orbital& obj, any@ data) const override {
		double amt = 0;
		data.retrieve(amt);
		obj.modMaxHealth(-amt);
	}

	void save(any@ data, SaveFile& file) const override {
		double amt = 0;
		data.retrieve(amt);
		file << amt;
	}

	void load(any@ data, SaveFile& file) const override {
		double amt = 0;
		file >> amt;
		data.store(amt);
	}
#section all
};

class AddHealthEmpireAttribute : OrbitalEffect {
	Document doc("Add base maximum health to the orbital based on an empire attribute.");
	Argument attribute(AT_EmpAttribute, doc="Attribute to take the extra health from.");
	Argument multiplier(AT_Decimal, "1.0", doc="Multiplication factor to the attribute value.");

#section server
	double amount(Orbital& obj) {
		double amt = obj.owner.getAttribute(attribute.integer);
		amt *= multiplier.decimal;
		return amt;
	}

	void onEnable(Orbital& obj, any@ data) const override {
		double amt = amount(obj);
		data.store(amt);
		obj.modMaxHealth(amt);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		double amt = amount(obj);
		double prev = 0;
		data.retrieve(prev);
		if(amt != prev) {
			data.store(amt);
			obj.modMaxHealth(amt - prev);
		}
	}

	void onDisable(Orbital& obj, any@ data) const override {
		double amt = 0;
		data.retrieve(amt);
		obj.modMaxHealth(-amt);
	}

	void save(any@ data, SaveFile& file) const override {
		double amt = 0;
		data.retrieve(amt);
		file << amt;
	}

	void load(any@ data, SaveFile& file) const override {
		double amt = 0;
		file >> amt;
		data.store(amt);
	}
#section all
};

class AddArmorEmpireAttribute : OrbitalEffect {
	Document doc("Add base maximum armor to the orbital based on an empire attribute.");
	Argument attribute(AT_EmpAttribute, doc="Attribute to take the extra armor from.");
	Argument multiplier(AT_Decimal, "1.0", doc="Multiplication factor to the attribute value.");

#section server
	double amount(Orbital& obj) {
		double amt = obj.owner.getAttribute(attribute.integer);
		amt *= multiplier.decimal;
		return amt;
	}

	void onEnable(Orbital& obj, any@ data) const override {
		double amt = amount(obj);
		data.store(amt);
		obj.modMaxArmor(amt);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		double amt = amount(obj);
		double prev = 0;
		data.retrieve(prev);
		if(amt != prev) {
			data.store(amt);
			obj.modMaxArmor(amt - prev);
		}
	}

	void onDisable(Orbital& obj, any@ data) const override {
		double amt = 0;
		data.retrieve(amt);
		obj.modMaxArmor(-amt);
	}

	void save(any@ data, SaveFile& file) const override {
		double amt = 0;
		data.retrieve(amt);
		file << amt;
	}

	void load(any@ data, SaveFile& file) const override {
		double amt = 0;
		file >> amt;
		data.store(amt);
	}
#section all
};

//AddResistance(<Amount> = 0, <Per Import> = 0)
// Add damage resistance to the orbital.
class AddResistance : OrbitalEffect {
	Document doc("Add armor resistance to the orbital.");
	Argument amt("Amount", AT_Decimal, "0.0", doc="Base resistance to add.");
	Argument perImport("Per Import", AT_Decimal, "0.0", doc="Resistance added per import.");

#section server
	double amount(Orbital& obj) {
		double amt = arguments[0].decimal;
		double per = arguments[1].decimal;
		if(per != 0)
			amt += per * double(obj.usableResourceCount);
		return amt;
	}

	void onEnable(Orbital& obj, any@ data) const override {
		double amt = amount(obj);
		data.store(amt);
		obj.modDR(amt);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		double amt = amount(obj);
		double prev = 0;
		data.retrieve(prev);
		if(amt != prev) {
			data.store(amt);
			obj.modDR(amt - prev);
		}
	}

	void onDisable(Orbital& obj, any@ data) const override {
		double amt = 0;
		data.retrieve(amt);
		obj.modDR(-amt);
	}

	void save(any@ data, SaveFile& file) const override {
		double amt = 0;
		data.retrieve(amt);
		file << amt;
	}

	void load(any@ data, SaveFile& file) const override {
		double amt = 0;
		file >> amt;
		data.store(amt);
	}
#section all
};

class AddResistanceEmpireAttribute : OrbitalEffect {
	Document doc("Add base resistance to the orbital based on an empire attribute.");
	Argument attribute(AT_EmpAttribute, doc="Attribute to take the extra resistance from.");
	Argument multiplier(AT_Decimal, "1.0", doc="Multiplication factor to the attribute value.");

#section server
	double amount(Orbital& obj) {
		double amt = obj.owner.getAttribute(attribute.integer);
		amt *= multiplier.decimal;
		return amt;
	}

	void onEnable(Orbital& obj, any@ data) const override {
		double amt = amount(obj);
		data.store(amt);
		obj.modDR(amt);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		double amt = amount(obj);
		double prev = 0;
		data.retrieve(prev);
		if(amt != prev) {
			data.store(amt);
			obj.modDR(amt - prev);
		}
	}

	void onDisable(Orbital& obj, any@ data) const override {
		double amt = 0;
		data.retrieve(amt);
		obj.modDR(-amt);
	}

	void save(any@ data, SaveFile& file) const override {
		double amt = 0;
		data.retrieve(amt);
		file << amt;
	}

	void load(any@ data, SaveFile& file) const override {
		double amt = 0;
		file >> amt;
		data.store(amt);
	}
#section all
};

//FTLMaintenance(<Amount>)
// Add an FTL maintenance cost to the module.
class FTLMaintenance : OrbitalEffect {
	Document doc("Makes the orbital cost FTL to maintain.");
	Argument amt("Amount", AT_Decimal, doc="FTL maintenance cost.");

#section server
	void onEnable(Orbital& obj, any@ data) const override {
		if(obj.owner !is null && obj.owner.valid)
			obj.owner.modFTLUse(arguments[0].decimal);
	}

	void onOwnerChange(Orbital& obj, any@ data, Empire@ prevOwner, Empire@ newOwner) const override {
		if(prevOwner !is null && prevOwner.valid)
			prevOwner.modFTLUse(-arguments[0].decimal);
		if(newOwner !is null && newOwner.valid)
			newOwner.modFTLUse(arguments[0].decimal);
	}

	void onDisable(Orbital& obj, any@ data) const override {
		if(obj.owner !is null && obj.owner.valid)
			obj.owner.modFTLUse(-arguments[0].decimal);
	}

	bool shouldDisable(Orbital& obj, any@ data) const override {
		if(obj.owner is null || !obj.owner.valid)
			return true;
		return obj.owner.FTLShortage;
	}

	bool shouldEnable(Orbital& obj, any@ data) const override {
		if(obj.owner is null || !obj.owner.valid)
			return false;
		return !obj.owner.isFTLShortage(arguments[0].decimal);
	}
#section all
};

//DisableOnFTLBlock()
// Disables the module if ftl is blocked in the region.
class DisableOnFTLBlock : OrbitalEffect {
	Document doc("Disables this orbital if FTL jamming is affecting its region.");
	
#section server
	bool shouldDisable(Orbital& obj, any@ data) const override {
		if(obj.owner is null || !obj.owner.valid)
			return false;
		Region@ reg = obj.region;
		if(reg is null)
			return false;
		if(reg.BlockFTLMask & obj.owner.mask != 0)
			return true;
		return false;
	}

	bool shouldEnable(Orbital& obj, any@ data) const override {
		if(obj.owner is null || !obj.owner.valid)
			return true;
		Region@ reg = obj.region;
		if(reg is null)
			return true;
		if(reg.BlockFTLMask & obj.owner.mask != 0)
			return false;
		return true;
	}
#section all
};

//CannotBuildManually()
// Module cannot be built manually.
class CannotBuildManually : OrbitalEffect {
	Document doc("Prevents this orbital from being manually contructed.");
	
	bool canBuildBy(Object@ obj, bool ignoreCost) const override {
		return false;
	}

	bool canBuildOn(Orbital& obj) const override {
		return false;
	}
};

class RequireBlackHoleSystem : OrbitalEffect {
	Document doc("This orbital can only be constructed in systems that have a black hole.");

	string getBuildError(Object@ obj, const vec3d& pos) const {
		return locale::OERR_BLACKHOLE;
	}

	bool canBuildAt(Object@ obj, const vec3d& pos) const {
		Region@ target = getRegion(pos);
		if(target is null)
			return false;
		return target.starCount > 0 && target.starTemperature == 0;
	}
};

class RequireCloseToStar : OrbitalEffect {
	Document doc("This orbital must be placed close to the star.");
	Argument max_distance(AT_Decimal, "110", doc="Maximum radius away from star.");
	Argument min_distance(AT_Decimal, "10", doc="Minimum radius away from star.");

	string getBuildError(Object@ obj, const vec3d& pos) const {
		return locale::OERR_CLOSE_TO_STAR;
	}

	bool canBuildAt(Object@ obj, const vec3d& pos) const {
		Region@ target = getRegion(pos);
		if(target is null)
			return false;
		double dist = pos.distanceTo(target.position);
		double starRad = target.starRadius;
		return dist > starRad && dist <= starRad + max_distance.decimal;
	}
};

class LimitInOrbitStatus : OrbitalEffect {
	Document doc("This orbital must be constructed in orbit of a planet, and can only be constructed if there is a limited amount of a status present.");
	Argument status(AT_Status, doc="Status type to check for.");
	Argument max_stacks(AT_Integer, "1", doc="Maximum stacks for the orbital.");
	Argument min_distance(AT_Decimal, "5", doc="Minimum distance this needs to be from the planet.");

	string getBuildError(Object@ obj, const vec3d& pos) const {
		Region@ target = getRegion(pos);
		if(target is null)
			return locale::OERR_PLANET_ORBIT;
		Object@ orbit = target.getOrbitObject(pos);
		if(orbit is null || obj is null || orbit.owner !is obj.owner)
			return locale::OERR_PLANET_ORBIT;
		if(orbit.position.distanceTo(pos) < orbit.radius + min_distance.decimal)
			return locale::OERR_PLANET_ORBIT;
		return locale::OERR_PLANET_LIMIT;
	}

	bool canBuildAt(Object@ obj, const vec3d& pos) const {
		Region@ target = getRegion(pos);
		if(target is null)
			return false;

		Object@ orbit = target.getOrbitObject(pos);
		if(orbit is null || obj is null || obj.owner !is orbit.owner)
			return false;

		if(orbit.position.distanceTo(pos) < orbit.radius + min_distance.decimal)
			return false;

		int count = orbit.getStatusStackCountAny(status.integer);
		if(count >= max_stacks.integer)
			return false;

		return true;
	}

#section server
	void onEnable(Orbital& obj, any@ data) const override {
		Region@ target = getRegion(obj.position);
		if(target is null) {
			obj.destroy();
			return;
		}

		Object@ orbit = target.getOrbitObject(obj.position);
		if(orbit is null) {
			obj.destroy();
			return;
		}

		int count = orbit.getStatusStackCountAny(status.integer);
		if(count >= max_stacks.integer) {
			obj.destroy();
			return;
		}
	}
#section all
};

//OnKillSpreadLeverageToFriendlies(<Quality Factor>)
// When this orbital is killed, all friendly empires get <Quality Factor> leverage on the killer.
class OnKillSpreadLeverageToFriendlies : OrbitalEffect {
	Document doc("Gives leverage to the orbital's owner and allies when destroyed.");
	Argument qual("Quality Factor", AT_Decimal, "1.0", doc="Magic number to decide the overall value of leverage granted.");

#section server
	void onKill(Orbital& obj, any@ data, Empire@ killedBy) const override {
		Empire@ owner = obj.owner;
		if(owner is null || !owner.valid)
			return;

		for(uint i = 0, cnt = getEmpireCount(); i < cnt; ++i) {
			Empire@ other = getEmpire(i);
			if(!other.major || other is killedBy)
				continue;
			if(other !is owner && other.isHostile(owner))
				continue;

			other.gainRandomLeverage(killedBy, arguments[0].decimal);
		}
	}
#section all
};

//DryDockConstruction()
// Allow this orbital to do dry dock construction.
tidy final class DryDockStatus {
	const Design@ design;
	int maintainCost = 0;
	int buildCost = 0;
	double percentPaid = 0;
	double laborGen = 0;
	double curLabor = 0;
	double totalLabor = 1;
	bool isFree = false;
};

class DryDockConstruction : OrbitalEffect {
	Document doc("Allows this orbital to act as a drydock.");
	
#section server-side
	void write(any@ data, Message& msg) const {
		DryDockStatus@ status;
		data.retrieve(@status);

		if(status is null) {
			msg.write0();
			return;
		}

		msg.write1();
		msg << status.design;
		msg.writeFixed(status.percentPaid, bits=8);
		msg << float(status.curLabor);
		msg << float(status.totalLabor);
		msg << float(status.laborGen);
		msg.writeBit(status.isFree);
	}

	void read(any@ data, Message& msg) const {
		if(!msg.readBit())
			return;

		DryDockStatus@ status;
		data.retrieve(@status);
		if(status is null) {
			@status = DryDockStatus();
			data.store(@status);
		}

		msg >> status.design;
		status.percentPaid = msg.readFixed(bits=8);
		status.curLabor = msg.read_float();
		status.totalLabor = msg.read_float();
		status.laborGen = msg.read_float();
		status.isFree = msg.readBit();
	}
#section server
	void save(any@ data, SaveFile& file) const {
		DryDockStatus@ status;
		data.retrieve(@status);

		file << status.design;
		file << status.maintainCost;
		file << status.buildCost;
		file << status.percentPaid;
		file << status.laborGen;
		file << status.curLabor;
		file << status.totalLabor;
		file << status.isFree;
	}

	void load(any@ data, SaveFile& file) const {
		DryDockStatus status;
		data.store(@status);

		file >> status.design;
		file >> status.maintainCost;
		file >> status.buildCost;
		file >> status.percentPaid;
		file >> status.laborGen;
		file >> status.curLabor;
		file >> status.totalLabor;
		file >> status.isFree;
	}

	void onEnable(Orbital& obj, any@ data) const override {
		DryDockStatus status;
		data.store(@status);
	}

	void onDisable(Orbital& obj, any@ data) const override {
		DryDockStatus@ status;
		data.retrieve(@status);

		if(!status.isFree) {
			int prevMaint = ceil(double(status.maintainCost) * status.percentPaid);
			obj.owner.modMaintenance(-prevMaint, MoT_Construction);
		}

		@status = null;
		data.store(@status);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		DryDockStatus@ status;
		data.retrieve(@status);
		if(status is null || status.design is null)
			return;
		int pct = int(status.curLabor / status.totalLabor * 1000);
		if(status.laborGen != 0) {
			double prevLabor = status.curLabor;
			status.curLabor = clamp(status.curLabor + status.laborGen * time,
					0, max(status.totalLabor * status.percentPaid, status.curLabor));
			obj.usingLabor = abs(prevLabor - status.curLabor) > 0.001;
			if(pct != int(status.curLabor / status.totalLabor * 1000))
				obj.triggerDelta();
		}
		else {
			obj.usingLabor = false;
		}
		if(status.curLabor >= status.totalLabor && status.percentPaid >= 1.f) {
			createShip(obj, status.design, move=false, free=status.isFree);
			obj.usingLabor = false;
			obj.destroy();
		}
	}

	bool sendDesign(Player& pl, Orbital& obj, any@ data, uint index, const Design@ value) const {
		if(pl != SERVER_PLAYER)
			return false;
		if(index == OV_DRY_Design) {
			DryDockStatus@ status;
			data.retrieve(@status);
			if(status is null)
				return false;

			@status.design = value;
			getBuildCost(value, status.buildCost, status.maintainCost, status.totalLabor);
			status.buildCost = double(status.buildCost) * config::DRYDOCK_BUILDCOST_FACTOR * obj.owner.DrydockCostFactor;
			status.curLabor = 0;
			return true;
		}
		return false;
	}

	bool sendValue(Player& pl, Orbital& obj, any@ data, uint index, double value) const {
		if(index == OV_DRY_SetFinanced) {
			if(pl != SERVER_PLAYER)
				return false;

			DryDockStatus@ status;
			data.retrieve(@status);
			if(status is null)
				return false;

			if(!status.isFree) {
				int prevMaint = ceil(double(status.maintainCost) * status.percentPaid);
				int newMaint = ceil(double(status.maintainCost) * value);
				obj.owner.modMaintenance(newMaint - prevMaint, MoT_Construction);
			}
			status.percentPaid = value;
			obj.triggerDelta();
			return true;
		}
		if(index == OV_DRY_Progress) {
			if(pl != SERVER_PLAYER)
				return false;

			DryDockStatus@ status;
			data.retrieve(@status);
			if(status is null)
				return false;

			status.curLabor = value * status.totalLabor;
			obj.triggerDelta();
			return true;
		}
		if(index == OV_DRY_Free) {
			if(pl != SERVER_PLAYER)
				return false;

			DryDockStatus@ status;
			data.retrieve(@status);
			if(status is null)
				return false;

			bool free = value != 0.0;
			if(free != status.isFree) {
				if(status.maintainCost != 0) {
					if(status.isFree) {
						int prevMaint = ceil(double(status.maintainCost) * status.percentPaid);
						obj.owner.modMaintenance(+prevMaint, MoT_Construction);
					}
					else {
						int prevMaint = ceil(double(status.maintainCost) * status.percentPaid);
						obj.owner.modMaintenance(-prevMaint, MoT_Construction);
					}
				}
				status.isFree = free;
			}
			obj.triggerDelta();
			return true;
		}
		if(index == OV_DRY_ModLabor) {
			if(pl != SERVER_PLAYER)
				return false;

			DryDockStatus@ status;
			data.retrieve(@status);
			if(status is null)
				return false;

			status.laborGen += value;
			obj.triggerDelta();
			return true;
		}
		if(index == OV_DRY_Financed) {
			DryDockStatus@ status;
			data.retrieve(@status);
			if(status is null)
				return false;

			double pct = value;
			double prevPct = status.percentPaid;
			double newPct = clamp(pct, 0.0, 1.0);
			pct = newPct - prevPct;

			int cost = ceil(double(status.buildCost) * pct);
			if(obj.owner.consumeBudget(cost) == -1)
				return true;

			if(!status.isFree) {
				int prevMaint = ceil(double(status.maintainCost) * prevPct);
				int newMaint = ceil(double(status.maintainCost) * newPct);
				obj.owner.modMaintenance(newMaint - prevMaint, MoT_Construction);
			}
			status.percentPaid = newPct;
			obj.triggerDelta();
			return true;
		}
		return false;
	}
#section server-side
	bool getValue(Player& pl, Orbital& obj, any@ data, uint index, double& value) const {
		DryDockStatus@ status;
		data.retrieve(@status);
		if(status is null)
			return false;

		switch(index) {
			case OV_DRY_Free: value = status.isFree ? 1.0 : 0.0; return true;
			case OV_DRY_Progress: value = status.curLabor / status.totalLabor; return true;
			case OV_DRY_Financed: value = status.percentPaid; return true;
			case OV_DRY_ETA:
				value = (status.laborGen == 0) ? INFINITY :
						 (status.totalLabor - status.curLabor) / status.laborGen;
				return true;
		}
		return false;
	}

	bool getDesign(Player& pl, Orbital& obj, any@ data, uint index, const Design@& value) const {
		if(index == OV_DRY_Design) {
			DryDockStatus@ status;
			data.retrieve(@status);
			if(status is null)
				return false;

			@value = status.design;
			return true;
		}
		return false;
	}
#section all
};

//PacksIntoShip(<Design> = "", <Maintenance> = True)
// This orbital can be packed into a ship of <Design>.
class PacksIntoShip : OrbitalEffect {
	Document doc("Allows the orbital to be packed into a specific ship design.");
	Argument design("Design", AT_Custom, "", doc="Design name to packup into.");
	Argument maint("Maintenance", AT_Boolean, "True", doc="Whether the created ship should cost maintenance.");

#section server-side
	void write(any@ data, Message& msg) const {
		const Design@ dsg;
		data.retrieve(@dsg);
		msg << dsg;
	}

	void read(any@ data, Message& msg) const {
		const Design@ dsg;
		msg >> dsg;
		data.store(@dsg);
	}
#section server
	void save(any@ data, SaveFile& file) const {
		const Design@ dsg;
		data.retrieve(@dsg);
		file << dsg;
	}

	void load(any@ data, SaveFile& file) const {
		const Design@ dsg;
		file >> dsg;
		data.store(@dsg);
	}

	void onEnable(Orbital& obj, any@ data) const override {
		const Design@ dsg;
		data.retrieve(@dsg);
		if(dsg is null) {
			for(uint i = 0, cnt = obj.owner.designCount; i < cnt; ++i) {
				auto@ check = obj.owner.designs[i];
				if(check.name == arguments[0].str) {
					@dsg = check.mostUpdated();
					break;
				}
			}
			data.store(@dsg);
		}
		if(arguments[1].boolean && obj.owner !is null && obj.owner.valid)
			obj.owner.modMaintenance(+getMaintenance(obj, data), MoT_Orbitals);
	}

	int getMaintenance(Orbital& obj, any@ data) const {
		const Design@ dsg;
		data.retrieve(@dsg);
		if(dsg is null)
			return 0;
		const OrbitalModule@ mod = getOrbitalModule(obj.coreModule);
		if(mod is null)
			return getMaintenanceCost(dsg);
		return getMaintenanceCost(dsg) - mod.maintenance;
	}

	void onDisable(Orbital& obj, any@ data) const override {
		if(arguments[1].boolean && obj.owner !is null && obj.owner.valid)
			obj.owner.modMaintenance(-getMaintenance(obj, data), MoT_Orbitals);
		const Design@ dsg = null;
		data.store(@dsg);
	}

	void onOwnerChange(Orbital& obj, any@ data, Empire@ prevOwner, Empire@ newOwner) const override {
		if(arguments[1].boolean) {
			int maint = getMaintenance(obj, data);
			if(prevOwner !is null && prevOwner.valid)
				prevOwner.modMaintenance(-maint, MoT_Orbitals);
			if(newOwner !is null && newOwner.valid)
				newOwner.modMaintenance(+maint, MoT_Orbitals);
		}
	}

	bool sendDesign(Player& pl, Orbital& obj, any@ data, uint index, const Design@ value) const {
		if(pl != SERVER_PLAYER)
			return false;
		if(index == OV_PackUp) {
			int prevMaintenance = 0, newMaintenance = 0;
			if(arguments[1].boolean)
				prevMaintenance = getMaintenance(obj, data);
			data.store(@value);
			if(arguments[1].boolean) {
				newMaintenance = getMaintenance(obj, data);
				if(prevMaintenance != newMaintenance && obj.owner !is null && obj.owner.valid)
					obj.owner.modMaintenance(newMaintenance - prevMaintenance, MoT_Orbitals);
			}
			obj.triggerDelta();
			return true;
		}
		return false;
	}

	bool sendValue(Player& pl, Orbital& obj, any@ data, uint index, double value) const {
		if(index == OV_PackUp) {
			if(pl != SERVER_PLAYER && pl.emp !is obj.owner)
				return false;

			const Design@ dsg;
			data.retrieve(@dsg);
			if(dsg is null)
				return false;
			createShip(obj.position, dsg, obj.owner);
			obj.destroy();
			return true;
		}
		return false;
	}
#section server-side
	bool getDesign(Player& pl, Orbital& obj, any@ data, uint index, const Design@& value) const {
		if(index == OV_PackUp) {
			const Design@ dsg;
			data.retrieve(@dsg);
			@value = dsg;
			return true;
		}
		return false;
	}
#section all
};

//RecordOrbitalDPS(<Amount> = 0, <Per Import> = 0)
// Add recorded dps to the orbital.
class RecordOrbitalDPS : OrbitalEffect {
	Document doc("Adds to the listed damage per second on an orbital.");
	Argument amt("Amount", AT_Decimal, "0.0", doc="Base DPS to add.");
	Argument perImport("Per Import", AT_Decimal, "0.0", doc="DPS to add per import");

#section server
	double amount(Orbital& obj) {
		double amt = arguments[0].decimal;
		double per = arguments[1].decimal;
		if(per != 0)
			amt += per * double(obj.usableResourceCount);
		return amt;
	}

	void onEnable(Orbital& obj, any@ data) const override {
		double amt = amount(obj);
		data.store(amt);
		obj.modDPS(amt);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		double amt = amount(obj);
		double prev = 0;
		data.retrieve(prev);
		if(amt != prev) {
			data.store(amt);
			obj.modDPS(amt - prev);
		}
	}

	void onDisable(Orbital& obj, any@ data) const override {
		double amt = 0;
		data.retrieve(amt);
		obj.modDPS(-amt);
	}

	void save(any@ data, SaveFile& file) const override {
		double amt = 0;
		data.retrieve(amt);
		file << amt;
	}

	void load(any@ data, SaveFile& file) const override {
		double amt = 0;
		file >> amt;
		data.store(amt);
	}
#section all
};

class LimitOncePerSystem : OrbitalEffect {
	Document doc("This orbital can only be constructed once per system.");
	Argument flag(AT_SystemFlag, doc="System flag to base the once per system limit on. Can be set to any arbitrary unique name.");
	Argument any_empire(AT_Boolean, "False", doc="If set to true, only one empire may build this in a system.");

	bool canBuildAt(Object@ obj, const vec3d& pos) const {
		auto@ system = getRegion(pos);
		if(system is null)
			return false;
		if(obj is null)
			return false;
		return !check(obj, system);
	}
	
	bool check(Object& obj, Region@ system) {
		if(any_empire.boolean)
			return system.getSystemFlagAny(flag.integer);
		else
			return system.getSystemFlag(obj.owner, flag.integer);
	}

	string getBuildError(Object@ obj, const vec3d& pos) const {
		return locale::OERR_LIMIT;
	}

#section server
	void onOwnerChange(Orbital& obj, any@ data, Empire@ prevOwner, Empire@ newOwner) const override {
		Region@ region = obj.region;
		if(region !is null) {
			if(prevOwner !is null && prevOwner.valid)
				region.setSystemFlag(prevOwner, flag.integer, false);
			if(newOwner !is null && newOwner.valid) {
				if(region.getSystemFlag(newOwner, flag.integer))
					obj.destroy();
				else
					region.setSystemFlag(newOwner, flag.integer, true);
			}
		}
	}

	void onRegionChange(Orbital& obj, any@ data, Region@ fromRegion, Region@ toRegion) const override {
		Empire@ owner = obj.owner;
		if(owner !is null && owner.valid) {
			if(fromRegion !is null)
				fromRegion.setSystemFlag(owner, flag.integer, false);
			if(toRegion !is null) {
				if(check(obj, toRegion)) {
					if(!obj.inFTL)
						obj.destroy();
				}
				else
					toRegion.setSystemFlag(owner, flag.integer, true);
			}
		}
	}

	void onEnable(Orbital& obj, any@ data) const override {
		Region@ region = obj.region;
		Empire@ owner = obj.owner;
		if(region !is null && owner !is null && owner.valid) {
			if(check(obj, region))
				obj.destroy();
			else
				region.setSystemFlag(owner, flag.integer, true);
		}
	}

	void onDisable(Orbital& obj, any@ data) const override {
		Region@ region = obj.region;
		Empire@ owner = obj.owner;
		if(region !is null && owner !is null && owner.valid)
			region.setSystemFlag(owner, flag.integer, false);
	}

	bool shouldDisable(Orbital& obj, any@ data) const override {
		return obj.inFTL || obj.region is null;
	}

	bool shouldEnable(Orbital& obj, any@ data) const override {
		return !obj.inFTL && obj.region !is null;
	}
#section all
};

class SetAsDefense : OrbitalEffect {
	Document doc("This orbital is set to make use of defense production by default.");

#section server
	void onEnable(Orbital& obj, any@ data) const override {
		Empire@ owner = obj.owner;
		if(owner !is null && owner.valid)
			owner.setDefending(obj, true);
	}

	void onOwnerChange(Orbital& obj, any@ data, Empire@ prevOwner, Empire@ newOwner) const override {
		if(prevOwner !is null && prevOwner.valid)
			prevOwner.setDefending(obj, false);
		if(newOwner !is null && newOwner.valid)
			newOwner.setDefending(obj, true);
	}
#section all
};

class FrameConstruction : OrbitalEffect {
	Document doc("This orbital is a construction frame for other orbitals.");
	Argument cost_factor(AT_Decimal, "1.0", doc="Factor to build cost of orbitals built on this frame.");
	Argument labor_factor(AT_Decimal, "1.0", doc="Factor to labor cost of orbitals built on this frame.");
	Argument labor_penalty_factor(AT_Decimal, "1.0", doc="Factor to labor cost penalty of orbitals built on this frame.");
	
#section server
	bool sendObject(Player& pl, Orbital& obj, any@ data, uint index, Object@ value) const {
		if(index == OV_FRAME_Target) {
			obj.destroy();
			return true;
		}
		return false;
	}
#section server-side
	bool getValue(Player& pl, Orbital& obj, any@ data, uint index, double& value) const {
		if(index == OV_FRAME_Usable) {
			value = 1.0;
			return true;
		}
		else if(index == OV_FRAME_CostFactor) {
			value = cost_factor.decimal;
			return true;
		}
		else if(index == OV_FRAME_LaborFactor) {
			value = labor_factor.decimal;
			return true;
		}
		else if(index == OV_FRAME_LaborPenaltyFactor) {
			value = labor_penalty_factor.decimal;
			return true;
		}
		return false;
	}
#section all
};

class BreakOrbitOnFTL : OrbitalEffect {
	Document doc("When the planet this orbital is orbiting FTLs, the orbital breaks its orbit.");

#section server
	void onTick(Orbital& obj, any@ data, double time) const override {
		Object@ around = obj.getOrbitingAround();
		if(around !is null && around.inFTL)
			obj.stopOrbit();
	}
#section all
};

class AllowResourceImport : OrbitalEffect {
	Document doc("This orbital can import resources.");

#section server
	void onEnable(Orbital& obj, any@ data) const override {
		obj.setImportEnabled(true);
	}
#section all
};

class AutoMasterSlave : OrbitalEffect {
	Document doc("Automatically slave this to the first orbital of this type.");

#section server
	void onEnable(Orbital& obj, any@ data) const override {
		uint core = obj.coreModule;
		uint id = uint(obj.id);

		auto@ datalist = obj.owner.getOrbitals();
		Object@ check;
		Orbital@ newMaster;
		while(receive(datalist, check)) {
			Orbital@ orb = cast<Orbital>(check);
			if(orb is null || !orb.valid)
				continue;
			if(uint(orb.id) >= id)
				continue;
			if(orb.coreModule != core)
				continue;

			@newMaster = orb;
			id = uint(orb.id);
		}

		obj.setMaster(newMaster);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		Orbital@ master = obj.getMaster();
		if(master !is null) {
			if(!master.valid || master.owner !is obj.owner)
				onEnable(obj, data);
		}
	}

	void onOwnerChange(Orbital& obj, any@ data, Empire@ prevOwner, Empire@ newOwner) const override {
		onEnable(obj, data);
	}
#section all
};

class CopyLaborFromMaster : OrbitalEffect {
	Document doc("Copy the labor income that this orbital's master is giving.");

#section server
	void onEnable(Orbital& obj, any@ data) const override {
		double amount = 0;
		data.store(amount);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		double prevAmount = 0;
		data.retrieve(prevAmount);

		double newAmount = 0;
		Orbital@ master = obj.getMaster();
		if(master !is null)
			newAmount = master.laborIncome;

		if(prevAmount != newAmount) {
			obj.modLaborIncome(newAmount - prevAmount);
			data.store(newAmount);
		}
	}

	void onDisable(Orbital& obj, any@ data) const override {
		double amount = 0;
		data.retrieve(amount);

		obj.modLaborIncome(-amount);
	}

	void save(any@ data, SaveFile& file) const override {
		double amount = 0;
		data.retrieve(amount);
		file << amount;
	}

	void load(any@ data, SaveFile& file) const override {
		double amount = 0;
		file >> amount;
		data.store(amount);
	}
#section all
};

tidy final class PressureCopier {
	Orbital@ copyTo;
	array<double> amount(TR_COUNT, 0.0);
};

class CopyPressureToMaster : OrbitalEffect {
	Document doc("Copy over all the pressure this orbital is importing to the orbital's master if it has one.");

#section server
	void onEnable(Orbital& obj, any@ data) const override {
		PressureCopier pc;
		data.store(@pc);
	}

	void onTick(Orbital& obj, any@ data, double time) const override {
		PressureCopier@ pc;
		data.retrieve(@pc);

		//Deal with master changes
		Orbital@ newMaster = obj.getMaster();
		if(newMaster !is pc.copyTo) {
			for(uint i = 0, cnt = pc.amount.length; i < cnt; ++i) {
				if(pc.amount[i] != 0) {
					pc.copyTo.modPressure(i, -pc.amount[i]);
					newMaster.modPressure(i, +pc.amount[i]);
				}
			}
			@pc.copyTo = newMaster;
		}

		//Deal with pressure changes
		if(pc.copyTo !is null) {
			for(uint i = 0, cnt = pc.amount.length; i < cnt; ++i) {
				double newValue = obj.resourcePressure[i];
				if(pc.amount[i] != newValue) {
					pc.copyTo.modPressure(i, newValue - pc.amount[i]);
					pc.amount[i] = newValue;
				}
			}
		}
	}

	void onDisable(Orbital& obj, any@ data) const override {
		PressureCopier@ pc;
		data.retrieve(@pc);

		if(pc.copyTo !is null) {
			for(uint i = 0, cnt = pc.amount.length; i < cnt; ++i) {
				if(pc.amount[i] != 0)
					pc.copyTo.modPressure(i, -pc.amount[i]);
			}
		}
	}

	void save(any@ data, SaveFile& file) const override {
		PressureCopier@ pc;
		data.retrieve(@pc);
		if(pc is null)
			@pc = PressureCopier();

		file << pc.copyTo;

		uint cnt = pc.amount.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			file << pc.amount[i];
	}

	void load(any@ data, SaveFile& file) const override {
		PressureCopier pc;
		data.store(@pc);

		file >> pc.copyTo;

		uint cnt = 0;
		file >> cnt;
		pc.amount.length = cnt;

		for(uint i = 0; i < cnt; ++i)
			file >> pc.amount[i];
	}
#section all
};

class MoveCargoToMaster : OrbitalEffect {
	Document doc("Move all the cargo on this orbital to the orbital's master if it has one.");

#section server
	void onTick(Orbital& obj, any@ data, double time) const override {
		if(obj.hasCargo && obj.cargoStored > 0 && obj.hasMaster())
			obj.transferAllCargoTo(obj.getMaster());
	}
#section all
};

class MoveImportsToMaster : OrbitalEffect {
	Document doc("Redirect all imports to this orbital to its master.");

#section server
	void onTick(Orbital& obj, any@ data, double time) const override {
		if(obj.hasMaster()) {
			Object@ master = obj.getMaster();
			obj.redirectAllImports(master);
		}
	}
#section all
};