import settings.map_lib;
import hooks;
import biomes;
import buildings;
import resources;
import planet_types;
import camps;
import anomalies;
import pickups;
import block_effects;
import artifacts;
import statuses;
from map_systems import IMapHook, MapHook;
import generic_hooks;
from resources import RARITY_DISTRIBUTION;
import cargo;
import ship_groups;

#section server
import systems;
import object_creation;
import remnant_designs;
from objects.Asteroid import createAsteroid;
from objects.Anomaly import createAnomaly;
from objects.Artifact import createArtifact;
from objects.Oddity import createNebula;
from empire import Creeps;
#section all

//MakeStar(<Temperature>, <Radius> = 100, <Position> = (0, 0, 0), Suffix = "")
// Generate a star with the specified temperature, radius and position.
class MakeStar : MapHook {
	double AVG_STAR_HEALTH = 20000000000;

	Document doc("Creates a star in the system.");
	Argument tempK("Temperature", AT_Range, doc="Star temperature in Kelvin.");
	Argument rad("Radius", AT_Range, "100.0", doc="Raidus of the star");
	Argument position("Position", AT_Position, "(0, 0, 0)", doc="Position relative to the center of the system to create the star.");
	Argument suffix("Suffix", AT_Locale, "", doc="Suffix to append to the star name.");
	Argument normalDist("NormalTempRange", AT_Boolean, "False", doc="Whether to use a normal or flat distribution for the star temperature.");
	Argument moves(AT_Boolean, "False", doc="Whether the star can move and the light should track it.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		double temp = 0.0;
		if(arguments[0].isRange && arguments[4].boolean)
			temp = normald(arguments[0].decimal,arguments[1].decimal2);
		else
			temp = arguments[0].fromRange();
		double radius = arguments[1].fromRange();
		vec3d pos = arguments[2].fromPosition();

		//Create star
		ObjectDesc starDesc;
		starDesc.type = OT_Star;
		starDesc.flags |= objNoDamage;
		if(system !is null) {
			starDesc.name = format(locale::SYSTEM_STAR, system.name);
			if(arguments[3].str.length > 0)
				starDesc.name += " "+arguments[3].str;
			starDesc.position = system.position + pos;
		}
		else {
			starDesc.name = locale::SYSTEM_STAR;
		}
		starDesc.radius = radius;
		starDesc.delayedCreation = true;

		Star@ star = cast<Star>(makeObject(starDesc));

		if(system !is null)
			@star.region = system.object;
		star.temperature = temp;
		star.finalizeCreation();
		if(system !is null)
			system.object.enterRegion(star);
		
		//Create star node
		Node@ node = bindNode(star, "StarNode");
		node.color = blackBody(temp, max((temp + 15000.0) / 40000.0, 1.0));
		if(system !is null)
			node.hintParentObject(system.object, false);

		double hp = AVG_STAR_HEALTH * (radius / 75.0);
		star.Health = hp;
		star.MaxHealth = hp;

		//Create light
		LightDesc lightDesc;
		lightDesc.att_quadratic = 1.f/(2000.f*2000.f);
		lightDesc.position = vec3f(star.position);
		lightDesc.diffuse = node.color * 1.0f;
		lightDesc.specular = lightDesc.diffuse;
		lightDesc.radius = star.radius;

		if(moves.boolean)
			makeLight(lightDesc, node);
		else
			makeLight(lightDesc);

		if(data !is null)
			@data.star = star;
		@current = star;
	}
#section all
};

//MakeBlackhole(<Radius> = 20, <Position> = (0, 0, 0))
// Generate a star with the specified temperature, radius and position.
class MakeBlackhole : MapHook {
	double BLACKHOLE_HEALTH = 200000000000;

	Document doc("Creates a black hole in the system.");
	Argument rad("Radius", AT_Range, "100.0", doc="Radius of the event horizon.");
	Argument position("Position", AT_Position, "(0, 0, 0)", doc="Position relative to the center of the system to create the black hole.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		double radius = arguments[0].fromRange();
		vec3d pos = arguments[1].fromPosition();

		//Create star
		ObjectDesc starDesc;
		starDesc.type = OT_Star;
		starDesc.flags |= objNoDamage;
		starDesc.name = format(locale::SYSTEM_BLACKHOLE, system.name);
		starDesc.position = system.position + pos;
		starDesc.radius = radius;
		starDesc.delayedCreation = true;

		Star@ star = cast<Star>(makeObject(starDesc));
		star.alwaysVisible = true;

		@star.region = system.object;
		star.temperature = 0.0;
		star.finalizeCreation();
		system.object.enterRegion(star);

		star.Health = BLACKHOLE_HEALTH;
		star.MaxHealth = BLACKHOLE_HEALTH;
		
		//Create star node
		Node@ node = bindNode(star, "BlackholeNode");
		node.color = blackBody(16000.0, max((16000.0 + 15000.0) / 40000.0, 1.0));
		node.hintParentObject(system.object, false);
		cast<BlackholeNode>(node).establish(star);

		//Create light
		LightDesc lightDesc;
		lightDesc.att_quadratic = 1.f/(2000.f*2000.f);
		lightDesc.position = vec3f(star.position);
		lightDesc.diffuse = node.color * 1.0f;
		lightDesc.diffuse.a = 0.f;
		lightDesc.specular = lightDesc.diffuse;
		lightDesc.radius = star.radius;
		makeLight(lightDesc);

		if(data !is null)
			@data.star = star;
		@current = star;
	}
#section all
};

int parseRarity(const string& v) {
	if(v.equals_nocase("common")) {
		return RR_Common;
	}
	else if(v.equals_nocase("uncommon")) {
		return RR_Uncommon;
	}
	else if(v.equals_nocase("rare")) {
		return RR_Rare;
	}
	else if(v.equals_nocase("epic")) {
		return RR_Epic;
	}
	else {
		error(" Error: Invalid rarity spec "+escape(v));
		return -1;
	}
}

