starruler-linux/scripts/menu/new_game.as

import menus;
import elements.BaseGuiElement;
import elements.GuiButton;
import elements.GuiPanel;
import elements.GuiOverlay;
import elements.GuiSprite;
import elements.GuiText;
import elements.GuiTextbox;
import elements.GuiSpinbox;
import elements.GuiCheckbox;
import elements.GuiDropdown;
import elements.GuiContextMenu;
import elements.GuiIconGrid;
import elements.GuiEmpire;
import elements.GuiMarkupText;
import elements.MarkupTooltip;
import elements.GuiBackgroundPanel;
import dialogs.SaveDialog;
import dialogs.LoadDialog;
import dialogs.MessageDialog;
import dialogs.QuestionDialog;
import util.settings_page;
import empire_data;
import traits;
import icons;
from util.draw_model import drawLitModel;

import void showMultiplayer() from "multiplayer_menu";

from maps import Map, maps, mapCount, getMap;

import settings.game_settings;
import util.game_options;

const int EMPIRE_SETUP_HEIGHT = 96;
const int GALAXY_SETUP_HEIGHT = 200;

const int REC_MAX_PEREMP = 25;
const int REC_MAX_OPTIMAL = 150;
const int REC_MAX_BAD = 400;
const int REC_MAX_OHGOD = 1000;

const array<Color> QDIFF_COLORS = {Color(0x00ff00ff), Color(0x1197e0ff), Color(0xff0000ff)};
const array<string> QDIFF_NAMES = {locale::AI_DIFF_EASY, locale::AI_DIFF_NORMAL, locale::AI_DIFF_HARD};
const array<string> QDIFF_DESC = {locale::AI_DIFF_EASY_DESC, locale::AI_DIFF_NORMAL_DESC, locale::AI_DIFF_HARD_DESC};
const array<Sprite> QDIFF_ICONS = {Sprite(spritesheet::AIDifficulty, 0), Sprite(spritesheet::AIDifficulty, 1), Sprite(spritesheet::AIDifficulty, 2)};

NameGenerator empireNames;
bool empireNamesInitialized = false;

class ConfirmStart : QuestionDialogCallback {
	void questionCallback(QuestionDialog@ dialog, int answer) {
		if(answer == QA_Yes) {
			new_game.start();
			hideNewGame(true);
		}
	}
};

class NewGame : BaseGuiElement {
	GameSettings settings;

	GuiBackgroundPanel@ empireBG;
	GuiBackgroundPanel@ gameBG;
	GuiBackgroundPanel@ chatBG;

	GuiButton@ backButton;
	GuiButton@ inviteButton;
	GuiButton@ playButton;

	EmpirePortraitCreation portraits;

	int nextEmpNum = 1;
	GuiPanel@ empirePanel;
	EmpireSetup@[] empires;
	GuiButton@ addAIButton;

	GuiSkinElement@ gameHeader;
	GuiButton@ mapsButton;
	array<GuiButton@> settingsButtons;
	array<GuiPanel@> settingsPanels;
	GuiButton@ resetButton;

	GuiPanel@ galaxyPanel;
	GalaxySetup@[] galaxies;
	GuiButton@ addGalaxyButton;

	GuiPanel@ mapPanel;
	GuiText@ mapHeader;
	GuiListbox@ mapList;

	GuiPanel@ chatPanel;
	GuiMarkupText@ chatLog;
	GuiTextbox@ chatBox;

	bool animating = false;
	bool hide = false;
	bool fromMP = false;
	bool choosingMap = false;

	string chatMessages;

	NewGame() {
		super(null, recti());

		@empireBG = GuiBackgroundPanel(this, Alignment(
			Left+0.05f, Top+0.1f, Left+0.5f-6, Bottom-0.1f));
		empireBG.title = locale::MENU_EMPIRES;
		empireBG.titleColor = Color(0x00ffe9ff);

		@gameBG = GuiBackgroundPanel(this, Alignment(
			Left+0.5f+6, Top+0.1f, Left+0.95f, Bottom-0.1f));

		@gameHeader = GuiSkinElement(gameBG, Alignment(Left+1, Top+1, Right-2, Top+41), SS_FullTitle);

		@mapsButton = GuiButton(gameHeader, Alignment(Left, Top+1, Width=200, Height=38));
		mapsButton.text = locale::MENU_GALAXIES;
		mapsButton.buttonIcon = Sprite(material::SystemUnderAttack);
		mapsButton.toggleButton = true;
		mapsButton.font = FT_Medium;
		mapsButton.pressed = true;
		mapsButton.style = SS_TabButton;

		@chatBG = GuiBackgroundPanel(this, Alignment(
			Left+0.05f, Bottom-0.1f-250, Left+0.5f-6, Bottom-0.1f));
		chatBG.title = locale::CHAT;
		chatBG.titleColor = Color(0xff8000ff);
		chatBG.visible = false;

		//Empire list
		@empirePanel = GuiPanel(empireBG,
			Alignment(Left, Top+34, Right, Bottom-4));

		@addAIButton = GuiButton(empirePanel,
			recti_area(vec2i(), vec2i(200, 36)),
			locale::ADD_AI);
		addAIButton.buttonIcon = icons::Add;

		//Game settings
		for(uint i = 0, cnt = GAME_SETTINGS_PAGES.length; i < cnt; ++i) {
			auto@ panel = GuiPanel(gameBG,
				Alignment(Left, Top+46, Right, Bottom-40));
			panel.visible = false;
			settingsPanels.insertLast(panel);

			auto@ page = GAME_SETTINGS_PAGES[i];
			page.create(panel);

			auto@ button = GuiButton(gameHeader, Alignment(Left+200+(i*200), Top+1, Width=200, Height=38));
			button.text = page.header;
			button.buttonIcon = page.icon;
			button.toggleButton = true;
			button.pressed = false;
			button.font = FT_Medium;
			button.style = SS_TabButton;
			settingsButtons.insertLast(button);
		}

		@resetButton = GuiButton(gameBG, Alignment(Left+0.5f-120, Bottom-40, Width=240, Height=35), locale::NG_RESET);
		resetButton.color = Color(0xff8080ff);
		resetButton.buttonIcon = icons::Reset;
		resetButton.visible = false;

		//Galaxy list
		@galaxyPanel = GuiPanel(gameBG,
			Alignment(Left, Top+46, Right, Bottom-4));
		galaxyPanel.visible = false;

		@addGalaxyButton = GuiButton(galaxyPanel,
			recti_area(vec2i(), vec2i(260, 36)),
			locale::ADD_GALAXY);
		addGalaxyButton.buttonIcon = Sprite(spritesheet::CardCategoryIcons, 3);

		//Maps choice list
		@mapPanel = GuiPanel(gameBG,
			Alignment(Left, Top+46, Right, Bottom-4));
		mapPanel.visible = true;
		choosingMap = true;

		@mapHeader = GuiText(mapPanel, Alignment(Left, Top, Right, Top+30));
		mapHeader.font = FT_Medium;
		mapHeader.horizAlign = 0.5;
		mapHeader.stroke = colors::Black;
		mapHeader.text = locale::CHOOSE_MAP;

		@mapList = GuiListbox(mapPanel,
			Alignment(Left+4, Top+34, Right-4, Bottom-4));
		mapList.itemStyle = SS_DropdownListItem;
		mapList.itemHeight = 100;

		updateMapList();

		//Chat
		@chatPanel = GuiPanel(chatBG, Alignment(Left+8, Top+34, Right-8, Bottom-38));
		@chatLog = GuiMarkupText(chatPanel, recti_area(0, 0, 100, 100));
		@chatBox = GuiTextbox(chatBG, Alignment(Left+6, Bottom-36, Right-6, Bottom-6));

		//Actions
		@playButton = GuiButton(this, Alignment(
			Right-0.05f-200, Bottom-0.1f+6, Width=200, Height=46),
			locale::START_GAME);
		playButton.buttonIcon = Sprite(spritesheet::MenuIcons, 9);

		@backButton = GuiButton(this, Alignment(
			Left+0.05f, Bottom-0.1f+6, Width=200, Height=46),
			locale::BACK);
		backButton.buttonIcon = Sprite(spritesheet::MenuIcons, 11);

		@inviteButton = GuiButton(this, Alignment(
			Left+0.05f+208, Bottom-0.1f+6, Width=200, Height=46),
			locale::INVITE_FRIEND);
		inviteButton.buttonIcon = Sprite(spritesheet::MenuIcons, 13);
		inviteButton.visible = cloud::inLobby;

		updateAbsolutePosition();
	}

	void updateMapList() {
		mapList.clearItems();
		for(uint i = 0, cnt = mapCount; i < cnt; ++i) {
			auto@ mp = getMap(i);
			if(mp.isUnique) {
				bool found = false;
				for(uint i = 0, cnt = galaxies.length; i < cnt; ++i) {
					if(galaxies[i].mp.id == mp.id) {
						found = true;
						break;
					}
				}
				if(found)
					continue;
			}
			if(mp.isListed && !mp.isScenario && (mp.dlc.length == 0 || hasDLC(mp.dlc)))
				mapList.addItem(MapElement(mp));
		}
	}

	void init() {
		if(!empireNamesInitialized) {
			empireNames.read("data/empire_names.txt");
			empireNames.useGeneration = false;
			empireNamesInitialized = true;
		}

		portraits.reset();
		clearEmpires();
		addEmpire(true, getRacePreset(0));
		if(!mpServer && !fromMP) {
			addEmpire(false);
			addEmpire(false);
			RaceChooser(empires[0], true);
		}
		updateAbsolutePosition();

		switchPage(0);

		if(fromMP) {
			mapPanel.visible = false;
			galaxyPanel.visible = true;
			choosingMap = false;
		}
		else {
			mapPanel.visible = true;
			galaxyPanel.visible = false;
			choosingMap = true;
			updateMapList();
		}

		addGalaxyButton.visible = !fromMP;
		addAIButton.visible = !fromMP;
		chatMessages = "";

		if(fromMP) {
			playButton.text = locale::MP_NOT_READY;
			playButton.color = colors::Orange;
		}
		else {
			playButton.text = locale::START_GAME;
			playButton.color = colors::White;
		}
	}

	void addChat(const string& str) {
		chatMessages += str+"\n";
		bool wasBottom = chatPanel.vert.pos >= (chatPanel.vert.end - chatPanel.vert.page);
		chatLog.text = chatMessages;
		chatPanel.updateAbsolutePosition();
		if(wasBottom) {
			chatPanel.vert.pos = max(0.0, chatPanel.vert.end - chatPanel.vert.page);
			chatPanel.updateAbsolutePosition();
		}
	}

	void resetAIColors() {
		for(uint i = 0, cnt = empires.length; i < cnt; ++i) {
			auto@ setup = empires[i];
			if(setup.player)
				continue;
			setup.settings.color = colors::Invisible;
		}
		for(uint i = 0, cnt = empires.length; i < cnt; ++i) {
			auto@ setup = empires[i];
			if(setup.player)
				continue;
			setUniqueColor(setup);
		}
	}

	void resetAIRaces() {
		for(uint i = 0, cnt = empires.length; i < cnt; ++i) {
			auto@ setup = empires[i];
			if(setup.player)
				continue;
			setup.settings.raceName = "";
		}
		for(uint i = 0, cnt = empires.length; i < cnt; ++i) {
			auto@ setup = empires[i];
			if(setup.player)
				continue;
			setup.applyRace(getUniquePreset());
		}
	}

	RacePreset@ getUniquePreset() {
		uint index = randomi(0, getRacePresetCount() - 1);
		for(uint i = 0, cnt = getRacePresetCount(); i < cnt; ++i) {
			auto@ preset = getRacePreset((index+i) % cnt);
			if(preset.dlc.length != 0 && !hasDLC(preset.dlc))
				continue;
			bool has = false;
			for(uint n = 0, ncnt = empires.length; n < ncnt; ++n) {
				if(empires[n].settings.raceName == preset.name) {
					has = true;
					break;
				}
			}
			if(!has) {
				return preset;
			}
		}
		for(uint i = 0, cnt = getRacePresetCount(); i < cnt; ++i) {
			auto@ preset = getRacePreset((index+i) % cnt);
			if(preset.dlc.length != 0 && !hasDLC(preset.dlc))
				continue;
			return preset;
		}
		return getRacePreset(index);
	}

	void setUniqueColor(EmpireSetup@ setup) {
		bool found = false;
		Color setColor;
		for(uint i = 0, cnt = getEmpireColorCount(); i < cnt; ++i) {
			Color col = getEmpireColor(i).color;
			bool has = false;
			for(uint n = 0, ncnt = empires.length; n < ncnt; ++n) {
				if(empires[n] !is setup && empires[n].settings.color.color == col.color) {
					has = true;
					break;
				}
			}
			if(!has) {
				found = true;
				setColor = col;
				break;
			}
		}
		if(!found) {
			Colorf rnd;
			rnd.fromHSV(randomd(0, 360.0), randomd(0.5, 1.0), 1.0);
			setColor = Color(rnd);
		}
		setup.settings.color = setColor;
		setup.update();
	}

