#priority init 2000
import tile_resources;
import util.formatting;
import hooks;
from saving import SaveIdentifier, SaveVersion;
import bool readLevelChain(ReadFile& file) from "planet_levels";

const double[] LEVEL_DISTRIBUTION = {0.76, 0.15, 0.06, 0.03};
const double[] RARITY_DISTRIBUTION = {
	0.88, 0.09, 0.02, 0.01, 0.05, 0.00002, //Level 0
	0.73, 0.20, 0.05, 0.02, 0.05, 0.00002, //Level 1
	0.70, 0.20, 0.06, 0.04, 0.05, 0.00002, //Level 2
	0.70, 0.18, 0.08, 0.04, 0.05, 0.00002, //Level 3
};
const int CARGO_WORTH_LEVEL = 10;

//Various ways excess budget may be exchanged into resources
enum WelfareMode {
	WM_Influence,
	WM_Energy,
	WM_Research,
	WM_HW_Labor,
	WM_Defense,
	
	WM_COUNT
};

tidy final class ResourceClass {
	uint id = 0;
	string ident;
	string name;
	array<const ResourceType@> types;
};

enum ResourceMode {
	RM_Normal,
	RM_Universal,
	RM_UniversalUnique,
	RM_NonRequirement,
};

enum ResourceRarity {
	RR_Common,
	RR_Uncommon,
	RR_Rare,
	RR_Epic,
	RR_Unique,
	RR_Mythical,

	RR_COUNT
};

enum VanishMode {
	VM_Never,
	VM_WhenExported,
	VM_Always,
	VM_ExportedInCombat,
	VM_Custom,
};

enum MoneyType {
	MoT_Misc,
	MoT_Construction,
	MoT_Orbitals,
	MoT_Buildings,
	MoT_Ships,
	MoT_Planet_Upkeep,
	MoT_Planet_Income,
	MoT_Colonizers,
	MoT_Handicap,
	MoT_Trade,
	MoT_Vassals,
	//Update save version when adding
	// See: components.ResourceManager

	MoT_COUNT
};

tidy final class ResourceType {
	const ResourceClass@ cls;
	uint id = 0;
	string ident;
	string name;
	string description;
	string blurb;
	string nativeBiome;
	string className;
	string dlc;
	uint level = 0;
	Sprite icon;
	Sprite smallIcon;
	ResourceSheet@ distantSheet;
	uint distantIndex = 0;
	double frequency = 1;
	double distribution = 1;
	double rarityScore = 1;
	double vanishTime = -1.0;
	VanishMode vanishMode = VM_Never;
	bool exportable = true;
	ResourceMode mode = RM_Normal;
	int[] tilePressure = array<int>(TR_COUNT, 0);
	int totalPressure = 0;
	int displayWeight = 0;
	int cargoWorth = 0;
	array<uint> affinities;
	ResourceRarity rarity = RR_Common;
	bool artificial = false;
	bool requirementDisplay = true;
	bool willLock = false;
	bool unique = false;
	double requireContestation = -INFINITY;
	int rarityLevel = -1;
	bool limitlessLevel = false;
	bool canBeTerraformed = true;

	bool get_hasEffect() const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
			if(hooks[i].hasEffect)
				return true;
		}
		if(!exportable)
			return true;
		return false;
	}

	double asteroidFrequency = 0.0;
	double asteroidCost = 0.0;

	int terraformCost = 0;
	double terraformLabor = 0.0;

	array<IResourceHook@> hooks;
	array<Hook@> ai;

	void addAffinity(uint v) {
		affinities.insertLast(v);
	}

	bool isMaterial(uint onLevel) const {
		if(mode == RM_NonRequirement)
			return true;
		if(!exportable)
			return true;
		if(level < onLevel)
			return true;
		return false;
	}

	bool canTerraform(Object@ from, Object@ to) const {
		auto@ curType = getResource(to.primaryResourceType);
		if(curType !is null && !curType.canBeTerraformed)
			return false;
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
			if(!hooks[i].canTerraform(from, to))
				return false;
		}
		return true;
	}
	
	double get_totalRarity() const {
		return 1.0 / rarityScore;
	}

	string formatEffect(Object& obj, array<const IResourceHook@>& hooks) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
			if(hooks[i].hasEffect)
				return hooks[i].formatEffect(obj, hooks);
		}
		if(!exportable)
			return locale::CANNOT_EXPORT;
		return "---";
	}

	bool shouldVanish(Object& obj, Resource@ native) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i) {
			if(hooks[i].shouldVanish(obj, native))
				return true;
		}
		return false;
	}

	void onAdd(Object& obj, Resource@ r) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].onAdd(obj, r);
	}

	void onRemove(Object& obj, Resource@ r) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].onRemove(obj, r);
	}

	void onTick(Object& obj, Resource@ r, double tick) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].onTick(obj, r, tick);
	}

	void onOwnerChange(Object& obj, Resource@ r, Empire@ prevOwner, Empire@ newOwner) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].onOwnerChange(obj, r, prevOwner, newOwner);
	}

	void onRegionChange(Object& obj, Resource@ r, Region@ fromRegion, Region@ toRegion) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].onRegionChange(obj, r, fromRegion, toRegion);
	}

	void save(Resource@ r, SaveFile& file) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].save(r, file);
	}

	void load(Resource@ r, SaveFile& file) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].load(r, file);
	}

	void applyGraphics(Object& obj, Node& node) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].applyGraphics(obj, node);
	}

	void onTerritoryAdd(Object& obj, Resource@ r, Territory@ terr) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].onTerritoryAdd(obj, r, terr);
	}

	void onTerritoryRemove(Object& obj, Resource@ r, Territory@ terr) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].onTerritoryRemove(obj, r, terr);
	}

	void onGenerate(Object& obj, Resource@ native) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].onGenerate(obj, native);
	}

	void onDestroy(Object& obj, Resource@ native) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].onDestroy(obj, native);
	}

	void nativeTick(Object& obj, Resource@ native, double time) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].nativeTick(obj, native, time);
	}

	void nativeSave(Resource@ r, SaveFile& file) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].nativeSave(r, file);
	}

	void nativeLoad(Resource@ r, SaveFile& file) const {
		for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
			hooks[i].nativeLoad(r, file);
	}
};