bool parseResourceSpec(array<const ResourceType@>@ resPossib, const string& v) {
	if(v.findFirst(":") == -1) {
		if(v == "null")
			return true;
		const ResourceType@ type = getResource(v);
		if(type is null) {
			error(" Error: Invalid resource "+escape(v));
			return false;
		}
		resPossib.insertLast(type);
		return true;
	}
	else {
		array<string>@ args = v.split(":");
		if(args.length > 3) {
			error(" Error: Invalid resource spec "+escape(v));
			return false;
		}

		int rarity = INT_MAX;
		if(args[0].equals_nocase("randomtype")) {
			if(args.length == 3)
				rarity = parseRarity(args[2]);
			const ResourceClass@ cls = getResourceClass(args[1]);
			if(cls is null) {
				error(" Error: Invalid resource type "+escape(v));
				return false;
			}

			for(uint i = 0, cnt = cls.types.length; i < cnt; ++i) {
				if(rarity != INT_MAX && cls.types[i].rarity != rarity)
					continue;
				if(cls.types[i].artificial || cls.types[i].distribution <= 0)
					continue;
				if(cls.types[i].unique)
					continue;
				resPossib.insertLast(cls.types[i]);
			}
			return true;
		}
		else if(args[0].equals_nocase("randomlevel")) {
			uint lv = toInt(args[1]);
			if(args.length == 3)
				rarity = parseRarity(args[2]);
			for(uint i = 0, cnt = getResourceCount(); i < cnt; ++i) {
				auto@ res = getResource(i);
				if(res.level != lv)
					continue;
				if(rarity != INT_MAX && res.rarity != rarity)
					continue;
				if(res.artificial || res.unique)
					continue;
				if(res.limitlessLevel)
					continue;
				if(res.frequency <= 0 || res.distribution <= 0)
					continue;
				resPossib.insertLast(res);
			}
			return true;
		}
		else if(args[0].equals_nocase("randomrarity")) {
			if(args.length == 2)
				rarity = parseRarity(args[1]);
			for(uint i = 0, cnt = getResourceCount(); i < cnt; ++i) {
				auto@ res = getResource(i);
				if(rarity != INT_MAX && res.rarity != rarity)
					continue;
				if(res.artificial || res.unique)
					continue;
				if(res.frequency <= 0 || res.distribution <= 0)
					continue;
				resPossib.insertLast(res);
			}
			return true;
		}
		else if(args[0].equals_nocase("levelgte")) {
			uint lv = toInt(args[1]);
			if(args.length == 3)
				rarity = parseRarity(args[2]);
			for(uint i = 0, cnt = getResourceCount(); i < cnt; ++i) {
				auto@ res = getResource(i);
				if(res.level < lv)
					continue;
				if(rarity != INT_MAX && res.rarity != rarity)
					continue;
				if(res.artificial || res.unique)
					continue;
				if(res.limitlessLevel)
					continue;
				if(res.frequency <= 0 || res.distribution <= 0)
					continue;
				resPossib.insertLast(res);
			}
			return true;
		}
		else {
			for(uint i = 0, cnt = args.length; i < cnt; ++i) {
				auto@ res = getResource(args[i]);
				if(res is null) {
					error(" Error: Invalid resource spec "+escape(v));
					return false;
				}
				resPossib.insertLast(res);
			}
			return true;
		}
	}
}

//MakePlanet(<Resource> = Destributed, <Radius> = 6:14, <Orbit Spacing> = 125:275,
//           <Grid Size> = (-1, -1))
// Create a new planet with <Resource> and size <Radius>. Spaced in the orbit from
// the last planet by <Orbit Spacing>.
class MakePlanet : MapHook {
	int AVG_PLANET_GRID_WIDTH = 15;
	int AVG_PLANET_GRID_HEIGHT = 9;
	double AVG_PLANET_HEALTH = 1500000000;
	array<const ResourceType@> resPossib;
	bool distribute = false;

	Document doc("Create a new planet in the system.");
	Argument resource(AT_Custom, "distributed", doc="The primary resource on the planet. 'distributed' to randomize.");
	Argument radius(AT_Range, "6:14", doc="Size of the planet, can be a random range.");
	Argument orbit_spacing(AT_Range, "125:275", doc="Distance from the previous planet.");
	Argument grid_size(AT_Position2D, "(-1, -1)", doc="Size of the planet's surface grid. (-1,-1) to randomize based on radius.");
	Argument conditions(AT_Boolean, "True", doc="Whether to let the planet randomly generate a condition.");
	Argument distribute_resource(AT_Boolean, "False", doc="Whether or not the selected resources should be frequency distributed.");
	Argument moons(AT_Boolean, "True", doc="Whether this planet should have a randomized amount of moons generated on it to start with.");
	Argument rings(AT_Boolean, "True", doc="Whether the planet can have rings generated around it.");
	Argument physics(AT_Boolean, "True", doc="Whether the planet should be a physical object.");

	bool instantiate() override {
		if(arguments[0].str.equals_nocase("distributed"))
			distribute = true;
		else if(!parseResourceSpec(resPossib, arguments[0].str))
			return false;
		return MapHook::instantiate();
	}

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		const ResourceType@ resource;
		if(resPossib.length > 0) {
			if(resPossib.length == 1)
				@resource = resPossib[0];
			else if(distribute_resource.boolean) {
				double roll = randomd();
				double freq = 0.0;
				for(uint i = 0, cnt = resPossib.length; i < cnt; ++i) {
					freq += resPossib[i].frequency;
					double chance = resPossib[i].frequency / freq;
					if(roll < chance) {
						@resource = resPossib[i];
						roll /= chance;
					}
					else {
						roll = (roll - chance) / (1.0 - chance);
					}
				}
			}
			else
				@resource = resPossib[randomi(0, resPossib.length-1)];
		}
		if(data is null && distribute)
			@resource = getDistributedResource();
		if(resource !is null)
			markResourceUsed(resource);

		double radius = arguments[1].decimal;
		if(arguments[1].isRange)
			radius = normald(arguments[1].decimal, arguments[1].decimal2);
		double spacing = arguments[2].fromRange() * config::SYSTEM_SIZE;

		system.radius += spacing;

		double pos = system.radius;
		if(spacing == 0)
			pos = randomd(200, system.radius);

		double angle = randomd(0,twopi);
		vec3d offset(cos(angle) * pos, 0, sin(angle) * -pos);
		
		ObjectDesc planetDesc;
		planetDesc.flags |= objNoDamage;
		planetDesc.flags |= objMemorable;
		planetDesc.type = OT_Planet;
		planetDesc.delayedCreation = true;
		@planetDesc.owner = null;
		planetDesc.radius = radius;
		planetDesc.position = system.position + offset;

		if(!physics.boolean) {
			planetDesc.flags |= objNoPhysics;
			planetDesc.flags |= objNoCollide;
		}

		planetDesc.name = system.name + " ";
		if(data !is null)
			appendRoman(data.planets.length + 1, planetDesc.name);
		else
			appendRoman(system.object.planetCount + 1, planetDesc.name);
		
		Planet@ planet = cast<Planet>(makeObject(planetDesc));
		@planet.region = system.object;

		if(data !is null)
			data.planets.insertLast(planet);
		