	void tick(double time) {
		if(mapIcons.length == 0) {
			mapIcons.length = mapCount;
			for(uint i = 0, cnt = mapCount; i < cnt; ++i) {
				auto@ mp = getMap(i);
				if(mp.isListed && !mp.isScenario && mp.icon.length != 0)
					mapIcons[i].load(mp.icon);
			}
		}
		inviteButton.visible = cloud::inLobby;
		addAIButton.disabled = empires.length >= 28;
		if(mpServer) {
			bool allReady = true;
			for(uint n = 0, ncnt = empires.length; n < ncnt; ++n) {
				auto@ emp = empires[n];
				if(emp.playerId != -1 && emp.playerId != CURRENT_PLAYER.id) {
					emp.found = false;
					if(!emp.settings.ready)
						allReady = false;
				}
			}

			array<Player@>@ players = getPlayers();
			for(uint i = 0, cnt = players.length; i < cnt; ++i) {
				Player@ pl = players[i];
				if(pl == CURRENT_PLAYER)
					continue;

				//Find if we already have an empire
				bool found = false;
				for(uint n = 0, ncnt = empires.length; n < ncnt; ++n) {
					auto@ emp = empires[n];
					if(emp.playerId == pl.id) {
						emp.found = true;
						found = true;
						if(pl.name.length != 0 && emp.name.text.length == 0)
							emp.name.text = pl.name;
					}
				}

				if(!found) {
					auto@ emp = addEmpire(false, getRacePreset(0));
					emp.name.text = pl.name;
					emp.address = pl.address;
					emp.setPlayer(pl.id);
				}
			}

			//Prune disconnected players
			for(uint n = 0, ncnt = empires.length; n < ncnt; ++n) {
				auto@ emp = empires[n];
				if(emp.playerId != -1 && !emp.found) {
					removeEmpire(emp);
					--n; --ncnt;
				}
			}

			//Update play button
			if(allReady)
				playButton.color = colors::Green;
			else
				playButton.color = colors::Orange;
		}
		else if(fromMP) {
			if(game_running) {
				hideNewGame(true);
				switchToMenu(main_menu, snap=true);
				return;
			}
			if(awaitingGalaxy) {
				hideNewGame(true);
				switchToMenu(main_menu, snap=true);
				showMultiplayer();
				return;
			}

			auto@ pl = findPlayer(CURRENT_PLAYER.id);
			if(pl !is null && pl.settings.ready) {
				playButton.text = locale::MP_READY;
				playButton.color = colors::Green;
			}
			else {
				playButton.text = locale::MP_NOT_READY;
				playButton.color = colors::Orange;
			}

			if(!mpIsConnected()) {
				message("Lost connection to server:\n    "
						+localize("DISCONNECT_"+uint(mpDisconnectReason)));

				hideNewGame(true);
				switchToMenu(main_menu, snap=true);
				showMultiplayer();
			}
		}
	}

	EmpireSetup@ addEmpire(bool player = false, const RacePreset@ preset = null) {
		if(empires.length >= 28)
			return null;
		uint y = empires.length * (EMPIRE_SETUP_HEIGHT + 8) + 8;
		EmpireSetup@ emp = EmpireSetup(this,
			Alignment(Left+4, Top+y, Right-4, Top+y + EMPIRE_SETUP_HEIGHT),
			player);
		portraits.randomize(emp.settings);
		if(player && settings::sNickname.length != 0)
			emp.name.text = settings::sNickname;
		else
			emp.name.text = "Empire "+(nextEmpNum++);
		if(preset is null) {
			if(player)
				@preset = getRacePreset(0);
			else
				@preset = getUniquePreset();
		}
		emp.defaultName = emp.name.text;
		addAIButton.position = vec2i((empirePanel.size.width - addAIButton.size.width)/2, y + EMPIRE_SETUP_HEIGHT + 4);
		emp.update();
		empires.insertLast(emp);
		empirePanel.updateAbsolutePosition();
		if(preset !is null)
			emp.applyRace(preset);
		else if(!player)
			emp.resetName();
		if(!player)
			setUniqueColor(emp);
		return emp;
	}

	EmpireSetup@ findPlayer(int id) {
		for(uint i = 0, cnt = empires.length; i < cnt; ++i) {
			if(empires[i].playerId == id)
				return empires[i];
		}
		return null;
	}

	void clearEmpires() {
		for(uint i = 0, cnt = empires.length; i < cnt; ++i)
			empires[i].remove();
		empires.length = 0;
		nextEmpNum = 2;
		updateEmpirePositions();
	}

	void removeEmpire(EmpireSetup@ emp) {
		emp.remove();
		empires.remove(emp);
		updateEmpirePositions();
	}

	void updateEmpirePositions() {
		uint cnt = empires.length;
		for(uint i = 0; i < cnt; ++i) {
			EmpireSetup@ emp = empires[i];
			emp.alignment.top.pixels = i * (EMPIRE_SETUP_HEIGHT + 8) + 8;
			emp.alignment.bottom.pixels = emp.alignment.top.pixels + EMPIRE_SETUP_HEIGHT;
			emp.updateAbsolutePosition();
		}
		addAIButton.position = vec2i((empirePanel.size.width - addAIButton.size.width)/2, cnt * (EMPIRE_SETUP_HEIGHT + 8) + 6);
	}

	GalaxySetup@ addGalaxy(Map@ mp) {
		uint y = galaxies.length * (GALAXY_SETUP_HEIGHT + 8) + 8;
		GalaxySetup@ glx = GalaxySetup(this,
			Alignment(Left+8, Top+y, Right-8, Top+y + GALAXY_SETUP_HEIGHT),
			mp);

		if(mp.eatsPlayers) {
			for(uint i = 0, cnt = galaxies.length; i < cnt; ++i)
				galaxies[i].setHomeworlds(false);
		}
		else {
			bool haveEating = false;
			for(uint i = 0, cnt = galaxies.length; i < cnt; ++i) {
				if(galaxies[i].mp.eatsPlayers) {
					haveEating = true;
				}
			}

			if(haveEating)
				glx.setHomeworlds(false);
		}

		addGalaxyButton.position = vec2i((galaxyPanel.size.width - addGalaxyButton.size.width)/2, y + GALAXY_SETUP_HEIGHT);
		galaxies.insertLast(glx);
		galaxyPanel.updateAbsolutePosition();
		updateGalaxyPositions();
		return glx;
	}

	void removeGalaxy(GalaxySetup@ glx) {
		glx.remove();
		galaxies.remove(glx);
		updateGalaxyPositions();

		if(glx.mp.eatsPlayers) {
			bool haveEating = false;
			for(uint i = 0, cnt = galaxies.length; i < cnt; ++i) {
				if(galaxies[i].mp.eatsPlayers) {
					haveEating = true;
				}
			}

			if(!haveEating) {
				for(uint i = 0, cnt = galaxies.length; i < cnt; ++i) {
					galaxies[i].setHomeworlds(true);
				}
			}
		}

		if(galaxies.length == 0) {
			mapHeader.text = locale::CHOOSE_MAP;
			mapPanel.visible = true;
			galaxyPanel.visible = false;
			choosingMap = true;
			updateMapList();
		}
	}

	void updateGalaxyPositions() {
		uint cnt = galaxies.length;
		for(uint i = 0; i < cnt; ++i) {
			GalaxySetup@ glx = galaxies[i];
			glx.alignment.top.pixels = i * (GALAXY_SETUP_HEIGHT + 8) + 8;
			glx.alignment.bottom.pixels = glx.alignment.top.pixels + GALAXY_SETUP_HEIGHT;
			glx.updateAbsolutePosition();
		}
		addGalaxyButton.position = vec2i((galaxyPanel.size.width - addGalaxyButton.size.width)/2, cnt * (GALAXY_SETUP_HEIGHT + 8) + 6);
		galaxyPanel.updateAbsolutePosition();
	}

	void apply() {
		apply(settings);
	}

	void reset() {
		uint newCnt = settings.empires.length;
		uint oldCnt = empires.length;
		for(uint i = newCnt; i < oldCnt; ++i) {
			removeEmpire(empires[i]);
			--i; --oldCnt;
		}
		for(uint i = 0; i < newCnt; ++i) {
			EmpireSetup@ setup;
			if(i >= oldCnt)
				@setup = addEmpire();
			else
				@setup = empires[i];
			auto@ sett = settings.empires[i];
			if(setup.playerId == sett.playerId
					&& setup.playerId == CURRENT_PLAYER.id) {
				if(setup.settings.delta > sett.delta)
					setup.apply(settings.empires[i]);
				else
					setup.load(settings.empires[i]);
			}
			else {
				setup.load(settings.empires[i]);
			}
		}
		updateEmpirePositions();

		newCnt = settings.galaxies.length;
		oldCnt = galaxies.length;
		for(uint i = newCnt; i < oldCnt; ++i) {
			removeGalaxy(galaxies[i]);
			--i; --oldCnt;
		}
		for(uint i = 0; i < newCnt; ++i) {
			GalaxySetup@ setup;
			if(i >= oldCnt)
				@setup = addGalaxy(getMap(settings.galaxies[i].map_id));
			else
				@setup = galaxies[i];
			setup.load(settings.galaxies[i]);
		}
		updateGalaxyPositions();

		for(uint i = 0, cnt = GAME_SETTINGS_PAGES.length; i < cnt; ++i)
			GAME_SETTINGS_PAGES[i].load(settings);

		addGalaxyButton.visible = !mpClient;
		addAIButton.visible = !mpClient;
	}

	void reset(GameSettings& settings) {
		this.settings = settings;
		reset();
	}

	void apply(GameSettings& settings) {
		uint empCnt = empires.length;
		settings.empires.length = empCnt;
		for(uint i = 0; i < empCnt; ++i) {
			settings.empires[i].index = i;
			empires[i].apply(settings.empires[i]);
		}

		uint glxCnt = galaxies.length;
		settings.galaxies.length = glxCnt;
		for(uint i = 0; i < glxCnt; ++i)
			galaxies[i].apply(settings.galaxies[i]);

		for(uint i = 0, cnt = GAME_SETTINGS_PAGES.length; i < cnt; ++i)
			GAME_SETTINGS_PAGES[i].apply(settings);
	}

	void start(){
		apply();

		Message msg;
		settings.write(msg);

		startNewGame(msg);
	}

	void switchPage(uint page) {
		mapsButton.pressed = page == 0;
		galaxyPanel.visible = page == 0 && !choosingMap;
		mapPanel.visible = page == 0 && choosingMap;
		if(mapPanel.visible)
			updateMapList();
		//if(page == 0)
		//	gameHeader.color = Color(0xff003fff);
		resetButton.visible = page != 0 && !mpClient;

		for(uint i = 0, cnt = settingsButtons.length; i < cnt; ++i) {
			settingsButtons[i].pressed = page == i+1;
			settingsPanels[i].visible = page == i+1;
			//if(page == i+1)
			//	gameHeader.color = GAME_SETTINGS_PAGES[i].color;
		}
	}

	bool onGuiEvent(const GuiEvent& event) {
		switch(event.type) {
			case GUI_Clicked:
				if(event.caller is playButton) {
					if(fromMP) {
						auto@ pl = findPlayer(CURRENT_PLAYER.id);
						if(pl !is null) {
							pl.settings.ready = !pl.settings.ready;
							pl.submit();
						}
					}
					else {
						if(mpServer) {
							bool allReady = true;
							for(uint n = 0, ncnt = empires.length; n < ncnt; ++n) {
								auto@ emp = empires[n];
								if(emp.playerId != -1 && emp.playerId != CURRENT_PLAYER.id) {
									if(!emp.settings.ready)
										allReady = false;
								}
							}

							if(!allReady) {
								question(locale::MP_CONFIRM_NOT_READY, ConfirmStart());
								return true;
							}
						}
						else {
							uint sysCount = 0;
							apply();
							for(uint i = 0, cnt = settings.galaxies.length; i < cnt; ++i)
								sysCount += settings.galaxies[i].systemCount * settings.galaxies[i].galaxyCount;
							uint empCount = empires.length;
							if(sysCount > REC_MAX_OHGOD) {
								question(locale::NG_WARN_OHGOD, ConfirmStart());
								return true;
							}
							else if(sysCount > REC_MAX_BAD) {
								question(locale::NG_WARN_BAD, ConfirmStart());
								return true;
							}
							else if(sysCount > REC_MAX_OPTIMAL) {
								question(locale::NG_WARN_OPTIMAL, ConfirmStart());
								return true;
							}
							else if(sysCount > REC_MAX_PEREMP * empCount) {
								question(locale::NG_WARN_PEREMP, ConfirmStart());
								return true;
							}
						}
						start();
						hideNewGame(true);
					}
					return true;
				}
				else if(event.caller is backButton) {
					if(!game_running)
						mpDisconnect();
					hideNewGame();
					return true;
				}
				else if(event.caller is inviteButton) {
					cloud::inviteFriend();
					return true;
				}
				else if(event.caller is addAIButton) {
					addEmpire();
					return true;
				}
				else if(event.caller is addGalaxyButton) {
					mapHeader.text = locale::ADD_GALAXY;
					mapPanel.visible = true;
					galaxyPanel.visible = false;
					updateMapList();
					choosingMap = true;
					return true;
				}
				else if(event.caller is resetButton) {
					for(uint i = 0, cnt = GAME_SETTINGS_PAGES.length; i < cnt; ++i) {
						if(settingsPanels[i].visible)
							GAME_SETTINGS_PAGES[i].reset();
					}
					return true;
				}
				else if(event.caller is mapsButton) {
					switchPage(0);
					return true;
				}
				else {
					for(uint i = 0, cnt = settingsButtons.length; i < cnt; ++i) {
						if(event.caller is settingsButtons[i]) {
							switchPage(i+1);
							return true;
						}
					}
				}
			break;
			case GUI_Confirmed:
				if(event.caller is chatBox) {
					string message = chatBox.text;
					if(message.length != 0)
						menuChat(message);
					chatBox.text = "";
				}
			break;
			case GUI_Changed:
				if(event.caller is mapList) {
					if(mapList.selected != -1)
						addGalaxy(cast<MapElement>(mapList.selectedItem).mp);
					if(galaxies.length != 0) {
						mapList.clearSelection();
						mapPanel.visible = false;
						galaxyPanel.visible = true;
						choosingMap = false;
					}
					return true;
				}
			break;
			case GUI_Animation_Complete:
				animating = false;
				return true;
		}

		return BaseGuiElement::onGuiEvent(event);
	}