interface IResourceHook {
	void initialize(ResourceType@ type, uint index);
	bool canTerraform(Object@ from, Object@ to) const;
	bool get_hasEffect() const;
	bool mergesEffect(Object& obj, const IResourceHook@ other) const;
	string formatEffect(Object& obj, array<const IResourceHook@>& hooks) const;
	const IResourceHook@ get_displayHook() const;
	const IResourceHook@ get_carriedHook() const;
	bool shouldVanish(Object& obj, Resource@ native) const;
	void onAdd(Object& obj, Resource@ r) const;
	void onRemove(Object& obj, Resource@ r) const;
	void onTick(Object& obj, Resource@ r, double tick) const;
	void onOwnerChange(Object& obj, Resource@ r, Empire@ prevOwner, Empire@ newOwner) const;
	void onRegionChange(Object& obj, Resource@ r, Region@ fromRegion, Region@ toRegion) const;
	void save(Resource@ r, SaveFile& file) const;
	void load(Resource@ r, SaveFile& file) const;
	void applyGraphics(Object& obj, Node& node) const;
	void onTerritoryAdd(Object& obj, Resource@ r, Territory@ terr) const;
	void onTerritoryRemove(Object& obj, Resource@ r, Territory@ terr) const;
	void onTradeDeliver(Civilian& civ, Object@ origin, Object@ target) const;
	void onTradeDestroy(Civilian& civ, Object@ origin, Object@ target, Object@ destroyer) const;

	void onGenerate(Object& obj, Resource@ native) const;
	void nativeTick(Object&, Resource@ native, double time) const;
	void onDestroy(Object&, Resource@ native) const;
	void nativeSave(Resource@ native, SaveFile& file) const;
	void nativeLoad(Resource@ native, SaveFile& file) const;
};

class ResourceHook : Hook, IResourceHook {
	uint hookIndex = 0;
	void initialize(ResourceType@ type, uint index) { hookIndex = index; }
	bool canTerraform(Object@ from, Object@ to) const { return true; }
	bool get_hasEffect() const { return false; }
	bool mergesEffect(Object& obj, const IResourceHook@ other) const { return getClass(other) is getClass(this); }
	string formatEffect(Object& obj, array<const IResourceHook@>& hooks) const { return "---"; }
	const IResourceHook@ get_displayHook() const { return this; }
	const IResourceHook@ get_carriedHook() const { return null; }
	bool shouldVanish(Object& obj, Resource@ native) const { return false; }
	void onAdd(Object& obj, Resource@ r) const {}
	void onRemove(Object& obj, Resource@ r) const {}
	void onTick(Object& obj, Resource@ r, double tick) const {}
	void onOwnerChange(Object& obj, Resource@ r, Empire@ prevOwner, Empire@ newOwner) const {}
	void onRegionChange(Object& obj, Resource@ r, Region@ fromRegion, Region@ toRegion) const {}
	void save(Resource@ r, SaveFile& file) const {}
	void load(Resource@ r, SaveFile& file) const {}
	void applyGraphics(Object& obj, Node& node) const {}
	void onTerritoryAdd(Object& obj, Resource@ r, Territory@ terr) const {};
	void onTerritoryRemove(Object& obj, Resource@ r, Territory@ terr) const {};
	void onGenerate(Object& obj, Resource@ native) const {}
	void nativeTick(Object&, Resource@ native, double time) const {}
	void onDestroy(Object&, Resource@ native) const {}
	void onTradeDeliver(Civilian& civ, Object@ origin, Object@ target) const {}
	void onTradeDestroy(Civilian& civ, Object@ origin, Object@ target, Object@ destroyer) const {}
	void nativeSave(Resource@ native, SaveFile& file) const {}
	void nativeLoad(Resource@ native, SaveFile& file) const {}
};

int integerSum(array<const IResourceHook@>& hooks, int argument) {
	int amount = 0;
	for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
		amount += cast<const Hook>(hooks[i]).arguments[argument].integer;
	return amount;
}

double decimalSum(array<const IResourceHook@>& hooks, int argument) {
	double amount = 0.0;
	for(uint i = 0, cnt = hooks.length; i < cnt; ++i)
		amount += cast<const Hook>(hooks[i]).arguments[argument].decimal;
	return amount;
}

Color getResourceRarityColor(uint rarity) {
	switch(rarity) {
		case RR_Common: return Color(0xffffffff);
		case RR_Uncommon: return Color(0x0062d6ff);
		case RR_Rare: return Color(0xab00d6ff);
		case RR_Epic: return Color(0xd6ac00ff);
		case RR_Unique: return Color(0xf5ff00ff);
		case RR_Mythical: return Color(0x00ffffff);
	}
	return Color(0xffffffff);
}