		//Generate biomes
		const Biome@ biome1;
		if(resource is null) {
			@biome1 = getDistributedBiome();
		}
		else {
			@biome1 = getBiome(resource.nativeBiome);
			if(biome1 is null)
				@biome1 = getDistributedBiome();
		}
		const Biome@ biome2 = getDistributedBiome();
		const Biome@ biome3 = getDistributedBiome();
		
		//Figure out planet size
		double sizeFact = clamp(radius / 10.0, 0.1, 5.0);
		int gridW = round(AVG_PLANET_GRID_WIDTH * sizeFact);
		int gridH = round(AVG_PLANET_GRID_HEIGHT * sizeFact);

		vec2d givenGrid = arguments[3].fromPosition2D();
		if(givenGrid.x > 0)
			gridW = ceil(givenGrid.x);
		if(givenGrid.y > 0)
			gridH = ceil(givenGrid.y);

		//Figure out planet type
		const PlanetType@ planetType = getBestPlanetType(biome1, biome2, biome3);
		planet.PlanetType = planetType.id;
		planet.OrbitSize = 100 + radius;
		
		//Setup orbit
		planet.orbitAround(system.position, offset.length);
		planet.orbitSpin(randomd(35.0, 90.0));
		
		//Create the planet surface;
		uint resId = uint(-1);
		if(resource !is null)
			resId = resource.id;
		planet.initSurface(gridW, gridH, biome1.id, biome2.id, biome3.id, resId);
			
		//Make node		
		PlanetNode@ plNode = cast<PlanetNode>(bindNode(planet, "PlanetNode"));
		plNode.establish(planet);
		plNode.planetType = planet.PlanetType;
		if(rings.boolean && randomi(0,9) == 0) {
			uint style = randomi();
			plNode.addRing(style);
			planet.setRing(style);
		}

		if(resource !is null)
			resource.applyGraphics(planet, plNode);
		else if(distribute && data !is null)
			data.distributedResources.insertLast(planet);

		double health = AVG_PLANET_HEALTH * sizeFact;
		planet.Health = health;
		planet.MaxHealth = health;
		
		planet.finalizeCreation();

		//Setup condition
		if(conditions.boolean && data !is null) {
			if(randomd() < config::PLANET_CONDITION_CHANCE)
				data.distributedConditions.insertLast(planet);
		}

		//Setup moons
		if(moons.boolean) {
			while(randomd() < config::PLANET_MOON_CHANCE) {
				planet.addMoon();
				planet.addStatus(getStatusID("Moon"));
			}
		}

		//Place in region
		system.object.enterRegion(planet);
		plNode.hintParentObject(system.object, false);

		@current = planet;
	}
#section all
};

#section server
Planet@ spawnPlanetSpec(const vec3d& point, const string& resourceSpec, bool distributeResource = true, double radius = 0.0, bool physics = true) {
	MakePlanet plHook;
	plHook.initClass();
	plHook.resource.str = resourceSpec;
	plHook.distribute_resource.boolean = distributeResource;
	plHook.moons.boolean = false;
	plHook.rings.boolean = false;
	plHook.conditions.boolean = false;
	plHook.physics.boolean = physics;
	if(radius != 0)
		plHook.radius.set(radius);
	plHook.instantiate();

	Object@ current;

	auto@ reg = getRegion(point);
	auto@ sys = getSystem(reg);
	plHook.trigger(null, sys, current);

	auto@ planet = cast<Planet>(current);
	planet.orbitAround(point, sys.position);
	return planet;
}
#section all

class MakeMoon : MapHook {
	Document doc("Add a moon to the previously generated planet.");
	Argument size(AT_Decimal, "0", doc="Radius size of the moon.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ obj = current;
		if(obj.isPlanet) {
			cast<Planet>(obj).addMoon(size.decimal);
			obj.addStatus(getStatusID("Moon"));
		}
	}
#section all
};

class BonusHealth : MapHook {
	Document doc("Add bonus health to the star or planet.");
	Argument amount(AT_Decimal, doc="Amount of bonus health to add.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ obj = current;
		if(obj.isPlanet) {
			Planet@ pl = cast<Planet>(obj);
			pl.Health += amount.decimal;
			pl.MaxHealth += amount.decimal;
		}
		else if(obj.isStar) {
			Star@ star = cast<Star>(obj);
			star.Health += amount.decimal;
			star.MaxHealth += amount.decimal;
		}
	}
#section all
};

class MakeNebula : MapHook {
	Document doc("Turn the system into a nebula.");
	Argument color(AT_Color, "#f0c870", doc="Color of the nebula.");

	array<Color> colorPossibs;

	bool instantiate() override {
		auto@ txt = color.str.split(":");
		for(uint i = 0, cnt = txt.length; i < cnt; ++i)
			colorPossibs.insertLast(toColor(txt[i]));
		return MapHook::instantiate();
	}

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Color col = colorPossibs[randomi(0, colorPossibs.length-1)];
		createNebula(system.position, system.radius, color=col.rgba, region=system.object);
	}
#section all
};

//ExpandSystem(<Radius> = 1000)
// Expand the current system's size by <Radius>.
class ExpandSystem : MapHook {
	Document doc("Expands the system boundary.");
	Argument radius("Radius", AT_Range, "1000", doc="Amount to add to the current system radius.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		system.radius += arguments[0].fromRange();;
	}
#section all
};

//SetupOrbit(<Radius> = 100, <Position> = (0, 0, 0), Orbit Pct = -1.0)
// Setup an orbit on the previous object.
class SetupOrbit : MapHook {
	Document doc("Gives the previously created object an orbit.");
	Argument radius("Radius", AT_Range, "100.0", doc="Radius at which the object should orbit.");
	Argument position("Position", AT_Position, "(0, 0, 0)", doc="Position relative to the system to orbit around.");
	Argument pct("Orbit Pct", AT_Range, "-1.0", doc="Percent through the year to start the orbit (0-1).");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ cur = current;
		if(cur is null || !cur.hasOrbit)
			return;

		double radius = arguments[0].fromRange();
		vec3d pos = arguments[1].fromPosition() + system.position;
		double pct = arguments[2].fromRange();
		vec2d off = random2d();
		cur.position = pos + vec3d(off.x, 0, off.y);
		cur.orbitAround(pos, radius);
		if(pct >= 0)
			cur.setOrbitPct(pct);
	}
#section all
};

class AddRegionStatus : MapHook {
	Document doc("Add a status that is given to all objects in the system it can apply to.");
	Argument status(AT_Status, doc="Type of status to add to objects in the system.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		system.object.addRegionStatus(null, status.integer);
	}
#section all
};