	void updateAbsolutePosition() {
		if(!animating) {
			if(!hide) {
				size = parent.size;
				position = vec2i(0, 0);
			}
			else {
				size = parent.size;
				position = vec2i(size.x, 0);
			}
		}
		if(fromMP || mpServer) {
			chatBG.visible = true;
			chatLog.size = vec2i(chatPanel.size.width-20, chatLog.size.height);
			empireBG.alignment.bottom.pixels = 262;
		}
		else {
			chatBG.visible = false;
			empireBG.alignment.bottom.pixels = 0;
		}
		addAIButton.position = vec2i((empirePanel.size.width - addAIButton.size.width)/2, addAIButton.position.y);
		addGalaxyButton.position = vec2i((galaxyPanel.size.width - addGalaxyButton.size.width)/2, addGalaxyButton.position.y);
		BaseGuiElement::updateAbsolutePosition();
	}

	void animateIn() {
		animating = true;
		hide = false;

		rect = recti_area(vec2i(parent.size.x, 0), parent.size);
		animate_time(this, recti_area(vec2i(), parent.size), MSLIDE_TIME);
	}

	void animateOut() {
		animating = true;
		hide = true;

		rect = recti_area(vec2i(), parent.size);
		animate_time(this, recti_area(vec2i(parent.size.x, 0), parent.size), MSLIDE_TIME);
	}
};

void drawRace(const Skin@ skin, const recti& absPos, const string& name,
		const string& portrait, const array<const Trait@>@ traits = null, bool showTraits = true) {
	const Font@ normal = skin.getFont(FT_Normal);
	const Font@ bold = skin.getFont(FT_Bold);
	recti namePos = recti_area(absPos.topLeft + vec2i(8, 0), vec2i(absPos.width * 0.35, absPos.height));

	//Portrait
	auto@ prt = getEmpirePortrait(portrait);
	if(prt !is null) {
		prt.portrait.draw(recti_area(absPos.topLeft + vec2i(8, 0), vec2i(absPos.height, absPos.height)));
		namePos.topLeft.x += absPos.height+8;
	}

	//Race name
	bold.draw(pos=namePos, text=name);

	//FTL Method
	recti ftlPos = recti_area(absPos.topLeft + vec2i(absPos.width*0.35 + 16, 0),
			vec2i(absPos.width * 0.35, absPos.height));

	//Traits
	if(traits !is null) {
		recti pos = recti_area(vec2i(absPos.botRight.x - 32, absPos.topLeft.y + 3), vec2i(24, 24));
		for(uint i = 0, cnt = traits.length; i < cnt; ++i) {
			auto@ trait = traits[i];
			if(trait.unique == "FTL") {
				trait.icon.draw(recti_area(ftlPos.topLeft, vec2i(absPos.height, absPos.height)).aspectAligned(trait.icon.aspect));
				ftlPos.topLeft.x += absPos.height+8;
				normal.draw(text=trait.name, pos=ftlPos);
			}
			else if(showTraits) {
				traits[i].icon.draw(pos.aspectAligned(traits[i].icon.aspect));
				pos -= vec2i(24, 0);
			}
		}
	}
}

Color colorFromNumber(int num) {
	float hue = (num*26534371)%360;
	Colorf col;
	col.fromHSV(hue, 1.f, 1.f);
	return Color(col);
}

class RaceElement : GuiListElement {
	const RacePreset@ preset;

	RaceElement(const RacePreset@ preset) {
		@this.preset = preset;
	}

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) {
		drawRace(ele.skin, absPos, preset.name, preset.portrait, preset.traits);
	}
};

class CustomRaceElement : GuiListElement {
	const EmpireSettings@ settings;

	CustomRaceElement(const EmpireSettings@ settings) {
		@this.settings = settings;
	}

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) {
		drawRace(ele.skin, absPos, settings.raceName, settings.portrait, settings.traits);
	}
};

class CurrentRaceElement : GuiListElement {
	EmpireSettings@ settings;
	bool valid = true;

	CurrentRaceElement(EmpireSettings@ settings) {
		@this.settings = settings;
	}

	void update() {
		valid = settings.getTraitPoints() >= 0 && !settings.hasTraitConflicts();
	}

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) {
		if(!valid) {
			Color color(0xff0000ff);
			color.a = abs((frameTime % 1.0) - 0.5) * 2.0 * 255.0;
			ele.skin.draw(SS_Button, SF_Normal, absPos.padded(-5, -3), color);
		}
		drawRace(ele.skin, absPos, settings.raceName, settings.portrait, traits=settings.traits, showTraits=false);
	}
};

class CustomizeOption : GuiListElement {
	void draw(GuiListbox@ ele, uint flags, const recti& absPos) {
		const Font@ bold = ele.skin.getFont(FT_Bold);

		recti namePos = recti_area(absPos.topLeft + vec2i(8, 0), vec2i(absPos.width * 0.95, absPos.height));
		icons::Customize.draw(recti_area(absPos.topLeft + vec2i(8, 0), vec2i(absPos.height, absPos.height)));
		namePos.topLeft.x += absPos.height+8;

		bold.draw(pos=namePos, text=locale::CUSTOMIZE_RACE, color=Color(0xff8000ff));
	}
};

class TraitList : GuiIconGrid {
	array<const Trait@> traits;

	TraitList(IGuiElement@ parent, Alignment@ align) {
		super(parent, align);

		MarkupTooltip tt(350, 0.f, true, true);
		tt.Lazy = true;
		tt.LazyUpdate = false;
		tt.Padding = 4;
		@tooltipObject = tt;
	}

	uint get_length() override {
		return traits.length;
	}

	string get_tooltip() override {
		if(hovered < 0 || hovered >= int(length))
			return "";

		auto@ trait = traits[hovered];
		return format("[color=$1][b]$2[/b][/color]\n$3",
			toString(trait.color), trait.name, trait.description);
	}

	void drawElement(uint i, const recti& pos) override {
		traits[i].icon.draw(pos.aspectAligned(traits[i].icon.aspect));
	}
};

class ChangeWelfare : GuiContextOption {
	ChangeWelfare(const string& text, uint index) {
		value = int(index);
		this.text = text;
		icon = Sprite(spritesheet::ConvertIcon, index);
	}

	void call(GuiContextMenu@ menu) override {
		playerEmpire.WelfareMode = uint(value);
	}
};

const Sprite[] DIFF_SPRITES = {
	Sprite(material::HappyFace),
	Sprite(material::StatusPeace),
	Sprite(material::StatusWar),
	Sprite(material::StatusCeaseFire),
	Sprite(spritesheet::AttributeIcons, 3),
	Sprite(spritesheet::AttributeIcons, 0),
	Sprite(spritesheet::VoteIcons, 3),
	Sprite(spritesheet::VoteIcons, 3, colors::Red)
};

const Color[] DIFF_COLORS = {
	colors::Green,
	colors::White,
	colors::White,
	colors::White,
	colors::Orange,
	colors::Red,
	colors::Red,
	colors::Red
};

const string[] DIFF_TOOLTIPS = {
	locale::DIFF_PASSIVE,
	locale::DIFF_EASY,
	locale::DIFF_NORMAL,
	locale::DIFF_HARD,
	locale::DIFF_MURDEROUS,
	locale::DIFF_CHEATING,
	locale::DIFF_SAVAGE,
	locale::DIFF_BARBARIC,
};

class ChangeDifficulty : GuiMarkupContextOption {
	int level;
	EmpireSetup@ setup;

	ChangeDifficulty(EmpireSetup@ setup, int value, const string& text) {
		level = value;
		set(text);
		@this.setup = setup;
	}

	void call(GuiContextMenu@ menu) override {
		setup.settings.difficulty = level;
		setup.update();
	}
};

class ChangeTeam : GuiMarkupContextOption {
	int team;
	EmpireSetup@ setup;

	ChangeTeam(EmpireSetup@ setup, int value) {
		team = value;
		if(value >= 0)
			set(format("[b][color=$2]$1[/color][/b]", format(locale::TEAM_TEXT, toString(value)),
						toString(colorFromNumber(value))));
		else
			set(format("[b][color=#aaa]$1...[/color][/b]", locale::NO_TEAM));
		@this.setup = setup;
	}

	void call(GuiContextMenu@ menu) override {
		setup.settings.team = team;
		setup.submit();
	}
};

class Chooser : GuiIconGrid {
	Color spriteColor;
	array<Color> colors;
	array<Sprite> sprites;

	uint selected = 0;

	Chooser(IGuiElement@ parent, Alignment@ align, const vec2i& itemSize) {
		super(parent, align);
		horizAlign = 0.5;
		vertAlign = 0.0;
		iconSize = itemSize;
		updateAbsolutePosition();
	}

	void add(const Color& col) {
		colors.insertLast(col);
	}

	void add(const Sprite& sprt) {
		sprites.insertLast(sprt);
	}

	uint get_length() override {
		return max(colors.length, sprites.length);
	}

	void drawElement(uint index, const recti& pos) override {
		if(uint(selected) == index)
			drawRectangle(pos, Color(0xffffff30));
		if(uint(hovered) == index)
			drawRectangle(pos, Color(0xffffff30));
		if(index < colors.length)
			drawRectangle(pos.padded(5), colors[index]);
		if(index < sprites.length)
			sprites[index].draw(pos, spriteColor);
	}
};

class RaceChooser : GuiOverlay {
	EmpireSetup@ setup;
	GuiSkinElement@ panel;

	GuiText@ header;
	GuiPanel@ list;

	const RacePreset@ selectedRace;
	array<GuiButton@> presetButtons;
	array<const RacePreset@> racePresets;

	GuiSprite@ portrait;
	GuiSprite@ flag;
	GuiSprite@ bgDisplay;

	GuiPanel@ descScroll;
	GuiMarkupText@ description;

	GuiPanel@ loreScroll;
	GuiMarkupText@ lore;

	GuiButton@ playButton;
	GuiButton@ customizeButton;
	GuiButton@ loadButton;
	GuiButton@ backButton;
	bool isInitial;
	bool hasChosenRace = false;
	bool chosenShipset = false;

	Chooser@ flags;
	Chooser@ colors;
	ShipsetChooser@ shipsets;