string getResourceTooltip(const ResourceType@ type, const Resource@ r = null, Object@ drawFrom = null, bool showName = true) {
	if(r !is null && drawFrom !is null && r.origin is null)
		return "[color=#aaa]"+locale::QUEUED_AUTO_IMPORT+"[/color]";

	string text;
	int curLevel = -1;
	if(r !is null && r.origin !is null && r.origin.hasSurfaceComponent)
		curLevel = r.origin.level;

	if(showName)
		text = format("[font=Medium][color=$2]$1[/color] [img=$3;24/][/font]\n", type.name,
			toString(getResourceRarityColor(type.rarity)), getSpriteDesc(type.smallIcon));
	if(type.level > 0) {
		text += locale::LEVEL+" "+type.level;
		if(type.affinities.length != 0)
			text += " - ";
	}
	if(type.affinities.length != 0) {
		uint affCnt = type.affinities.length;
		for(uint i = 0; i < affCnt; ++i) {
			uint a = type.affinities[i];
			text += format("[img=$1;20/]", getSpriteDesc(getAffinitySprite(a)));
		}
		text += "\n";
	}
	else if(type.level > 0) {
		text += "\n";
	}

	//Pressure
	if(type.totalPressure > 0) {
		string prs;
		for(uint i = 0; i < TR_COUNT; ++i) {
			int val = type.tilePressure[i];
			if(val > 0) {
				if(prs.length != 0)
					prs += ", ";
				int prod = val;
				if(r !is null && r.origin !is null && r.origin.owner is playerEmpire)
					prod = max(round(float(val) * r.efficiency), 0.f);
				if(prod != val)
					prs += format("$1/$2 [img=$3;20/]", toString(prod), toString(val), getTileResourceSpriteSpec(i));
				else
					prs += format("$1 [img=$2;20/]", toString(val), getTileResourceSpriteSpec(i));
			}
		}
		text += format("$1[offset=80][b]$2[/b][/offset]\n[vspace=8/]", locale::RES_PROVIDES_PRESSURE, prs);
	}

	if(type.description.length == 0)
		text += format(type.blurb, toString(curLevel, 0));
	else
		text += format(type.description, toString(curLevel, 0));
	
	if(type.totalPressure > 0) {
		uint types = 0;
		for(uint i = 0; i < TR_COUNT; ++i)
			if(type.tilePressure[i] > 0)
				types += 1;
		
		if(types <= 2) {
			if(type.description.length > 0 || type.blurb.length > 0)
				text += "\n\n";
			
			bool first = true;
			for(uint i = 0; i < TR_COUNT; ++i) {
				if(type.tilePressure[i] > 0) {
					if(!first)
						text += "\n\n";
					first = false;
					text += format("[img=$1;20/] ", getTileResourceSpriteSpec(i)) + localize("PRESSURE_" + getTileResourceIdent(i));
				}
			}
		}
	}

	//Import marker
	if(r !is null) {
		if(drawFrom !is null) {
			if(r.origin is null) {
				text += "\n\n[color=#aaa]"+locale::QUEUED_AUTO_IMPORT+"[/color]";
			}
			else if(r.origin is drawFrom && r.exportedTo !is null) {
				text += "\n\n[color=#aaa]"+format(locale::RESOURCE_EXPORTED_TO, r.exportedTo.name)+"[/color]";
			}
			else if(r.exportedTo is drawFrom) {
				text += "\n\n[color=#aaa]"+format(locale::RESOURCE_IMPORTED_FROM, r.origin.name)+"[/color]";
			}
		}
	}

	//Warnings
	if(r !is null) {
		if(r.type.vanishMode != VM_Never) {
			double timeLeft = r.type.vanishTime - r.vanishTime;
			if(r.exportedTo !is null)
				timeLeft /= r.exportedTo.resourceVanishRate;
			else if(r.origin !is null)
				timeLeft /= r.origin.resourceVanishRate;

			text += "\n\n";
			if(r.usable && r.origin !is null && r.origin.owner is playerEmpire && (type.vanishMode == VM_Always || r.exportedTo !is null))
				text += "[color=#fb0]"+format(locale::VANISH_TIP, formatTime(timeLeft))+"[/color]";
			else
				text += format(locale::VANISH_TIP_NOUSE, formatTime(timeLeft));
		}
		
		if(!r.usable) {
			string err;
			if(r.origin !is null)
				err = r.origin.getDisabledReason(r.id);
			else if(drawFrom !is null)
				err = drawFrom.getDisabledReason(r.id);
			
			if(err.length > 0) {
				text += "\n\n";
				string base;
				if(r.origin is drawFrom) {
					if(r.exportedTo is null)
						base = locale::EXPBLOCK_USE;
					else
						base = locale::EXPBLOCK_EXPORT;
				}
				else {
					base = locale::EXPBLOCK_IMPORT;
				}
				text += format(base, err);
			}
		}
	}
	else {
		if(type.vanishMode != VM_Never) {
			text += "\n\n";
			text += format(locale::VANISH_TIP_NOUSE, formatTime(type.vanishTime));
		}
	}
	return text;
}


string formatBuildCost(const Design@ dsg, Object@ obj = null, string fmt = "$1 / $2, $3") {
	int buildCost = 0;
	int maintainCost = 0;
	double laborCost = 0;

	getBuildCost(dsg, buildCost, maintainCost, laborCost, -1, obj);
	return format(fmt, formatMoney(buildCost), formatMoney(maintainCost), standardize(laborCost)+" "+locale::RESOURCE_LABOR);
}

void getBuildCost(const Design@ dsg, int&out buildCost, int&out maintainCost, double&out laborCost, int count = 1, Object@ obj = null) {
	double build = 0;
	double maintain = 0;
	double labor = 0;

	uint cnt = dsg.subsystemCount;
	for(uint i = 0; i < cnt; ++i) {
		const Subsystem@ sys = dsg.subsystems[i];
		for(uint j = 0, hexCnt = sys.hexCount; j < hexCnt; ++j) {
			if(sys.has(HV_BuildCost))
				build += sys.hexVariable(HV_BuildCost, j);
			if(sys.has(HV_MaintainCost))
				maintain += sys.hexVariable(HV_MaintainCost, j);
			if(sys.has(HV_LaborCost))
				labor += sys.hexVariable(HV_LaborCost, j);
		}
	}
	if(obj !is null) {
		build *= double(obj.shipBuildCost) / 100.0;
		build *= obj.constructionCostMod;
	}

	buildCost = max(ceil(build), 0.0);
	maintainCost = max(ceil(maintain), 0.0);

	if(count >= 0) {
		buildCost *= count;
		maintainCost *= count;
		labor *= count;
	}

	if(buildCost < 0)
		buildCost = INT_MAX>>1;
	if(maintainCost < 0)
		maintainCost = INT_MAX>>1;
	laborCost = labor;
}

int getBuildCost(const Design@ dsg, int count = 1, Object@ buildAt = null) {
	double build = 0;
	uint cnt = dsg.subsystemCount;
	for(uint i = 0; i < cnt; ++i) {
		const Subsystem@ sys = dsg.subsystems[i];
		if(!sys.has(HV_BuildCost))
			continue;
		for(uint j = 0, hexCnt = sys.hexCount; j < hexCnt; ++j)
			build += sys.hexVariable(HV_BuildCost, j);
	}
	if(buildAt !is null) {
		build *= double(buildAt.shipBuildCost) / 100.0;
		build *= buildAt.constructionCostMod;
	}

	int v = ceil(build);
	if(count >= 0)
		v *= count;
	if(v < 0)
		v = INT_MAX>>1;
	return v;
}

int getMaintenanceCost(const Design@ dsg, int count = 1) {
	double maintain = 0;
	uint cnt = dsg.subsystemCount;
	for(uint i = 0; i < cnt; ++i) {
		const Subsystem@ sys = dsg.subsystems[i];
		if(!sys.has(HV_MaintainCost))
			continue;
		for(uint j = 0, hexCnt = sys.hexCount; j < hexCnt; ++j)
			maintain += sys.hexVariable(HV_MaintainCost, j);
	}

	if(count >= 0)
		maintain *= count;
	int v = max(ceil(maintain), 0.0);
	if(v < 0)
		v = INT_MAX>>1;
	return v;
}