class NoRegionVision : MapHook {
	Document doc("Indicate that this system does not have automatic shared region vision.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		system.donateVision = false;
	}
#section all
};

//AddPlanetResource(<Resource> = Distributed)
// Add another resource to the previously generated object.
class AddPlanetResource : MapHook {
	Document doc("Adds a single resource to the most recently created planet.");
	Argument resID("Resource", AT_Custom, "distributed", doc="Type or types of resource to choose from.");
	array<const ResourceType@> resPossib;
	bool distribute = false;

	bool instantiate() {
		if(arguments[0].str.equals_nocase("distributed"))
			distribute = true;
		else if(!parseResourceSpec(resPossib, arguments[0].str))
			return false;
		return MapHook::instantiate();
	}

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ cur = current;
		if(cur is null || !cur.hasResources)
			return;

		const ResourceType@ resource;
		if(resPossib.length > 0) {
			if(resPossib.length == 1)
				@resource = resPossib[0];
			else
				@resource = resPossib[randomi(0, resPossib.length-1)];
		}
		if(data is null && distribute)
			@resource = getDistributedResource();
		if(cur.isAsteroid) {
			return;
		}
		else {
			if(resource !is null) {
				markResourceUsed(resource);
				cur.addResource(resource.id);
			}
			else if(distribute && data !is null)
				data.distributedResources.insertLast(cur);
		}
	}
#section all
};

//AddResource(<Tile Resource>, <Amount>)
// Add an income to the previously generated object.
class AddResource : MapHook {
	Document doc("Adds a basic resource income to the most recently created planet.");
	Argument tileRes("Tile Resource", AT_TileResource, doc="Type of basic resource to produce.");
	Argument rate("Rate", AT_Integer, "1", doc="Amount of generation to add.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ cur = current;
		if(cur is null || !cur.hasSurfaceComponent)
			return;
		cur.modResource(arguments[0].integer, +arguments[1].integer);
	}
#section all
};

//NoNeedPopulationForLevel()
// Set the current planet to not need population to level up.
class NoNeedPopulationForLevel : MapHook {
#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ cur = current;
		if(cur is null || !cur.hasSurfaceComponent)
			return;
		cur.setNeedsPopulationForLevel(false);
	}
#section all
};

//Rename(<Name>)
// Rename the object.
class Rename : MapHook {
	Document doc("Renames the most recently created object.");
	Argument name("Name", AT_Locale, doc="Name for the object.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ cur = current;
		if(cur is null)
			return;
		cur.name = arguments[0].str;
	}
#section all
};

//NameSystem(<Name>)
// Rename the system.
class NameSystem : MapHook {
	Document doc("Renames the system.");
	Argument name("Name", AT_Locale, doc="Name for the system.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		system.object.name = arguments[0].str;
		system.name = arguments[0].str;
	}
#section all
};

//AddQuality(<Amount> = 100)
// Add extra quality to the system. Affects various distributions.
class AddQuality : MapHook {
	Document doc("Adds quality to the system. Quality decides quantity and value of resources, anomalies, etc.");
	Argument amt("Amount", AT_Range, doc="Quality to add. 100 is a typical improvement.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		if(data !is null)
			data.quality += arguments[0].fromRange();
	}
#section all
};

//AddPopulation(<Amount>)
// Add <Amount> population to the previous planet.
class AddPopulation : MapHook {
	Document doc("Adds population to the most recently created planet.");
	Argument amt("Amount", AT_Range, doc="Population to add.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ cur = current;
		if(cur is null || !cur.hasSurfaceComponent)
			return;
		cur.addPopulation(arguments[0].fromRange());
	}
#section all
};

//SpawnBuilding(<Type>, <Position>)
// Spawn a <Type> building on the previous planet at <Position>.
class SpawnBuilding : MapHook {
	Document doc("Places a building on the most recently created planet.");
	Argument type("Type", AT_Custom, doc="Building ID to place.");
	Argument pos("Position", AT_Position2D, doc="Where to place the center of the building on the planet.");
	Argument develop(AT_Boolean, "False", doc="Whether to mark all tiles its on as developed.");
	const BuildingType@ bldType;

	bool instantiate() {
		@bldType = getBuildingType(arguments[0].str);
		if(bldType is null) {
			error(" Error: Could not find building type: '"+escape(arguments[0].str)+"'");
			return false;
		}
		return MapHook::instantiate();
	}

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ cur = current;
		if(cur is null || !cur.hasSurfaceComponent)
			return;
		cur.spawnBuilding(bldType.id, vec2i(arguments[1].fromPosition2D()), develop.boolean);
	}
#section all
};

class ForceUsefulSurface : MapHook {
	Document doc("Force the planet to have a percentage of useful region on its surface.");
	Argument percent(AT_Decimal, doc="Percent of the surface that needs to be useful.");
	Argument biome(AT_PlanetBiome, doc="Biome to fill the planet with to ensure surface.");

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ cur = current;
		if(cur is null || !cur.hasSurfaceComponent)
			return;
		auto@ type = getBiome(biome.str);
		if(type !is null)
			cur.forceUsefulSurface(percent.decimal, type.id);
		else
			print("No such biome: "+biome.str);
	}
#section all
};

//MakeAsteroid(<Resource> = Distributed, <Distribution Chance> = 0.4)
// Create a new asteroid with the given resource available.
// If <Resource> is set to Distributed, distribute some random resources
// with <Distribution Chance>.
class MakeAsteroid : MapHook {
	Document doc("Creates an asteroid in the system.");
	Argument cargo(AT_Cargo, EMPTY_DEFAULT, doc="Type of cargo to create on the asteroid.");
	Argument cargo_amount(AT_Range, "500:10000", doc="Amount of cargo for the asteroid to have.");
	Argument resource(AT_Custom, EMPTY_DEFAULT, doc="Resource to put on the asteroid.");
	Argument distribution_chance(AT_Decimal, "0.4", doc="For distributed resources, chance to add additional resource. Repeats until failure.");

#section server
	array<const ResourceType@> resPossib;
	bool distribute = false;
	bool noResource = false;

	bool instantiate() {
		if(resource.str.length != 0) {
			if(resource.str.equals_nocase("distributed"))
				distribute = true;
			else if(resource.str.equals_nocase("none"))
				noResource = true;
			else if(!parseResourceSpec(resPossib, resource.str))
				return false;
		}
		return MapHook::instantiate();
	}

	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		vec2d rpos;
		if(data !is null)
			rpos = random2d(150.0, system.radius * 1.5 - 250.0);
		else
			rpos = random2d(150.0, system.radius * 0.8);
		vec3d pos = system.position + vec3d(rpos.x, randomd(-50.0, 50.0), rpos.y);
		Asteroid@ roid = createAsteroid(pos, system.object, delay=true);
		roid.orbitAround(system.position);
		roid.orbitSpin(randomd(20.0, 60.0));
		@current = roid;