	RaceChooser(EmpireSetup@ setup, bool isInitial = false) {
		@this.setup = setup;
		this.isInitial = isInitial;
		super(null);
		closeSelf = false;

		@panel = GuiSkinElement(this, Alignment(Left-4, Top+0.05f, Right+4, Bottom-0.05f), SS_Panel);

		@customizeButton = GuiButton(panel, Alignment(Right-232, Bottom-78, Width=220, Height=33));
		customizeButton.text = locale::CUSTOMIZE_RACE;
		customizeButton.setIcon(icons::Edit);

		@loadButton = GuiButton(panel, Alignment(Right-232, Bottom-78+33, Width=220, Height=33));
		loadButton.text = locale::LOAD_CUSTOM_RACE;
		loadButton.setIcon(icons::Load);

		int w = 250, h = 140;
		int off = max((size.width - (getRacePresetCount() * w)) / 2 - 20, 0);

		GuiSkinElement listBG(panel, Alignment(Left-4, Top+12, Right+4, Top+154), SS_PlainBox);

		@list = GuiPanel(panel, Alignment(Left+off, Top+12, Right-off, Top+174));
		updateAbsolutePosition();

		vec2i pos;
		uint curSelection = 0;
		for(uint i = 0, cnt = getRacePresetCount(); i < cnt; ++i) {
			auto@ preset = getRacePreset(i);
			if(preset.dlc.length != 0 && !hasDLC(preset.dlc))
				continue;

			racePresets.insertLast(preset);

			GuiButton btn(list, recti_area(pos.x, pos.y, w, h));
			btn.toggleButton = true;
			btn.style = SS_GlowButton;
			btn.pressed = i == 0;

			GuiSprite icon(btn, recti_area(2, 2, w*0.75, h-4));
			icon.horizAlign = 0.0;
			icon.vertAlign = 1.0;
			icon.desc = getSprite(preset.portrait);

			GuiText name(btn, recti_area(0, 0, w-4, h));
			name.font = FT_Big;
			name.stroke = colors::Black;
			name.text = preset.name;
			name.vertAlign = 0.4;
			name.horizAlign = 0.9;

			GuiSkinElement tagbar(btn, recti_area(1, h-28, w-3, 24), SS_PlainBox);
			tagbar.color = Color(0xffffff80);

			GuiText tagline(btn, recti_area(0, h-30, w-4, 24));
			tagline.font = FT_Italic;
			tagline.stroke = colors::Black;
			tagline.color = Color(0xaaaaaaff);
			tagline.text = preset.tagline;
			tagline.horizAlign = 1.0;

			TraitList traits(btn, Alignment(Left, Bottom-56, Right, Bottom-28));
			traits.iconSize = vec2i(24, 24);
			traits.horizAlign = 1.0;
			traits.fallThrough = true;
			traits.traits = preset.traits;

			if(preset.equals(setup.settings)) {
				curSelection = i;
				hasChosenRace = true;
			}

			if(!setup.player && !preset.aiSupport) {
				icon.saturation = 0.f;
				traits.visible = false;
				btn.disabled = true;
				btn.color = Color(0xffffffaa);
				name.color = Color(0xaa3030ff);

				setMarkupTooltip(btn, locale::AI_CANNOT_PLAY);
			}

			presetButtons.insertLast(btn);
			pos.x += w;
		}


		BaseGuiElement leftBG(panel, Alignment(Left+12, Top+174, Left+0.33f-6, Bottom-90));
		int y = 0;

		GuiSkinElement portBG(leftBG, Alignment(Left, Top+y, Right, Bottom), SS_PlainBox);

		@bgDisplay = GuiSprite(portBG, Alignment().padded(2), Sprite(getEmpireColor(setup.settings.color).background));
		bgDisplay.color = Color(0xffffff80);
		bgDisplay.stretchOutside = true;

		@portrait = GuiSprite(portBG, Alignment(Left+2, Top, Right-2, Height=232));
		portrait.horizAlign = 0.0;
		portrait.vertAlign = 1.0;

		@flag = GuiSprite(portBG, Alignment(Right-164, Top+4, Width=160, Height=160));
		flag.horizAlign = 1.0;
		flag.vertAlign = 0.0;
		flag.color = setup.settings.color;
		flag.color.a = 0xc0;
		flag.desc = getSprite(setup.settings.flag);

		y += 220 + 12;
		GuiSkinElement colBG(leftBG, Alignment(Left, Top+y, Right, Height=34), SS_PlainBox);
		@colors = Chooser(colBG, Alignment().padded(8, 0), vec2i(48, 32));
		for(uint i = 0, cnt = getEmpireColorCount(); i < cnt; ++i) {
			Color color = getEmpireColor(i).color;
			colors.add(color);
			if(color.color == setup.settings.color.color)
				colors.selected = i;
		}
		updateAbsolutePosition();

		y += 34 + 12;
		GuiSkinElement flagBG(leftBG, Alignment(Left, Top+y, Right, Height=110), SS_PlainBox);
		@flags = Chooser(flagBG, Alignment().padded(8, 0), vec2i(48, 48));
		flags.spriteColor = setup.settings.color;
		for(uint i = 0, cnt = getEmpireFlagCount(); i < cnt; ++i) {
			string flag = getSpriteDesc(Sprite(getEmpireFlag(i).flag));
			flags.add(getSprite(flag));
			if(flag == setup.settings.flag)
				flags.selected = i;
		}
		
		y += 110 + 12;
		GuiSkinElement shipsetBG(leftBG, Alignment(Left, Top+y, Right, Height=150), SS_PlainBox);
		@shipsets = ShipsetChooser(shipsetBG, Alignment().padded(8, 0), vec2i(160, 70));
		shipsets.selectedColor = setup.settings.color;
		shipsets.selected = 0;
		shipsets.horizAlign = 0.0;
		for(uint i = 0, cnt = getShipsetCount(); i < cnt; ++i) {
			auto@ ss = getShipset(i);
			if(ss.available && (ss.dlc.length == 0 || hasDLC(ss.dlc)))
				shipsets.add(ss);
			if(ss.ident == setup.settings.shipset)
				shipsets.selected = shipsets.length-1;
		}

		GuiSkinElement loreBox(panel, Alignment(Left+0.33f+6, Top+174, Left+0.66f-6, Bottom-90), SS_PlainBox);
		@loreScroll = GuiPanel(loreBox, Alignment().fill());
		@lore = GuiMarkupText(loreScroll, recti_area(12, 12, 376, 100));
		lore.fitWidth = true;

		GuiSkinElement descBox(panel, Alignment(Left+0.66f+6, Top+174, Right-12, Bottom-90), SS_PlainBox);
		@descScroll = GuiPanel(descBox, Alignment().fill());
		@description = GuiMarkupText(descScroll, recti_area(12, 12, 376, 100));
		description.fitWidth = true;

		@playButton = GuiButton(panel, Alignment(Left+0.5f-150, Bottom-78, Left+0.5f+150, Bottom-12));
		playButton.font = FT_Medium;
		playButton.color = Color(0x00c0ffff);

		@backButton = GuiButton(panel, Alignment(Left+12, Bottom-78, Left+220, Bottom-12), locale::BACK);
		backButton.font = FT_Medium;
		backButton.buttonIcon = icons::Back;

		selectRace(curSelection);
		updateAbsolutePosition();
		updateAbsolutePosition();
	}

	void updateAbsolutePosition() {
		if(shipsets !is null && shipsets.parent !is null)
			shipsets.parent.visible = screenSize.height >= 900;
		BaseGuiElement::updateAbsolutePosition();
	}

	void close() override {
		if(isInitial)
			return;
		GuiOverlay::close();
	}

	void selectRace(uint select) {
		for(uint i = 0, cnt = presetButtons.length; i < cnt; ++i)
			presetButtons[i].pressed = i == select;

		auto@ preset = racePresets[select];

		string desc;
		if(preset.isHard)
			desc += format("[font=Subtitle][color=#ffc000]$1[/color][/font]", locale::RACE_IS_HARD);
		for(uint i = 0, cnt = preset.traits.length; i < cnt; ++i) {
			if(desc.length != 0)
				desc += "\n\n";
			desc += format("[font=Medium]$1[/font][vspace=4/]\n[offset=20]", preset.traits[i].name);
			desc += preset.traits[i].description;
			desc += "[/offset]";
		}
		description.text = desc;

		string txt = format("[font=Big]$1[/font]\n", preset.name);
		txt += format("[right][font=Medium][color=#aaa]$1[/color][/font][/right]\n\n", preset.tagline);
		txt += preset.lore;
		lore.text = txt;

		if(isInitial)
			playButton.text = format(locale::PLAY_AS_RACE, preset.name);
		else
			playButton.text = format(locale::CHOOSE_A_RACE, preset.name);
		playButton.buttonIcon = getSprite(preset.portrait);

		portrait.desc = getSprite(preset.portrait);

		loreScroll.updateAbsolutePosition();
		descScroll.updateAbsolutePosition();
		@selectedRace = preset;

		if(!chosenShipset) {
			setup.settings.shipset = preset.shipset;
			for(uint i = 0, cnt = shipsets.length; i < cnt; ++i) {
				if(shipsets.items[i].ident == preset.shipset) {
					shipsets.selected = i;
					break;
				}
			}
		}
	}

	bool onGuiEvent(const GuiEvent& evt) {
		if(evt.type == GUI_Clicked) {
			if(evt.caller is flags) {
				uint sel = flags.hovered;
				if(sel != uint(-1)) {
					string sprt = getSpriteDesc(Sprite(getEmpireFlag(sel).flag));
					setup.settings.flag = sprt;
					flag.desc = getSprite(sprt);
					flags.selected = sel;
				}
				return true;
			}
			else if(evt.caller is colors) {
				uint sel = colors.hovered;
				if(sel != uint(-1)) {
					auto empCol = getEmpireColor(sel);
					Color col = empCol.color;
					setup.settings.color = col;
					bgDisplay.desc = Sprite(empCol.background);
					flag.color = col;
					flag.color.a = 0xc0;
					flags.spriteColor = col;
					shipsets.selectedColor = col;
					colors.selected = sel;
				}
				return true;
			}
			else if(evt.caller is shipsets) {
				uint sel = shipsets.hovered;
				if(sel != uint(-1)) {
					chosenShipset = true;
					setup.settings.shipset = shipsets.items[sel].ident;
					shipsets.selected = sel;
				}
				return true;
			}
			else if(evt.caller is customizeButton) {
				isInitial = false;
				if(hasChosenRace) {
					setup.applyRace(selectedRace);
					setup.submit();
				}
				setup.openRaceWindow();
				close();
				return true;
			}
			else if(evt.caller is backButton) {
				if(isInitial) {
					isInitial = false;
					new_game.backButton.emitClicked();
					close();
					return true;
				}
				close();
				return true;
			}
			else if(evt.caller is loadButton) {
				isInitial = false;
				LoadRaceDialog(null, setup.settings, setup);
				close();
				return true;
			}
			else if(evt.caller is playButton) {
				setup.applyRace(selectedRace);
				setup.submit();
				if(isInitial) {
					isInitial = false;
					setup.resetName();
					setup.ng.resetAIColors();
					setup.ng.resetAIRaces();
				}
				close();
				return true;
			}
			else {
				for(uint i = 0, cnt = presetButtons.length; i < cnt; ++i) {
					if(evt.caller.isChildOf(presetButtons[i])) {
						hasChosenRace = true;
						selectRace(i);
						return true;
					}
				}
			}
		}
		return GuiOverlay::onGuiEvent(evt);
	}
};

class EmpireSetup : BaseGuiElement, IGuiCallback {
	GuiButton@ portraitButton;
	GuiEmpire@ portrait;
	EmpireSettings settings;

	NewGame@ ng;
	GuiTextbox@ name;
	GuiButton@ removeButton;
	GuiText@ handicapLabel;
	GuiSpinbox@ handicap;
	GuiButton@ raceBox;
	GameAddress address;
	GuiButton@ colorButton;
	GuiButton@ flagButton;
	GuiButton@ difficulty;
	GuiButton@ aiSettings;
	GuiSprite@ aiIcon;
	GuiText@ aiText;
	GuiButton@ teamButton;
	GuiText@ raceName;
	GuiSprite@ raceFTLIcon;
	GuiText@ raceFTL;
	TraitList@ traitList;
	bool player;
	bool found = true;
	int playerId = -1;
	ChoosePopup@ popup;
	GuiSprite@ readyness;
	string defaultName;

	EmpireSetup(NewGame@ menu, Alignment@ align, bool Player = false) {
		super(menu.empirePanel, align);
		
		@portraitButton = GuiButton(this, Alignment(Left+8, Top+4, Left+EMPIRE_SETUP_HEIGHT, Bottom-4));
		portraitButton.style = SS_NULL;
		@portrait = GuiEmpire(portraitButton, Alignment().fill());
		@portrait.settings = settings;

		@ng = menu;
		@name = GuiTextbox(this, Alignment(Left+EMPIRE_SETUP_HEIGHT+8, Top+14, Right-310, Top+0.5f-4));
		name.font = FT_Subtitle;
		name.style = SS_HoverTextbox;
		name.selectionColor = Color(0xffffff40);

		@colorButton = GuiButton(this, Alignment(Right-302, Top+14, Width=50, Height=30));
		colorButton.style = SS_HoverButton;

		@flagButton = GuiButton(this, Alignment(Right-244, Top+14, Width=50, Height=30));
		flagButton.style = SS_HoverButton;

		@teamButton = GuiButton(this, Alignment(Right-186, Top+14, Width=50, Height=30));
		teamButton.style = SS_HoverButton;

		@difficulty = GuiButton(this, Alignment(Right-128, Top+14, Width=50, Height=30));
		difficulty.style = SS_HoverButton;
		difficulty.visible = false;

		@aiSettings = GuiButton(this, Alignment(Right-128, Top+10, Width=66, Height=38));
		aiSettings.style = SS_HoverButton;
		aiSettings.visible = false;

		@aiIcon = GuiSprite(aiSettings, Alignment().padded(1, 1, 1, 5));
		@aiText = GuiText(aiSettings, Alignment());
		aiText.horizAlign = 0.5;
		aiText.vertAlign = 0.2;
		aiText.font = FT_Small;
		aiText.stroke = colors::Black;

		@raceBox = GuiButton(this, Alignment(Left+EMPIRE_SETUP_HEIGHT+8, Top+0.5f+4, Right-8, Bottom-14));
		raceBox.style = SS_HoverButton;

		@raceName = GuiText(raceBox, Alignment(Left+8, Top, Left+0.35f, Bottom));
		raceName.font = FT_Bold;

		@raceFTLIcon = GuiSprite(raceBox, Alignment(Left+0.4f, Top, Left+0.4f+22, Bottom));
		@raceFTL = GuiText(raceBox, Alignment(Left+0.4f+26, Top, Right-0.3f, Bottom));

		@traitList = TraitList(raceBox, Alignment(Right-0.3f, Top+2, Right-30, Bottom));
		traitList.iconSize = vec2i(24, 24);
		traitList.horizAlign = 1.0;
		traitList.fallThrough = true;

		player = Player;
		@removeButton = GuiButton(this,
			Alignment(Right-50, Top, Right, Top+30));
		removeButton.color = colors::Red;
		removeButton.setIcon(icons::Remove);
		if(!player) {
			removeButton.visible = true;
			aiSettings.visible = true;
		}
		else {
			removeButton.visible = false;
			playerId = 1;
		}

		@readyness = GuiSprite(portrait, Alignment(Right-40, Bottom-40, Right, Bottom));
		readyness.visible = false;

		applyRace(getRacePreset(randomi(0, getRacePresetCount()-1)));
		updateAbsolutePosition();
	}