double getLaborCost(const Design@ dsg, int count = 1) {
	double time = 0;
	uint cnt = dsg.subsystemCount;
	for(uint i = 0; i < cnt; ++i) {
		const Subsystem@ sys = dsg.subsystems[i];
		if(!sys.has(HV_LaborCost))
			continue;
		for(uint j = 0, hexCnt = sys.hexCount; j < hexCnt; ++j)
			time += sys.hexVariable(HV_LaborCost, j);
	}

	if(count >= 0)
		time *= count;
	return time;
}

tidy final class Resources : Serializable, Savable {
	array<uint> types;
	int[] amounts;

	Resources() {
	}

	int modAmount(const ResourceType@ type, int mod, bool remove = true) {
		int index = types.find(type.id);
		if(index == -1) {
			types.insertLast(type.id);
			amounts.insertLast(mod);
			return mod;
		}
		else {
			amounts[index] += mod;
			int amt = amounts[index];
			if(remove && amt == 0) {
				types.removeAt(index);
				amounts.removeAt(index);
			}
			return amt;
		}
	}

	int getAmount(const ResourceType@ type) const {
		int index = types.find(type.id);
		if(index == -1)
			return 0;
		return amounts[index];
	}
	
	void clear() {
		types.length = 0;
		amounts.length = 0;
	}

	uint get_length() const {
		return types.length;
	}

	int get_universalCount() const {
		int amt = 0;
		uint cnt = types.length;
		for(uint i = 0; i < cnt; ++i) {
			auto@ type = getResource(types[i]);
			if(type.mode == RM_Universal)
				amt += amounts[i];
			else if(type.mode == RM_UniversalUnique)
				amt += 1;
		}
		return amt;
	}

	bool get_empty() const {
		return types.length == 0;
	}

	void read(Message& msg) {
		uint allTypeCount = getResourceCount();
		uint cnt = msg.readSmall();
		types.length = cnt;
		amounts.length = cnt;
		for(uint i = 0; i < cnt; ++i) {
			types[i] = msg.readLimited(allTypeCount-1);
			amounts[i] = msg.readSignedSmall();
		}
	}

	void write(Message& msg) {
		uint allTypeCount = getResourceCount();
		uint cnt = types.length;
		msg.writeSmall(cnt);
		for(uint i = 0; i < cnt; ++i) {
			msg.writeLimited(types[i], allTypeCount-1);
			msg.writeSignedSmall(amounts[i]);
		}
	}

	void load(SaveFile& msg) {
		uint cnt = 0;
		msg >> cnt;
		types.length = cnt;
		amounts.length = cnt;
		for(uint i = 0; i < cnt; ++i) {
			types[i] = msg.readIdentifier(SI_Resource);
			msg >> amounts[i];
		}
	}

	void save(SaveFile& msg) {
		uint cnt = types.length;
		msg << cnt;
		for(uint i = 0; i < cnt; ++i) {
			msg.writeIdentifier(SI_Resource, types[i]);
			msg << amounts[i];
		}
	}

	void print() const {
		uint cnt = types.length;
		for(uint i = 0; i < cnt; ++i)
			::print(getResource(types[i]).name+": "+amounts[i]);
	}
};

enum ResourceRequirementType {
	RRT_Resource,
	RRT_Class,
	RRT_Class_Types,
	RRT_Level,
	RRT_Level_Types,
};

tidy final class ResourceRequirement {
	ResourceRequirementType type = RRT_Resource;
	const ResourceClass@ cls;
	const ResourceType@ resource;
	uint level = 0;
	uint amount = 0;

	bool equivalent(const ResourceRequirement@ other) const {
		if(type != other.type)
			return false;
		if(cls !is other.cls)
			return false;
		if(resource !is other.resource)
			return false;
		if(level != other.level)
			return false;
		return true;
	}

	int meetQuality(const ResourceType@ check, bool doneUniversal) const {
		if(check.mode == RM_UniversalUnique) {
			if(doneUniversal)
				return 0;
			return 10;
		}
		if(check.mode == RM_Universal)
			return 11;

		switch(type) {
			case RRT_Resource:
				if(resource is check)
					return 1;
			break;
			case RRT_Class:
				if(check.cls is cls)
					return 2;
			break;
			case RRT_Level:
				if(check.level == level)
					return 3;
			break;
		}
		return 0;
	}

	int opCmp(const ResourceRequirement@ other) const {
		if(type < other.type)
			return -1;
		else if(type > other.type)
			return 1;
		return 0;
	}
};