		if(noResource) {
			roid.initMesh();
			return;
		}

		double totChance = config::ASTEROID_OCCURANCE + config::RESOURCE_ASTEROID_OCCURANCE;
		double resChance = config::RESOURCE_ASTEROID_OCCURANCE;
		double roll = randomd(0, totChance);

		int cargoType = cargo.integer;
		if(cargoType == -1) {
			auto@ ore = getCargoType("Ore");
			if(ore !is null)
				cargoType = ore.id;
		}

		bool cargoSpec = cargo.integer != -1 && config::ASTEROID_OCCURANCE != 0;
		bool resSpec = (resPossib.length != 0 || distribute) && config::RESOURCE_ASTEROID_OCCURANCE != 0;

		if((cargoSpec && !resSpec) || ((cargoSpec == resSpec) && roll >= resChance)) {
			roid.addCargo(cargoType, cargo_amount.fromRange());
		}
		else {
			if(distribute || resPossib.length == 0) {
				do {
					const ResourceType@ type = getDistributedAsteroidResource();
					if(roid.getAvailableCostFor(type.id) < 0.0)
						roid.addAvailable(type.id, type.asteroidCost);
				}
				while(randomd() < distribution_chance.decimal);
			}
			else {
				const ResourceType@ resource;
				if(resPossib.length > 0) {
					if(resPossib.length == 1)
						@resource = resPossib[0];
					else
						@resource = resPossib[randomi(0, resPossib.length-1)];
				}
			
				if(resource !is null) {
					if(roid.getAvailableCostFor(resource.id) < 0.0)
						roid.addAvailable(resource.id, resource.asteroidCost);
				}
			}
		}

		roid.initMesh();
	}
#section all
};

class MakeAsteroidBelt : MapHook {
	Document doc("Creates an asteroid belt in the system.");
	Argument count("Count", AT_Integer, "8", doc="Number of asteroids in the belt.");
	Argument cargo(AT_Cargo, "Ore", doc="Type of cargo to create on the asteroid belt.");
	Argument cargo_amount(AT_Range, "500:10000", doc="Amount of cargo for the asteroids to have.");
	Argument distribution_chance(AT_Decimal, "0.4", doc="For distributed resources, chance to add additional resource. Repeats until failure.");

	bool instantiate() {
		if(arguments[0].integer <= 0)
			return false;
		return MapHook::instantiate();
	}

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		if(config::ASTEROID_OCCURANCE == 0 && config::RESOURCE_ASTEROID_OCCURANCE == 0)
			return;
		double radius = randomd(0.5,1.5) * system.radius;
		double angle = randomd(0, twopi);
		double totChance = config::ASTEROID_OCCURANCE + config::RESOURCE_ASTEROID_OCCURANCE;
		double resChance = config::RESOURCE_ASTEROID_OCCURANCE;
		
		for(uint i = 0, cnt = arguments[0].integer; i < cnt; ++i) {
			angle += twopi / double(cnt);
			double ang = angle + randomd(-0.25,0.25) * twopi / double(cnt);
		
			vec3d pos = system.position + vec3d(cos(ang) * radius, randomd(-50.0, 50.0), sin(ang) * radius);
			
			Asteroid@ roid = createAsteroid(pos, system.object, delay=true);
			roid.orbitAround(system.position);
			roid.orbitSpin(randomd(20.0, 60.0));
			@current = roid;

			if(randomd(0, totChance) >= resChance && cargo.integer != -1) {
				roid.addCargo(cargo.integer, cargo_amount.fromRange());
			}
			else {
				do {
					const ResourceType@ type = getDistributedAsteroidResource();
					if(roid.getAvailableCostFor(type.id) < 0.0)
						roid.addAvailable(type.id, type.asteroidCost);
				}
				while(randomd() < distribution_chance.decimal);
			}

			roid.initMesh();
		}
	}
#section all
};

//MakeAnomaly(<Type> = Distributed)
// Generate a anomaly field in this system of type <Type>.
class MakeAnomaly : MapHook {
	Document doc("Creates an anomaly in the system.");
	Argument anomType("Type", AT_Custom, "distributed", doc="Type of anomaly to create.");
	const AnomalyType@ type;

	bool instantiate() {
		if(!arguments[0].str.equals_nocase("distributed")) {
			@type = getAnomalyType(arguments[0].str);
			if(type is null) {
				error(" Error: Could not find anomaly type: "+arguments[0].str);
				return false;
			}
		}
		return MapHook::instantiate();
	}

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		const AnomalyType@ gen = type;
		if(gen is null)
			@gen = getDistributedAnomalyType();

		vec2d rpos = random2d(150.0, system.radius - 250.0);
		vec3d pos = system.position + vec3d(rpos.x, randomd(-50.0, 50.0), rpos.y);
		Anomaly@ anomaly = createAnomaly(pos, gen.id);
		@current = anomaly;
	}
#section all
};

class SpawnRandomRemnants : MapHook {
	Document doc("Spawn a remnant fleet with a random design at a particular size.");
	Argument size(AT_Integer, doc="Base size of the remnant flagship.");
	Argument occupation(AT_Range, "0.8", doc="Percentage of support that is filled.");
	Argument gametime_size(AT_Range, "0", doc="If spawned after game start, increase the flagship size by this much per minute of game time.");
	Argument offset(AT_Decimal, "0", doc="Minimum offset from the edge of the system to the fleet.");

#section server
	void postTrigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		int sz = size.integer;
		sz += round(gametime_size.fromRange() * gameTime / 60.0);

		vec2d campPos = random2d(200.0, (system.radius - offset.decimal) * 0.95);
		vec3d pos = system.position + vec3d(campPos.x, 0, campPos.y);

		spawnRemnantFleet(pos, sz, occupation.fromRange());
	}
#section all
}

//MakeCreepCamp(<Type> = Distributed)
// Generate a creep camp in this system of type <Type>.
class MakeCreepCamp : MapHook {
	Document doc("Creates a creep camp in the system.");
	Argument campID("Type", AT_Custom, "distributed", doc="Type of camp to create.");
	Argument offset(AT_Decimal, "0", doc="Minimum offset from the edge of the system to the camp.");
	const CampType@ campType;

	MakeCreepCamp() {
		argument("Type", AT_Custom, "distributed");
	}