	void showDifficulties() {
		GuiContextMenu menu(mousePos);
		menu.itemHeight = 54;
		menu.addOption(ChangeDifficulty(this, 0, locale::DIFF_PASSIVE));
		menu.addOption(ChangeDifficulty(this, 1, locale::DIFF_EASY));
		menu.addOption(ChangeDifficulty(this, 2, locale::DIFF_NORMAL));
		menu.addOption(ChangeDifficulty(this, 3, locale::DIFF_HARD));
		menu.addOption(ChangeDifficulty(this, 4, locale::DIFF_MURDEROUS));
		menu.addOption(ChangeDifficulty(this, 5, locale::DIFF_CHEATING));
		menu.addOption(ChangeDifficulty(this, 6, locale::DIFF_SAVAGE));
		menu.addOption(ChangeDifficulty(this, 7, locale::DIFF_BARBARIC));

		menu.updateAbsolutePosition();
	}

	void showAISettings() {
		AIPopup popup(aiSettings, this);
		aiSettings.Hovered = false;
		aiSettings.Pressed = false;
	}

	void showTeams() {
		GuiContextMenu menu(mousePos);
		menu.itemHeight = 30;

		//Figure out how many distinct teams we have
		uint distinctTeams = 0;
		uint teamMask = 0;
		int maxTeam = 0;
		for(uint i = 0, cnt = ng.empires.length; i < cnt; ++i) {
			int team = ng.empires[i].settings.team;
			if(team < 0)
				continue;

			maxTeam = max(maxTeam, team);
			uint mask = 1<<(team-1);
			if(mask & teamMask == 0) {
				teamMask |= mask;
				++distinctTeams;
			}
		}

		//Add more teams than we currently have
		menu.addOption(ChangeTeam(this, -1));
		for(uint i = 1; i <= min(max(distinctTeams+5, maxTeam+1), 30); ++i)
			menu.addOption(ChangeTeam(this, i));

		menu.updateAbsolutePosition();
	}
	
	void forceAITraits(EmpireSettings& settings) {
		for(uint i = 0, cnt = settings.traits.length; i < cnt; ++i) {
			auto@ trait = settings.traits[i];
			if(!trait.aiSupport) {
				if(trait.unique.length == 0) {
					settings.traits.removeAt(i);
					--cnt; --i;
				}
				else {
					const Trait@ repl;
					uint replCount = 0;
					for(uint n = 0, ncnt = getTraitCount(); n < ncnt; ++n) {
						auto@ other = getTrait(n);
						if(other.unique == trait.unique && other.aiSupport && other.hasDLC) {
							replCount += 1;
							if(randomd() < 1.0 / double(replCount))
								@repl = other;
						}
					}

					if(repl !is null) {
						@settings.traits[i] = repl;
					}
					else {
						settings.traits.removeAt(i);
						--cnt; --i;
					}
				}
			}
		}
	}

	void applyRace(const RacePreset@ preset) {
		preset.apply(settings);
		if(!player) {
			forceAITraits(settings);
			if(defaultName == name.text)
				resetName();
		}
		update();
	}

	void applyRace(const EmpireSettings@ custom) {
		settings.copyRaceFrom(custom);
		if(!player) {
			forceAITraits(settings);
			if(defaultName == name.text)
				resetName();
		}
	}

	void resetName() {
		string race = settings.raceName;
		if(race.startswith_nocase("the "))
			race = race.substr(4);
		name.text = format(localize(empireNames.generate()), race);
		defaultName = name.text;
	}

	void setPlayer(int id) {
		player = id != -1;
		playerId = id;
		name.disabled = player || !mpClient;
		removeButton.visible = !mpClient && (!player || id != CURRENT_PLAYER.id);
		aiSettings.visible = !player;
		readyness.visible = player && id != 1;

		bool editable = id == CURRENT_PLAYER.id || (!mpClient && id == -1);
		raceBox.disabled = !editable;
		colorButton.disabled = !editable;
		flagButton.disabled = !editable;
		teamButton.disabled = !editable;
		aiSettings.disabled = !editable;
	}

	void openRaceWindow() {
		TraitsWindow win(this);
	}

	void update() {
		updateTraits();

		if(difficulty.visible) {
			difficulty.color = DIFF_COLORS[settings.difficulty];
			setMarkupTooltip(difficulty, locale::TT_DIFF+"\n"+DIFF_TOOLTIPS[settings.difficulty], width=300);
			if(difficulty.color.color != colors::White.color)
				difficulty.style = SS_Button;
			else
				difficulty.style = SS_HoverButton;
		}

		if(aiSettings.visible) {
			aiIcon.desc = QDIFF_ICONS[clamp(settings.difficulty, 0, 2)];
			aiText.color = QDIFF_COLORS[clamp(settings.difficulty, 0, 2)];
			aiText.text = getAIName(settings);
		}

		name.textColor = settings.color;
		raceName.text = settings.raceName;
		for(uint i = 0, cnt = settings.traits.length; i < cnt; ++i) {
			auto@ trait = settings.traits[i];
			if(trait.unique == "FTL") {
				raceFTLIcon.desc = trait.icon;
				raceFTL.text = trait.name;
			}
		}
	}

	void updateTraits() {
		traitList.traits.length = 0;
		for(uint i = 0, cnt = getTraitCount(); i < cnt; ++i) {
			auto@ trait = getTrait(i);
			if(settings.hasTrait(trait) && trait.unique != "FTL")
				traitList.traits.insertLast(trait);
		}
		if(settings.ready) {
			readyness.tooltip = locale::MP_PLAYER_READY;
			readyness.desc = icons::Ready;
		}
		else {
			readyness.tooltip = locale::MP_PLAYER_NOT_READY;
			readyness.desc = icons::NotReady;
		}
	}

	void submit() {
		if(mpClient)
			changeEmpireSettings(settings);
		if(!player)
			forceAITraits(settings);
		settings.delta += 1;
		update();
	}

	bool onGuiEvent(const GuiEvent& evt) {
		switch(evt.type) {
			case GUI_Clicked:
				if(evt.caller is removeButton) {
					if(player)
						mpKick(playerId);
					else
						ng.removeEmpire(this);
					return true;
				}
				else if(evt.caller is difficulty) {
					showDifficulties();
					return true;
				}
				else if(evt.caller is aiSettings) {
					showAISettings();
					return true;
				}
				else if(evt.caller is teamButton) {
					showTeams();
					return true;
				}
				else if(evt.caller is raceBox || evt.caller is portraitButton) {
					RaceChooser(this);
					raceBox.Hovered = false;
					return true;
				}
				else if(evt.caller is colorButton) {
					vec2i pos(evt.caller.absolutePosition.topLeft.x,
							evt.caller.absolutePosition.botRight.y);
					uint cnt = getEmpireColorCount();
					vec2i size(220, ceil(double(cnt)/4.0) * 38.0);
					@popup = ChoosePopup(pos, size, vec2i(48, 32));
					@popup.callback = this;
					popup.extraHeight = 60;
					ColorPicker picker(popup.overlay, recti_area(pos+vec2i(20,size.y+2), vec2i(size.x-40, 50)));
					@picker.callback = this;
					for(uint i = 0; i < cnt; ++i)
						popup.add(getEmpireColor(i).color);
					return true;
				}
				else if(evt.caller is flagButton) {
					vec2i pos(evt.caller.absolutePosition.topLeft.x,
							evt.caller.absolutePosition.botRight.y);
					uint cnt = getEmpireFlagCount();
					vec2i size(220, ceil(double(cnt)/4.0) * 52.0);
					@popup = ChoosePopup(pos, size, vec2i(48, 48));
					@popup.callback = this;
					popup.spriteColor = settings.color;
					for(uint i = 0; i < cnt; ++i)
						popup.add(Sprite(getEmpireFlag(i).flag));
					return true;
				}
				else if(evt.caller is popup) {

				}
			break;
			case GUI_Confirmed:
				if(evt.caller is popup) {
					if(popup.colors.length > 0)
						settings.color = getEmpireColor(evt.value).color;
					else if(popup.sprites.length > 0)
						settings.flag = getEmpireFlag(evt.value).flagDef;
					@popup = null;
					submit();
					return true;
				}
				if(cast<ColorPicker>(evt.caller) !is null) {
					settings.color = cast<ColorPicker>(evt.caller).picked;
					popup.remove();
					@popup = null;
					submit();
				}
			break;
		}
		return BaseGuiElement::onGuiEvent(evt);
	}

	void apply(EmpireSettings& es) {
		es = settings;
		es.name = name.text;
		es.playerId = playerId;

		if(player || playerId != -1)
			es.type = ET_Player;
		else if(es.type == ET_Player)
			es.type = ET_WeaselAI;
	}

	void load(EmpireSettings& es) {
		name.text = es.name;
		player = es.type == uint(ET_Player);
		setPlayer(es.playerId);
		settings = es;
		update();
	}

	void draw() {
		Color color = settings.color;

		skin.draw(SS_EmpireSetupItem, SF_Normal, AbsolutePosition.padded(-10, 0), color);
		BaseGuiElement::draw();

		if(colorButton.visible) {
			setClip(colorButton.absoluteClipRect);
			drawRectangle(colorButton.absolutePosition.padded(6), color);
		}

		auto@ flag = getEmpireFlag(settings.flag);
		if(flag !is null && flagButton.visible) {
			setClip(flagButton.absoluteClipRect);
			flag.flag.draw(recti_centered(flagButton.absolutePosition,
						vec2i(flagButton.size.height, flagButton.size.height)),
					color);
		}

		if(difficulty.visible) {
			setClip(difficulty.absoluteClipRect);
			DIFF_SPRITES[settings.difficulty].draw(recti_centered(difficulty.absolutePosition,
						vec2i(difficulty.size.height, difficulty.size.height)));
		}

		if(teamButton.visible) {
			setClip(teamButton.absoluteClipRect);
			if(settings.team >= 0) {
				material::TabDiplomacy.draw(recti_centered(teamButton.absolutePosition,
							vec2i(teamButton.size.height, teamButton.size.height)));
				skin.getFont(FT_Small).draw(
					pos=teamButton.absolutePosition,
					text=locale::TEAM,
					horizAlign=0.5, vertAlign=0.0,
					stroke=colors::Black,
					color=colors::White);
				skin.getFont(FT_Medium).draw(
					pos=teamButton.absolutePosition,
					text=toString(settings.team),
					horizAlign=0.5, vertAlign=1.0,
					stroke=colors::Black,
					color=colorFromNumber(settings.team));
			}
			else {
				shader::SATURATION_LEVEL = 0.f;
				material::TabDiplomacy.draw(recti_centered(teamButton.absolutePosition,
							vec2i(teamButton.size.height, teamButton.size.height)),
						Color(0xffffff80), shader::Desaturate);
			}
		}
	}
};

string getAIName(EmpireSettings& settings) {
	string text;
	text = QDIFF_NAMES[clamp(settings.difficulty, 0, 2)];

	if(settings.aiFlags & AIF_Passive != 0)
		text += "|";
	if(settings.aiFlags & AIF_Aggressive != 0)
		text += "@";
	if(settings.aiFlags & AIF_Biased != 0)
		text += "^";
	if(settings.aiFlags & AIF_CheatPrivileged != 0)
		text += "$";
	if(settings.type == ET_BumAI)
		text += "?";

	int cheatLevel = 0;
	if(settings.cheatWealth > 0)
		cheatLevel += ceil(double(settings.cheatWealth) / 10.0);
	if(settings.cheatStrength > 0)
		cheatLevel += settings.cheatStrength;
	if(settings.cheatAbundance > 0)
		cheatLevel += settings.cheatAbundance;

	if(cheatLevel > 0) {
		if(cheatLevel > 3)
			cheatLevel = 3;
		while(cheatLevel > 0) {
			text += "+";
			cheatLevel -= 1;
		}
	}

	return text;
}

class AIPopup : BaseGuiElement {
	GuiOverlay@ overlay;

	GuiListbox@ difficulties;

	GuiText@ behaveHeading;
	GuiText@ cheatHeading;

	EmpireSetup@ setup;

	GuiCheckbox@ aggressive;
	GuiCheckbox@ passive;
	GuiCheckbox@ biased;
	GuiCheckbox@ legacy;

	GuiCheckbox@ wealth;
	GuiSpinbox@ wealthAmt;
	GuiCheckbox@ strength;
	GuiSpinbox@ strengthAmt;
	GuiCheckbox@ abundance;
	GuiSpinbox@ abundanceAmt;
	GuiCheckbox@ privileged;

	GuiButton@ okButton;