tidy final class ResourceRequirements {
	ResourceRequirement@[] reqs;

	void addRequirement(ResourceRequirement@ req) {
		reqs.insertLast(req);
		reqs.sortAsc();
	}

	bool satisfiedBy(const Resources@ res, array<int>@ remaining = null,
			bool allowUniversal = true, array<int>@ reqRemaining = null) const {
		int universal = res.universalCount;
		int unsatisfied = 0;
		if(remaining is null)
			@remaining = array<int>();
		remaining = res.amounts;

		uint reqCnt = reqs.length;
		uint resCnt = res.length;
		if(reqRemaining !is null)
			reqRemaining.length = reqCnt;
		for(uint i = 0; i < reqCnt; ++i) {
			ResourceRequirement@ r = reqs[i];
			uint total = r.amount;

			switch(r.type) {
				case RRT_Resource: {
					if(r.resource.mode == RM_Normal) {
						for(uint j = 0; j < resCnt; ++j) {
							if(res.types[j] == r.resource.id) {
								uint take = min(remaining[j], total);
								remaining[j] -= take;
								total -= take;
								if(total <= 0)
									break;
							}
						}
					}
					if(reqRemaining !is null)
						reqRemaining[i] = total;
					unsatisfied += total;
				} break;
				case RRT_Class:
					for(uint j = 0; j < resCnt; ++j) {
						auto@ type = getResource(res.types[j]);
						if(type.mode != RM_Normal)
							continue;
						const ResourceClass@ cls = type.cls;
						if(cls is r.cls) {
							uint take = min(remaining[j], total);
							remaining[j] -= take;
							total -= take;
							if(total <= 0)
								break;
						}
					}
					if(reqRemaining !is null)
						reqRemaining[i] = total;
					unsatisfied += total;
				break;
				case RRT_Class_Types:
					for(uint j = 0; j < resCnt; ++j) {
						auto@ type = getResource(res.types[j]);
						if(type.mode != RM_Normal)
							continue;
						const ResourceClass@ cls = type.cls;
						if(cls is r.cls) {
							total -= 1;
							remaining[j] -= 1;
							if(total <= 0)
								break;
						}
					}
					if(reqRemaining !is null)
						reqRemaining[i] = total;
					unsatisfied += total;
				break;
				case RRT_Level:
					for(uint j = 0; j < resCnt; ++j) {
						auto@ type = getResource(res.types[j]);
						if(type.mode != RM_Normal)
							continue;
						if(type.level == r.level) {
							uint take = min(remaining[j], total);
							remaining[j] -= take;
							total -= take;
							if(total <= 0)
								break;
						}
					}
					if(reqRemaining !is null)
						reqRemaining[i] = total;
					unsatisfied += total;
				break;
				case RRT_Level_Types:
					for(uint j = 0; j < resCnt; ++j) {
						auto@ type = getResource(res.types[j]);
						if(type.mode != RM_Normal)
							continue;
						if(type.level == r.level) {
							total -= 1;
							remaining[j] -= 1;
							if(total <= 0)
								break;
						}
					}
					if(reqRemaining !is null)
						reqRemaining[i] = total;
					unsatisfied += total;
				break;
			}
		}

		if(allowUniversal)
			return unsatisfied <= universal;
		else
			return unsatisfied == 0;
	}

	void parse(string text) {
		string[] parts = text.split(",");
		for(uint i = 0, cnt = parts.length; i < cnt; ++i) {
			string spec = parts[i].trimmed();
			int space = spec.findFirst(" ");
			if(space == -1) {
				error("Invalid resource specifier: "+parts[i]);
				continue;
			}

			ResourceRequirement req;
			req.amount = toUInt(spec.substr(0, space));
			string resource = spec.substr(space+1);

			//Detect types of modifier
			bool typesOf = false;
			if(resource.startswith_nocase("types of ")) {
				resource = resource.substr(9);
				typesOf = true;
			}

			//Detect resource level
			if(resource.startswith_nocase("level")) {
				req.level = toUInt(resource.substr(5));
				if(typesOf)
					req.type = RRT_Level_Types;
				else
					req.type = RRT_Level;

				reqs.insertLast(req);
				continue;
			}

			//Detect single resource amount
			const ResourceType@ res = getResource(resource);
			if(res !is null) {
				if(typesOf) {
					error("Invalid resource specifier: "+parts[i]);
					error("  Cannot take types of specific resource.");
					continue;
				}

				req.type = RRT_Resource;
				@req.resource = res;

				reqs.insertLast(req);
				continue;
			}

			//Detect resource class
			const ResourceClass@ cls = getResourceClass(resource);
			if(cls !is null) {
				if(typesOf)
					req.type = RRT_Class_Types;
				else
					req.type = RRT_Class;
				@req.cls = cls;

				reqs.insertLast(req);
				continue;
			}

			error("Invalid resource specifier: "+parts[i]);
			error("  Unknown resource '"+resource+"'.");
		}

		reqs.sortAsc();
	}
};

tidy class Resource : Serializable, Savable {
	int id = -1;
	const ResourceType@ type;
	Object@ origin;
	Object@ exportedTo;
	bool usable = true;
	bool locked = false;
	uint8 disabled = 0;
	double vanishTime;
	float efficiency = 1.f;
	any[] data;

	void write(Message& msg) {
		msg.writeLimited(type.id, resources::resources.length-1);
		msg.writeSmall(id);
		msg << origin;
		msg << exportedTo;
		msg << usable;
		msg << disabled;
		msg << efficiency;
		msg << locked;
		if(type.vanishMode != VM_Never)
			msg << float(vanishTime);
	}

	void read(Message& msg) {
		@type = getResource(msg.readLimited(resources::resources.length-1));
		id = msg.readSmall();
		msg >> origin;
		msg >> exportedTo;
		msg >> usable;
		msg >> disabled;
		msg >> efficiency;
		msg >> locked;
		if(type.vanishMode != VM_Never)
			vanishTime = msg.read_float();
	}

	void save(SaveFile& msg) {
		msg.writeIdentifier(SI_Resource, type.id);
		msg << id;
		msg << origin;
		msg << exportedTo;
		msg << usable;
		msg << disabled;
		msg << vanishTime;
		msg << efficiency;
		msg << locked;
	}

	void load(SaveFile& msg) {
		uint res = msg.readIdentifier(SI_Resource);
		@type = getResource(res);
		data.length = type.hooks.length;

		msg >> id;
		msg >> origin;
		msg >> exportedTo;
		msg >> usable;
		msg >> disabled;
		msg >> vanishTime;
		msg >> efficiency;

		if(msg >= SV_0027)
			msg >> locked;
	}

	void descFrom(const Resource@ other) {
		if(other is null) {
			id = -1;
			@type = null;
			@exportedTo = null;
			return;
		}
		id = other.id;
		@type = other.type;
		@origin = other.origin;
		@exportedTo = other.exportedTo;
		usable = other.usable;
		locked = other.locked;
		disabled = other.disabled;
		vanishTime = other.vanishTime;
		efficiency = other.efficiency;
	}

	int opCmp(const Resource& other) const {
#section client
		if(exportedTo is null && other.exportedTo !is null)
			return 1;
		if(exportedTo !is null && other.exportedTo is null)
			return -1;
		if(other.exportedTo is origin)
			return 1;
		if(exportedTo is other.origin)
			return -1;
#section all
		if(type is null || other.type is null)
			return 0;
		if(type.displayWeight > other.type.displayWeight)
			return 1;
		else if(type.displayWeight < other.type.displayWeight)
			return -1;
		if(type.level < other.type.level)
			return -1;
		if(type.level > other.type.level)
			return 1;
		if(type.rarityScore > other.type.rarityScore)
			return -1;
		if(type.rarityScore < other.type.rarityScore)
			return 1;
		if(type.id < other.type.id)
			return -1;
		if(type.id > other.type.id)
			return 1;
		return 0;
	}
};

tidy final class QueuedImport : Resource {
	Empire@ forEmpire;

	void save(SaveFile& msg) {
		Resource::save(msg);
		msg << forEmpire;
	}

	void load(SaveFile& msg) {
		Resource::load(msg);
		msg >> forEmpire;
	}

	void writeQueued(Message& msg) {
		Resource::write(msg);
		msg << forEmpire;
	}

	void readQueued(Message& msg) {
		Resource::read(msg);
		msg >> forEmpire;
	}
};