	bool instantiate() {
		if(!arguments[0].str.equals_nocase("distributed")) {
			@campType = getCreepCamp(arguments[0].str);
			if(campType is null) {
				error(" Error: Could not find creep camp type: '"+escape(arguments[0].str)+"'");
				return false;
			}
		}
		return MapHook::instantiate();
	}

#section server
	void postTrigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		if(config::REMNANT_OCCURANCE == 0.0)
			return;

		const CampType@ type = campType;
		if(type is null)
			@type = getDistributedCreepCamp();

		vec2d campPos = random2d(200.0, (system.radius - offset.decimal) * 0.95);
		vec3d pos = system.position + vec3d(campPos.x, 0, campPos.y);

		makeCreepCamp(pos, type, system.object);
	}
#section all
};

#section server
void makeCreepCamp(const vec3d& pos, const CampType@ type, Region@ region = null) {
	//Create pickup
	Pickup@ pickup;
	double roll = randomd(0.0, type.pickupFrequency);
	for(uint i = 0, cnt = type.pickups.length; i < cnt; ++i) {
		const PickupType@ ptype = type.pickups[i];
		if(roll <= ptype.frequency) {
			double minRad = 20.0 + ptype.physicalSize * 2.0;
			double maxRad = 40.0 + ptype.physicalSize * 4.0;
			vec2d off = random2d(minRad, maxRad);

			@pickup = createPickup(pos + vec3d(off.x, randomd(5.0, 10.0), off.y), ptype.id, defaultEmpire);
			pickup.finalizeCreation();
			pickup.setCampType(type.id);

			if(region !is null) {
				@pickup.region = region;
				region.enterRegion(pickup);
			}
			break;
		}
		else {
			roll -= ptype.frequency;
		}
	}

	//Add statuses to region
	if(region !is null) {
		for(uint i = 0, cnt = type.region_statuses.length; i < cnt; ++i)
			region.addRegionStatus(null, type.region_statuses[i].id);
	}

	//Create defenders
	Object@ lastLeader;
	for(uint i = 0, cnt = type.ships.length; i < cnt; ++i) {
		const Design@ dsg = type.ships[i];
		uint minCnt = type.shipMins[i];
		uint maxCnt = type.shipMaxes[i];
		int amt = randomi(minCnt, maxCnt);

		if(!dsg.hull.hasTag(ST_IsSupport)) {
			for(; amt > 0; --amt) {
				vec3d leaderPos = pos;
				if(lastLeader !is null)
					leaderPos += random3d(10.0, 40.0);

				@lastLeader = createShip(leaderPos, dsg, Creeps, free=true, memorable=true);
				lastLeader.setAutoMode(config::REMNANT_AGGRESSION == 0 ? AM_HoldPosition : AM_RegionBound);
				lastLeader.sightRange = 0;
				lastLeader.setRotation(quaterniond_fromAxisAngle(vec3d_up(), randomd(-pi, pi)));

				for(uint i = 0, cnt = type.statuses.length; i < cnt; ++i)
					lastLeader.addStatus(type.statuses[i].id);

				if(type.shipNames[i].length != 0) {
					lastLeader.name = type.shipNames[i];
					lastLeader.named = true;
				}

				pickup.addPickupProtector(lastLeader);
			}
		}
		else {
			for(; amt > 0; --amt)
				createShip(lastLeader.position, dsg, Creeps, lastLeader, free=true);
		}
	}

	//Create randomized defenders
	if(type.flagshipSize > 0) {
		vec3d leaderPos = pos;
		if(lastLeader !is null)
			leaderPos += random3d(10.0, 40.0);
		@lastLeader = spawnRemnantFleet(leaderPos, type.flagshipSize, type.supportOccupation);
		lastLeader.setAutoMode(config::REMNANT_AGGRESSION == 0 ? AM_HoldPosition : AM_RegionBound);

		for(uint i = 0, cnt = type.statuses.length; i < cnt; ++i)
			lastLeader.addStatus(type.statuses[i].id);
		pickup.addPickupProtector(lastLeader);
	}
	if(type.targetStrength > 0) {
		vec3d leaderPos = pos;
		if(lastLeader !is null)
			leaderPos += random3d(10.0, 40.0);
		@lastLeader = spawnRemnantFleet(leaderPos, composeRemnantFleet(type.targetStrength));
		lastLeader.setAutoMode(config::REMNANT_AGGRESSION == 0 ? AM_HoldPosition : AM_RegionBound);

		for(uint i = 0, cnt = type.statuses.length; i < cnt; ++i)
			lastLeader.addStatus(type.statuses[i].id);
		pickup.addPickupProtector(lastLeader);
	}
}
#section all

class SetStaticSeeableRange : MapHook {
	Document doc("Set the seeable range of static objects (anomalies, asteroids, etc) in this system.");
	Argument range(AT_Decimal, doc="Seeable range to set.");

#section server
	void postTrigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		for(uint i = 0, cnt = system.object.objectCount; i < cnt; ++i) {
			Object@ obj = system.object.objects[i];
			if(obj.hasStatuses)
				continue;
			obj.seeableRange = range.decimal;
		}
	}
#section all
};

//MakeAdjacentCreepCamp(<Type> = Distributed, <Place Far> = False)
// Generate a creep camp in an adjacent system of type <Type>.
class MakeAdjacentCreepCamp : MapHook {
	Document doc("Creates a creep camp in an adjacent system.");
	Argument campID("Type", AT_Custom, "distributed", doc="Type of camp to create.");
	Argument placeFar("Place Far", AT_Boolean, "True", doc="Whether the camp should be pushed to the edge of the system.");
	const CampType@ campType;

	bool instantiate() {
		if(!arguments[0].str.equals_nocase("distributed")) {
			@campType = getCreepCamp(arguments[0].str);
			if(campType is null) {
				error(" Error: Could not find creep camp type: '"+escape(arguments[0].str)+"'");
				return false;
			}
		}
		return MapHook::instantiate();
	}

#section server
	void postTrigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		if(data !is null && data.ignoreAdjacencies)
			return;
		if(config::REMNANT_OCCURANCE == 0.0)
			return;
		const CampType@ type = campType;
		if(type is null)
			@type = getDistributedCreepCamp();

		if(system.adjacent.length == 0)
			return;
		int at = randomi(0, system.adjacent.length-1);
		SystemDesc@ other = getSystem(system.adjacent[at]);

		vec2d campPos = random2d(200.0, other.radius);
		if(arguments[1].boolean) {
			vec3d off = (other.position - system.position).normalized(other.radius * 0.8);
			campPos = vec2d(off.x, off.z);
		}

		vec3d pos = other.position + vec3d(campPos.x, 0, campPos.y);

		makeCreepCamp(pos, type);
	}
#section all
};