	AIPopup(IGuiElement@ around, EmpireSetup@ setup) {
		@overlay = GuiOverlay(null);
		overlay.closeSelf = false;
		overlay.fade.a = 0;
		@this.setup = setup;

		recti pos = recti_area(
				vec2i(around.absolutePosition.botRight.x, around.absolutePosition.topLeft.y),
				vec2i(600, 200));
		if(pos.botRight.y > screenSize.y)
			pos += vec2i(0, screenSize.y - pos.botRight.y);
		if(pos.botRight.x > screenSize.x)
			pos += vec2i(screenSize.x - pos.botRight.x, 0);

		super(overlay, pos);
		updateAbsolutePosition();
		setGuiFocus(this);

		@difficulties = GuiListbox(this, Alignment(Left+4, Top+4, Left+250, Bottom-4));
		difficulties.required = true;
		difficulties.itemHeight = 64;

		for(uint i = 0; i < 3; ++i) {
			difficulties.addItem(GuiMarkupListText(
				format("[color=$1][font=Medium][stroke=#000]$2[/stroke][/font][/color]\n[color=#aaa][i]$3[/i][/color]",
					toString(QDIFF_COLORS[i]), QDIFF_NAMES[i], QDIFF_DESC[i])));
		}

		@behaveHeading = GuiText(this, Alignment(Left+260, Top+6, Left+260+170, Top+36));
		behaveHeading.font = FT_Medium;
		behaveHeading.stroke = colors::Black;
		behaveHeading.text = locale::AI_BEHAVIOR;

		pos = recti_area(vec2i(260, 36), vec2i(170, 30));

		@aggressive = GuiCheckbox(this, pos, locale::AI_AGGRESSIVE);
		setMarkupTooltip(aggressive, locale::AI_AGGRESSIVE_DESC);
		pos += vec2i(0, 30);

		@passive = GuiCheckbox(this, pos, locale::AI_PASSIVE);
		setMarkupTooltip(passive, locale::AI_PASSIVE_DESC);
		pos += vec2i(0, 30);

		@biased = GuiCheckbox(this, pos, locale::AI_BIASED);
		setMarkupTooltip(biased, locale::AI_BIASED_DESC);
		pos += vec2i(0, 30);

		@legacy = GuiCheckbox(this, pos, locale::AI_LEGACY);
		legacy.textColor = Color(0xaaaaaaff);
		legacy.visible = !hasDLC("Heralds");
		setMarkupTooltip(legacy, locale::AI_LEGACY_DESC);
		pos += vec2i(0, 30);

		@cheatHeading = GuiText(this, Alignment(Left+260+165, Top+6, Right-12, Top+36));
		cheatHeading.font = FT_Medium;
		cheatHeading.stroke = colors::Black;
		cheatHeading.text = locale::AI_CHEATS;

		pos = recti_area(vec2i(260+165, 36), vec2i(170, 30));

		@wealth = GuiCheckbox(this, recti_area(pos.topLeft, vec2i(110, 30)), locale::AI_WEALTH);
		setMarkupTooltip(wealth, locale::AI_WEALTH_DESC);
		@wealthAmt = GuiSpinbox(this, recti_area(pos.topLeft+vec2i(115, 0), vec2i(50, 30)), 10, 0, 1000, 1, 0);
		pos += vec2i(0, 30);

		@strength = GuiCheckbox(this, recti_area(pos.topLeft, vec2i(110, 30)), locale::AI_STRENGTH);
		setMarkupTooltip(strength, locale::AI_STRENGTH_DESC);
		@strengthAmt = GuiSpinbox(this, recti_area(pos.topLeft+vec2i(115, 0), vec2i(50, 30)), 1, 0, 100, 1, 0);
		pos += vec2i(0, 30);

		@abundance = GuiCheckbox(this, recti_area(pos.topLeft, vec2i(110, 30)), locale::AI_ABUNDANCE);
		setMarkupTooltip(abundance, locale::AI_ABUNDANCE_DESC);
		@abundanceAmt = GuiSpinbox(this, recti_area(pos.topLeft+vec2i(115, 0), vec2i(50, 30)), 1, 0, 100, 1, 0);
		pos += vec2i(0, 30);

		@privileged = GuiCheckbox(this, pos, locale::AI_PRIVILEGED);
		setMarkupTooltip(privileged, locale::AI_PRIVILEGED_DESC);
		pos += vec2i(0, 30);

		@okButton = GuiButton(this, Alignment(Left+260+135, Bottom-34, Width=70, Height=30), locale::OK);

		reset();
	}

	void reset() {
		difficulties.selected = clamp(setup.settings.difficulty, 0, 2);
		aggressive.checked = setup.settings.aiFlags & AIF_Aggressive != 0;
		passive.checked = setup.settings.aiFlags & AIF_Passive != 0;
		biased.checked = setup.settings.aiFlags & AIF_Biased != 0;
		privileged.checked = setup.settings.aiFlags & AIF_CheatPrivileged != 0;
		legacy.checked = setup.settings.type == ET_BumAI;
		if(legacy.checked)
			legacy.visible = true;

		wealth.checked = setup.settings.cheatWealth > 0;
		wealthAmt.visible = wealth.checked;
		if(wealth.checked)
			wealthAmt.value = setup.settings.cheatWealth;

		strength.checked = setup.settings.cheatStrength > 0;
		strengthAmt.visible = strength.checked;
		if(strength.checked)
			strengthAmt.value = setup.settings.cheatStrength;

		abundance.checked = setup.settings.cheatAbundance > 0;
		abundanceAmt.visible = abundance.checked;
		if(abundance.checked)
			abundanceAmt.value = setup.settings.cheatAbundance;
	}

	void apply() {
		uint flags = 0;
		if(aggressive.checked)
			flags |= AIF_Aggressive;
		if(passive.checked)
			flags |= AIF_Passive;
		if(biased.checked)
			flags |= AIF_Biased;
		if(privileged.checked)
			flags |= AIF_CheatPrivileged;

		if(legacy.checked)
			setup.settings.type = ET_BumAI;
		else
			setup.settings.type = ET_WeaselAI;

		wealthAmt.visible = wealth.checked;
		if(wealthAmt.visible)
			setup.settings.cheatWealth = wealthAmt.value;
		else
			setup.settings.cheatWealth = 0;

		strengthAmt.visible = strength.checked;
		if(strengthAmt.visible)
			setup.settings.cheatStrength = strengthAmt.value;
		else
			setup.settings.cheatStrength = 0;

		abundanceAmt.visible = abundance.checked;
		if(abundanceAmt.visible)
			setup.settings.cheatAbundance = abundanceAmt.value;
		else
			setup.settings.cheatAbundance = 0;

		setup.settings.difficulty = difficulties.selected;
		setup.settings.aiFlags = flags;
		setup.submit();
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.type == GUI_Changed) {
			if(evt.caller is passive) {
				if(passive.checked)
					aggressive.checked = false;
				apply();
				return true;
			}
			if(evt.caller is aggressive) {
				if(aggressive.checked)
					passive.checked = false;
				apply();
				return true;
			}
			apply();
		}
		if(evt.type == GUI_Clicked) {
			if(evt.caller is okButton) {
				apply();
				remove();
				return true;
			}
		}
		return BaseGuiElement::onGuiEvent(evt);
	}

	void remove() {
		overlay.remove();
		@overlay = null;
		BaseGuiElement::remove();
	}

	void draw() override {
		clearClip();
		skin.draw(SS_Panel, SF_Normal, AbsolutePosition);
		BaseGuiElement::draw();
	}
};

class ChoosePopup : GuiIconGrid {
	GuiOverlay@ overlay;
	int extraHeight = 0;

	Color spriteColor;
	array<Color> colors;
	array<Sprite> sprites;

	ChoosePopup(const vec2i& pos, const vec2i& size, const vec2i& itemSize) {
		@overlay = GuiOverlay(null);
		overlay.closeSelf = false;
		overlay.fade.a = 0;
		super(overlay, recti_area(pos, size));
		horizAlign = 0.5;
		vertAlign = 0.0;
		iconSize = itemSize;
		updateAbsolutePosition();
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.caller is this && evt.type == GUI_Clicked) {
			if(hovered != -1)
				emitConfirmed(uint(hovered));
			overlay.close();
			return true;
		}
		return GuiIconGrid::onGuiEvent(evt);
	}

	void remove() {
		overlay.remove();
		@overlay = null;
		GuiIconGrid::remove();
	}

	void add(const Color& col) {
		colors.insertLast(col);
	}

	void add(const Sprite& sprt) {
		sprites.insertLast(sprt);
	}

	uint get_length() override {
		return max(colors.length, sprites.length);
	}

	void drawElement(uint index, const recti& pos) override {
		if(uint(hovered) == index)
			drawRectangle(pos, Color(0xffffff30));
		if(index < colors.length)
			drawRectangle(pos.padded(5), colors[index]);
		if(index < sprites.length)
			sprites[index].draw(pos, spriteColor);
	}

	void draw() override {
		clearClip();
		skin.draw(SS_Panel, SF_Normal, AbsolutePosition.padded(0,0,0,-extraHeight));
		GuiIconGrid::draw();
	}
};

class ColorPicker : BaseGuiElement {
	Color picked;
	bool pressed = false;
	
	ColorPicker(IGuiElement@ parent, const recti& pos) {
		super(parent, pos);
		updateAbsolutePosition();
	}

	void draw() {
		shader::HSV_VALUE = 1.f;
		shader::HSV_SAT_START = 0.5f;
		shader::HSV_SAT_END = 1.f;
		drawRectangle(AbsolutePosition, material::HSVPalette, Color());
		if(AbsolutePosition.isWithin(mousePos)) {
			clearClip();
			recti area = recti_area(mousePos-vec2i(10), vec2i(20));
			drawRectangle(area.padded(-1), colors::Black);
			drawRectangle(area, getColor(mousePos-AbsolutePosition.topLeft));
		}
		BaseGuiElement::draw();
	}

	Color getColor(vec2i offset) {
		Colorf col;
		float hue = float(offset.x) / float(AbsolutePosition.width) * 360.f;
		float sat = (1.f - float(offset.y) / float(AbsolutePosition.height)) * 0.5f + 0.5f;
		col.fromHSV(hue, sat, 1.f);
		col.a = 1.f;
		return Color(col);
	}
	
	bool onMouseEvent(const MouseEvent& event, IGuiElement@ source) {
		if(event.type == MET_Button_Down || (event.type == MET_Moved && pressed)) {
			pressed = true;
			picked = getColor(mousePos - AbsolutePosition.topLeft);

			GuiEvent evt;
			@evt.caller = this;
			evt.type = GUI_Changed;
			onGuiEvent(evt);
			return true;
		}
		else if(pressed && event.type == MET_Button_Up) {
			pressed = false;
			emitConfirmed();
			return true;
		}
		return BaseGuiElement::onMouseEvent(event, source);
	}
};

class PortraitChooser : GuiIconGrid {
	array<Sprite> sprites;
	uint selected = 0;
	Color selectedColor;

	PortraitChooser(IGuiElement@ parent, Alignment@ align, const vec2i& itemSize) {
		super(parent, align);
		horizAlign = 0.5;
		vertAlign = 0.0;
		iconSize = itemSize;
		updateAbsolutePosition();
	}

	void add(const Sprite& sprt) {
		sprites.insertLast(sprt);
	}

	uint get_length() override {
		return sprites.length;
	}

	void drawElement(uint index, const recti& pos) override {
		if(selected == index)
			drawRectangle(pos, selectedColor);
		if(uint(hovered) == index)
			drawRectangle(pos, Color(0xffffff30));
		if(index < sprites.length)
			sprites[index].draw(pos);
	}
};

class ShipsetChooser : GuiIconGrid {
	array<const Shipset@> items;
	uint selected = 0;
	Color selectedColor;

	ShipsetChooser(IGuiElement@ parent, Alignment@ align, const vec2i& itemSize) {
		super(parent, align);
		horizAlign = 0.5;
		vertAlign = 0.0;
		iconSize = itemSize;
		updateAbsolutePosition();
	}

	void add(const Shipset@ shipset) {
		items.insertLast(shipset);
	}

	uint get_length() override {
		return items.length;
	}

	void drawElement(uint index, const recti& pos) override {
		if(selected == index) {
			Color col = selectedColor;
			col.a = 0x15;
			drawRectangle(pos, col);
		}
		if(uint(hovered) == index)
			drawRectangle(pos, Color(0xffffff15));
		if(index < items.length) {
			const Shipset@ shipset = items[index];
			const Hull@ hull = shipset.hulls[0];
			if(hull !is null) {
				quaterniond rot;
				rot = quaterniond_fromAxisAngle(vec3d_front(), -0.9);
				rot *= quaterniond_fromAxisAngle(vec3d_up(), 0.6);
				rot *= quaterniond_fromAxisAngle(vec3d_right(), -0.5);
				setClip(pos);
				Color lightColor = colors::White;
				if(selected == index) {
					NODE_COLOR = Colorf(selectedColor);
					lightColor = selectedColor;
				}
				else
					NODE_COLOR = Colorf(1.f, 1.f, 1.f, 1.f);
				drawLitModel(hull.model, hull.material, pos+vec2i(-4,0), rot, 1.9, lightColor=lightColor);
				clearClip();
			}

			const Font@ ft = skin.getFont(FT_Bold);
			if(selected == index || uint(hovered) == index)
				ft.draw(text=shipset.name, pos=pos.padded(0,4),
						horizAlign=0.5, vertAlign=0.0, stroke=colors::Black,
						color=(selected == index ? selectedColor : colors::White));
		}
	}
};

class WeaponSkinChooser : GuiIconGrid {
	array<const EmpireWeaponSkin@> items;
	uint selected = 0;
	Color selectedColor;

	WeaponSkinChooser(IGuiElement@ parent, Alignment@ align, const vec2i& itemSize) {
		super(parent, align);
		horizAlign = 0.5;
		vertAlign = 0.0;
		iconSize = itemSize;
		updateAbsolutePosition();
	}

	void add(const EmpireWeaponSkin@ it) {
		items.insertLast(it);
	}

	uint get_length() override {
		return items.length;
	}

	void drawElement(uint index, const recti& pos) override {
		if(selected == index) {
			Color col = selectedColor;
			col.a = 0x15;
			drawRectangle(pos, col);
		}
		if(uint(hovered) == index)
			drawRectangle(pos, Color(0xffffff15));
		if(index < items.length)
			items[index].icon.draw(pos);
	}
};