tidy final class QueuedResource : Serializable, Savable {
	Empire@ forEmpire;
	int id = -1;
	Object@ to;
	bool locked;

	void write(Message& msg) {
		msg << forEmpire;
		msg << id;
		msg << to;
		msg << locked;
	}

	void read(Message& msg) {
		msg >> forEmpire;
		msg >> id;
		msg >> to;
		msg >> locked;
	}

	void save(SaveFile& msg) {
		msg << forEmpire;
		msg << id;
		msg << to;
		msg << locked;
	}

	void load(SaveFile& msg) {
		msg >> forEmpire;
		msg >> id;
		msg >> to;
		if(msg >= SV_0027)
			msg >> locked;
	}
};

tidy class AutoImportDesc : Serializable {
	Object@ to;
	const ResourceType@ type;
	const ResourceClass@ cls;
	int level = -1;
	bool handled = false;

	void write(Message& msg) {
		msg << to;
		if(type !is null) {
			msg.write1();
			msg.writeSmall(type.id);
		}
		else {
			msg.write0();
		}
		if(cls !is null) {
			msg.write1();
			msg.writeSmall(cls.id);
		}
		else {
			msg.write0();
		}
		msg.writeSignedSmall(level);
		msg << handled;
	}

	void read(Message& msg) {
		msg >> to;
		if(msg.readBit())
			@type = getResource(msg.readSmall());
		else
			@type = null;
		if(msg.readBit())
			@cls = getResourceClass(msg.readSmall());
		else
			@cls = null;
		level = msg.readSignedSmall();
		msg >> handled;
	}

	bool equivalent(const AutoImportDesc& other) const {
		return type is other.type && cls is other.cls && level == other.level;
	}

	bool satisfies(const ResourceType@ type, bool alreadyPresent = false) {
		if(type.mode != RM_Normal)
			return false;
		if(!alreadyPresent && !type.exportable)
			return false;
		if(level != -1 && type.level != uint(level))
			return false;
		if(cls !is null && type.cls !is cls)
			return false;
		if(this.type !is null && type !is this.type)
			return false;
		return true;
	}
};

int getGroupSize(const Design@ dsg) {
	return ceil(40.0 / sqrt(dsg.size));
}

namespace resources {
	::dictionary resourceIdents;
	::ResourceType@[] resources;
	double totalFrequency = 0.0;
	double asteroidFrequency = 0.0;

	::dictionary classIdents;
	::ResourceClass@[] resClasses;
};

tidy final class RarityFrequency {
	double totalDistribution = 0.0;
	array<ResourceType@> types;
};
tidy final class LevelFrequency {
	double totalDistribution = 0.0;
	array<ResourceType@> types;
	array<RarityFrequency> rarities(6);
};
array<LevelFrequency> LevelFrequencies(4);

uint getResourceCount() {
	return resources::resources.length;
}

const ResourceType@ getResource(uint id) {
	if(id >= resources::resources.length)
		return null;
	return resources::resources[id];
}

int getResourceID(const string& ident) {
	ResourceType@ type;
	resources::resourceIdents.get(ident, @type);
	if(type !is null)
		return int(type.id);
	return -1;
}

string getResourceIdent(int id) {
	if(id < 0 || id >= int(resources::resources.length))
		return "-";
	return resources::resources[id].ident;
}

const ResourceType@ getResource(const string& ident) {
	ResourceType@ type;
	resources::resourceIdents.get(ident, @type);
	return type;
}

const ResourceType@ getDistributedResourceContest(double contestation) {
	uint tries = 0;
	const ResourceType@ type;
	do {
		@type = getDistributedResource();
		++tries;
	}
	while(tries < 10 && type.requireContestation > contestation);
	return type;
}

const ResourceType@ getDistributedResource() {
	double num = randomd(0, resources::totalFrequency);
	double orig = num;
	for(uint i = 0, cnt = resources::resources.length; i < cnt; ++i) {
		const ResourceType@ type = resources::resources[i];
		double freq = type.rarityScore;

		if(num <= freq)
			return type;
		num -= freq;
	}
	return resources::resources[resources::resources.length-1];
}

const ResourceType@ getDistributedResource(uint level) {
	auto@ lFreq = LevelFrequencies[level];
	double num = randomd(0, lFreq.totalDistribution);
	double orig = num;
	for(uint i = 0, cnt = lFreq.types.length; i < cnt; ++i) {
		const ResourceType@ type = lFreq.types[i];
		double freq = type.distribution;

		if(num <= freq)
			return type;
		num -= freq;
	}
	return lFreq.types[lFreq.types.length-1];
}

const ResourceType@ getRandomResource(uint level) {
	auto@ lFreq = LevelFrequencies[level];
	if(lFreq.types.length == 0)
		return null;
	return lFreq.types[randomi(0,lFreq.types.length-1)];
}

const ResourceType@ getDistributedAsteroidResource() {
	double num = randomd(0, resources::asteroidFrequency);
	const ResourceType@ type;
	for(uint i = 0, cnt = resources::resources.length; i < cnt; ++i) {
		@type = resources::resources[i];
		if(type.asteroidFrequency <= 0.0)
			continue;

		double freq = type.asteroidFrequency;
		if(num <= freq)
			return type;
		num -= freq;
	}
	return type;
}

void markResourceUsed(const ResourceType@ type) {
	if(type.unique) {
		ResourceType@ mut = resources::resources[type.id];

		uint lev = clamp(type.level, 0, 3);
		if(type.rarityLevel != -1)
			lev = clamp(type.rarityLevel, 0, 3);

		uint rar = clamp(uint(type.rarity), 0, 3);
		LevelFrequencies[lev].totalDistribution -= type.distribution;
		LevelFrequencies[lev].rarities[rar].totalDistribution -= type.distribution;

		resources::totalFrequency -= mut.rarityScore;
		resources::asteroidFrequency -= mut.asteroidFrequency;
		mut.rarityScore = 0;
		mut.distribution = 0;
		mut.asteroidFrequency = 0;
	}
}

const ResourceClass@ getResourceClass(uint id) {
	if(id >= resources::resClasses.length)
		return null;
	return resources::resClasses[id];
}

const ResourceClass@ getResourceClass(string ident) {
	ResourceClass@ type;
	resources::classIdents.get(ident, @type);
	return type;
}

uint getResourceClassCount() {
	return resources::resClasses.length;
}