//MakeArtifact(<Type> = Distributed)
// Generate a anomaly field in this system of type <Type>.
class MakeArtifact : MapHook {
	Document doc("Creates an artifact in the system.");
	Argument artifactType("Type", AT_Custom, "distributed", doc="Type of artifact to create.");
	const ArtifactType@ type;

	bool instantiate() {
		if(!arguments[0].str.equals_nocase("distributed")) {
			@type = getArtifactType(arguments[0].str);
			if(type is null) {
				error(" Error: Could not find artifact type: "+arguments[0].str);
				return false;
			}
		}
		return MapHook::instantiate();
	}

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		if(data !is null)
			data.artifacts += 1;
		@current = makeArtifact(system, type is null ? getDistributedArtifactType(system.contestation).id : type.id);
	}
#section all
};

#section server
Artifact@ makeArtifact(SystemDesc@ system, uint type = uint(-1)) {
	const ArtifactType@ gen;
	if(type == uint(-1))
		@gen = getDistributedArtifactType();
	else
		@gen = getArtifactType(type);
	vec2d rpos = random2d(150.0, system.radius - 250.0);
	vec3d pos = system.position + vec3d(rpos.x, randomd(-50.0, 50.0), rpos.y);
	Artifact@ obj = createArtifact(pos, gen, system.object);
	obj.orbitAround(system.position);
	@obj.region = system.object;
	system.object.enterRegion(obj);
	return obj;
}
#section all

//RepeatHomeworlds()
// Repeats the block for every homeworld in this system, and sets
// the object to the appropriate empire's homeworld.
class RepeatHomeworlds : BlockEffect {
#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const {
		if(data.homeworlds is null)
			return;
		for(uint n = 0, ncnt = data.homeworlds.length; n < ncnt; ++n) {
			Empire@ emp = data.homeworlds[n];
			for(uint i = 0, cnt = inner.length; i < cnt; ++i) {
				auto@ cur = cast<IMapHook@>(inner[i]);
				if(cur !is null)
					cur.trigger(data, system, current);
			}

			Object@ cur = current;
			Planet@ pl = cast<Planet>(cur);
			if(pl !is null) {
				@pl.owner = emp;
				@emp.Homeworld = pl;
			}
		}
	}
#section all
};

//AddAdjacentAnomalies(<Amount>)
// Add <Amount> anomaly to random adjacent systems.
class AddAdjacentAnomalies : MapHook {
	Document doc("Creates anomalies in adjacent systems.");
	Argument count("Count", AT_Range, doc="Number to create.");
	MakeAnomaly maker;

#section server
	void postTrigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		if(system.adjacent.length == 0)
			return;
		if(data !is null && data.ignoreAdjacencies)
			return;
		if(config::ANOMALY_OCCURANCE == 0.0)
			return;

		uint cnt = arguments[0].fromRange();
		for(uint i = 0; i < cnt; ++i) {
			int at = randomi(0, system.adjacent.length-1);
			SystemDesc@ other = getSystem(system.adjacent[at]);
			maker.trigger(null, other, current);
		}
	}
#section all
};

//AddAdjacentArtifacts(<Amount>)
// Add <Amount> anomaly to random adjacent systems.
class AddAdjacentArtifacts : MapHook {
	Document doc("Creates artifacts in adjacent systems.");
	Argument count("Count", AT_Range, doc="Number to create.");
	MakeArtifact maker;

#section server
	void postTrigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		if(system.adjacent.length == 0)
			return;
		if(data !is null && data.ignoreAdjacencies)
			return;

		uint cnt = arguments[0].fromRange();
		for(uint i = 0; i < cnt; ++i) {
			int at = randomi(0, system.adjacent.length-1);
			SystemDesc@ other = getSystem(system.adjacent[at]);
			maker.trigger(null, other, current);
		}
	}
#section all
};

//GuaranteeAdjacentResource(<Resource>, <Distance> = 1)
// Guarantee an adjacent resource out of a type spec.
class GuaranteeAdjacentResource : MapHook {
	Document doc("Attempts to guarantee that specific reosurces will be available in adjacent systems. Logs on failure.");
	Argument res("Resource", AT_Custom, doc="Type(s) of resource to guarantee. Only one will be picked.");
	Argument count("Distance", AT_Integer, "1", doc="System hop distance within which to allow the resource.");
	array<const ResourceType@> resPossib;

	bool instantiate() {
		if(!parseResourceSpec(resPossib, arguments[0].str))
			return false;
		return MapHook::instantiate();
	}

#section server
	void add(array<Object@>& objects, array<SystemData@>& sources, SystemData@ data, int distance) {
		for(uint i = 0, cnt = data.adjacentData.length; i < cnt; ++i) {
			auto@ other = data.adjacentData[i];
			for(uint n = 0, ncnt = other.distributedResources.length; n < ncnt; ++n) {
				Planet@ pl = cast<Planet>(other.distributedResources[n]);
				if(pl !is null) {
					objects.insertLast(pl);
					sources.insertLast(other);
				}
			}
			if(distance > 1)
				add(objects, sources, other, distance-1);
		}
	}

	void postTrigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		if(data is null)
			return;
		if(data.ignoreAdjacencies)
			return;

		const ResourceType@ resource;
		if(resPossib.length > 0) {
			if(resPossib.length == 1)
				@resource = resPossib[0];
			else
				@resource = resPossib[randomi(0, resPossib.length-1)];
		}
		if(resource is null)
			return;

		array<Object@> objects;
		array<SystemData@> sources;
		add(objects, sources, data, arguments[1].integer);

		if(objects.length != 0) {
			uint i = randomi(0, objects.length-1);
			Object@ target = objects[i];
			sources[i].distributedResources.remove(target);

			target.addResource(resource.id);
		}
		else {
			warn("WARNING: Map guarantee '"+arguments[0].str+"' could not find planet around system '"+system.name+"'.");
		}
	}
#section all
};

class OnPlanet : MapHook {
	GenericEffect@ eff;
	Document doc("Run the passed hook as a single-time planet effect hook on the object. Because it only runs once, hooks with ticks or data storage will not work!");
	Argument hook(AT_Custom, doc="Hook to run.");

	bool instantiate() override {
		@eff = cast<GenericEffect>(parseHook(hook.str, "planet_effects::"));
		if(eff is null) {
			error("GenericEffect(): could not find inner hook: "+escape(hook.str));
			return false;
		}
		return MapHook::instantiate();
	}

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ c = current;
		if(c !is null)
			eff.enable(c, null);
	}
#section all
};

class Trigger : MapHook {
	BonusEffect@ eff;
	Document doc("Run the specified hook on the current object.");
	Argument hook(AT_Custom, doc="Hook to run.");