class TraitDisplay : BaseGuiElement {
	const Trait@ trait;
	GuiSprite@ icon;
	GuiMarkupText@ name;
	GuiMarkupText@ description;
	GuiText@ points;
	GuiText@ conflicts;
	GuiCheckbox@ check;
	bool hovered = false;
	bool conflict = false;

	TraitDisplay(IGuiElement@ parent) {
		super(parent, recti());

		@icon = GuiSprite(this, Alignment(Left+20, Top+12, Left+52, Bottom-12));

		@name = GuiMarkupText(this, Alignment(Left+65, Top+8, Right-168, Top+38));
		name.defaultFont = FT_Medium;
		name.defaultStroke = colors::Black;

		@description = GuiMarkupText(this, Alignment(Left+124, Top+34, Right-168, Bottom-8));

		@conflicts = GuiText(this, Alignment(Right-360, Top+8, Right-56, Bottom-8));
		conflicts.vertAlign = 0.1;
		conflicts.horizAlign = 1.0;

		@points = GuiText(this, Alignment(Right-160, Top+8, Right-56, Bottom-8));
		points.horizAlign = 1.0;
		points.font = FT_Subtitle;

		@check = GuiCheckbox(this, Alignment(Right-48, Top+0.5f-20, Right-8, Top+0.5f+20), "");
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		switch(evt.type) {
			case GUI_Mouse_Entered:
				hovered = true;
			break;
			case GUI_Mouse_Left:
				hovered = false;
			break;
			case GUI_Changed:
				if(evt.caller is check) {
					check.checked = !check.checked;
					emitClicked();
					return true;
				}
			break;
		}
		return BaseGuiElement::onGuiEvent(evt);
	}

	bool onMouseEvent(const MouseEvent& evt, IGuiElement@ caller) override {
		switch(evt.type) {
			case MET_Button_Down:
				if(evt.button == 0)
					return true;
			break;
			case MET_Button_Up:
				if(evt.button == 0) {
					emitClicked();
					return true;
				}
			break;
		}
		return BaseGuiElement::onMouseEvent(evt, caller);
	}

	void set(const Trait@ trait, bool selected, bool conflict) {
		@this.trait = trait;
		this.conflict = conflict;
		description.text = trait.description;
		icon.desc = trait.icon;
		name.defaultColor = trait.color;

		if(trait.gives > 0) {
			points.text = format(locale::RACE_POINTS_POS, toString(trait.gives));
			points.color = colors::Green;
			points.visible = true;
		}
		else if(trait.cost > 0) {
			points.text = format(locale::RACE_POINTS_NEG, toString(trait.cost));
			points.color = colors::Red;
			points.visible = true;
		}
		else {
			points.text = locale::RACE_POINTS_NEU;
			points.color = Color(0xaaaaaaff);
			points.visible = false;
		}

		bool displayConflicts = false;
		if(trait.conflicts.length > 0) {
			if(conflict) {
				conflicts.color = colors::Red;
				conflicts.font = FT_Bold;
				conflicts.vertAlign = 0.2;
			}
			else {
				conflicts.color = Color(0xaaaaaaff);
				conflicts.font = FT_Italic;
				conflicts.vertAlign = 0.1;
			}
			string str = locale::CONFLICTS+" ";
			for(uint i = 0, cnt = trait.conflicts.length; i < cnt; ++i) {
				if(!trait.conflicts[i].available)
					continue;
				if(i != 0)
					str += ", ";
				str += trait.conflicts[i].name;
				displayConflicts = true;
			}

			conflicts.text = str;
		}
		if(displayConflicts) {
			conflicts.visible = true;
			points.vertAlign = 0.7;
		}
		else {
			conflicts.visible = false;
			points.vertAlign = 0.5;
		}

		if(trait.unique.length != 0) {
			check.style = SS_Radiobox;
			if(description.alignment.right.pixels != 52) {
				description.alignment.right.pixels = 52;
				description.updateAbsolutePosition();
			}
		}
		else {
			check.style = SS_Checkbox;
			if(description.alignment.right.pixels != 168) {
				description.alignment.right.pixels = 168;
				description.updateAbsolutePosition();
			}
		}

		name.text = trait.name;
		check.checked = selected;
	}

	void draw() {
		if(check.checked)
			skin.draw(SS_Glow, SF_Normal, AbsolutePosition, trait.color);
		skin.draw(SS_Panel, SF_Normal, AbsolutePosition.padded(4), trait.color);
		if(hovered)
			drawRectangle(AbsolutePosition.padded(8), Color(0xffffff10));
		BaseGuiElement::draw();
	}
};

class SaveRaceDialog : SaveDialog {
	EmpireSettings settings;
	EmpireSetup@ setup;

	SaveRaceDialog(IGuiElement@ bind, EmpireSettings@ settings, EmpireSetup@ setup) {
		this.settings = settings;
		@this.setup = setup;
		super(bind, modProfile["races"], settings.raceName+".race");
	}

	void clickConfirm() override {
		exportRace(settings, path);
	}
};

class LoadRaceDialog : LoadDialog {
	EmpireSettings settings;
	EmpireSetup@ setup;
	TraitsWindow@ win;

	LoadRaceDialog(TraitsWindow@ win, EmpireSettings@ settings, EmpireSetup@ setup) {
		this.settings = settings;
		@this.setup = setup;
		@this.win = win;
		super(win, modProfile["races"]);
	}

	void clickConfirm() override {
		importRace(setup.settings, path);
		if(win !is null)
			win.update();
		setup.submit();
	}
};

class TraitElement : GuiListElement {
	const Trait@ trait;

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) {
		recti iconPos = recti_area(absPos.topLeft+vec2i(10, 5), vec2i(absPos.height-10, absPos.height-10));
		trait.icon.draw(iconPos);

		recti textPos = absPos.padded(absPos.height + 10, 0, 10, 4);
		ele.skin.getFont(FT_Medium).draw(
			text=trait.name, pos=textPos);
	}

	string get_tooltipText() {
		return format("[color=$1][b]$2[/b][/color]\n$3",
			toString(trait.color), trait.name, trait.description);
	}
};

class TraitsWindow : BaseGuiElement {
	GuiOverlay@ overlay;
	EmpireSetup@ setup;

	GuiBackgroundPanel@ bg;

	GuiListbox@ categories;
	array<const TraitCategory@> usedCategories;

	GuiPanel@ profilePanel;

	GuiText@ nameLabel;
	GuiTextbox@ name;

	GuiText@ portraitLabel;
	PortraitChooser@ portrait;

	GuiText@ shipsetLabel;
	ShipsetChooser@ shipset;

	GuiText@ weaponSkinLabel;
	WeaponSkinChooser@ weaponSkin;

	GuiText@ traitsLabel;
	GuiListbox@ traitList;

	GuiText@ pointsLabel;

	GuiPanel@ traitPanel;
	GuiText@ noTraits;
	array<TraitDisplay@> traits;

	GuiButton@ acceptButton;
	GuiButton@ saveButton;
	GuiButton@ loadButton;

	TraitsWindow(EmpireSetup@ setup) {
		@this.setup = setup;
		@overlay = GuiOverlay(null);
		overlay.closeSelf = false;
		super(overlay, Alignment(Left+0.11f, Top+0.11f, Right-0.11f, Bottom-0.11f));
		updateAbsolutePosition();

		@bg = GuiBackgroundPanel(this, Alignment().fill());
		bg.titleColor = Color(0xff8000ff);
		bg.title = locale::CUSTOMIZE_RACE;

		@categories = GuiListbox(bg, Alignment(Left+4, Top+32, Left+250, Bottom-4));
		categories.itemHeight = 44;
		categories.style = SS_PlainOverlay;
		categories.itemStyle = SS_TabButton;
		categories.addItem(GuiMarkupListText(locale::RACE_PROFILE));
		categories.required = true;

		for(uint i = 0, cnt = getTraitCategoryCount(); i < cnt; ++i) {
			auto@ cat = getTraitCategory(i);
			bool hasTraits = false;
			for(uint n = 0, ncnt = getTraitCount(); n < ncnt; ++n) {
				if(getTrait(n).category is cat && getTrait(n).available && getTrait(n).hasDLC) {
					hasTraits = true;
					break;
				}
			}
			if(hasTraits) {
				categories.addItem(GuiMarkupListText(cat.name));
				usedCategories.insertLast(cat);
			}
		}

		@acceptButton = GuiButton(bg, Alignment(Right-140, Bottom-40, Right-3, Bottom-3), locale::ACCEPT);
		@loadButton = GuiButton(bg, Alignment(Right-274, Bottom-40, Right-154, Bottom-3), locale::LOAD);
		@saveButton = GuiButton(bg, Alignment(Right-400, Bottom-40, Right-280, Bottom-3), locale::SAVE);
		@pointsLabel = GuiText(bg, Alignment(Left+264, Bottom-40, Right-410, Bottom-3));
		pointsLabel.font = FT_Medium;

		Alignment panelAlign(Left+258, Top+32, Right-4, Bottom-40);

		@profilePanel = GuiPanel(bg, panelAlign);
		@traitPanel = GuiPanel(bg, panelAlign);
		traitPanel.visible = false;

		int y = 8;

		@nameLabel = GuiText(profilePanel, Alignment(Left+12, Top+y, Left+200, Top+y+30), locale::RACE_NAME, FT_Bold);
		@name = GuiTextbox(profilePanel, Alignment(Left+200, Top+y, Right-12, Top+y+30), setup.settings.raceName);
		y += 38;

		int h = 80 + (getEmpirePortraitCount() / ((size.width - 200) / 70)) * 80;
		@portraitLabel = GuiText(profilePanel, Alignment(Left+12, Top+y, Left+200, Top+y+30), locale::PORTRAIT, FT_Bold);
		@portrait = PortraitChooser(profilePanel, Alignment(Left+200, Top+y, Right-12, Top+y+h), vec2i(70, 70));
		portrait.selectedColor = setup.settings.color;
		
		portrait.selected = randomi(0, getEmpirePortraitCount()-1);
		portrait.horizAlign = 0.0;
		for(uint i = 0, cnt = getEmpirePortraitCount(); i < cnt; ++i) {
			auto@ img = getEmpirePortrait(i);
			portrait.add(Sprite(img.portrait));
			if(img.ident == setup.settings.portrait)
				portrait.selected = i;
		}
		y += h+8;

		h = 80 + (getShipsetCount() / ((size.width - 200) / 150)) * 80;
		@shipsetLabel = GuiText(profilePanel, Alignment(Left+12, Top+y, Left+200, Top+y+30), locale::SHIPSET, FT_Bold);
		@shipset = ShipsetChooser(profilePanel, Alignment(Left+200, Top+y, Right-12, Top+y+h), vec2i(150, 70));
		shipset.selectedColor = setup.settings.color;
		shipset.selected = 0;
		shipset.horizAlign = 0.0;
		for(uint i = 0, cnt = getShipsetCount(); i < cnt; ++i) {
			auto@ ss = getShipset(i);
			if(ss.available && (ss.dlc.length == 0 || hasDLC(ss.dlc)))
				shipset.add(ss);
			if(ss.ident == setup.settings.shipset)
				shipset.selected = shipset.length-1;
		}
		y += h+8;

		@weaponSkinLabel = GuiText(profilePanel, Alignment(Left+12, Top+y, Left+200, Top+y+30), locale::WEAPON_SKIN, FT_Bold);
		@weaponSkin = WeaponSkinChooser(profilePanel, Alignment(Left+200, Top+y, Right-12, Top+y+80), vec2i(120, 70));
		weaponSkin.selectedColor = setup.settings.color;
		weaponSkin.selected = 0;
		weaponSkin.horizAlign = 0.0;
		for(uint i = 0, cnt = getEmpireWeaponSkinCount(); i < cnt; ++i) {
			auto@ skin = getEmpireWeaponSkin(i);
			weaponSkin.add(skin);
			if(skin.ident == setup.settings.effectorSkin)
				weaponSkin.selected = weaponSkin.length-1;
		}
		y += 88;

		@traitsLabel = GuiText(profilePanel, Alignment(Left+12, Top+y, Left+200, Top+y+30), locale::TRAITS, FT_Bold);
		@traitList = GuiListbox(profilePanel, Alignment(Left+200, Top+y, Right-12, Bottom-8));
		traitList.itemStyle = SS_StaticListboxItem;
		traitList.itemHeight = 50;
		addLazyMarkupTooltip(traitList);
		@noTraits = GuiText(profilePanel, Alignment(Left+240, Top+y+10, Right-12, Top+y+50), locale::NO_TRAITS);
		noTraits.color = Color(0xaaaaaaff);
		noTraits.vertAlign = 0.0;
		y += 58;

		update();
		updateAbsolutePosition();
	}