void parseLine(string& line, ResourceType@ r, ReadFile@ file) {
	if(line.findFirst("(") == -1) {
		//Pressure line
		array<string>@ decls = line.split(",");
		for(uint i = 0, cnt = decls.length; i < cnt; ++i) {
			array<string>@ parts = decls[i].split(" ");
			if(parts.length != 3 || !parts[2].trimmed().equals_nocase("pressure")) {
				error("Invalid pressure spec: "+escape(decls[i]));
				continue;
			}

			uint resource = getTileResource(parts[1]);
			if(resource == TR_INVALID) {
				error("Invalid pressure spec: "+escape(decls[i]));
				continue;
			}

			int amt = toInt(parts[0]);
			r.tilePressure[resource] += amt;
		}
	}
	else {
		//Hook line
		auto@ hook = cast<IResourceHook>(parseHook(line, "resource_effects::", instantiate=false, file=file));
		if(hook !is null)
			r.hooks.insertLast(hook);
	}
}

void loadResources(const string& filename) {
	ReadFile file(filename, true);
	
	string key, value;
	ResourceType@ r;
	bool advance = true;
	while(!advance || file++) {
		key = file.key;
		value = file.value;
		advance = true;
		
		if(file.fullLine) {
			if(r is null) {
				error("Missing 'Resource: ID' line in " + filename);
				continue;
			}

			string line = file.line;
			parseLine(line, r, file);
		}
		else if(key == "Resource") {
			if(r !is null)
				addResourceType(r);
			@r = ResourceType();
			r.ident = value;
		}
		else if(key == "Level Chain") {
			advance = !readLevelChain(file);
		}
		else if(r is null) {
			error("Missing 'Resource: ID' line in " + filename);
		}
		else if(key == "Name") {
			r.name = localize(value);
		}
		else if(key == "Description") {
			r.description = localize(value);
		}
		else if(key == "Blurb") {
			r.blurb = localize(value);
		}
		else if(key == "Native Biome") {
			r.nativeBiome = value;
		}
		else if(key == "Class") {
			r.className = value;
		}
		else if(key == "DLC") {
			r.dlc = value;
		}
		else if(key == "Level") {
			r.level = toUInt(value);
			if(r.cargoWorth == 0)
				r.cargoWorth = (r.level+1) * CARGO_WORTH_LEVEL;
		}
		else if(key == "Rarity Level") {
			r.rarityLevel = toInt(value);
		}
		else if(key == "Limitless Level") {
			r.limitlessLevel = toBool(value);
		}
		else if(key == "Can Be Terraformed") {
			r.canBeTerraformed = toBool(value);
		}
		else if(key == "Frequency") {
			r.frequency = toDouble(value);
		}
		else if(key == "Distribution") {
			r.distribution = toDouble(value);
		}
		else if(key == "Vanish Time") {
			r.vanishTime = toDouble(value);
		}
		else if(key == "Cargo Worth") {
			r.cargoWorth = toInt(value);
		}
		else if(key == "Vanish Mode") {
			if(value == "Never")
				r.vanishMode = VM_Never;
			else if(value == "When Exported")
				r.vanishMode = VM_WhenExported;
			else if(value == "Always")
				r.vanishMode = VM_Always;
			else if(value == "Exported In Combat")
				r.vanishMode = VM_ExportedInCombat;
			else if(value == "Custom")
				r.vanishMode = VM_Custom;
			else
				error("Invalid vanish mode: "+value);
		}
		else if(key == "Artificial") {
			r.artificial = toBool(value);
			if(r.artificial)
				r.distribution = 0.0;
		}
		else if(key == "Exportable") {
			r.exportable = toBool(value);
		}
		else if(key == "Unique") {
			r.unique = toBool(value);
		}
		else if(key == "Require Contestation") {
			r.requireContestation = toDouble(value);
		}
		else if(key == "Mode") {
			if(value == "Normal")
				r.mode = RM_Normal;
			else if(value == "Universal")
				r.mode = RM_Normal;
			else if(value == "Universal Unique")
				r.mode = RM_UniversalUnique;
			else if(value == "Non Requirement")
				r.mode = RM_NonRequirement;
			else
				error("Invalid resource mode: "+value);
		}
		else if(key == "Affinity") {
			uint aff = getAffinityFromDesc(value);
			if(aff != A_NULL)
				r.addAffinity(aff);
		}
		else if(key == "Rarity") {
			if(value == "Common")
				r.rarity = RR_Common;
			else if(value == "Uncommon")
				r.rarity = RR_Uncommon;
			else if(value == "Rare")
				r.rarity = RR_Rare;
			else if(value == "Epic")
				r.rarity = RR_Epic;
			else if(value == "Mythical")
				r.rarity = RR_Mythical;
			else if(value == "Unique") {
				r.rarity = RR_Unique;
				r.unique = true;
			}
			else
				error("Invalid resource rarity: "+value);
		}
		else if(key == "Display Requirement") {
			r.requirementDisplay = toBool(value);
		}
		else if(key == "Will Lock") {
			r.willLock = toBool(value);
		}
		else if(key == "Display Weight") {
			r.displayWeight = toDouble(value);
		}
		else if(key == "Asteroid Frequency") {
			r.asteroidFrequency = toDouble(value);
		}
		else if(key == "Asteroid Labor") {
			r.asteroidCost = toDouble(value);
		}
		else if(key == "Terraform Cost") {
			r.terraformCost = toInt(value);
		}
		else if(key == "Terraform Labor") {
			r.terraformLabor = toDouble(value);
		}
		else if(key == "Icon") {
			r.icon = getSprite(value);
		}
		else if(key == "Small Icon") {
			r.smallIcon = getSprite(value);
		}
		else if(key == "Distant Icon") {
			//TODO
		}
		else if(key == "Pressure") {
			array<string>@ decls = value.split(",");
			for(uint i = 0, cnt = decls.length; i < cnt; ++i) {
				array<string>@ parts = decls[i].split(" ");
				if(parts.length != 2) {
					error("Invalid pressure spec: "+escape(decls[i]));
					continue;
				}

				uint resource = getTileResource(parts[1]);
				if(resource == TR_INVALID) {
					error("Invalid pressure spec: "+escape(decls[i]));
					continue;
				}

				int amt = toInt(parts[0]);
				r.tilePressure[resource] += amt;
			}
		}
		else if(key.equals_nocase("AI")) {
			auto@ hook = parseHook(value, "ai.resources::", instantiate=false, file=file);
			if(hook !is null)
				r.ai.insertLast(hook);
			else
				file.error("Could not find AI hook "+value);
		}
		else {
			string line = file.line;
			parseLine(line, r, file);
		}
	}
	
	if(r !is null)
		addResourceType(r);
}