	bool instantiate() override {
		@eff = cast<BonusEffect>(parseHook(hook.str, "bonus_effects::"));
		if(eff is null) {
			error("Trigger(): could not find inner hook: "+escape(hook.str));
			return false;
		}
		return MapHook::instantiate();
	}

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		Object@ c = current;
		if(c is null)
			eff.activate(c, null);
	}
#section all
};

class TriggerRegion : MapHook {
	BonusEffect@ eff;
	Document doc("Run the specified hook on the current region.");
	Argument hook(AT_Custom, doc="Hook to run.");

	bool instantiate() override {
		@eff = cast<BonusEffect>(parseHook(hook.str, "bonus_effects::"));
		if(eff is null) {
			error("TriggerRegion(): could not find inner hook: "+escape(hook.str));
			return false;
		}
		return MapHook::instantiate();
	}

#section server
	void trigger(SystemData@ data, SystemDesc@ system, Object@& current) const override {
		if(system !is null)
			eff.activate(system.object, null);
	}
#section all
};

//Copy a region during map generation
void mapCopyRegion(SystemDesc@ from, SystemDesc@ to, uint typeMask = ~0) {
#section server
	Region@ reg = from.object;
	reg.wait();

	Object@ current;

	MakePlanet plHook;
	plHook.initClass();
	plHook.instantiate();
	plHook.distribute = false;
	plHook.resPossib.length = 1;

	MakeAsteroid roidHook;
	roidHook.noResource = true;
	roidHook.initClass();
	roidHook.instantiate();

	MakeStar starHook;
	starHook.initClass();
	starHook.instantiate();

	MakeAnomaly anomalyHook;
	anomalyHook.initClass();
	anomalyHook.instantiate();

	MakeArtifact artifactHook;
	artifactHook.initClass();
	artifactHook.instantiate();

	//Mirror region properties
	to.donateVision = from.donateVision;
	from.object.mirrorRegionStatusTo(to.object);

	//Copy
	for(uint i = 0, cnt = reg.objectCount; i < cnt; ++i) {
		Object@ obj = reg.objects[i];

		if(typeMask & (1<<obj.type) == 0)
			continue;

		vec3d destPos = obj.position - from.position;
		destPos.z = -destPos.z;
		destPos += to.position;

		if(obj.isPlanet) {
			obj.wait();

			@plHook.resPossib[0] = getResource(obj.primaryResourceType);
			plHook.radius.set(obj.radius);
			plHook.grid_size.set(vec2d(obj.surfaceGridSize));

			plHook.trigger(null, to, current);

			Planet@ pl = cast<Planet>(current);
			pl.orbitAround(destPos, to.position);
			to.radius = from.radius;

			if(pl.statusInstanceCount != 0 || obj.statusInstanceCount != 0) {
				for(uint j = 0, jcnt = pl.statusInstanceCount; j < jcnt; ++j)
					pl.removeStatus(pl.statusInstanceId[j]);
				for(uint j = 0, jcnt = obj.statusInstanceCount; j < jcnt; ++j)
					pl.addStatus(obj.statusInstanceType[j]);
			}

			pl.mirrorSurfaceFrom(obj);
		}
		else if(obj.isAsteroid) {
			Asteroid@ base = cast<Asteroid>(obj);
			base.wait();

			roidHook.trigger(null, to, current);

			Asteroid@ roid = cast<Asteroid>(current);
			roid.orbitAround(destPos, to.position);

			for(uint i = 0, cnt = base.getAvailableCount(); i < cnt; ++i)
				roid.addAvailable(base.getAvailable(i), base.getAvailableCost(i));

			for(uint i = 0, cnt = base.cargoTypes; i < cnt; ++i)
				roid.addCargo(base.cargoType[i], base.getCargoStored(base.cargoType[i]));
		}
		else if(obj.isStar) {
			Star@ base = cast<Star>(obj);

			starHook.arguments[0].set(base.temperature);
			starHook.arguments[1].set(base.radius);
			starHook.arguments[2].set(destPos - to.position);

			starHook.trigger(null, to, current);
		}
		else if(obj.isArtifact) {
			Artifact@ base = cast<Artifact>(obj);

			@artifactHook.type = getArtifactType(base.ArtifactType);
			artifactHook.trigger(null, to, current);

			Artifact@ artifact = cast<Artifact>(current);
			artifact.orbitAround(destPos, to.position);
		}
		else if(obj.isAnomaly) {
			Anomaly@ base = cast<Anomaly>(obj);

			@anomalyHook.type = getAnomalyType(base.anomalyType);

			anomalyHook.trigger(null, to, current);

			Anomaly@ anomaly = cast<Anomaly>(current);
			anomaly.position = destPos;
			anomaly.clearOptions();
			for(uint i = 0, cnt = base.optionCount; i < cnt; ++i)
				anomaly.addOption(base.option[i]);
		}
		else if(obj.isPickup) {
			Pickup@ base = cast<Pickup>(obj);
			
			Pickup@ pickup = createPickup(destPos, base.PickupType, defaultEmpire);
			pickup.finalizeCreation();

			Ship@ baseProt = cast<Ship>(base.getProtector());
			if(baseProt !is null) {
				baseProt.wait();

				vec3d leadPos = baseProt.position - from.position;
				leadPos.z = -leadPos.z;
				leadPos += to.position;

				Ship@ leader = createShip(leadPos,
						baseProt.blueprint.design, Creeps, free=true, memorable=true);
				leader.name = baseProt.name;
				leader.named = baseProt.named;
				leader.setAutoMode(config::REMNANT_AGGRESSION == 0 ? AM_HoldPosition : AM_RegionBound);
				leader.sightRange = 0;

				pickup.addPickupProtector(leader);

				for(uint n = 0, ncnt = baseProt.supportCount; n < ncnt; ++n) {
					Ship@ supp = cast<Ship>(baseProt.supportShip[n]);
					if(supp !is null)
						createShip(leadPos, supp.blueprint.design, Creeps, leader, free=true);
				}
			}
		}
		else if(obj.isOddity) {
			Oddity@ odd = cast<Oddity>(obj);
			if(odd.isGate())
				continue;

			ObjectDesc desc;
			desc.type = OT_Oddity;
			desc.radius = odd.radius;
			desc.position = destPos;
			desc.flags |= objNoPhysics;
			desc.flags |= objNoDamage;

			auto@ mirr = Oddity(desc);
			mirr.noCollide = true;
			mirr.makeVisuals(odd.getVisualType(), color=odd.getVisualColor());
		}
	}
#section all
}