	void update() {
		int sel = categories.selected;
		profilePanel.visible = sel == 0;
		traitPanel.visible = sel != 0;

		uint index = 0;
		const TraitCategory@ cat;
		if(sel > 0)
			@cat = usedCategories[sel - 1];

		int points = STARTING_TRAIT_POINTS;
		for(uint i = 0, cnt = setup.settings.traits.length; i < cnt; ++i) {
			points += setup.settings.traits[i].gives;
			points -= setup.settings.traits[i].cost;
		}

		if(traitPanel.visible) {
			int y = 0;
			array<const Trait@> list;
			for(uint i = 0, cnt = getTraitCount(); i < cnt; ++i) {
				auto@ trait = getTrait(i);
				if(cat !is null && cat !is trait.category)
					continue;
				if(!setup.player && !trait.aiSupport)
					continue;
				if(!trait.available)
					continue;
				if(!trait.hasDLC)
					continue;
				list.insertLast(trait);
			}
			list.sortAsc();

			for(uint i = 0, cnt = list.length; i < cnt; ++i) {
				auto@ trait = list[i];
				TraitDisplay@ disp;
				if(index < traits.length) {
					@disp = traits[index];
				}
				else {
					@disp = TraitDisplay(traitPanel);
					traits.insertLast(disp);
				}

				disp.set(trait, setup.settings.hasTrait(trait), trait.hasConflicts(setup.settings.traits));
				disp.alignment.set(Left, Top+y, Right, Top+y+140);
				disp.updateAbsolutePosition();
				int needH = disp.description.renderer.height+48;
				if(needH != 140) {
					disp.alignment.set(Left, Top+y, Right, Top+y+needH);
					disp.updateAbsolutePosition();
				}

				++index;
				y += needH;
			}

			for(uint i = index, cnt = traits.length; i < cnt; ++i)
				traits[i].remove();
			traits.length = index;
			traitPanel.updateAbsolutePosition();
		}

		if(profilePanel.visible) {
			uint cnt = setup.settings.traits.length;
			traitList.removeItemsFrom(cnt);
			for(uint i = 0; i < cnt; ++i) {
				auto@ item = cast<TraitElement>(traitList.getItemElement(i));
				if(item is null) {
					@item = TraitElement();
					traitList.addItem(item);
				}

				@item.trait = setup.settings.traits[i];
			}
			noTraits.visible = cnt == 0;
		}

		if(points > 0) {
			pointsLabel.color = colors::Green;
			pointsLabel.text = format(locale::RACE_POINTS_AVAIL_POS, toString(points));
			pointsLabel.visible = true;
		}
		else if(points < 0) {
			pointsLabel.color = colors::Red;
			pointsLabel.text = format(locale::RACE_POINTS_AVAIL_NEG, toString(-points));
			pointsLabel.visible = true;
		}
		else {
			pointsLabel.color = Color(0xaaaaaaff);
			pointsLabel.text = format(locale::RACE_POINTS_AVAIL_POS, toString(points));
			pointsLabel.visible = false;
		}

		if(points >= 0 && !setup.settings.hasTraitConflicts())
			acceptButton.color = colors::Green;
		else
			acceptButton.color = colors::Red;
	}

	bool onGuiEvent(const GuiEvent& evt) override {
		if(evt.caller is acceptButton) {
			if(evt.type == GUI_Clicked) {
				overlay.close();
				return true;
			}
		}
		if(evt.caller is saveButton) {
			if(evt.type == GUI_Clicked) {
				SaveRaceDialog(this, setup.settings, setup);
				return true;
			}
		}
		else if(evt.caller is loadButton) {
			if(evt.type == GUI_Clicked) {
				LoadRaceDialog(this, setup.settings, setup);
				return true;
			}
		}
		if(evt.type == GUI_Clicked) {
			if(evt.caller is portrait) {
				int hov = portrait.hovered;
				if(hov >= 0) {
					setup.settings.portrait = getEmpirePortrait(hov).ident;
					portrait.selected = hov;
				}
				setup.submit();
				return true;
			}
			if(evt.caller is shipset) {
				int hov = shipset.hovered;
				if(hov >= 0) {
					setup.settings.shipset = shipset.items[hov].ident;
					shipset.selected = hov;
				}
				setup.submit();
				return true;
			}
			if(evt.caller is weaponSkin) {
				int hov = weaponSkin.hovered;
				if(hov >= 0) {
					setup.settings.effectorSkin = weaponSkin.items[hov].ident;
					weaponSkin.selected = hov;
				}
				setup.submit();
				return true;
			}
			
			auto@ disp = cast<TraitDisplay>(evt.caller);
			if(disp !is null) {
				if(disp.trait.unique.length != 0)
					setup.settings.chooseTrait(disp.trait);
				else if(setup.settings.hasTrait(disp.trait))
					setup.settings.removeTrait(disp.trait);
				else
					setup.settings.addTrait(disp.trait);
				update();
				setup.submit();
			}
		}
		if(evt.type == GUI_Changed) {
			if(evt.caller is name) {
				setup.settings.raceName = name.text;
				setup.submit();
				return true;
			}
			if(evt.caller is categories) {
				update();
				return true;
			}
		}
		return BaseGuiElement::onGuiEvent(evt);
	}

	void draw() override {
		BaseGuiElement::draw();
	}
};

class GalaxySetup : BaseGuiElement {
	Map@ mp;
	NewGame@ ng;
	GuiText@ name;

	GuiText@ timesLabel;
	GuiSpinbox@ timesBox;

	GuiPanel@ settings;

	GuiButton@ removeButton;
	GuiButton@ hwButton;
	GuiSprite@ hwX;

	GalaxySetup(NewGame@ menu, Alignment@ align, Map@ fromMap) {
		super(menu.galaxyPanel, align);
		@mp = fromMap.create();
		@ng = menu;

		@name = GuiText(this, Alignment(Left+6, Top+5, Right-262, Height=28));
		name.text = mp.name;
		name.font = FT_Medium;
		name.color = mp.color;
		name.stroke = colors::Black;

		@timesBox = GuiSpinbox(this, Alignment(Right-190, Top+7, Width=52, Height=22), 1.0);
		timesBox.min = 1.0;
		timesBox.max = 100.0;
		timesBox.decimals = 0;
		timesBox.color = Color(0xffffff60);

		@timesLabel = GuiText(this, Alignment(Right-135, Top+7, Width=25, Height=22), "x");

		timesBox.visible = !mp.isUnique;
		timesLabel.visible = !mp.isUnique;

		@removeButton = GuiButton(this, Alignment(Right-84, Top+4, Right-25, Top+34));
		removeButton.setIcon(icons::Remove);
		removeButton.color = colors::Red;

		@hwButton = GuiButton(this, Alignment(Right-230, Top+5, Width=26, Height=26));
		hwButton.setIcon(Sprite(spritesheet::PlanetType, 2, Color(0xffffffaa)), padding=0);
		hwButton.toggleButton = true;
		hwButton.pressed = false;
		hwButton.style = SS_IconButton;
		hwButton.color = Color(0xff0000ff);
		setMarkupTooltip(hwButton, locale::NGTT_MAP_HW);
		@hwX = GuiSprite(hwButton, Alignment(), Sprite(spritesheet::QuickbarIcons, 3, Color(0xffffff80)));
		hwX.visible = false;

		@settings = GuiPanel(this,
			Alignment(Left, Top+42, Right, Bottom-4));
		mp.create(settings);
	}

	void setHomeworlds(bool value) {
		hwButton.pressed = !value;
		hwX.visible = hwButton.pressed;
		if(hwButton.pressed)
			hwButton.fullIcon.color = Color(0xffffffff);
		else
			hwButton.fullIcon.color = Color(0xffffffaa);
	}

	void apply(MapSettings& set) {
		set.map_id = mp.id;
		set.galaxyCount = timesBox.value;
		@set.parent = ng.settings;
		set.allowHomeworlds = !hwButton.pressed;
		mp.apply(set);
	}

	void load(MapSettings& set) {
		auto@ _map = getMap(set.map_id);
		if(getClass(mp) !is getClass(_map))
			@mp = cast<Map>(getClass(_map).create());
		timesBox.value = set.galaxyCount;

		hwButton.pressed = !set.allowHomeworlds;
		hwX.visible = hwButton.pressed;
		if(hwButton.pressed)
			hwButton.fullIcon.color = Color(0xffffffff);
		else
			hwButton.fullIcon.color = Color(0xffffffaa);

		mp.load(set);
	}

	bool onGuiEvent(const GuiEvent& evt) {
		switch(evt.type) {
			case GUI_Clicked:
				if(evt.caller is removeButton) {
					ng.removeGalaxy(this);
					return true;
				}
				else if(evt.caller is hwButton) {
					setHomeworlds(!hwButton.pressed);
					return true;
				}
			break;
		}
		return BaseGuiElement::onGuiEvent(evt);
	}

	void draw() {
		recti bgPos = AbsolutePosition.padded(-5,0,-4,0);
		clipParent(bgPos);
		skin.draw(SS_GalaxySetupItem, SF_Normal, bgPos.padded(-4,0), mp.color);
		resetClip();
		auto@ icon = mapIcons[mp.index];
		if(mp.icon.length != 0 && icon.isLoaded(0)) {
			recti pos = AbsolutePosition.padded(0,42,0,0).aspectAligned(1.0, horizAlign=1.0, vertAlign=1.0);
			icon.draw(pos, Color(0xffffff80));
		}
		BaseGuiElement::draw();
	}
};

class MapElement : GuiListElement {
	Map@ mp;

	MapElement(Map@ _map) {
		@mp = _map;
	}

	void draw(GuiListbox@ ele, uint flags, const recti& absPos) override {
		const Font@ title = ele.skin.getFont(FT_Subtitle);
		const Font@ normal = ele.skin.getFont(FT_Normal);

		ele.skin.draw(SS_ListboxItem, flags, absPos, mp.color);
		auto@ icon = mapIcons[mp.index];
		if(mp.icon.length != 0 && icon.isLoaded(0)) {
			recti pos = absPos.aspectAligned(1.0, horizAlign=1.0, vertAlign=1.0);
			icon.draw(pos, Color(0xffffff80));
		}

		title.draw(pos=absPos.resized(0, 32).padded(12,4),
				text=mp.name, color=mp.color, stroke=colors::Black);
		normal.draw(pos=absPos.padded(12,36,12+absPos.height,0), offset=vec2i(),
				lineHeight=-1, text=mp.description, color=colors::White);
	}
};

class Quickstart : ConsoleCommand {
	void execute(const string& args) {
		new_game.start();
	}
};

NewGame@ new_game;
array<DynamicTexture> mapIcons;

void init() {
	@new_game = NewGame();
	new_game.visible = false;

	addConsoleCommand("quickstart", Quickstart());
}

array<Player@> connectedPlayers;
set_int connectedSet;
void tick(double time) {
	if(new_game.visible)
		new_game.tick(time);
	if(!game_running && mpServer) {
		array<Player@>@ players = getPlayers();

		//Send connect events
		for(uint i = 0, cnt = players.length; i < cnt; ++i) {
			Player@ pl = players[i];
			if(pl.id == CURRENT_PLAYER.id)
				continue;
			string name = pl.name;
			if(name.length == 0)
				continue;
			if(!connectedSet.contains(pl.id)) {
				string msg = format("[color=#aaa]* "+locale::MP_CONNECT_EVENT+"[/color]",
					format("[b]$1[/b]", bbescape(name)));
				recvMenuJoin(ALL_PLAYERS, msg);
				connectedPlayers.insertLast(pl);
				connectedSet.insert(pl.id);
			}
		}

		connectedSet.clear();
		for(uint i = 0, cnt = players.length; i < cnt; ++i)
			connectedSet.insert(players[i].id);

		//Send disconnect events
		for(uint i = 0, cnt = connectedPlayers.length; i < cnt; ++i) {
			if(!connectedSet.contains(connectedPlayers[i].id)) {
				Color color;
				string name = connectedPlayers[i].name;

				string msg = format("[color=#aaa]* "+locale::MP_DISCONNECT_EVENT+"[/color]", 
					format("[b]$2[/b]", toString(color), bbescape(name)));
				recvMenuLeave(ALL_PLAYERS, msg);
				connectedPlayers.removeAt(i);
				--i; --cnt;
			}
		}
	}
}

void showNewGame(bool fromMP = false) {
	new_game.visible = true;
	new_game.fromMP = fromMP;
	new_game.init();
	menu_container.visible = false;
	menu_container.animateOut();
	new_game.animateIn();
}

void hideNewGame(bool snap = false) {
	new_game.fromMP = false;
	menu_container.visible = true;
	if(!snap) {
		menu_container.animateIn();
		new_game.animateOut();
	}
	else {
		animate_remove(new_game);
		new_game.visible = false;
		menu_container.show();
	}
}

void changeEmpireSettings_client(Player& pl, EmpireSettings@ settings) {
	auto@ emp = new_game.findPlayer(pl.id);
	emp.settings.raceName = settings.raceName;
	emp.settings.traits = settings.traits;
	emp.settings.portrait = settings.portrait;
	emp.settings.shipset = settings.shipset;
	emp.settings.effectorSkin = settings.effectorSkin;
	emp.settings.color = settings.color;
	emp.settings.flag = settings.flag;
	emp.settings.ready = settings.ready;
	emp.settings.team = settings.team;
	emp.update();
}

bool sendPeriodic(Message& msg) {
	if(game_running)
		return false;
	new_game.apply();
	msg << new_game.settings;
	return true;
}

void recvPeriodic(Message& msg) {
	msg >> new_game.settings;
	new_game.reset();
	new_game.updateAbsolutePosition();
}

void chatMessage(Player& pl, string text) {
	auto@ emp = new_game.findPlayer(pl.id);
	Color color = emp.settings.color;
	string msg = format("[b][color=$1]$2[/color][/b] [offset=100]$3[/offset]",
		toString(color), bbescape(emp.name.text), bbescape(text));
	recvMenuChat(ALL_PLAYERS, msg);
}

void chatMessage_client(string text) {
	new_game.addChat(text);
	sound::generic_click.play();
}

void chatJoin_client(string text) {
	new_game.addChat(text);
	sound::generic_ok.play();
}

void chatLeave_client(string text) {
	new_game.addChat(text);
	sound::generic_warn.play();
}