void preInit() {
	//Load resources
	FileList list("data/resources", "*.txt", true);
	for(uint i = 0, cnt = list.length; i < cnt; ++i)
		loadResources(list.path[i]);

	//Calculate resource frequencies
	double rarTotal = 0;
	resources::totalFrequency = 0.0;
	for(uint i = 0, cnt = getResourceCount(); i < cnt; ++i) {
		ResourceType@ type = resources::resources[i];
		for(uint n = 0, ncnt = type.hooks.length; n < ncnt; ++n)
			type.hooks[n].initialize(type, n);

		uint lev = clamp(type.level, 0, 3);
		if(type.rarityLevel != -1)
			lev = clamp(type.rarityLevel, 0, 3);
		uint rar = clamp(uint(type.rarity), 0, 5);

		LevelFrequency@ lFreq = LevelFrequencies[lev];
		RarityFrequency@ rFreq = lFreq.rarities[rar];

		double freq = 0.0;
		if(type.distribution > 0 && rFreq.totalDistribution > 0) {
			freq = LEVEL_DISTRIBUTION[lev] * RARITY_DISTRIBUTION[rar+lev*6] *
				(type.distribution / rFreq.totalDistribution) * type.frequency;

		}
		if(type.unique)
			freq *= config::UNIQUE_RESOURCE_OCCURANCE / 0.3;

		resources::totalFrequency += freq;
		type.rarityScore = freq;
	}
}

tidy final class ResourceSheet {
#section gui
	Sprite sprt;
	array<Material> mats;

	ResourceSheet(const Sprite& sprt) {
		this.sprt = sprt;

		mats.length = 6;
		mats[0] = material::PlanetLevel0;
		mats[1] = material::PlanetLevel1;
		mats[2] = material::PlanetLevel2;
		mats[3] = material::PlanetLevel3;
		mats[4] = material::PlanetLevel4;
		mats[5] = material::PlanetLevel5;
		for(uint i = 0; i < 6; ++i) {
			if(sprt.mat !is null)
				@mats[i].texture2 = sprt.mat.texture0;
			else if(sprt.sheet !is null)
				@mats[i].texture2 = sprt.sheet.material.texture0;
			mats[i].constant = true;
		}
	}

	~ResourceSheet() {
		for(uint i = 0; i < 6; ++i)
			mats[i].constant = false;
	}

	void getUV(uint resourceIcon, vec4f& uvs) {
		if(resourceIcon < 0xffffffff) {
			if(sprt.sheet !is null)
				sprt.sheet.getSourceUV(resourceIcon, uvs);
			else
				uvs = vec4f(0.f, 0.f, 1.f, 1.f);
		}
		else
			uvs = vec4f();
	}

	Material@ getMaterial(uint level) {
		return mats[clamp(level, 0, 5)];
	}
#section all
};

array<ResourceSheet@> sheets;
void init() {
	auto@ list = resources::resources;
	for(uint i = 0, cnt = list.length; i < cnt; ++i) {
		auto@ type = list[i];
		for(uint n = 0, ncnt = type.hooks.length; n < ncnt; ++n)
			if(!cast<Hook>(type.hooks[n]).instantiate())
				error("Could not instantiate hook: "+addrstr(type.hooks[n])+" in "+type.ident);
		if(type.smallIcon.valid) {
			if(!type.icon.valid)
				type.icon = type.smallIcon;
		}
		else if(type.icon.valid) {
			type.smallIcon = type.icon;
		}
		for(uint n = 0, ncnt = type.ai.length; n < ncnt; ++n) {
			if(!type.ai[n].instantiate())
				error("Could not instantiate AI hook: "+addrstr(type.ai[n])+" in resource "+type.ident);
		}
	}

#section gui
	for(uint i = 0, cnt = list.length; i < cnt; ++i) {
		auto@ r = list[i];
		if(!r.smallIcon.valid)
			continue;

		//Find associated resource sheet
		ResourceSheet@ rs;
		for(uint n = 0, ncnt = sheets.length; n < ncnt; ++n) {
			if((sheets[n].sprt.sheet is r.smallIcon.sheet && r.smallIcon.sheet !is null)
					|| (sheets[n].sprt.mat is r.smallIcon.mat && r.smallIcon.mat !is null)) {
				@rs = sheets[n];
				break;
			}
		}

		if(rs is null) {
			@rs = ResourceSheet(r.smallIcon);
			sheets.insertLast(rs);
		}

		@r.distantSheet = rs;
	}
#section all
}

ThreadLocal<Resource@> res;
Resource@ _tempResource() {
	Resource@ r = res.get();
	if(r is null) {
		@r = Resource();
		res.set(r);
	}
	return r;
}

void addResourceType(ResourceType@ type) {
	//Add resource
	type.id = resources::resources.length;
	resources::resources.insertLast(@type);
	resources::resourceIdents.set(type.ident, @type);

	if(type.dlc.length != 0 && !hasDLC(type.dlc)) {
		type.distribution = 0.0;
		type.frequency = 0.0;
	}

	if(type.asteroidFrequency > 0) {
		if(type.vanishMode == VM_Never)
			type.asteroidFrequency *= config::ASTEROID_PERMANENT_FREQ;
		resources::asteroidFrequency += type.asteroidFrequency;
	}

	uint lev = type.level;
	if(type.rarityLevel != -1)
		lev = clamp(type.rarityLevel, 0, 3);

	LevelFrequency@ lFreq = LevelFrequencies[clamp(lev, 0, 3)];
	RarityFrequency@ rFreq = lFreq.rarities[clamp(uint(type.rarity), 0, 5)];

	lFreq.totalDistribution += type.distribution;
	lFreq.types.insertLast(type);
	rFreq.totalDistribution += type.distribution;
	rFreq.types.insertLast(type);
	
	//Figure out class
	if(type.className.length != 0) {
		ResourceClass@ cls;
		resources::classIdents.get(type.className, @cls);

		if(cls is null) {
			@cls = ResourceClass();
			cls.id = resources::resClasses.length;
			cls.ident = type.className;
			cls.name = localize("RESOURCE_CLASS_"+cls.ident);

			resources::resClasses.insertLast(cls);
			resources::classIdents.set(cls.ident, @cls);
		}

		@type.cls = cls;
		cls.types.insertLast(type);
	}

	//Calculate total pressure
	for(uint i = 0; i < TR_COUNT; ++i)
		type.totalPressure += type.tilePressure[i];
}

void saveIdentifiers(SaveFile& file) {
	for(uint i = 0, cnt = resources::resources.length; i < cnt; ++i) {
		ResourceType type = resources::resources[i];
		file.addIdentifier(SI_Resource, type.id, type.ident);
	}
}