AI Empire  Check-in [28693ba5f2]

Font: Small = DroidSans_8
Font: Normal = DroidSans_11
Font: Bold = DroidSans_11_Bold
Font: Italic = OpenSans_11_Italic
Font: Medium = DroidSans_16
Font: Big = DroidSans_20

Font: Subsys = DroidSans_11
Font: Name = GoodTimes_9
Font: Detail = DroidSans_8

Font: Title = GoodTimes_18
Font: Subtitle = DroidSans_14
Font: Button = DroidSans_11

Color: Text = #fff
Color: Selected = #a0000080
Color: Disabled = #888888ff

Color: ButtonText = #fff

// {{{ Generic Styles
Style: RoundedBox
	Element: Normal
		Rect: [3,3][182,39]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Hovered
		Rect: [3,43][182,79]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Active
		Rect: [3,83][182,119]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Hovered, Active
		Inherit: RoundedBox, Active

	Element: Disabled
		Rect: [195,343][374,379]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

Style: StraightBox
	Element: Normal
		Rect: [194,4][373,39]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Active
		Rect: [194,84][373,119]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Hovered
		Rect: [194,44][373,79]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Active, Hovered
		Rect: [194,124][373,159]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

Style: TinyBox
	Element: Normal
		Rect: [194,4][373,39]
		Margin: 2
		Vertical: Scaled
		Horizontal: Scaled

	Element: Hovered
		Rect: [194,84][373,119]
		Margin: 2
		Vertical: Scaled
		Horizontal: Scaled

Style: ItemBox
	Element: Normal
		Rect: [3,124][182,159]
		Margin: 4
		Vertical: Scaled
		Horizontal: Scaled

	Element: Hovered
		Rect: [3,164][182,199]
		Margin: 4
		Vertical: Scaled
		Horizontal: Scaled

	Element: Active
		Rect: [3,204][182,239]
		Margin: 4
		Vertical: Scaled
		Horizontal: Scaled

	Element: Hovered, Active
		Rect: [3,699][182,734]
		Margin: 4
		Vertical: Scaled
		Horizontal: Scaled

	Element: Disabled
		Rect: [3,124][182,159]
		Margin: 4
		Vertical: Scaled
		Horizontal: Scaled

		Add Gradient:
			TopLeft : #00000020
			TopRight: #00000020
			BotLeft : #00000020
			BotRight: #00000020

			GX1: 0
			GY1: 0
			GX2: 100%
			GY2: 100%

Style: InputBox
	Element: Normal
		Rect: [2,493][181,528]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Active
		Rect: [2,533][181,568]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Hovered
		Rect: [2,573][181,608]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Active, Hovered
		Rect: [2,613][181,648]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Disabled
		Rect: [2,653][181,692]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

Style: PlainBox
	Element: Normal
		Rect: [400,40][426,61]
		Margin: 2
		
		Horizontal: Scaled
		Vertical: Scaled

Style: PlainNameBox
	Element: Normal
		Rect: [429,42][459,56]
		Margin: 16,14
		Horizontal: Scaled

Style: HexPattern
	Element: Normal
		Rect: [390,11][412,36]
		Margin: 1
		Vertical: Tiled
		Horizontal: Tiled

Style: SmallHexPattern
	Element: Normal
		Rect: [390,40][395,56]
		Margin: 0
		Vertical: Tiled
		Horizontal: Tiled

Style: PatternBox
	Element: Normal
		Layer: PlainBox
		Layer: SmallHexPattern
			Color Override: #ffffff40
			OX1: +3
			OY1: +3
			OX2: -3
			OY2: -3

		GradientMode: Overlay
		Add Gradient:
			TopLeft : #4443
			TopRight: #4443
			BotLeft : #2221
			BotRight: #2221

			GX1: +3
			GY1: +3
			GX2: -3
			GY2: -3

Style: Panel
	Element: Normal
		Rect: [195,179][375,215]
		Margin: 6

		Vertical: Scaled
		Horizontal: Scaled

		Add Gradient:
			TopLeft : #1b1b1bff
			TopRight: #1b1b1bff
			BotLeft : #101010ff
			BotRight: #101010ff

			GX1: +4
			GY1: 50%
			GX2: -5
			GY2: -5

Style: HorizBar
	Element: Normal
		Rect: [205,221][365,257]
		Margin: 6

		Vertical: Scaled
		Horizontal: Scaled

Style: PlainOverlay
	Element: Normal
		Rect: [400,40][426,61]
		Margin: 2
		
		Horizontal: Scaled
		Vertical: Scaled

		Add Gradient:
			TopLeft : #1c1c1cff
			TopRight: #1c1c1cff
			BotLeft : #151515ff
			BotRight: #151515ff

			GX1: 1
			GY1: 1
			GX2: -1
			GY2: -1

	Element: Hovered
		Rect: [400,40][426,61]
		Margin: 2
		
		Horizontal: Scaled
		Vertical: Scaled

		Add Gradient:
			TopLeft : #2c2c2cff
			TopRight: #2c2c2cff
			BotLeft : #202020ff
			BotRight: #202020ff

			GX1: 1
			GY1: 1
			GX2: -1
			GY2: -1

	Element: Disabled
		Inherit: PlainOverlay, Normal

Style: OverlayBox
	Element: Normal
		Inherit: Panel
			
Style: LightPanel
	Element: Normal
		Rect: [195,221][375,257]
		Margin: 6

		Vertical: Scaled
		Horizontal: Scaled

Style: Highlight
	Element: Normal
		Rect: [5,740][182,773]
		Margin: 6

		Vertical: Scaled
		Horizontal: Scaled

Style: Glow
	Element: Normal
		Rect: [4,780][184,849]
		Margin: 10

		Vertical: Scaled
		Horizontal: Scaled

Style: SubtleGlow
	Element: Normal
		Rect: [4,854][184,922]
		Margin: 10

		Vertical: Scaled
		Horizontal: Scaled

Style: HighlightPanel
	Element: Normal
		Inherit: Panel, Normal

	Element: Hovered
		Inherit: Panel, Normal

		Add Gradient:
			TopLeft : #2c2c2c40
			TopRight: #2c2c2c40
			BotLeft : #20202040
			BotRight: #20202040

			GX1: 3
			GY1: 3
			GX2: -3
			GY2: -3

Style: RoundedTitle
	Element: Normal
		Rect: [195,264][393,294]
		Margin: 6, 6, 120, 6

		Horizontal: Scaled
		Vertical: Scaled

Style: CenterTitle
	Element: Normal
		Rect: [195,308][410,334]
		Margin: 90, 6

		Horizontal: Scaled
		Vertical: Scaled

Style: FullTitle
	Element: Normal
		Rect: [198,450][332,480]
		Margin: 6

		Horizontal: Scaled
		Vertical: Scaled

Style: PanelTitle
	Element: Normal
		Layer: FullTitle
			Color Override: #fff
			OX1: 0
			OY1: 0
			OX2: 100%
			OY2: 100%
		Layer: RoundedTitle
			OX1: 0
			OY1: 0
			OX2: 70%
			OY2: 100%

Style: WindowTitle
	Inherit: FullTitle

Style: SubTitle
	Element: Normal
		Rect: [201,487][327,517]
		Margin: 6

		Horizontal: Scaled
		Vertical: Scaled

Style: HorizAccent
	Element: Normal
		Rect: [197,385][302,439]
		Margin: 8

		Horizontal: Scaled
		Vertical: Scaled
// }}}
// {{{ Generic Parts
Style: DownArrow
	Element: Normal
		Rect: [443,6][455,19]

Style: UpArrow
	Element: Normal
		Rect: [457,6][470,19]
		
Style: RightArrow
	Element: Normal
		Rect: [429,6][441,19]

Style: LeftArrow
	Element: Normal
		Rect: [416,6][428,19]

Style: Field
	Inherit: PlainBox

Style: FieldName
	Inherit: PlainNameBox

Style: BG3D
	Element: Normal
		Rect: [202,526][446,636]

Style: ProgressBarBG
	Element: Normal
		Rect: [382,70][488,80]
		Margin: 6, 4
		Horizontal: Scaled
		Vertical: Scaled

Style: ProgressBar
	Element: Normal
		Rect: [383,83][487,91]
		Margin: 3, 4
		Horizontal: Scaled
		Vertical: Scaled

Style: DragHandle
	Element: Normal
		Inherit: ItemBox, Active

Style: ResizeHandle
	Element: Normal
		Inherit: ItemBox, Normal
	Element: Active
		Inherit: ItemBox, Active

Style: Checkmark
	Element: Normal
		Rect: [419,23][430,34]
// }}}
// {{{ Basic GUI Elements
Style: Button
	Inherit: RoundedBox

Style: BaselineButton
	Element: Normal
		Rect: [3,3][182,35]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Hovered
		Rect: [3,43][182,75]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Active
		Rect: [3,83][182,115]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

	Element: Hovered, Active
		Inherit: BaselineButton, Active

	Element: Disabled
		Rect: [195,343][374,375]
		Margin: 6
		Vertical: Scaled
		Horizontal: Scaled

Style: IconButton
	Element: Normal
	Element: Hovered
		Inherit: Highlight
	Element: Active
		Inherit: Highlight
	Element: Hovered,Active
		Inherit: Highlight

Style: IconToggle
	Element: Normal
	Element: Hovered
		Inherit: Highlight
	Element: Active
		Inherit: Highlight
		Layer: Button
	Element: Hovered,Active
		Inherit: Highlight
		Layer: Button

Style: Tab
	Inherit: Button

Style: PageTab
	Element: Normal
		Layer: Button
	Element: Hovered
		Layer: Button
		Layer: SubtleGlow
			Color Override: #ffffff
	Element: Active
		Layer: Button
		Layer: SubtleGlow

Style: Listbox

Style: ListboxItem
	Inherit: ItemBox

Style: StaticListboxItem
	Element: Normal
		Inherit: ItemBox, Normal

Style: DropdownList

Style: DropdownListItem
	Element: Normal
		Inherit: ItemBox

	Element: Hovered
		Inherit: ItemBox, Active

	Element: Active
		Inherit: ItemBox, Active

	Element: Active, Hovered
		Inherit: ItemBox, Active, Hovered

Style: Dropdown
	Inherit: RoundedBox

Style: DropdownArrow
	Element: Normal
		Layer: DownArrow
			OX1: +7
			OY1: +7
			OX2: -7
			OY2: -7

Style: Dialog
	Element: Normal
		Inherit: Panel

Style: Tooltip
	Element: Normal
		Rect: [2,454][181,489]
		Margin: 6

		Horizontal: Scaled
		Vertical: Scaled

Style: Textbox
	Inherit: InputBox

	Element: Focused
		Inherit: InputBox, Active

Style: HoverTextbox
	Element: Normal
	Element: Disabled
	Element: Disabled, Hovered
	Element: Hovered
		Inherit: InputBox
	Element: Focused
		Inherit: InputBox
	Element: Hovered, Focused
		Inherit: InputBox, Active

Style: HoverButton
	Element: Normal
	Element: Disabled
	Element: Disabled, Hovered
	Element: Active
		Inherit: Button, Active
	Element: Hovered
		Inherit: Button
	Element: Hovered, Active
		Inherit: Button, Active

Style: GlowButton
	Element: Normal
		Inherit: PlainBox
	Element: Hovered
		Layer: PlainBox
		Layer: Highlight
			Color Override: #00c0ff
	Element: Hovered, Disabled
		Inherit: PlainBox
	Element: Active
		GradientMode: Overlay
		Layer: PlainBox

		Add Gradient:
			TopLeft : #2228
			TopRight: #2228
			BotLeft : #00c0ff48
			BotRight: #00c0ff48

			GX1: 0
			GY1: 0
			GX2: 100%
			GY2: 100%
	Element: Active, Hovered
		Layer: GlowButton, Active
		Layer: Highlight
			Color Override: #00c0ff

Style: TabButton
	Element: Normal
		GradientMode: Overlay
		Layer: PlainBox

		Add Gradient:
			TopLeft : #4448
			TopRight: #4448
			BotLeft : #2228
			BotRight: #2228

			GX1: 1
			GY1: 1
			GX2: -1
			GY2: -1
	Element: Hovered
		GradientMode: Overlay
		Layer: TabButton, Normal
		Add Gradient:
			TopLeft : #fff0
			TopRight: #fff0
			BotLeft : #fff3
			BotRight: #fff3

			GX1: 1
			GY1: 1
			GX2: -1
			GY2: -1
	Element: Active
		GradientMode: Overlay
		Layer: PlainBox
			Color Override: #00c0ff

		Add Gradient:
			TopLeft : #2228
			TopRight: #2228
			BotLeft : #00c0ff48
			BotRight: #00c0ff48

			GX1: 1
			GY1: 1
			GX2: -1
			GY2: -1
	Element: Active, Hovered
		GradientMode: Overlay
		Layer: TabButton, Active
		Add Gradient:
			TopLeft : #fff0
			TopRight: #fff0
			BotLeft : #fff2
			BotRight: #fff2

			GX1: 1
			GY1: 1
			GX2: -1
			GY2: -1

Style: AccordionHeader
	Element: Normal
		Inherit: PatternBox

	Element: Hovered
		Inherit: PatternBox
		Layer: Highlight

	Element: Active
		Inherit: PatternBox

	Element: Hovered, Active
		Inherit: PatternBox
		Layer: Highlight

	Element: Disabled
		GradientMode: Overlay

		Add Gradient:
			TopLeft : #2221
			TopRight: #2221
			BotLeft : #4446
			BotRight: #4446

			GX1: 0
			GY1: 0
			GX2: 100%
			GY2: -2

		Add Gradient:
			TopLeft : #444f
			TopRight: #444f
			BotLeft : #444f
			BotRight: #444f

			GX1: 0
			GY1: -2
			GX2: 100%
			GY2: 100%

Style: BuildElement
	Element: Normal
		GradientMode: Overlay

		Add Gradient:
			TopLeft : #0000
			TopRight: #0000
			BotLeft : #2224
			BotRight: #2224

			GX1: 0
			GY1: 0
			GX2: 100%
			GY2: -1

		Add Gradient:
			TopLeft : #222f
			TopRight: #222f
			BotLeft : #222f
			BotRight: #222f

			GX1: 0
			GY1: -1
			GX2: 100%
			GY2: 100%

	Element: Hovered
		GradientMode: Overlay

		Add Gradient:
			TopLeft : #222a
			TopRight: #222a
			BotLeft : #444a
			BotRight: #444a

			GX1: 0
			GY1: 0
			GX2: 100%
			GY2: -1

		Add Gradient:
			TopLeft : #222f
			TopRight: #222f
			BotLeft : #222f
			BotRight: #222f

			GX1: 0
			GY1: -1
			GX2: 100%
			GY2: 100%

Style: SpinButton
	Inherit: TinyBox

Style: ContextMenu

Style: ContextMenuItem
	Element: Normal
		Inherit: ItemBox

	Element: Hovered
		Inherit: ItemBox, Active

	Element: Active
		Inherit: ItemBox, Active

	Element: Active, Hovered
		Inherit: ItemBox, Active

Style: Checkbox
	Element: Normal
		Inherit: ItemBox

	Element: Hovered
		Inherit: ItemBox, Hovered

	Element: Active
		Layer: ItemBox, Active

		Layer: Checkmark
			OX1: 4
			OY1: 0
			OX2: 100%
			OY2: -4

	Element: Active, Hovered
		Layer: ItemBox, Active, Hovered

		Layer: Checkmark
			OX1: 4
			OY1: 0
			OX2: 100%
			OY2: -4

Style: Radiobox
	Element: Normal
		Inherit: ItemBox

	Element: Hovered
		Inherit: ItemBox, Hovered

	Element: Active
		Layer: ItemBox

		Layer: ItemBox, Active
			OX1: 20%
			OY1: 20%
			OX2: -20%
			OY2: -20%

	Element: Active, Hovered
		Layer: ItemBox, Hovered

		Layer: ItemBox, Active
			OX1: 20%
			OY1: 20%
			OX2: -20%
			OY2: -20%

Style: ScrollVert
	Inherit: Panel

Style: ScrollVertHandle
	Element: Normal
		Inherit: StraightBox

	Element: Hovered
		Inherit: StraightBox, Hovered

	Element: Active
		Inherit: StraightBox, Active

Style: ScrollHoriz
	Inherit: Panel

Style: ScrollHorizHandle
	Element: Normal
		Inherit: StraightBox

	Element: Hovered
		Inherit: StraightBox, Hovered

	Element: Active
		Inherit: StraightBox, Active

Style: ScrollButton
	Inherit: Button

Style: ScrollUp
	Element: Normal
		Layer: ScrollButton
		Layer: UpArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4
	
	Element: Hovered
		Layer: ScrollButton, Hovered
		Layer: UpArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4	

	Element: Active
		Layer: ScrollButton, Active
		Layer: UpArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

Style: ScrollDown
	Element: Normal
		Layer: ScrollButton
		Layer: DownArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

	Element: Hovered
		Layer: ScrollButton, Hovered
		Layer: DownArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

	Element: Active
		Layer: ScrollButton, Active
		Layer: DownArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

Style: ScrollLeft
	Element: Normal
		Layer: ScrollButton
		Layer: LeftArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

	Element: Hovered
		Layer: ScrollButton, Hovered
		Layer: LeftArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

	Element: Active
		Layer: ScrollButton, Active
		Layer: LeftArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

Style: ScrollRight
	Element: Normal
		Layer: ScrollButton
		Layer: RightArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

	Element: Hovered
		Layer: ScrollButton, Hovered
		Layer: RightArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

	Element: Active
		Layer: ScrollButton, Active
		Layer: RightArrow
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

Style: DistributionBar
	Inherit: StraightBox

Style: DistributionElement
	Element: Normal
		GradientMode: Overlay
		Add Gradient:
			TopLeft : #bbb9
			TopRight: #bbb9
			BotLeft : #4449
			BotRight: #4449

			GX1: 0
			GY1: 0
			GX2: 100%
			GY2: 100%

Style: ChoiceBox
	Inherit: ItemBox

// }}}
// {{{ Tab Bar
Style: GameTabBar
	Element: Normal
		Rect: [1,400] [100,424]
		Margin: 0

		Vertical: Scaled
		Horizontal: Scaled

Style: GameTab
	Element: Normal
		Rect: [2,345] [86,371]
		Margin: 17, 0
		Horizontal: Scaled

	Element: Hovered
		Rect: [2,317] [86,343]
		Margin: 17, 0
		Horizontal: Scaled

	Element: Pressed
		Inherit: GameTab, Normal

	Element: Active
		Rect: [2,372] [86,398]
		AspectMargin: Horizontal
		Margin: 17,0
		Horizontal: Scaled

Style: GameTabClose
	Element: Normal
		Rect: [3,429][17,443]
		
	Element: Hovered
		Rect: [17,429][31,443]

	Element: Active
		Rect: [32,429][46,443]
		
		
Style: GameTabNew
	Element: Normal
		Rect: [138,350][169,369]
		Margin: 9
		Horizontal: Scaled

	Element: Hovered
		Rect: [106,350][136,369]
		Margin: 9
		Horizontal: Scaled
		
	Element: Active
		Rect: [138,373][169,392]
		Margin: 9
		Horizontal: Scaled
		
Style: HomeIcon
	Element: Normal
		Rect: [105, 300][136, 319]
		
	Element: Hovered
		Rect: [138, 300][169, 319]
		
	Element: Active
		Rect: [105, 324][136,343]
		
Style: GoIcon
	Element: Normal
		Rect: [105,253][136,272]

	Element: Hovered
		Rect: [138,253][169,272]

	Element: Active
		Rect: [105,277][136,296]		

Style: GalaxyIcon
	Element: Normal
		Rect: [132,428] [157,451]

		Vertical: Uniform
		Horizontal: Uniform

Style: PlanetIcon
	Inherit: GalaxyIcon

Style: SupportIcon
	Inherit: GalaxyIcon

Style: SystemIcon
	Inherit: GalaxyIcon

Style: DesignsIcon
	Element: Normal
		Rect: [94,429] [119,451]

		Vertical: Uniform
		Horizontal: Uniform

Style: ResearchIcon
	Element: Normal
		Rect: [62,428] [87,451]

		Vertical: Uniform
		Horizontal: Uniform

Style: GlobalBar
	Element: Normal
		Rect: [107,374] [136,425]
		Margin: 4

		Vertical: Scaled
		Horizontal: Scaled

		Add Gradient:
			TopLeft : #1b1b1b44
			TopRight: #1b1b1b44
			BotLeft : #00000044
			BotRight: #00000044

			GX1: 1
			GY1: 1
			GX2: -1
			GY2: -1

Style: GoDialog
	Element: Normal
		Inherit: Panel

Style: GoItem
	Element: Normal
		Inherit: ItemBox

	Element: Active
		Inherit: ItemBox, Active

	Element: Hovered
		Inherit: ItemBox, Hovered

	Element: Active, Hovered
		Inherit: ItemBox, Active, Hovered
// }}}
// {{{ Global Bar
Style: BudgetProgress
	Inherit: ProgressBarBG

Style: BudgetProgressBar
	Element: Normal
		Inherit: ProgressBar

Style: ResearchProgress
	Inherit: ProgressBarBG

Style: ResearchProgressBar
	Element: Normal
		Inherit: ProgressBar

Style: Notification
	Element: Normal
		Inherit: PlainBox

Style: TimeDisplay
	Element: Normal
		Inherit: PlainBox

		Layer: SmallHexPattern
			OX1: +3
			OY1: +3
			OX2: -3
			OY2: -3
// }}}
// {{{ AI Empire Tab
Style: AIEmpireBG
	Element: Normal
		Inherit: HexPattern

		Add Gradient:
			TopLeft : #333f
			TopRight: #333f
			BotLeft : #000e
			BotRight: #000e

			GX1: 0%
			GY1: 0%
			GX2: 100%
			GY2: 100%

Style: ResearchField
	Inherit: HighlightPanel
// }}}
// {{{ Research Tab
Style: ResearchBG
	Element: Normal
		Inherit: HexPattern

		Add Gradient:
			TopLeft : #212e
			TopRight: #212e
			BotLeft : #000e
			BotRight: #000e

			GX1: 0%
			GY1: 0%
			GX2: 100%
			GY2: 100%

Style: ResearchField
	Inherit: HighlightPanel
// }}}
// {{{ Design Tabs
Style: DesignOverviewBG
	Element: Normal
		Inherit: HexPattern

		Add Gradient:
			TopLeft : #112e
			TopRight: #112e
			BotLeft : #000e
			BotRight: #000e

			GX1: 0%
			GY1: 0%
			GX2: 100%
			GY2: 100%

Style: DesignClassHeader
	Element: Normal
		Inherit: PanelTitle

Style: DesignClass
	Element: Normal
		Inherit: Panel

Style: DesignBorder
	Element: Normal
		Inherit: Panel
	Element: Hovered
		Inherit: Panel

		Add Gradient:
			TopLeft : #1112
			TopRight: #1112
			BotLeft : #aaa2
			BotRight: #aaa2

			GX1: +4
			GY1: +4
			GX2: -4
			GY2: -4

	Element: Active
		Inherit: Panel

		Add Gradient:
			TopLeft : #fff3
			TopRight: #fff3
			BotLeft : #fff3
			BotRight: #fff3

			GX1: 0
			GY1: 0
			GX2: 100%
			GY2: +4

		Add Gradient:
			TopLeft : #fff3
			TopRight: #fff3
			BotLeft : #fff3
			BotRight: #fff3

			GX1: 0
			GY1: -4
			GX2: 100%
			GY2: 100%

		Add Gradient:
			TopLeft : #fff3
			TopRight: #fff3
			BotLeft : #fff3
			BotRight: #fff3

			GX1: 0
			GY1: +4
			GX2: +4
			GY2: -4

		Add Gradient:
			TopLeft : #fff3
			TopRight: #fff3
			BotLeft : #fff3
			BotRight: #fff3

			GX1: -4
			GY1: +4
			GX2: 100%
			GY2: -4

	Element: Hovered, Active
		Inherit: DesignBorder, Active

		Add Gradient:
			TopLeft : #1112
			TopRight: #1112
			BotLeft : #aaa2
			BotRight: #aaa2

			GX1: +4
			GY1: +4
			GX2: -4
			GY2: -4

Style: DesignGradient
	Element: Normal
		GradientMode: Overlay
		Add Gradient:
			TopLeft : #aaa3
			TopRight: #8883
			BotLeft : #8883
			BotRight: #2223

			GX1: 0
			GY1: 0
			GX2: 100%
			GY2: 100%

Style: DesignSummary
	Element: Normal
		Layer: DesignBorder, Normal
			Color Override: #fff
		Layer: DesignGradient
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4
		Layer: PlainBox
			OX1: 2
			OY1: -34
			OX2: -2
			OY2: -2

Style: DesignEditorBG
	Inherit: DesignOverviewBG

Style: DesignNavigationClass
	Inherit: LightPanel

Style: DesignNavigationIcon
	Inherit: RoundedBox

Style: ModuleButton
	Inherit: Button
// }}}
// {{{ Diplomacy Tabs
Style: DiplomacyBG
	Element: Normal
		Inherit: HexPattern

		Add Gradient:
			TopLeft : #121e
			TopRight: #121e
			BotLeft : #000e
			BotRight: #000e

			GX1: 0%
			GY1: 0%
			GX2: 100%
			GY2: 100%

Style: EmpireBox
	Element: Normal
		Layer: RoundedBox

		Layer: Panel
			Color Override: #fff
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4

Style: PlayerEmpireBox
	Inherit: EmpireBox

Style: DelegationBox
	Element: Normal
		Layer: RoundedBox
			Color Override: #fff
			OX1: 0
			OY1: 4
			OX2: 100%
			OY2: -4

		Layer: RoundedBox
			OX1: 0
			OY1: 0
			OX2: -46
			OY2: 100%

Style: VotingBox
	Element: Normal
		Inherit: PlainBox

Style: VoteTotal
	Element: Normal
		Layer: PlainBox

Style: InfluenceVoteBox
	Inherit: PatternBox

Style: TreatyBox
	Inherit: PatternBox

Style: InfluenceEffectBox
	Inherit: PatternBox
// }}}
// {{{ Planet Tab
Style: QueueBackground
	Inherit: SmallHexPattern

Style: ConstructionBox
	Inherit: Panel

Style: PlanetBox
	Element: Normal
		Layer: RoundedBox
			Color Override: #ffffff80

Style: PlanetElement
	Element: Normal
		Layer: Panel
			OX1: 0
			OY1: 0
			OX2: 100%
			OY2: 100%

		Layer: PlainBox
			OX1: +4
			OY1: +4
			OX2: -4
			OY2: -4
// }}}
// {{{ System Tab
Style: SystemListBG
	Element: Normal
		Inherit: HexPattern

		Add Gradient:
			TopLeft : #210e
			TopRight: #210e
			BotLeft : #000e
			BotRight: #000e

			GX1: 0%
			GY1: 0%
			GX2: 100%
			GY2: 100%

Style: SystemPanel
	Element: Normal
		Layer: Panel
			Color Override: #fff

		Layer: PanelTitle
			OX1: +1
			OY1: +1
			OX2: -2
			OY2: +31

Style: PlanetBar
	Element: Normal
		Inherit: PlainBox
			
// }}}
// {{{ Support Tab
Style: GroupPanel
	Inherit: Panel

Style: GroupSupportClass
	Inherit: PatternBox
// }}}
// {{{ Wiki Tab
Style: WikiBG
	Element: Normal
		Inherit: HexPattern

		Add Gradient:
			TopLeft : #211e
			TopRight: #211e
			BotLeft : #000e
			BotRight: #000e

			GX1: 0%
			GY1: 0%
			GX2: 100%
			GY2: 100%
// }}}
// {{{ Popups
Style: PopupBG
	Element: Normal
		Layer: Panel
			Color Override: #fff

		Layer: SubTitle
			OX1: +2
			OY1: +1
			OX2: -3
			OY2: 25

		Layer: BG3D
			OX1: +3
			OY1: +24
			OX2: -4
			OY2: -35

Style: ShipPopupBG
	Element: Normal
		Layer: Panel
			Color Override: #fff

		Layer: SubTitle
			OX1: +2
			OY1: +1
			OX2: -3
			OY2: 25

		Layer: BG3D
			OX1: +3
			OY1: +24
			OX2: -4
			OY2: -80

Style: GenericPopupBG
	Element: Normal
		Layer: Panel
			Color Override: #fff

		Layer: SubTitle
			OX1: +2
			OY1: +1
			OX2: -3
			OY2: 25

		Layer: BG3D
			OX1: +3
			OY1: +24
			OX2: -4
			OY2: -4

Style: SelectablePopup
	Inherit: PopupBG

Style: ManageButton
	Element: Normal
		Rect: [203,644][280,664]
// }}}
// {{{ Info Bar
Style: InfoBar
	Element: Normal
		Inherit: PlainBox

Style: InfoBarPlain
	Element: Normal
		Layer: Panel
			Color Override: #fff
			OX1: 0
			OY1: 0
			OX2: 100%
			OY2: 130%
// }}}
// {{{ Main Menu
Style: MapSelectorItem
	Element: Normal
		Inherit: Panel

	Element: Hovered
		Inherit: Panel, Active

Style: EmpireSetupItem
	Element: Normal
		Layer: Panel
			OX1: 0
			OY1: 0
			OX2: 100%
			OY2: 100%

Style: GalaxySetupItem
	Element: Normal
		Layer: PatternBox
			OX1: 0
			OY1: 0
			OX2: 100%
			OY2: 100%
		Layer: Panel
			OX1: 0
			OY1: 0
			OX2: 100%
			OY2: 40

Style: MainMenuPanel
	Element: Normal
		Layer: Panel
			Color Override: #ffffffff

Style: MainMenuDescPanel
	Inherit: MainMenuPanel

Style: MainMenuItem
	Element: Normal
	Element: Hovered
		Inherit: ItemBox, Active
	Element: Active
		Inherit: PlainBox, Normal

		Add Gradient:
			TopLeft : #aa444440
			TopRight: #aa444440
			BotLeft : #aa444440
			BotRight: #aa444440

			GX1: 0
			GY1: 0
			GX2: 100%
			GY2: 100%

	Element: Hovered, Active
		Inherit: ItemBox, Active
// }}}

	Name: AI Empire
	Compatibility: 200
	Description: <<
		Forces the AI on for player Empires, allows configuration of player AI (difficulty, cheats) at the new game screen, and allows runtime configuration of what roles the AI manages.

		[h1]Current version: 0.4.3[/h1]

		[h1][b]Defects[/b][/h1]
		- I'm having a lot of trouble preventing all the construction that the AI wants to do. In particular it buys a factory right away and it'll fill up fleets for you.
		- The tab UI hasn't gotten a lot of love yet.
		- This probably doesn't save/load well.
		- This probably doesn't work with multiplayer well.

		[h1][b]Changelog[/b][/h1]
		- 0.4.3 - clean up the UI a bit. controllable: scuttling.
		- 0.4.2 - controllable: artifact use
		- 0.4.1 - controls are now also in AI's race and FTL components
		- 0.4.0 - controllable: construction. 'diplomacy' now includes treaties and war/peace declarations.
			- controllable: scouting and also (Anomaly Resolution) whether scouts will decide for themselves which option to pick after scanning an anomaly.
		- 0.3.3 - minor fixes, depend on Missing Expansion rather than directly on the community patch
		- 0.3.0 - added 'prevent achievements' button. Doesn't turn cheats on, but flags game as having ever had cheats on.
		- 0.2.0 - first version with AI controls
			  - 'AI Empire' tab added
			  - controllable: diplomacy, colonization, remnant hunting, research
		    also, defense of systems and attacks on enemy systems when at war
		  - all disabled initially
		- 0.1.0 - initial version, AI is on for player but you have no control over it
	>>
	Derives From: Missing Expansion
	Override: scripts/menu/new_game.as
	Override: scripts/server/empire_ai/EmpireAI.as
	Override: scripts/server/empire_ai/weasel
	Override: scripts/server/cheats.as
	Override: data/skin definitions/default.txt

import tabs.Tab;
import elements.GuiButton;
import elements.GuiPanel;
import elements.GuiMarkupText;
import icons;
from tabs.tabbar import newTab, switchToTab;

const Color colorForbidden = Color(0xaaaaaaff);
const Color colorAllowed = colors::Energy;

Tab@ createAIEmpireTab() {
        return AIEmpireTab();
}

void init() {
	Tab@ tab = createAIEmpireTab();
	newTab(tab);
	cheatCommandAI(playerEmpire, "forbid all");
}

class AIEmpireTab : Tab {
	GuiPanel@ panel;
	GuiButton@ forbidDiplomacyButton;
	GuiMarkupText@ forbidDiplomacyText;
	bool forbidDiplomacy;
	GuiButton@ forbidColonizationButton;
	GuiMarkupText@ forbidColonizationText;
	bool forbidColonization;
	GuiButton@ forbidCreepingButton;
	GuiMarkupText@ forbidCreepingText;
	bool forbidCreeping;
	GuiButton@ forbidResearchButton;
	GuiMarkupText@ forbidResearchText;
	bool forbidResearch;
	GuiButton@ forbidDefenseButton;
	GuiMarkupText@ forbidDefenseText;
	bool forbidDefense;
	GuiButton@ forbidAttackButton;
	GuiMarkupText@ forbidAttackText;
	bool forbidAttack;
	GuiButton@ forbidConstructionButton;
	GuiMarkupText@ forbidConstructionText;
	bool forbidConstruction;
	GuiButton@ forbidScoutingButton;
	GuiMarkupText@ forbidScoutingText;
	bool forbidScouting;
	GuiButton@ forbidAnomalyChoiceButton;
	GuiMarkupText@ forbidAnomalyChoiceText;
	bool forbidAnomalyChoice;
	GuiButton@ forbidArtifactButton;
	GuiMarkupText@ forbidArtifactText;
	bool forbidArtifact;
	GuiButton@ forbidScuttleButton;
	GuiMarkupText@ forbidScuttleText;
	bool forbidScuttle;
	GuiButton@ preventAchievementsButton;
	GuiMarkupText@ preventAchievementsText;
	bool preventAchievements;

	GuiButton@ enableAIButton;
	GuiMarkupText@ enableAIText;
	GuiButton@ disableAIButton;
	GuiMarkupText@ disableAIText;

	AIEmpireTab() {
		super();
		title = "AI Empire";

		forbidDiplomacy = true;
		forbidColonization = true;
		forbidCreeping = true;
		forbidResearch = true;
		forbidDefense = true;
		forbidAttack = true;
		forbidConstruction = true;
		forbidScouting = true;
		forbidAnomalyChoice = true;
		forbidArtifact = true;
		forbidScuttle = true;
		preventAchievements = false;

		@panel = GuiPanel(this, Alignment());

		@forbidDiplomacyButton = GuiButton(panel, recti_area(15,50, 120,25));
		@forbidDiplomacyText = GuiMarkupText(forbidDiplomacyButton, Alignment(Left, Top, Right, Bottom));
		forbidDiplomacyText.text = "[center]Diplomacy[/center]";
		forbidDiplomacyButton.color = colorForbidden;

		@preventAchievementsButton = GuiButton(panel, recti_area(0,370, 200,25));
		@preventAchievementsText = GuiMarkupText(preventAchievementsButton, Alignment(Left, Top, Right, Bottom));
		preventAchievementsText.text = "[center]Prevent Achievements[/center]";
		preventAchievementsButton.color = colorForbidden;

		@forbidColonizationButton = GuiButton(panel, recti_area(15,80, 120,25));
		@forbidColonizationText = GuiMarkupText(forbidColonizationButton, Alignment(Left, Top, Right, Bottom));
		forbidColonizationText.text = "[center]Colonization[/center]";
		forbidColonizationButton.color = colorForbidden;

		@forbidCreepingButton = GuiButton(panel, recti_area(15,110, 120,25));
		@forbidCreepingText = GuiMarkupText(forbidCreepingButton, Alignment(Left, Top, Right, Bottom));
		forbidCreepingText.text = "[center]Remnant Hunting[/center]";
		forbidCreepingButton.color = colorForbidden;

		@forbidResearchButton = GuiButton(panel, recti_area(15,140, 120,25));
		@forbidResearchText = GuiMarkupText(forbidResearchButton, Alignment(Left, Top, Right, Bottom));
		forbidResearchText.text = "[center]Research[/center]";
		forbidResearchButton.color = colorForbidden;

		@forbidDefenseButton = GuiButton(panel, recti_area(15,230, 120,25));
		@forbidDefenseText = GuiMarkupText(forbidDefenseButton, Alignment(Left, Top, Right, Bottom));
		forbidDefenseText.text = "[center]Wartime Defense[/center]";
		forbidDefenseButton.color = colorForbidden;

		@forbidAttackButton = GuiButton(panel, recti_area(15,200, 120,25));
		@forbidAttackText = GuiMarkupText(forbidAttackButton, Alignment(Left, Top, Right, Bottom));
		forbidAttackText.text = "[center]Wartime Offense[/center]";
		forbidAttackButton.color = colorForbidden;

		@forbidConstructionButton = GuiButton(panel, recti_area(15+200,50, 120,25));
		@forbidConstructionText = GuiMarkupText(forbidConstructionButton, Alignment(Left, Top, Right, Bottom));
		forbidConstructionText.text = "[center]Construction[/center]";
		forbidConstructionButton.color = colorForbidden;

		@forbidScoutingButton = GuiButton(panel, recti_area(15,170, 120,25));
		@forbidScoutingText = GuiMarkupText(forbidScoutingButton, Alignment(Left, Top, Right, Bottom));
		forbidScoutingText.text = "[center]Scouting[/center]";
		forbidScoutingButton.color = colorForbidden;

		@forbidAnomalyChoiceButton = GuiButton(panel, recti_area(15,260, 200,25));
		@forbidAnomalyChoiceText = GuiMarkupText(forbidAnomalyChoiceButton, Alignment(Left, Top, Right, Bottom));
		forbidAnomalyChoiceText.text = "[center]Anomaly Resolution[/center]";
		forbidAnomalyChoiceButton.color = colorForbidden;

		@forbidArtifactButton = GuiButton(panel, recti_area(15,290, 120,25));
		@forbidArtifactText = GuiMarkupText(forbidArtifactButton, Alignment(Left, Top, Right, Bottom));
		forbidArtifactText.text = "[center]Artifact Use[/center]";
		forbidArtifactButton.color = colorForbidden;

		@forbidScuttleButton = GuiButton(panel, recti_area(15,320, 120,25));
		@forbidScuttleText = GuiMarkupText(forbidScuttleButton, Alignment(Left, Top, Right, Bottom));
		forbidScuttleText.text = "[center]Scuttling[/center]";
		forbidScuttleButton.color = colorForbidden;

		@enableAIButton = GuiButton(panel, recti_area(0,0, 60,25));
		@enableAIText = GuiMarkupText(enableAIButton, Alignment(Left, Top, Right, Bottom));
		enableAIText.text = "[center]All on[/center]";
		enableAIButton.color = colorAllowed;

		@disableAIButton = GuiButton(panel, recti_area(70,0, 60,25));
		@disableAIText = GuiMarkupText(disableAIButton, Alignment(Left, Top, Right, Bottom));
		disableAIText.text = "[center]All off[/center]";
		disableAIButton.color = colorForbidden;
	}

	void tick(double time) override {
	}

	bool onGuiEvent(const GuiEvent& event) {
		if (event.type == GUI_Clicked) {
			if (event.caller is enableAIButton) {
				cheatCommandAI(playerEmpire, "allow all");
				setAll(colorAllowed, false);
				return true;
			}
			else if (event.caller is disableAIButton) {
				cheatCommandAI(playerEmpire, "forbid all");
				setAll(colorForbidden, true);
				return true;
			}
			else if (event.caller is forbidDiplomacyButton) {
				toggle(forbidDiplomacyButton, forbidDiplomacy, "Diplomacy");
				return true;
			}
			else if (event.caller is forbidColonizationButton) {
				toggle(forbidColonizationButton, forbidColonization, "Colonization");
				return true;
			}
			else if (event.caller is forbidCreepingButton) {
				toggle(forbidCreepingButton, forbidCreeping, "Creeping");
				return true;
			}
			else if (event.caller is forbidResearchButton) {
				toggle(forbidResearchButton, forbidResearch, "Research");
				return true;
			}
			else if (event.caller is forbidDefenseButton) {
				toggle(forbidDefenseButton, forbidDefense, "Defense");
				return true;
			}
			else if (event.caller is forbidAttackButton) {
				toggle(forbidAttackButton, forbidAttack, "Attack");
				return true;
			}
			else if (event.caller is forbidConstructionButton) {
				toggle(forbidConstructionButton, forbidConstruction, "Construction");
				return true;
			}
			else if (event.caller is forbidScoutingButton) {
				toggle(forbidScoutingButton, forbidScouting, "Scouting");
				return true;
			}
			else if (event.caller is forbidAnomalyChoiceButton) {
				toggle(forbidAnomalyChoiceButton, forbidAnomalyChoice, "AnomalyChoice");
				return true;
			}
			else if (event.caller is forbidArtifactButton) {
				toggle(forbidArtifactButton, forbidArtifact, "Artifact");
				return true;
			}
			else if (event.caller is forbidScuttleButton) {
				toggle(forbidScuttleButton, forbidScuttle, "Scuttle");
				return true;
			}
			else if (event.caller is preventAchievementsButton) {
				cheatCommandAI(playerEmpire, "no achievements");
				preventAchievementsButton.color = colorAllowed;
				preventAchievements = true;
				return true;
			}
		}
		return BaseGuiElement::onGuiEvent(event);
	}

	void toggle (GuiButton& btn, bool& flag, string cmd) {
		if (flag) {
			btn.color = colorAllowed;
			cheatCommandAI(playerEmpire, "allow " + cmd);
			flag = false;
		} else {
			btn.color = colorForbidden;
			cheatCommandAI(playerEmpire, "forbid " + cmd);
			flag = true;
		}
	}

	void setAll(Color color, bool b) {
		forbidDiplomacy = b;
		forbidColonization = b;
		forbidCreeping = b;
		forbidResearch = b;
		forbidDefense = b;
		forbidAttack = b;
		forbidConstruction = b;
		forbidScouting = b;
		forbidAnomalyChoice = b;
		forbidArtifact = b;
		forbidScuttle = b;
		forbidDiplomacyButton.color = color;
		forbidColonizationButton.color = color;
		forbidCreepingButton.color = color;
		forbidResearchButton.color = color;
		forbidDefenseButton.color = color;
		forbidAttackButton.color = color;
		forbidConstructionButton.color = color;
		forbidScoutingButton.color = color;
		forbidAnomalyChoiceButton.color = color;
		forbidArtifactButton.color = color;
		forbidScuttleButton.color = color;
	}

        void draw() {
                skin.draw(SS_AIEmpireBG, SF_Normal, AbsolutePosition);
                Tab::draw();
        }
}

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));

		//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);

		@addAIButton = GuiButton(this, Alignment(
			Left+300, Bottom-0.1f+6, Width=200, Height=46),
			locale::ADD_AI);
		addAIButton.buttonIcon = icons::Add;

		@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+408, 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;
		empireBG.title = locale::MENU_EMPIRES + " (" + (empires.length + 1) + ")";
		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;
		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();
		}
	}

	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;
		}
		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@ randomizeButton;
	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);

		@randomizeButton = GuiButton(panel, Alignment(Right-452, Bottom-78, Width=220, Height=33));
		randomizeButton.text = "Randomize Race";

		@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;
		// DOF - Adjust shipset selection box size.
		// Trying dynamic size based on number of shipsets.  Target 6 per row, max 4 rows (don't want to get too tall for lower resolutions).
		uint SSBoxHeight = min(int(ceil(getShipsetCount()/8.0)),4) * 75;
		GuiSkinElement shipsetBG(leftBG, Alignment(Left, Top+y, Right, Height=SSBoxHeight), 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 randomizeButton) {
				hasChosenRace = true;
				selectRace(randomi(0, presetButtons.length - 1));
			}
			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);
		forceAITraits(settings);
		if(!player) {
			//forceAITraits(settings);
			if(defaultName == name.text)
				resetName();
		}
		update();
	}

	void applyRace(const EmpireSettings@ custom) {
		settings.copyRaceFrom(custom);
		forceAITraits(settings);
		if(!player) {
			//settings.copyRaceFrom(custom);
			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;
	GuiButton@ applyToAllButton;

	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+165, Bottom-34, Width=70, Height=30), locale::OK);
		@applyToAllButton = GuiButton(this, Alignment(Left+260, Bottom-34, Width=120, Height=30), "Apply to all");

		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(bool toAll = false) {
		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;

		if (toAll) {
			for (uint i = 0; i < setup.ng.empires.length; i++) {
				setup.ng.empires[i].settings.difficulty = difficulties.selected;
				setup.ng.empires[i].settings.aiFlags = flags;
				setup.ng.empires[i].submit();
			}
		} else {
			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;
			} else if(evt.caller is applyToAllButton) {
				apply(true);
				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();
}

import orbitals;
import object_creation;
import tile_resources;
import void setInstantColonize(bool) from "planets.SurfaceComponent";
from empire import sendChatMessage;

import influence;
from bonus_effects import BonusEffect;
from generic_effects import GenericEffect;
import hooks;

bool CHEATS_ENABLED_THIS_GAME = false;
bool CHEATS_ENABLED = false;
bool getCheatsEnabled() {
	return CHEATS_ENABLED;
}

bool getCheatsEverOn() {
	return CHEATS_ENABLED_THIS_GAME;
}

void setCheatsEnabled(Player& player, bool enabled) {
	if(player != HOST_PLAYER)
		return;
	CHEATS_ENABLED = enabled;
	if(enabled)
		CHEATS_ENABLED_THIS_GAME = true;
	cheatsEnabled(ALL_PLAYERS, enabled);
	if(mpServer) {
		if(enabled)
			sendChatMessage(locale::MP_CHEATS_ENABLED, color=Color(0xaaaaaaff), offset=30);
		else
			sendChatMessage(locale::MP_CHEATS_DISABLED, color=Color(0xaaaaaaff), offset=30);
	}
}

void cheatSeeAll(Player& player, bool enabled) {
	if(!CHEATS_ENABLED || player.emp is null || !player.emp.valid)
		return;
	player.emp.visionMask = enabled ? ~0 : player.emp.mask;
}

void cheatColonize(bool enabled) {
	if(!CHEATS_ENABLED)
		return;
	setInstantColonize(enabled);
}

void cheatSpawnFlagship(Object@ spawnAt, const Design@ design, Empire@ owner) {
	if(!CHEATS_ENABLED)
		return;
	if(design.hasTag(ST_IsSupport))
		return;
	createShip(spawnAt, design, owner, free=true);
}

void cheatSpawnFlagship(vec3d spawnAt, const Design@ design, Empire@ owner) {
	if(!CHEATS_ENABLED)
		return;
	if(design.hasTag(ST_IsSupport))
		return;
	Ship@ ship = createShip(spawnAt, design, owner, free=true);
	ship.addMoveOrder(spawnAt);
}

void cheatSpawnSupports(Object@ spawnAt, const Design@ design, uint count) {
	if(!CHEATS_ENABLED)
		return;
	if(!design.hasTag(ST_IsSupport))
		return;
	if(!spawnAt.hasLeaderAI || spawnAt.owner is null || !spawnAt.owner.valid)
		return;
	for(uint i = 0; i < count; ++i)
		createShip(spawnAt, design, spawnAt.owner);
}

void cheatSpawnSupports(vec3d spawnAt, const Design@ design, uint count, Empire@ owner) {
	if(!CHEATS_ENABLED)
		return;
	if(!design.hasTag(ST_IsSupport))
		return;
	for(uint i = 0; i < count; ++i)
		createShip(spawnAt, design, owner);
}

void cheatSpawnOrbital(vec3d spawnAt, uint orbitalType, Empire@ owner) {
	if(!CHEATS_ENABLED)
		return;
	const OrbitalModule@ def = getOrbitalModule(orbitalType);
	if(def is null)
		return;
	createOrbital(spawnAt, def, owner);
}

void cheatInfluence(Player& player, int amount) {
	if(!CHEATS_ENABLED || player.emp is null || !player.emp.valid)
		return;
	player.emp.addInfluence(amount);
}

void cheatResearch(Player& player, double amount) {
	if(!CHEATS_ENABLED || player.emp is null || !player.emp.valid)
		return;
	player.emp.generatePoints(amount);
}

void cheatMoney(Player& player, int amount) {
	if(!CHEATS_ENABLED || player.emp is null || !player.emp.valid)
		return;
	player.emp.addBonusBudget(amount);
}

void cheatEnergy(Player& player, int amount) {
	if(!CHEATS_ENABLED || player.emp is null || !player.emp.valid)
		return;
	player.emp.modEnergyStored(amount);
}

void cheatFTL(Player& player, int amount) {
	if(!CHEATS_ENABLED || player.emp is null || !player.emp.valid)
		return;
	if(player.emp.FTLCapacity < amount)
		player.emp.modFTLCapacity(amount);
	player.emp.modFTLStored(amount);
}

void cheatActivateAI(Player& player) {
	if(!CHEATS_ENABLED || player.emp is null || !player.emp.valid)
		return;
	player.emp.initBasicAI();
}

void cheatDebugAI(Empire@ emp) {
	if(!CHEATS_ENABLED || emp is null)
		return;
	emp.debugAI();
}

void commandPlayerAI(string cmd) {
	playerEmpire.commandAI(cmd);
}

void cheatCommandAI(Empire@ emp, string cmd) {
	if(emp is playerEmpire) {
		if (cmd == "no achievements") {
			CHEATS_ENABLED_THIS_GAME = true;
		}
		else {
			emp.commandAI(cmd);
		}
		return;
	}
	if(!CHEATS_ENABLED || emp is null)
		return;
	emp.commandAI(cmd);
}

void cheatTrigger(Player& player, Object@ obj, Empire@ emp, string hook) {
	Empire@ plEmp = player.emp;
	if(!CHEATS_ENABLED || plEmp is null || !plEmp.valid)
		return;
	BonusEffect@ trig = cast<BonusEffect>(parseHook(hook, "bonus_effects::", required=false));
	if(trig !is null) {
		trig.activate(obj, emp);
		return;
	}
	GenericEffect@ eff = cast<GenericEffect>(parseHook(hook, "planet_effects::"));
	if(eff !is null) {
		eff.enable(obj, null);
		return;
	}
}

void cheatChangeOwner(Object@ obj, Empire@ newOwner) {
	if(!CHEATS_ENABLED || obj is null || newOwner is null)
		return;
	if(obj.isPlanet) {
		obj.takeoverPlanet(newOwner);
	}
	else if(obj.isShip) {
		if(obj.hasLeaderAI) {
			uint cnt = obj.supportCount;
			for(uint i = 0; i < cnt; ++i)
				@obj.supportShip[i].owner = newOwner;
		}

		@obj.owner = newOwner;
	}
	else {
		@obj.owner = newOwner;
	}
}

void cheatAlliance(Empire& from, Empire& to) {
	if(!CHEATS_ENABLED)
		return;
	if(from is to)
		return;
	if(!from.valid || !to.valid)
		return;
}

void cheatDestroy(Object@ obj) {
	if(!CHEATS_ENABLED || obj is null)
		return;
	obj.destroy();
}

void cheatLabor(Object@ obj, double amount) {
	if(!CHEATS_ENABLED || obj is null)
		return;
	obj.modLaborIncome(amount);
}

void syncInitial(Message& msg) {
	msg << CHEATS_ENABLED;
	msg << CHEATS_ENABLED_THIS_GAME;
}

void save(SaveFile& msg) {
	msg << CHEATS_ENABLED;
	msg << CHEATS_ENABLED_THIS_GAME;
}

void load(SaveFile& msg) {
	msg >> CHEATS_ENABLED;
	if(msg >= SV_0025)
		msg >> CHEATS_ENABLED_THIS_GAME;
	else
		CHEATS_ENABLED_THIS_GAME = CHEATS_ENABLED;
}

import settings.game_settings;

import AIController@ createBumAI() from "empire_ai.BumAI";
import AIController@ createBasicAI() from "empire_ai.BasicAI";
import AIController@ createWeaselAI() from "empire_ai.weasel.WeaselAI";

interface AIController {
	void debugAI();
	void commandAI(string cmd);
	void aiPing(Empire@ fromEmpire, vec3d position, uint type);
	void init(Empire& emp, EmpireSettings& settings);
	void init(Empire& emp);
	void tick(Empire& emp, double time);
	void pause(Empire& emp);
	void resume(Empire& emp);
	void load(SaveFile& msg);
	void save(SaveFile& msg);
	int getDifficultyLevel();
	vec3d get_aiFocus();
	string getOpinionOf(Empire& emp, Empire@ other);
	int getStandingTo(Empire& emp, Empire@ other);
}

class EmpireAI : Component_EmpireAI, Savable {
	AIController@ ctrl;
	uint aiType;
	bool paused = false;
	bool override = true;

	EmpireAI() {
	}
	
	vec3d get_aiFocus() {
		if(ctrl !is null)
			return ctrl.aiFocus;
		else
			return vec3d();
	}
	
	int get_difficulty() {
		if(ctrl !is null)
			return ctrl.getDifficultyLevel();
		else
			return -1;
	}

	bool get_isAI(Empire& emp) {
		return ctrl !is null && (emp.player is null || override);
	}

	string getRelation(Player& pl, Empire& emp) {
		auto@ other = pl.emp;
		if(ctrl is null || other is null || !other.valid || other.ContactMask.value & emp.mask == 0)
			return "";
		else
			return ctrl.getOpinionOf(emp, other);
	}

	int getRelationState(Player& pl, Empire& emp) {
		auto@ other = pl.emp;
		if(ctrl is null || other is null || !other.valid || other.ContactMask.value & emp.mask == 0)
			return 0;
		else
			return ctrl.getStandingTo(emp, other);
	}

	uint getAIType() {
		return aiType;
	}
	
	void debugAI() {
		if(ctrl !is null)
			ctrl.debugAI();
	}
	
	void commandAI(string cmd) {
		if(ctrl !is null)
			ctrl.commandAI(cmd);
	}

	void load(SaveFile& msg) {
		msg >> paused;
		msg >> override;
		msg >> aiType;

		createAI(aiType);
		if(ctrl !is null)
			ctrl.load(msg);
	}

	void save(SaveFile& msg) {
		msg << paused;
		msg << override;
		msg << aiType;

		if(ctrl !is null)
			ctrl.save(msg);
	}

	void createAI(uint type) {
		aiType = type;

		//Create the controller
		switch(type) {
			case ET_Player:
				//Do nothing
			break;
			case ET_BumAI:
				@ctrl = createBasicAI();
			break;
			case ET_WeaselAI:
				@ctrl = createWeaselAI();
			break;
		}

	}

	void aiPing(Empire@ fromEmpire, vec3d position, uint type = 0) {
		if(ctrl !is null)
			ctrl.aiPing(fromEmpire, position, type);
	}

	void init(Empire& emp, EmpireSettings& settings) {
		createAI(settings.type);

		//Initialize
		if(ctrl !is null)
			ctrl.init(emp, settings);
	}

	void initBasicAI(Empire& emp) {
		override = true;
		if(ctrl !is null)
			return;

		createAI(ET_WeaselAI);

		if(ctrl !is null) {
			EmpireSettings settings;
			settings.difficulty = 2;
			settings.aiFlags |= AIF_Aggressive;
			ctrl.init(emp, settings);
			ctrl.init(emp);
		}
	}
	
	void init(Empire& emp) {
		if(ctrl !is null)
			ctrl.init(emp);
	}

	void aiTick(Empire& emp, double tick) {
		if(ctrl is null)
			return;

		if(emp.player is null || override) {
			if(paused) {
				ctrl.resume(emp);
				paused = false;
			}
			ctrl.tick(emp, tick);
		}
		else {
			if(!paused) {
				ctrl.pause(emp);
				paused = true;
			}
		}
	}
};

// Budget
// ------
// Tasked with managing the empire's money and making sure we have enough to spend
// on various things, as well as dealing with prioritization and budget allocation.
//

import empire_ai.weasel.WeaselAI;

enum BudgetType {
	BT_Military,
	BT_Infrastructure,
	BT_Colonization,
	BT_Development,

	BT_COUNT
};

final class AllocateBudget {
	int id = -1;
	uint type;
	int cost = 0;
	int maintenance = 0;

	double requestTime = 0;
	double priority = 1;

	bool allocated = false;
	int opCmp(const AllocateBudget@ other) const {
		if(priority < other.priority)
			return -1;
		if(priority > other.priority)
			return 1;
		if(requestTime < other.requestTime)
			return 1;
		if(requestTime > other.requestTime)
			return -1;
		return 0;
	}

	void save(SaveFile& file) {
		file << id;
		file << type;
		file << cost;
		file << maintenance;
		file << requestTime;
		file << priority;
		file << allocated;
	}

	void load(SaveFile& file) {
		file >> id;
		file >> type;
		file >> cost;
		file >> maintenance;
		file >> requestTime;
		file >> priority;
		file >> allocated;
	}
};

final class BudgetPart {
	uint type;

	array<AllocateBudget@> allocations;

	//How much we've spent this cycle
	int spent = 0;

	//How much is remaining to be spent this cycle
	int remaining = 0;

	//How much maintenance we've gained this cycle
	int gainedMaintenance = 0;

	//How much maintenance we can still gain this cycle
	int remainingMaintenance = 0;

	void update(AI& ai, Budget& budget) {

		for(uint i = 0, cnt = allocations.length; i < cnt; ++i) {
			auto@ alloc = allocations[i];
			if(alloc.priority < 1.0) {
				if(alloc.cost >= remaining && alloc.maintenance >= remainingMaintenance) {
					budget.spend(type, alloc.cost, alloc.maintenance);
					alloc.allocated = true;
					allocations.removeAt(i);
					break;
				}
			}
			else {
				if(budget.canSpend(type, alloc.cost, alloc.maintenance, alloc.priority)) {
					budget.spend(type, alloc.cost, alloc.maintenance);
					alloc.allocated = true;
					allocations.removeAt(i);
					break;
				}
			}
		}
	}

	void turn(AI& ai, Budget& budget) {
		spent = 0;
		remaining = 0;

		gainedMaintenance = 0;
		remainingMaintenance = 0;
	}

	void save(Budget& budget, SaveFile& file) {
		file << spent;
		file << remaining;
		file << gainedMaintenance;
		file << remainingMaintenance;

		uint cnt = allocations.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i) {
			budget.saveAlloc(file, allocations[i]);
			allocations[i].save(file);
		}
	}

	void load(Budget& budget, SaveFile& file) {
		file >> spent;
		file >> remaining;
		file >> gainedMaintenance;
		file >> remainingMaintenance;

		uint cnt = 0;
		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ alloc = budget.loadAlloc(file);
			alloc.load(file);
		}
	}
};

final class Budget : AIComponent {
	//Budget thresholds
	private int _criticalThreshold = 350;
	private int _lowThreshold = 400;
	private int _mediumThreshold = 500;
	private int _highThreshold = 1000;
	private int _veryHighThreshold = 2000;

	//Focus flags
	private bool _askedFocus = false;
	private bool _focusing = false;
	//Focused budget type
	private uint _focus;

	int get_criticalThreshold() const { return _criticalThreshold; }
	int get_lowThreshold() const { return _lowThreshold; }
	int get_mediumThreshold() const { return _mediumThreshold; }
	int get_highThreshold() const { return _highThreshold; }
	int get_veryHighThreshold() const { return _veryHighThreshold; }

	array<BudgetPart@> parts;
	int NextAllocId = 0;

	int InitialBudget = 0;
	int InitialUpcoming = 0;

	double Progress = 0;
	double RemainingTime = 0;

	int FreeBudget = 0;
	int FreeMaintenance = 0;

	bool checkedMilitarySpending = false;

	void create() {
		parts.length = BT_COUNT;
		for(uint i = 0; i < BT_COUNT; ++i) {
			@parts[i] = BudgetPart();
			parts[i].type = BudgetType(i);
		}
	}

	void save(SaveFile& file) {
		file << InitialBudget;
		file << InitialUpcoming;
		file << Progress;
		file << RemainingTime;
		file << FreeBudget;
		file << FreeMaintenance;
		file << NextAllocId;
		file << checkedMilitarySpending;
		file << _askedFocus;
		file << _focusing;
		file << _focus;

		for(uint i = 0, cnt = parts.length; i < cnt; ++i)
			parts[i].save(this, file);
	}

	void load(SaveFile& file) {
		file >> InitialBudget;
		file >> InitialUpcoming;
		file >> Progress;
		file >> RemainingTime;
		file >> FreeBudget;
		file >> FreeMaintenance;
		file >> NextAllocId;
		file >> checkedMilitarySpending;
		file >> _askedFocus;
		file >> _focusing;
		file >> _focus;

		for(uint i = 0, cnt = parts.length; i < cnt; ++i)
			parts[i].load(this, file);
	}

	array<AllocateBudget@> loadIds;
	AllocateBudget@ loadAlloc(int id) {
		if(id == -1)
			return null;
		for(uint i = 0, cnt = loadIds.length; i < cnt; ++i) {
			if(loadIds[i].id == id)
				return loadIds[i];
		}
		AllocateBudget alloc;
		alloc.id = id;
		loadIds.insertLast(alloc);
		return alloc;
	}
	AllocateBudget@ loadAlloc(SaveFile& file) {
		int id = -1;
		file >> id;
		if(id == -1)
			return null;
		else
			return loadAlloc(id);
	}
	void saveAlloc(SaveFile& file, AllocateBudget@ alloc) {
		int id = -1;
		if(alloc !is null)
			id = alloc.id;
		file << id;
	}
	void postLoad(AI& ai) {
		loadIds.length = 0;
	}

	void spend(uint type, int money, int maint = 0) {
		auto@ part = parts[type];

		part.spent += money;
		part.gainedMaintenance += maint;

		if(part.remaining >= money) {
			part.remaining -= money;
		}
		else if(part.remaining >= 0) {
			money -= part.remaining;
			FreeBudget -= money;
			part.remaining = 0;
		}
		else {
			FreeBudget -= money;
		}

		if(part.remainingMaintenance >= maint) {
			part.remainingMaintenance -= maint;
		}
		else if(part.remainingMaintenance >= 0) {
			maint -= part.remainingMaintenance;
			FreeMaintenance -= maint;
			part.remainingMaintenance = 0;
		}
		else {
			FreeMaintenance -= money;
		}
	}

	bool canSpend(uint type, int money, int maint = 0, double priority = 1.0) {
		int canFree = FreeBudget;
		int canFreeMaint = FreeMaintenance;

		if (priority < 2.0) {
			//Rules for normal priority requests
			//Don't allow any spending not in our current focus
			if (_focusing) {
				if (type != _focus)
					return false;
			}
			if (type != BT_Colonization
				&& (maint > 200 && ai.empire.EstNextBudget < mediumThreshold)
				|| (maint > 100 && ai.empire.EstNextBudget < lowThreshold)
				|| (maint > 0 && ai.empire.EstNextBudget < criticalThreshold))
				//Don't allow any high maintenance cost if our estimated next budget is too low
				return false;

			//Don't allow generic spending until we've checked if we need to spend on military this cycle
			if(type == BT_Development && !checkedMilitarySpending && Progress < 0.33)
				canFree = 0;
			if(type == BT_Colonization)
				canFree += 160;
		}
		else {
			//Rules for high priority requests
			if (money > FreeBudget && ai.empire.canBorrow(money - FreeBudget))
			//Allow borrowing from next budget for high priority requests
			canFree = money;
		}

		auto@ part = parts[type];
		if(money > part.remaining + canFree)
			return false;
		if(maint != 0 && maint > part.remainingMaintenance + canFreeMaint)
			return false;
		return true;
	}

	int spendable(uint type) {
		return FreeBudget + parts[type].remaining;
	}

	int maintainable(uint type) {
		return FreeMaintenance + parts[type].remainingMaintenance;
	}

	void claim(uint type, int money, int maint = 0) {
		auto@ part = parts[type];

		FreeBudget -= money;
		part.remaining += money;

		FreeMaintenance -= maint;
		part.remainingMaintenance += maint;
	}

	void turn() {
		if(log && gameTime > 10.0) {
			ai.print("==============");
			ai.print("Unspent:");
			ai.print(" Military: "+parts[BT_Military].remaining+" / "+parts[BT_Military].remainingMaintenance);
			ai.print(" Infrastructure: "+parts[BT_Infrastructure].remaining+" / "+parts[BT_Infrastructure].remainingMaintenance);
			ai.print(" Colonization: "+parts[BT_Colonization].remaining+" / "+parts[BT_Colonization].remainingMaintenance);
			ai.print(" Development: "+parts[BT_Development].remaining+" / "+parts[BT_Development].remainingMaintenance);
			ai.print(" FREE: "+FreeBudget+" / "+FreeMaintenance);
			ai.print("==============");
			ai.print("Total Expenditures:");
			ai.print(" Military: "+parts[BT_Military].spent+" / "+parts[BT_Military].gainedMaintenance);
			ai.print(" Infrastructure: "+parts[BT_Infrastructure].spent+" / "+parts[BT_Infrastructure].gainedMaintenance);
			ai.print(" Colonization: "+parts[BT_Colonization].spent+" / "+parts[BT_Colonization].gainedMaintenance);
			ai.print(" Development: "+parts[BT_Development].spent+" / "+parts[BT_Development].gainedMaintenance);
			ai.print("==============");
		 }

		//Collect some data about this turn
		InitialBudget = ai.empire.RemainingBudget;
		InitialUpcoming = ai.empire.EstNextBudget;

		FreeBudget = InitialBudget;
		FreeMaintenance = InitialUpcoming;

		checkedMilitarySpending = false;

		//Handle focus status
		if (_focusing) {
			_focusing = false;
			if (log)
				ai.print("Budget: ending focus");
		}
		else if (_askedFocus) {
			_focusing = true;
			_askedFocus = false;
			if (log)
				ai.print("Budget: starting focus");
		}

		//Tell the budget parts to perform turns
		for(uint i = 0, cnt = parts.length; i < cnt; ++i)
			parts[i].turn(ai, this);
	}

	void remove(AllocateBudget@ alloc) {
		if(alloc is null)
			return;
		if(alloc.allocated) {
			FreeBudget += alloc.cost;
			FreeMaintenance += alloc.maintenance;
		}
		parts[alloc.type].allocations.remove(alloc);
	}

	AllocateBudget@ allocate(uint type, int cost, int maint = 0, double priority = 1.0) {
		AllocateBudget alloc;
		alloc.id = NextAllocId++;
		alloc.type = type;
		alloc.cost = cost;
		alloc.maintenance = maint;
		alloc.priority = priority;

		return allocate(alloc);
	}

	AllocateBudget@ allocate(AllocateBudget@ allocation) {
		allocation.requestTime = gameTime;
		parts[allocation.type].allocations.insertLast(allocation);
		parts[allocation.type].allocations.sortDesc();
		return allocation;
	}

	void applyNow(AllocateBudget@ alloc) {
		auto@ part = parts[alloc.type];
		spend(alloc.type, alloc.cost, alloc.maintenance);
		alloc.allocated = true;
		part.allocations.remove(alloc);
	}

	void grantBonus(int cost, int maint = 0) {
		//Spread some bonus budget across all the different parts
		FreeBudget += cost;
		FreeMaintenance += maint;
	}

	bool canFocus() {
		return !(ai.empire.EstNextBudget <= criticalThreshold || _askedFocus || _focusing);
	}

	//Focus spendings on one particular budget part for one turn
	//Only high priority requests will be considered for other parts
	//Should be called at the start of a turn for best results
	void focus(BudgetType type) {
		if (ai.empire.EstNextBudget > criticalThreshold && !_askedFocus && !_focusing) {
			_focus = type;
			//If we are still at the start of a turn, focus immediately, else wait until next turn
			//The second condition compensates for slight timing inaccuracies and execution delay
			if (Progress < 0.33 || Progress > 0.995) {
				_focusing = true;
				_askedFocus = false;
				if (log)
					ai.print("Budget: starting focus");
			}
			else
				_askedFocus = true;
		}
	}

	void tick(double time) {
		//Record some simple data
		Progress = ai.empire.BudgetTimer / ai.empire.BudgetCycle;
		RemainingTime = ai.empire.BudgetCycle - ai.empire.BudgetTimer;

		//Update one of the budget parts
		for(uint i = 0, cnt = parts.length; i < cnt; ++i) {
			auto@ part = parts[i];
			part.update(ai, this);
		}
	}

	void focusTick(double time) {
		//Detect any extra budget we need to use
		int ExpectBudget = FreeBudget;
		int ExpectMaint = FreeMaintenance;
		for(uint i = 0, cnt = parts.length; i < cnt; ++i) {
			ExpectBudget += parts[i].remaining;
			ExpectMaint += parts[i].remainingMaintenance;
		}

		int HaveBudget = ai.empire.RemainingBudget;
		int HaveMaint = ai.empire.EstNextBudget;
		if(ExpectBudget != HaveBudget || ExpectMaint != HaveMaint)
			grantBonus(HaveBudget - ExpectBudget, max(0, HaveMaint - ExpectMaint));
	}
};

AIComponent@ createBudget() {
	return Budget();
}

// Colonization
// ------------
// Deals with colonization for requested resources.
//

import empire_ai.weasel.WeaselAI;
import empire_ai.weasel.ImportData;
import empire_ai.weasel.Resources;
import empire_ai.weasel.Planets;
import empire_ai.weasel.Systems;
import empire_ai.weasel.Budget;
import empire_ai.weasel.Creeping;

import util.formatting;

import systems;

enum ColonizationPhase {
	CP_Expansion,
	CP_Stabilization,
};

interface RaceColonization {
	bool orderColonization(ColonizeData& data, Planet@ sourcePlanet);
	double getGenericUsefulness(const ResourceType@ type);
};

final class ColonizeData {
	int id = -1;
	Planet@ target;
	Planet@ colonizeFrom;
	bool completed = false;
	bool canceled = false;
	double checkTime = -1.0;

	void save(Colonization& colonization, SaveFile& file) {
		file << target;
		file << colonizeFrom;
		file << completed;
		file << canceled;
		file << checkTime;
	}

	void load(Colonization& colonization, SaveFile& file) {
		file >> target;
		file >> colonizeFrom;
		file >> completed;
		file >> canceled;
		file >> checkTime;
	}
};

tidy final class WaitUsed {
	ImportData@ forData;
	ExportData@ resource;

	void save(Colonization& colonization, SaveFile& file) {
		colonization.resources.saveImport(file, forData);
		colonization.resources.saveExport(file, resource);
	}

	void load(Colonization& colonization, SaveFile& file) {
		@forData = colonization.resources.loadImport(file);
		@resource = colonization.resources.loadExport(file);
	}
};

final class ColonizePenalty : Savable {
	Planet@ pl;
	double until;

	void save(SaveFile& file) {
		file << pl;
		file << until;
	}

	void load(SaveFile& file) {
		file >> pl;
		file >> until;
	}
};

final class PotentialColonize {
	Planet@ pl;
	const ResourceType@ resource;
	double weight = 0;
};

final class ColonizeLog {
	int typeId;
	double time;
};

tidy final class ColonizeQueue {
	ResourceSpec@ spec;
	Planet@ target;
	ColonizeData@ step;
	ImportData@ forData;
	ColonizeQueue@ parent;
	array<ColonizeQueue@> children;

	void save(Colonization& colonization, SaveFile& file) {
		file << spec;
		file << target;

		colonization.saveColonize(file, step);
		colonization.resources.saveImport(file, forData);

		uint cnt = children.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			children[i].save(colonization, file);
	}

	void load(Colonization& colonization, SaveFile& file) {
		@spec = ResourceSpec();
		file >> spec;
		file >> target;

		@step = colonization.loadColonize(file);
		@forData = colonization.resources.loadImport(file);

		uint cnt = 0;
		file >> cnt;
		children.length = cnt;
		for(uint i = 0; i < cnt; ++i) {
			@children[i] = ColonizeQueue();
			@children[i].parent = this;
			children[i].load(colonization, file);
		}
	}
};

final class Colonization : AIComponent {
	const ResourceClass@ foodClass, waterClass, scalableClass;

	Resources@ resources;
	Planets@ planets;
	Systems@ systems;
	Budget@ budget;
	Creeping@ creeping;
	RaceColonization@ race;

	array<ColonizeQueue@> queue;
	array<ColonizeData@> colonizing;
	array<ColonizeData@> awaitingSource;
	array<WaitUsed@> waiting;
	array<ColonizePenalty@> penalties;
	set_int penaltySet;
	int nextColonizeId = 0;
	array<ColonizeLog@> colonizeLog;

	array<PotentialSource@> sources;
	double sourceUpdate = 0;

	//Maximum colonizations that can still be done this turn
	uint remainColonizations = 0;
	//Amount of colonizations that have happened so far this budget cycle
	uint curColonizations = 0;
	//Amount of colonizations that happened the previous budget cycle
	uint prevColonizations = 0;

	//Whether to automatically find sources and order colonizations
	bool performColonization = true;
	bool queueColonization = true;

	//Colonization focus
	private uint _phase = CP_Expansion;

	//Territory request data
	private bool _needsMoreTerritory = false;
	private bool _needsNewTerritory = false;
	private uint _territoryRequests = 0;
	private Region@ _newTerritoryTarget;

	Object@ colonizeWeightObj;

	bool get_needsMoreTerritory() const { return _needsMoreTerritory; }
	bool get_needsNewTerritory() const { return _needsNewTerritory; }

	void create() {
		@resources = cast<Resources>(ai.resources);
		@planets = cast<Planets>(ai.planets);
		@systems = cast<Systems>(ai.systems);
		@budget = cast<Budget>(ai.budget);
		@creeping = cast<Creeping>(ai.creeping);
		@race = cast<RaceColonization>(ai.race);

		//Get some heuristic resource classes
		@foodClass = getResourceClass("Food");
		@waterClass = getResourceClass("WaterType");
		@scalableClass = getResourceClass("Scalable");

	}

	void save(SaveFile& file) {
		file << nextColonizeId;
		file << remainColonizations;
		file << curColonizations;
		file << prevColonizations;
		file << _phase;
		file << _needsMoreTerritory;
		file << _needsNewTerritory;
		file << _territoryRequests;
		if (_newTerritoryTarget !is null) {
			file.write1();
			file << _newTerritoryTarget;
		}
		else
			file.write0();

		uint cnt = colonizing.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i) {
			saveColonize(file, colonizing[i]);
			colonizing[i].save(this, file);
		}

		cnt = waiting.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			waiting[i].save(this, file);

		cnt = penalties.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			penalties[i].save(file);

		cnt = colonizeLog.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i) {
			file.writeIdentifier(SI_Resource, colonizeLog[i].typeId);
			file << colonizeLog[i].time;
		}

		cnt = queue.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			queue[i].save(this, file);
	}

	void load(SaveFile& file) {
		file >> nextColonizeId;
		file >> remainColonizations;
		file >> curColonizations;
		file >> prevColonizations;
		file >> _phase;
		file >> _needsMoreTerritory;
		file >> _needsNewTerritory;
		file >> _territoryRequests;
		if(file.readBit()) {
			file >> _newTerritoryTarget;
		}

		uint cnt = 0;
		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ data = loadColonize(file);
			if(data !is null) {
				data.load(this, file);
				if(data.target !is null) {
					colonizing.insertLast(data);
					if(data.colonizeFrom is null)
						awaitingSource.insertLast(data);
				}
				else {
					data.canceled = true;
				}
			}
			else {
				ColonizeData().load(this, file);
			}
		}

		file >> cnt;
		waiting.length = cnt;
		for(uint i = 0; i < cnt; ++i) {
			@waiting[i] = WaitUsed();
			waiting[i].load(this, file);
		}

		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			ColonizePenalty pen;
			pen.load(file);
			if(pen.pl !is null) {
				penaltySet.insert(pen.pl.id);
				penalties.insertLast(pen);
			}
		}

		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			ColonizeLog logEntry;
			logEntry.typeId = file.readIdentifier(SI_Resource);
			file >> logEntry.time;
			colonizeLog.insertLast(logEntry);
		}

		file >> cnt;
		queue.length = cnt;
		for(uint i = 0; i < cnt; ++i) {
			@queue[i] = ColonizeQueue();
			queue[i].load(this, file);
		}
	}

	array<ColonizeData@> loadIds;
	ColonizeData@ loadColonize(int id) {
		if(id == -1)
			return null;
		for(uint i = 0, cnt = loadIds.length; i < cnt; ++i) {
			if(loadIds[i].id == id)
				return loadIds[i];
		}
		ColonizeData data;
		data.id = id;
		loadIds.insertLast(data);
		return data;
	}
	ColonizeData@ loadColonize(SaveFile& file) {
		int id = -1;
		file >> id;
		if(id == -1)
			return null;
		else
			return loadColonize(id);
	}
	void saveColonize(SaveFile& file, ColonizeData@ data) {
		int id = -1;
		if(data !is null)
			id = data.id;
		file << id;
	}
	void postLoad(AI& ai) {
		loadIds.length = 0;
	}

	bool canBeColonized(Planet& target) {
		if(!target.valid)
			return false;
		if(target.owner.valid)
			return false;
		return true;
	}

	bool canColonize(Planet& source) {
		if(source.level == 0)
			return false;
		if(source.owner !is ai.empire)
			return false;
		return true;
	}

	bool shouldForceExpansion() {
		uint otherColonizedSystems = 0;
		for (uint i = 0, cnt = systems.outsideBorder.length; i < cnt; ++i) {
			auto@ sys = systems.outsideBorder[i];
			//Check if any system in our tradable area is unexplored
			if (!sys.explored)
				return false;
			if (sys.planets.length > 0) {
				uint otherColonizedPlanets = 0;
				for (uint j = 0, cnt = sys.planets.length; j < cnt; ++j) {
					auto@ pl = sys.planets[j];
					int resId = pl.primaryResourceType;
					if (resId != -1) {
						//Check if any planet can still be colonized in our tradable area
						if (!pl.owner.valid && !pl.quarantined)
							return false;
						else
							++otherColonizedPlanets;
					}
				}
				//Check if all planets in the system are colonized
				if (otherColonizedPlanets == sys.planets.length)
					++otherColonizedSystems;
			}
		}
		//Check if all systems in our tradable area belong to other empires
		if (otherColonizedSystems == systems.outsideBorder.length)
			//If 0, we colonized everything!
			return false;

		return true;
	}

	double getSourceWeight(PotentialSource& source, ColonizeData& data) {
		double w = source.weight;
		w /= data.target.position.distanceTo(source.pl.position);
		return w;
	}

	void updateSources() {
		planets.getColonizeSources(sources);
	}

	void focusTick(double time) {
		if(sourceUpdate < gameTime && performColonization) {
			updateSources();
			if(sources.length == 0 && gameTime < 60.0)
				sourceUpdate = gameTime + 1.0;
			else
				sourceUpdate = gameTime + 10.0;
		}

		if (ai.behavior.forbidColonization) return;

		//Find some new colonizations we can queue up from resources
		fillQueueFromRequests();

		//If we've gained any requests, see if we can order another colonize
		if(remainColonizations > 0
				&& (budget.Progress < ai.behavior.colonizeMaxBudgetProgress || gameTime < 3.0 * 60.0)
				&& (sources.length > 0 || !performColonization) && canColonize()
				&& queueColonization) {
			//Actually go order some colonizations from the queue
			if(orderFromQueue()) {
				doColonize();
			}
			else if(awaitingSource.length == 0) {
				if(genericExpand() !is null)
					doColonize();
			}
		}

		//Find colonization sources for everything that needs them
		if(awaitingSource.length != 0 && performColonization) {
			for(uint i = 0, cnt = awaitingSource.length; i < cnt; ++i) {
				auto@ target = awaitingSource[i];

				PotentialSource@ src;
				double bestSource = 0;

				for(uint j = 0, jcnt = sources.length; j < jcnt; ++j) {
					double w = getSourceWeight(sources[j], target);
					if(w > bestSource) {
						bestSource = w;
						@src = sources[j];
					}
				}

				if(src !is null) {
					orderColonization(target, src.pl);
					sources.remove(src);
					--i; --cnt;
				}
			}
		}

		//Check if any resources we're waiting for are being used
		for(uint i = 0, cnt = waiting.length; i < cnt; ++i) {
			auto@ wait = waiting[i];
			if(wait.resource.obj is null || !wait.resource.obj.valid || wait.resource.obj.owner !is ai.empire || wait.resource.request !is null) {
				wait.forData.isColonizing = false;
				waiting.removeAt(i);
				--i; --cnt;
			}
		}

		//Prune old colonization penalties
		for(uint i = 0, cnt = penalties.length; i < cnt; ++i) {
			auto@ pen = penalties[i];
			if(pen.pl !is null && pen.pl.owner is ai.empire)
				pen.pl.forceAbandon();
			if(pen.until < gameTime) {
				if(pen.pl !is null)
					penaltySet.erase(pen.pl.id);
				penalties.removeAt(i);
				--i; --cnt;
			}
		}
	}

	void orderColonization(ColonizeData& data, Planet& sourcePlanet) {
		if(log)
			ai.print("start colonizing "+data.target.name, sourcePlanet);

		if(race !is null) {
			if(race.orderColonization(data, sourcePlanet))
				return;
		}

		@data.colonizeFrom = sourcePlanet;
		awaitingSource.remove(data);

		sourcePlanet.colonize(data.target);
	}

	void tick(double time) {
		//Check if we've finished colonizing anything
		for(uint i = 0, cnt = colonizing.length; i < cnt; ++i) {
			auto@ c = colonizing[i];

			//Remove if we can no longer colonize it
			Empire@ visOwner = c.target.visibleOwnerToEmp(ai.empire);
			if(visOwner !is ai.empire && (visOwner is null || visOwner.valid)) {
				//Fail out this colonization
				cancelColonization(c);
				--i; --cnt;
				continue;
			}

			//Check for succesful colonization
			if(visOwner is ai.empire) {
				double population = c.target.population;
				if(population >= 1.0) {
					finishColonization(c);
					colonizing.removeAt(i);
					--i; --cnt;
					continue;
				}
				else {
					if(c.checkTime == -1.0) {
						c.checkTime = gameTime;
					}
					else {
						double grace = ai.behavior.colonizeFailGraceTime;
						if(population > 0.9)
							grace *= 2.0;
						if(c.checkTime + grace < gameTime) {
							//Fail out this colonization and penalize the target
							creeping.requestClear(systems.getAI(c.target.region));
							cancelColonization(c, penalize=ai.behavior.colonizePenalizeTime);
							--i; --cnt;
							continue;
						}
					}
				}
			}

			//This colonization is still waiting for a good source
			if(c.colonizeFrom is null)
				continue;

			//Check for failed colonization
			if(!canColonize(c.colonizeFrom) || !performColonization) {
				if(c.target.owner is ai.empire && performColonization)
					c.target.stopColonizing(c.target);

				@c.colonizeFrom = null;
				awaitingSource.insertAt(0, c);
			}
		}

		//Update the colonization queue
		updateQueue();
	}

	void cancelColonization(ColonizeData@ data, double penalize = 0) {
		if(data.colonizeFrom !is null && data.colonizeFrom.owner is ai.empire)
			data.colonizeFrom.stopColonizing(data.target);
		if(data.colonizeFrom is null)
			awaitingSource.remove(data);
		if(data.target.owner is ai.empire)
			data.target.forceAbandon();
		data.canceled = true;
		sourceUpdate = 0;
		colonizing.remove(data);

		if(penalize != 0) {
			ColonizePenalty pen;
			@pen.pl = data.target;
			pen.until = gameTime + penalize;

			penaltySet.insert(pen.pl.id);
			penalties.insertLast(pen);
		}
	}

	void finishColonization(ColonizeData@ data) {
		if(data.colonizeFrom is null)
			awaitingSource.remove(data);

		//If we just colonized a new territory, reset request data
		if (data.target.region is _newTerritoryTarget) {
			_needsNewTerritory = false;
			@_newTerritoryTarget = null;
		}

		PlanetAI@ plAI = planets.register(data.target);

		ColonizeLog logEntry;
		logEntry.typeId = data.target.primaryResourceType;
		logEntry.time = gameTime;
		colonizeLog.insertLast(logEntry);

		data.completed = true;
		sourceUpdate = 0;
	}

	double timeSinceMatchingColonize(ResourceSpec& spec) {
		for(int i = colonizeLog.length - 1; i >= 0; --i) {
			auto@ res = getResource(colonizeLog[i].typeId);
			if(res !is null && spec.meets(res))
				return gameTime - colonizeLog[i].time;
		}
		return gameTime;
	}

	bool isColonizing(Planet& pl) {
		for(uint i = 0, cnt = colonizing.length; i < cnt; ++i) {
			if(colonizing[i].target is pl)
				return true;
		}
		for(uint i = 0, cnt = queue.length; i < cnt; ++i) {
			if(isColonizing(pl, queue[i]))
				return true;
		}
		return false;
	}

	bool isColonizing(Planet& pl, ColonizeQueue@ q) {
		if(q.target is pl)
			return true;
		for(uint i = 0, cnt = q.children.length; i < cnt; ++i) {
			if(isColonizing(pl, q.children[i]))
				return true;
		}
		return false;
	}

	double getGenericUsefulness(const ResourceType@ type) {
		//Return a relative value for colonizing the resource this planet has in a vacuum,
		//rather than as an explicit requirement for a planet.
		double weight = 1.0;
		if(type.level == 0) {
			weight *= 2.0;
		}
		else {
			weight /= sqr(double(1 + type.level));
			weight *= 0.001;
		}
		if(type.cls is foodClass || type.cls is waterClass)
			weight *= 10.0;
		if(type.cls is scalableClass)
			weight *= 0.0001;
		if(type.totalPressure > 0)
			weight *= double(type.totalPressure);
		if(race !is null)
			weight *= race.getGenericUsefulness(type);
		return weight;
	}

	ColonizeData@ colonize(Planet& pl) {
		if(log)
			ai.print("queue colonization", pl);

		ColonizeData data;
		data.id = nextColonizeId++;
		@data.target = pl;

		budget.spend(BT_Colonization, 0, ai.behavior.colonizeBudgetCost);

		colonizing.insertLast(data);
		awaitingSource.insertLast(data);
		return data;
	}

	ColonizeData@ colonize(ResourceSpec@ spec) {
		Planet@ newColony;
		double w;
		double bestWeight = 0.0;

		for(uint i = 0, cnt = potentials.length; i < cnt; ++i) {
			auto@ p = potentials[i];

			Region@ reg = p.pl.region;
			if(reg is null)
				continue;
			if(!spec.meets(p.resource))
				continue;
			if(isColonizing(p.pl))
				continue;
			//Skip planets out of our new territory target if we are colonizing a new one
			if (_newTerritoryTarget !is null && p.pl.region !is _newTerritoryTarget)
				continue;

			auto@ sys = systems.getAI(reg);
			w = 1.0;
			if (sys.border)
				w *= 0.25;
			if (!sys.owned && !sys.border)
				w /= 0.25;
			if (sys.obj.PlanetsMask & ~ai.mask != 0)
				w *= 0.25;
			if (w > bestWeight) {
				@newColony = p.pl;
				bestWeight = w;
			}
		}

		if(newColony !is null)
			return colonize(newColony);
		else
			return null;
	}

	array<PotentialColonize@> potentials;
	void checkSystem(SystemAI@ sys) {
		uint presentMask = sys.seenPresent;
		if(presentMask & ai.mask == 0) {
			if(!ai.behavior.colonizeEnemySystems && (presentMask & ai.enemyMask) != 0)
				return;
			if(!ai.behavior.colonizeNeutralOwnedSystems && (presentMask & ai.neutralMask) != 0)
				return;
			if(!ai.behavior.colonizeAllySystems && (presentMask & ai.allyMask) != 0)
				return;
		}

		double sysWeight = 1.0;
		if(presentMask & ai.mask == 0)
			sysWeight *= ai.behavior.weightOutwardExpand;

		uint plCnt = sys.planets.length;
		for(uint n = 0; n < plCnt; ++n) {
			Planet@ pl = sys.planets[n];
			Empire@ visOwner = pl.visibleOwnerToEmp(ai.empire);
			if(!pl.valid || visOwner.valid)
				continue;
			if(isColonizing(pl))
				continue;
			if(penaltySet.contains(pl.id))
				continue;
			if(pl.quarantined)
				continue;

			int resId = pl.primaryResourceType;
			if(resId == -1)
				continue;

			PotentialColonize p;
			@p.pl = pl;
			@p.resource = getResource(resId);
			p.weight = 1.0 * sysWeight;
			//TODO: this should be weighted according to the position of the planet,
			//we should try to colonize things in favorable positions
			potentials.insertLast(p);
		}
	}

	double nextPotentialCheck = 0.0;
	array<PotentialColonize@>@ getPotentialColonize() {
		if(gameTime < nextPotentialCheck)
			return potentials;

		potentials.length = 0;
		for(uint i = 0, cnt = systems.owned.length; i < cnt; ++i)
			checkSystem(systems.owned[i]);
		for(uint i = 0, cnt = systems.outsideBorder.length; i < cnt; ++i)
			checkSystem(systems.outsideBorder[i]);

		if(needsNewTerritory) {
			for(uint i = 0, cnt = systems.all.length; i < cnt; ++i) {
				if(systems.all[i].explored)
					checkSystem(systems.all[i]);
			}
		}

		if(systems.owned.length == 0) {
			Region@ homeSys = ai.empire.HomeSystem;
			if(homeSys !is null) {
				auto@ homeAI = systems.getAI(homeSys);
				if(homeAI !is null)
					checkSystem(homeAI);
			}
			else {
				for(uint i = 0, cnt = systems.all.length; i < cnt; ++i) {
					if(systems.all[i].visible)
						checkSystem(systems.all[i]);
				}
			}
		}

		if(potentials.length == 0 && gameTime < 60.0)
			nextPotentialCheck = gameTime + 1.0;
		else
			nextPotentialCheck = gameTime + randomd(10.0, 40.0);

		//TODO: This should be able to colonize across empires we have trade agreements with?
		return potentials;
	}

	bool canColonize() {
		if(remainColonizations == 0)
			return false;
		if(curColonizations >= ai.behavior.guaranteeColonizations) {
			if(!budget.canSpend(BT_Colonization, 0, ai.behavior.colonizeBudgetCost))
				return false;
		}
		if(ai.behavior.maxConcurrentColonizations <= colonizing.length)
			return false;
		return true;
	}

	void doColonize() {
		remainColonizations -= 1;
		curColonizations += 1;
		budget.spend(BT_Colonization, 0, ai.behavior.colonizeBudgetCost);
	}

	ColonizeData@ genericExpand() {
		auto@ potentials = getPotentialColonize();

		//Do generic expansion using any remaining colonization steps we have
		if(ai.behavior.colonizeGenericExpand) {
			PotentialColonize@ expand;
			double w;
			double bestWeight = 0.0;

			for(uint i = 0, cnt = potentials.length; i < cnt; ++i) {
				auto@ p = potentials[i];
				w = p.weight * getGenericUsefulness(p.resource);
				modPotentialWeight(p, w);

				Region@ reg = p.pl.region;
				if(reg is null)
					continue;
				if(reg.PlanetsMask & ai.mask != 0)
					continue;
				//Skip planets out of our new territory target if we are colonizing a new one
				if (_newTerritoryTarget !is null && p.pl.region !is _newTerritoryTarget)
					continue;
				if(w == 0)
					continue;
				if (w > bestWeight) {
					@expand = p;
					bestWeight = w;
				}
			}

			if(expand !is null) {
				auto@ data = colonize(expand.pl);
				potentials.remove(expand);
				if (needsNewTerritory && _newTerritoryTarget is null) {
					//Check if our target planet is outside our tradable area
					bool found = false;
					for (uint i = 0, cnt = systems.owned.length; i < cnt; ++i) {
						if (systems.owned[i].obj is expand.pl.region)
							found = true;
					}
					for (uint i = 0, cnt = systems.outsideBorder.length; i < cnt; ++i) {
						if (systems.outsideBorder[i].obj is expand.pl.region)
							found = true;
					}
					if (!found)
						@_newTerritoryTarget = expand.pl.region;
				}
				return data;
			}
		}
		return null;
	}

	void turn() {
		//Figure out how much we can colonize
		remainColonizations = ai.behavior.maxColonizations;

		//Decide colonization phase
		if (_phase == CP_Expansion) {
			if (ai.empire.EstNextBudget < budget.criticalThreshold) {
				remainColonizations = 0;
				_phase = CP_Stabilization;
				if (log)
					ai.print("Colonization: entering stabilization phase with estimated next budget: " + ai.empire.EstNextBudget);
			}
			else if (ai.empire.EstNextBudget < budget.lowThreshold) {
				remainColonizations = 1;
				if (log)
					ai.print("Colonization: continuing expansion phase with estimated next budget: " + ai.empire.EstNextBudget);
			}
			else if (ai.empire.EstNextBudget < budget.mediumThreshold) {
				remainColonizations = min(2, ai.behavior.maxColonizations);
				if (log)
					ai.print("Colonization: continuing expansion phase with estimated next budget: " + ai.empire.EstNextBudget);
			}
		}
		else if (_phase == CP_Stabilization) {
			if (ai.empire.RemainingBudget > budget.mediumThreshold) {
				_phase = CP_Expansion;
				if (log)
					ai.print("Colonization: entering expansion phase with budget: " + ai.empire.RemainingBudget);
			}
			else {
				remainColonizations = 1;
				if (log)
					ai.print("Colonization: continuing stabilization phase with budget: " + ai.empire.RemainingBudget);
			}
		}

		if (ai.empire.EstNextBudget <= 0 && !ai.behavior.forbidScuttle) {
			//We are in trouble. Abandon planets sucking budget up
			if (log)
				ai.print("Colonization: negative budget, abandoning planets");
			auto@ homeworld = ai.empire.Homeworld;
			for (uint i = 0, cnt = planets.planets.length; i < cnt; i++) {
				auto@ pl = planets.planets[i].obj;
				if (pl is homeworld)
					continue;
				int resId = pl.primaryResourceType;
				if(resId == -1)
					continue;
				const ResourceType@ type = getResource(resId);
				if ((type.cls is scalableClass || type.level > 0) && pl.resourceLevel == 0) {
					pl.forceAbandon();
				}
			}
			//If we are still in trouble, abandon more planets
			if (ai.empire.EstNextBudget <= 0) {
				for (uint i = 0, cnt = planets.planets.length; i < cnt; i++) {
					auto@ pl = planets.planets[i].obj;
					if (pl is homeworld)
						continue;
					int resId = pl.primaryResourceType;
					if(resId == -1)
						continue;
					const ResourceType@ type = getResource(resId);
					if ((type.cls is foodClass || type.cls is waterClass) && !pl.primaryResourceExported)
						pl.forceAbandon();
				}
				//More!
				if (ai.empire.EstNextBudget <= 0) {
					for (uint i = 0, cnt = planets.planets.length; i < cnt; i++) {
						auto@ pl = planets.planets[i].obj;
						if (pl is homeworld)
							continue;
						int resId = pl.primaryResourceType;
						if(resId == -1)
							continue;
						const ResourceType@ type = getResource(resId);
						if (!(type.cls is foodClass || type.cls is waterClass || type.cls is scalableClass) && type.level == 0)
							pl.forceAbandon();
					}
				}
			}
		}

		//Check if we need to push for territory
		if (shouldForceExpansion()) {
			//If we already spent at least three turns trying to extend our territory, colonize a new one
			if (needsMoreTerritory && _territoryRequests >= 3)
				_needsNewTerritory = true;
			else {
				_needsMoreTerritory = true;
				_territoryRequests++;
			}
		}
		else {
			_needsMoreTerritory = false;
			_needsNewTerritory = false;
			_territoryRequests = 0;
			@_newTerritoryTarget = null;
		}

		prevColonizations = curColonizations;
		curColonizations = 0;

		updateSources();

		if(log) {
			ai.print("Empire colonization standings at "+formatGameTime(gameTime)+":");
			for(uint i = 0, cnt = getEmpireCount(); i < cnt; ++i) {
				Empire@ other = getEmpire(i);
				if(other.major)
					ai.print("  "+ai.pad(other.name, 20)+" - "+ai.pad(other.TotalPlanets.value+" planets", 15)+" - "+other.points.value+" points");
			}
		}
	}

	bool shouldQueueFor(const ResourceSpec@ spec, ColonizeQueue@ inside = null) {
		auto@ list = inside is null ? this.queue : inside.children;
		for(uint i = 0, cnt = list.length; i < cnt; ++i) {
			auto@ q = list[i];

			//haven't managed to resolve it fully, skip it as well
			if(spec.type == RST_Level_Specific) {
				if(q.spec.type == RST_Level_Specific && q.spec.level == spec.level) {
					if(!isResolved(q))
						return false;
				}
			}

			//Check anything inner to this tree element
			if(!shouldQueueFor(spec, q))
				return false;
		}

		return true;
	}

	bool shouldQueueFor(ImportData@ imp, ColonizeQueue@ inside = null) {
		auto@ list = inside is null ? this.queue : inside.children;
		for(uint i = 0, cnt = list.length; i < cnt; ++i) {
			auto@ q = list[i];

			//If we already have this in our queue tree, don't colonize it again
			if(imp.forLevel) {
				if(q.forData is imp)
					return false;
				if(q.parent !is null && q.parent.step !is null && q.parent.step.target is imp.obj) {
					if(q.spec == imp.spec)
						return false;
				}
			}

			//If we're already trying to get something of this level, but we
			//haven't managed to resolve it fully, skip it as well
			if(imp.spec.type == RST_Level_Specific) {
				if(q.spec.type == RST_Level_Specific && q.spec.level == imp.spec.level) {
					if(!isResolved(q))
						return false;
				}
			}

			//Check anything inner to this tree element
			if(!shouldQueueFor(imp, q))
				return false;
		}

		return true;
	}

	ColonizeQueue@ queueColonize(ResourceSpec& spec, bool place = true) {
		ColonizeQueue q;
		@q.spec = spec;

		if(place)
			queue.insertLast(q);
		return q;
	}

	bool unresolvedInQueue() {
		for(uint i = 0, cnt = queue.length; i < cnt; ++i) {
			auto@ q = queue[i];
			if(q.parent !is null)
				continue;
			if(!isResolved(q))
				return true;
		}
		return false;
	}

	bool isResolved(ColonizeQueue@ q) {
		if(q.step is null || q.step.canceled)
			return false;
		for(uint i = 0 , cnt = q.children.length; i < cnt; ++i) {
			if(!isResolved(q.children[i]))
				return false;
		}
		return true;
	}

	bool isResolved(ImportData@ req, ColonizeQueue@ inside = null) {
		auto@ list = inside is null ? this.queue : inside.children;
		for(uint i = 0, cnt = list.length; i < cnt; ++i) {
			auto@ q = list[i];
			if(q.forData is req)
				return isResolved(q);
			if(isResolved(req, inside=q))
				return true;
		}
		return false;
	}

	Planet@ resolve(ColonizeQueue@ q) {
		if(q.step !is null)
			return q.step.target;

		auto@ potentials = getPotentialColonize();
		PotentialColonize@ take;
		double takeWeight = 0.0;

		for(uint i = 0, cnt = potentials.length; i < cnt; ++i) {
			auto@ p = potentials[i];
			if(!q.spec.meets(p.resource))
				continue;

			//Skip planets out of our new territory target if we are colonizing a new one
			if (_newTerritoryTarget !is null && p.pl.region !is _newTerritoryTarget)
				continue;

			if(p.weight > takeWeight) {
				takeWeight = p.weight;
				@take = p;
			}
		}

		if(take !is null) {
			@q.target = take.pl;
			potentials.remove(take);

			array<ResourceSpec@> allReqs;
			for(uint i = 1, cnt = take.resource.level; i <= cnt; ++i) {
				const PlanetLevel@ lvl = getPlanetLevel(take.pl, i);
				if(lvl !is null) {
					array<ResourceSpec@> reqList;
					array<ResourceSpec@> curReqs;
					curReqs = allReqs;

					const ResourceRequirements@ reqs = lvl.reqs;
					for(uint i = 0, cnt = reqs.reqs.length; i < cnt; ++i) {
						auto@ need = reqs.reqs[i];

						bool found = false;
						for(uint n = 0, ncnt = curReqs.length; n < ncnt; ++n) {
							if(curReqs[n].implements(need)) {
								found = true;
								curReqs.removeAt(n);
								break;
							}
						}

						if(!found)
							reqList.insertLast(implementSpec(need));
					}

					reqList.sortDesc();

					auto@ resRace = cast<RaceResources>(race);
					if(resRace !is null)
						resRace.levelRequirements(take.pl, i, reqList);

					for(uint i = 0, cnt = reqList.length; i < cnt; ++i) {
						auto@ spec = reqList[i];
						allReqs.insertLast(spec);

						auto@ inner = queueColonize(spec, place=false);

						@inner.parent = q;
						q.children.insertLast(inner);

						resolve(inner);
					}
				}
			}

			return take.pl;
		}

		return null;
	}

	void kill(ColonizeQueue@ q) {
		for(uint i = 0, cnt = q.children.length; i < cnt; ++i)
			kill(q.children[i]);
		q.children.length = 0;
		if(q.forData !is null)
			q.forData.isColonizing = false;
		@q.parent = null;
	}

	void modPotentialWeight(PotentialColonize@ c, double& weight) {
		if(colonizeWeightObj !is null)
			weight /= c.pl.position.distanceTo(colonizeWeightObj.position)/1000.0;
	}

	bool update(ColonizeQueue@ q) {
		//See if we can find a matching import request
		if(q.forData is null && q.parent !is null && q.parent.target !is null) {
			for(uint i = 0, cnt = resources.requested.length; i < cnt; ++i) {
				auto@ req = resources.requested[i];
				if(req.isColonizing)
					continue;
				if(req.obj !is q.parent.target)
					continue;
				if(req.spec != q.spec)
					continue;

				req.isColonizing = true;
				@q.forData = req;
			}
		}

		//Cancel everything if our request is already being met
		if(q.forData !is null && q.forData.beingMet) {
			kill(q);
			return false;
		}

		//If it's not resolved, try to resolve it
		if(q.target is null)
			resolve(q);

		//If the colonization failed, try to find a new planet for it
		if((q.step !is null && q.step.canceled) || (q.step is null && q.target !is null && !canBeColonized(q.target))) {
			auto@ potentials = getPotentialColonize();
			PotentialColonize@ take;
			double takeWeight = 0.0;

			for(uint i = 0, cnt = potentials.length; i < cnt; ++i) {
				auto@ p = potentials[i];
				if(!q.spec.meets(p.resource))
					continue;

				//Skip planets out of our new territory target if we are colonizing a new one
				if (_newTerritoryTarget !is null && p.pl.region !is _newTerritoryTarget)
					continue;

				double w = p.weight;
				modPotentialWeight(p, w);

				if(w > takeWeight) {
					takeWeight = p.weight;
					@take = p;
				}
			}

			if(take !is null) {
				@q.target = take.pl;
				@q.step = null;
				potentials.remove(take);
			}
		}

		for(uint i = 0, cnt = q.children.length; i < cnt; ++i) {
			if(!update(q.children[i])) {
				@q.children[i].parent = null;
				q.children.removeAt(i);
				--i; --cnt;
			}
		}

		if(q.children.length == 0 && q.step !is null && q.step.completed) {
			if(q.forData !is null) {
				q.forData.isColonizing = false;

				PlanetAI@ plAI = planets.getAI(q.target);
				if(plAI !is null) {
					if(plAI.resources.length != 0) {
						WaitUsed wait;
						@wait.forData = q.forData;
						@wait.resource = plAI.resources[0];
						waiting.insertLast(wait);
						q.forData.isColonizing = true;
					}
				}
			}
			return false;
		}
		return true;
	}

	void updateQueue() {
		for(uint i = 0, cnt = queue.length; i < cnt; ++i) {
			auto@ q = queue[i];
			if(!update(q)) {
				queue.removeAt(i);
				--i; --cnt;
			}
		}
	}

	bool orderFromQueue(ColonizeQueue@ inside = null) {
		auto@ list = inside is null ? this.queue : inside.children;
		for(uint i = 0, cnt = list.length; i < cnt; ++i) {
			auto@ q = list[i];
			if(q.step is null && q.target !is null) {
				@q.step = colonize(q.target);
				return true;
			}

			if(orderFromQueue(q))
				return true;
		}
		return false;
	}

	void dumpQueue(ColonizeQueue@ inside = null) {
		auto@ list = inside is null ? this.queue : inside.children;

		string prefix = "";
		if(inside !is null) {
			prefix += " ";
			ColonizeQueue@ top = inside.parent;
			while(top !is null) {
				prefix += " ";
				@top = top.parent;
			}
		}

		for(uint i = 0, cnt = list.length; i < cnt; ++i) {
			auto@ q = list[i];

			string txt = "- "+q.spec.dump();
			if(q.forData !is null)
				txt += " for request "+q.forData.obj.name+"";
			else if(q.parent !is null && q.parent.target !is null)
				txt += " for parent "+q.parent.target.name+"";
			if(q.target !is null)
				txt += " ==> "+q.target.name;
			print(prefix+txt);

			dumpQueue(q);
		}
	}

	void fillQueueFromRequests() {
		for(uint i = 0, cnt = resources.requested.length; i < cnt && remainColonizations > 0; ++i) {
			auto@ req = resources.requested[i];
			if(!req.isOpen)
				continue;
			if(!req.cycled)
				continue;
			if(req.claimedFor)
				continue;
			if(req.isColonizing)
				continue;

			if(shouldQueueFor(req)) {
				auto@ q = queueColonize(req.spec);
				@q.forData = req;
				req.isColonizing = true;
			}
		}
	}

};

AIComponent@ createColonization() {
	return Colonization();
}

// Consider
// --------
// Helps AI usage hints to consider various things in the empire.
//

import empire_ai.weasel.WeaselAI;
import empire_ai.weasel.Systems;
import empire_ai.weasel.Planets;
import empire_ai.weasel.Development;
import empire_ai.weasel.Construction;
import empire_ai.weasel.Fleets;
import empire_ai.weasel.Resources;
import empire_ai.weasel.Colonization;
import empire_ai.weasel.Intelligence;

import buildings;
import ai.consider;

from ai.artifacts import ArtifactConsider;
from orbitals import OrbitalModule;

class Consider : AIComponent, Considerer {
	Systems@ systems;
	Fleets@ fleets;
	Planets@ planets;
	Construction@ construction;
	Development@ development;
	Resources@ resources;
	Intelligence@ intelligence;
	Colonization@ colonization;

	void create() {
		@systems = cast<Systems>(ai.systems);
		@fleets = cast<Fleets>(ai.fleets);
		@planets = cast<Planets>(ai.planets);
		@development = cast<Development>(ai.development);
		@construction = cast<Construction>(ai.construction);
		@resources = cast<Resources>(ai.resources);
		@intelligence = cast<Intelligence>(ai.intelligence);
		@colonization = cast<Colonization>(ai.colonization);
	}

	Empire@ get_empire() {
		return ai.empire;
	}

	Object@ secondary;
	ArtifactConsider@ artifactConsider;
	double bestWeight;
	ImportData@ request;
	const BuildingType@ bldType;
	const OrbitalModule@ _module;
	ConsiderComponent@ comp;
	ConsiderFilter@ cfilter;

	double get_selectedWeight() {
		return bestWeight;
	}

	Object@ get_currentSupplier() {
		return secondary;
	}

	ArtifactConsider@ get_artifact() {
		return artifactConsider;
	}

	void set_artifact(ArtifactConsider@ cons) {
		@artifactConsider = cons;
	}

	double get_idleTime() {
		if(request !is null)
			return gameTime - request.idleSince;
		return 0.0;
	}

	double timeSinceMatchingColonize() {
		if(request is null)
			return INFINITY;
		return colonization.timeSinceMatchingColonize(request.spec);
	}

	const BuildingType@ get_building() {
		return bldType;
	}

	void set_building(const BuildingType@ type) {
		@bldType = type;
	}
	
	const OrbitalModule@ get_module() {
		return _module;
	}
	
	void set_module(const OrbitalModule@ type) {
		@_module = type;
	}

	ConsiderComponent@ get_component() {
		return comp;
	}

	void set_component(ConsiderComponent@ comp) {
		@this.comp = comp;
	}

	void set_filter(ConsiderFilter@ filter) {
		@this.cfilter = filter;
	}

	void clear() {
		@secondary = null;
		@artifactConsider = null;
		@request = null;
		@comp = null;
		@bldType = null;
		@cfilter = null;
	}

	Object@ OwnedSystems(const ConsiderHook& hook, uint limit = uint(-1)) {
		Object@ best;
		bestWeight = 0.0;

		uint offset = randomi(0, systems.owned.length-1);
		uint cnt = min(systems.owned.length, limit);
		for(uint i = 0; i < cnt; ++i) {
			uint index = (i+offset) % systems.owned.length;
			Region@ obj = systems.owned[index].obj;
			if(obj !is null) {
				if(cfilter !is null && !cfilter.filter(obj))
					continue;
				double w = hook.consider(this, obj);
				if(w > bestWeight) {
					bestWeight = w;
					@best = obj;
				}
			}
		}

		clear();
		return best;
	}

	Object@ Fleets(const ConsiderHook& hook) {
		Object@ best;
		bestWeight = 0.0;
		for(uint i = 0, cnt = fleets.fleets.length; i < cnt; ++i) {
			Object@ fleet = fleets.fleets[i].obj;
			if(fleet !is null) {
				if(cfilter !is null && !cfilter.filter(fleet))
					continue;
				double w = hook.consider(this, fleet);
				if(w > bestWeight) {
					bestWeight = w;
					@best = fleet;
				}
			}
		}

		clear();
		return best;
	}

	Object@ BorderSystems(const ConsiderHook& hook) {
		Object@ best;
		bestWeight = 0.0;
		for(uint i = 0, cnt = systems.border.length; i < cnt; ++i) {
			Region@ obj = systems.border[i].obj;
			if(obj.PlanetsMask & ~ai.mask == 0)
				continue;
			if(obj !is null) {
				if(cfilter !is null && !cfilter.filter(obj))
					continue;
				double w = hook.consider(this, obj);
				if(w > bestWeight) {
					bestWeight = w;
					@best = obj;
				}
			}
		}
		for(uint i = 0, cnt = systems.outsideBorder.length; i < cnt; ++i) {
			Region@ obj = systems.outsideBorder[i].obj;
			if(obj.PlanetsMask & ~ai.mask == 0)
				continue;
			if(obj !is null) {
				if(cfilter !is null && !cfilter.filter(obj))
					continue;
				double w = hook.consider(this, obj);
				if(w > bestWeight) {
					bestWeight = w;
					@best = obj;
				}
			}
		}

		clear();
		return best;
	}

	Object@ OtherSystems(const ConsiderHook& hook) {
		Object@ best;
		bestWeight = 0.0;
		for(uint i = 0, cnt = intelligence.intel.length; i < cnt; ++i) {
			auto@ intel = intelligence.intel[i];
			if(intel is null)
				continue;

			for(uint i = 0, cnt = intel.theirOwned.length; i < cnt; ++i) {
				Region@ obj = intel.theirOwned[i].obj;
				if(obj.PlanetsMask & ~ai.mask == 0)
					continue;
				if(obj !is null) {
					if(cfilter !is null && !cfilter.filter(obj))
						continue;
					double w = hook.consider(this, obj);
					if(w > bestWeight) {
						bestWeight = w;
						@best = obj;
					}
				}
			}
		}

		clear();
		return best;
	}
	
	Object@ SystemsInTerritory(const ConsiderHook& hook, const Territory& territory, uint limit = uint(-1)) {
		Object@ best;
		bestWeight = 0.0;

		uint regionCount = territory.getRegionCount();
		uint offset = randomi(0, regionCount -1);
		uint cnt = min(regionCount, limit);
		for(uint i = 0; i < cnt; ++i) {
			uint index = (i+offset) % regionCount;
			Region@ obj = territory.getRegion(index);
			if(obj !is null) {
				if(cfilter !is null && !cfilter.filter(obj))
					continue;
				double w = hook.consider(this, obj);
				if(w > bestWeight) {
					bestWeight = w;
					@best = obj;
				}
			}
		}

		clear();
		return best;
	}

	Object@ ImportantPlanets(const ConsiderHook& hook) {
		Object@ best;
		bestWeight = 0.0;
		for(uint i = 0, cnt = development.focuses.length; i < cnt; ++i) {
			Object@ obj = development.focuses[i].obj;
			if(obj !is null) {
				if(cfilter !is null && !cfilter.filter(obj))
					continue;
				double w = hook.consider(this, obj);
				if(w > bestWeight) {
					bestWeight = w;
					@best = obj;
				}
			}
		}

		clear();
		return best;
	}
	
	Object@ ImportantPlanetsInTerritory(const ConsiderHook& hook, const Territory& territory) {
		Object@ best;;
		bestWeight = 0.0;
		for(uint i = 0, cnt = development.focuses.length; i < cnt; ++i) {
			Object@ obj = development.focuses[i].obj;
			if(obj !is null) {
				if(cfilter !is null && !cfilter.filter(obj))
					continue;
				if (obj.region !is null) {
					if (obj.region.getTerritory(ai.empire) !is territory)
						continue;
					double w = hook.consider(this, obj);
					if(w > bestWeight) {
						bestWeight = w;
						@best = obj;
					}
				}
			}
		}

		clear();
		return best;
	}

	Object@ AllPlanets(const ConsiderHook& hook) {
		Object@ best;
		bestWeight = 0.0;
		for(uint i = 0, cnt = planets.planets.length; i < cnt; ++i) {
			Object@ obj = planets.planets[i].obj;
			if(obj !is null) {
				if(cfilter !is null && !cfilter.filter(obj))
					continue;
				double w = hook.consider(this, obj);
				if(w > bestWeight) {
					bestWeight = w;
					@best = obj;
				}
			}
		}

		clear();
		return best;
	}
	
	Object@ PlanetsInTerritory(const ConsiderHook& hook, const Territory& territory) {
		Object@ best;
		bestWeight = 0.0;
		for(uint i = 0, cnt = planets.planets.length; i < cnt; ++i) {
			Object@ obj = planets.planets[i].obj;
			if(obj !is null) {
				if(cfilter !is null && !cfilter.filter(obj))
					continue;
				if (obj.region !is null) {
					if (obj.region.getTerritory(ai.empire) !is territory)
						continue;
					double w = hook.consider(this, obj);
					if(w > bestWeight) {
						bestWeight = w;
						@best = obj;
					}
				}
			}
		}

		clear();
		return best;
	}

	Object@ SomePlanets(const ConsiderHook& hook, uint count, bool alwaysImportant) {
		Object@ best;
		bestWeight = 0.0;
		if(alwaysImportant) {
			for(uint i = 0, cnt = development.focuses.length; i < cnt; ++i) {
				Object@ obj = development.focuses[i].obj;
				if(obj !is null) {
					if(cfilter !is null && !cfilter.filter(obj))
						continue;
					double w = hook.consider(this, obj);
					if(w > bestWeight) {
						bestWeight = w;
						@best = obj;
					}
				}
			}
		}

		uint planetCount = planets.planets.length;
		uint offset = randomi(0, planetCount-1);
		uint cnt = min(count, planetCount);
		for(uint i = 0; i < cnt; ++i) {
			uint index = (offset+i) % planetCount;
			Object@ obj = planets.planets[index].obj;
			if(obj !is null) {
				if(cfilter !is null && !cfilter.filter(obj))
					continue;
				double w = hook.consider(this, obj);
				if(w > bestWeight) {
					bestWeight = w;
					@best = obj;
				}
			}
		}

		clear();
		return best;
	}

	Object@ FactoryPlanets(const ConsiderHook& hook) {
		Object@ best;
		bestWeight = 0.0;
		for(uint i = 0, cnt = construction.factories.length; i < cnt; ++i) {
			Object@ obj = construction.factories[i].obj;
			if(obj !is null && obj.isPlanet) {
				if(cfilter !is null && !cfilter.filter(obj))
					continue;
				double w = hook.consider(this, obj);
				if(w > bestWeight) {
					bestWeight = w;
					@best = obj;
				}
			}
		}

		clear();
		return best;
	}

	Object@ MatchingImportRequests(const ConsiderHook& hook, const ResourceType@ type, bool considerExisting) {
		Object@ best;
		bestWeight = 0.0;
		for(uint i = 0, cnt = resources.requested.length; i < cnt; ++i) {
			ImportData@ req = resources.requested[i];
			if(!considerExisting) {
				if(req.beingMet || req.claimedFor)
					continue;
			}
			if(req.spec.meets(type, req.obj, req.obj)) {
				@secondary = null;
				@request = req;
				double w = hook.consider(this, req.obj);
				if(w > bestWeight) {
					if(cfilter !is null && !cfilter.filter(req.obj))
						continue;
					bestWeight = w;
					@best = req.obj;
				}
			}
		}
		if(considerExisting) {
			for(uint i = 0, cnt = resources.used.length; i < cnt; ++i) {
				ExportData@ res = resources.used[i];
				ImportData@ req = res.request;
				if(req !is null && req.spec.meets(type, req.obj, req.obj)) {
					@secondary = res.obj;
					@request = req;
					double w = hook.consider(this, req.obj);
					if(w > bestWeight) {
						if(cfilter !is null && !cfilter.filter(req.obj))
							continue;
						bestWeight = w;
						@best = req.obj;
					}
				}
			}
		}

		clear();
		return best;
	}
};

AIComponent@ createConsider() {
	return Consider();
}

// Construction
// ------------
// Manages factories and allows build requests for flagships, orbitals, and
// anything else that requires labor.
//

import empire_ai.weasel.WeaselAI;
import empire_ai.weasel.Budget;
import empire_ai.weasel.Planets;
import empire_ai.weasel.Designs;
import empire_ai.weasel.Resources;
import empire_ai.weasel.Systems;
import empire_ai.weasel.Orbitals;

import orbitals;
import saving;

import systems;
import regions.regions;

import ai.construction;

from constructible import ConstructibleType;
from constructions import ConstructionType, getConstructionType;

class AllocateConstruction : IConstruction {
	protected bool _completed = false;
	protected bool _started = false;
	
	protected int _id = -1;
	uint moneyType = BT_Development;
	Factory@ tryFactory;
	double maxTime = INFINITY;
	double completedAt = 0;
	AllocateBudget@ alloc;
	int cost = 0;
	int maintenance = 0;
	double priority = 1.0;

	AllocateConstruction() {
	}
	
	int id {
		get const { return _id; }
		set { _id = value; }
	}
	
	bool get_started() const { return _started; }
	
	bool completed {
		get const { return _completed; }
		set { _completed = value; }
	}

	void _save(Construction& construction, SaveFile& file) {
		file << moneyType;
		construction.saveFactory(file, tryFactory);
		file << maxTime;
		file << _completed;
		file << _started;
		file << completedAt;
		construction.budget.saveAlloc(file, alloc);
		file << cost;
		file << maintenance;
		file << priority;
		save(construction, file);
	}

	void save(Construction& construction, SaveFile& file) {
	}

	void _load(Construction& construction, SaveFile& file) {
		file >> moneyType;
		@tryFactory = construction.loadFactory(file);
		file >> maxTime;
		file >> _completed;
		file >> _started;
		file >> completedAt;
		@alloc = construction.budget.loadAlloc(file);
		file >> cost;
		file >> maintenance;
		file >> priority;
		load(construction, file);
	}

	void load(Construction& construction, SaveFile& file) {
	}

	bool tick(AI& ai, Construction& construction, double time) {
		if(tryFactory !is null && alloc.allocated) {
			construction.start(tryFactory, this);
			return false;
		}
		return true;
	}

	void update(AI& ai, Factory@ f) {
		@alloc = cast<Budget>(ai.budget).allocate(moneyType, cost, maintenance, priority);
	}

	double laborCost(AI& ai, Object@ obj) {
		return 0.0;
	}

	bool canBuild(AI& ai, Factory@ f) {
		return true;
	}

	void construct(AI& ai, Factory@ f) {
		_started = true;
	}

	string toString() {
		return "construction";
	}
};

class BuildFlagship : AllocateConstruction, IFlagshipConstruction {
	protected const Design@ _design;
	double baseLabor = 0.0;
	DesignTarget@ target;

	BuildFlagship() {
	}

	BuildFlagship(const Design@ dsg) {
		set(dsg);
	}

	BuildFlagship(DesignTarget@ target) {
		@this.target = target;
	}
	
	const Design@ get_design() const { return _design; }

	void save(Construction& construction, SaveFile& file) {
		file << baseLabor;
		if(_design !is null) {
			file.write1();
			file << _design;
		}
		else {
			file.write0();
		}
		construction.designs.saveDesign(file, target);
	}

	void load(Construction& construction, SaveFile& file) {
		file >> baseLabor;
		if(file.readBit())
			file >> _design;
		@target = construction.designs.loadDesign(file);
	}

	void set(const Design& dsg) {
		@_design = dsg.mostUpdated();
		baseLabor = _design.total(HV_LaborCost);
	}

	double laborCost(AI& ai, Object@ obj) {
		return baseLabor;
	}

	bool tick(AI& ai, Construction& construction, double time) override {
		if(target !is null) {
			if(target.active !is null) {
				set(target.active);
				@target = null;
			}
		}
		return AllocateConstruction::tick(ai, construction, time);
	}

	bool canBuild(AI& ai, Factory@ f) override {
		if(!f.obj.canBuildShips)
			return false;
		return _design !is null;
	}

	void update(AI& ai, Factory@ f) {
		double c = _design.total(HV_BuildCost);
		c *= double(f.obj.shipBuildCost) / 100.0;
		c *= f.obj.constructionCostMod;

		cost = ceil(c);
		maintenance = ceil(_design.total(HV_MaintainCost));

		AllocateConstruction::update(ai, f);
	}

	void construct(AI& ai, Factory@ f) {
		f.obj.buildFlagship(_design);
		AllocateConstruction::construct(ai, f);
	}

	string toString() {
		if(_design is null)
			return "flagship (design in progress)";
		return "flagship " + _design.name;
	}
};

class BuildFlagshipSourced : BuildFlagship {
	Object@ buildAt;
	Object@ buildFrom;

	BuildFlagshipSourced() {
	}

	BuildFlagshipSourced(const Design@ dsg) {
		set(dsg);
	}

	BuildFlagshipSourced(DesignTarget@ target) {
		@this.target = target;
	}

	void save(Construction& construction, SaveFile& file) override {
		BuildFlagship::save(construction, file);
		file << buildAt;
		file << buildFrom;
	}

	void load(Construction& construction, SaveFile& file) override {
		BuildFlagship::load(construction, file);
		file >> buildAt;
		file >> buildFrom;
	}

	bool canBuild(AI& ai, Factory@ f) override {
		if(buildAt !is null && f.obj !is buildAt)
			return false;
		return BuildFlagship::canBuild(ai, f);
	}

	void construct(AI& ai, Factory@ f) override {
		f.obj.buildFlagship(_design, constructFrom=buildFrom);
		AllocateConstruction::construct(ai, f);
	}
};

class BuildStation : AllocateConstruction, IStationConstruction {
	protected const Design@ _design;
	double baseLabor = 0.0;
	DesignTarget@ target;
	vec3d position;
	bool local = false;

	BuildStation() {
	}

	BuildStation(const Design@ dsg, const vec3d& position) {
		this.position = position;
		set(dsg);
	}

	BuildStation(DesignTarget@ target, const vec3d& position) {
		this.position = position;
		@this.target = target;
	}

	BuildStation(const Design@ dsg, bool local) {
		this.local = true;
		set(dsg);
	}

	BuildStation(DesignTarget@ target, bool local) {
		@this.target = target;
		this.local = true;
	}
	
	const Design@ get_design() const { return _design; }

	void save(Construction& construction, SaveFile& file) {
		file << baseLabor;
		file << position;
		file << local;
		if(_design !is null) {
			file.write1();
			file << _design;
		}
		else {
			file.write0();
		}
		construction.designs.saveDesign(file, target);
	}

	void load(Construction& construction, SaveFile& file) {
		file >> baseLabor;
		file >> position;
		file >> local;
		if(file.readBit())
			file >> _design;
		@target = construction.designs.loadDesign(file);
	}

	void set(const Design& dsg) {
		@_design = dsg.mostUpdated();
		baseLabor = _design.total(HV_LaborCost);
	}

	double laborCost(AI& ai, Object@ obj) {
		double labor = baseLabor;

		labor *= obj.owner.OrbitalLaborCostFactor;

		if(!local) {
			Region@ reg = getRegion(position);
			Region@ targReg = obj.region;
			if(reg !is null && targReg !is null) {
				int hops = cast<Systems>(ai.systems).tradeDistance(targReg, reg);
				if(hops > 0) {
					double penalty = 1.0 + config::ORBITAL_LABOR_COST_STEP * double(hops);
					baseLabor *= penalty;
				}
			}
		}
		return labor;
	}

	bool tick(AI& ai, Construction& construction, double time) override {
		if(target !is null) {
			if(target.active !is null) {
				set(target.active);
				@target = null;
			}
		}
		return AllocateConstruction::tick(ai, construction, time);
	}

	bool canBuild(AI& ai, Factory@ f) override {
		if(_design is null)
			return false;
		if(!f.obj.canBuildOrbitals)
			return false;
		Region@ targReg = f.obj.region;
		if(targReg is null)
			return false;
		if(!local) {
			Region@ reg = getRegion(position);
			if(reg is null)
				return false;
			if(!cast<Systems>(ai.systems).canTrade(targReg, reg))
				return false;
		}
		return true;
	}

	void update(AI& ai, Factory@ f) {
		double c = _design.total(HV_BuildCost);
		c *= f.obj.owner.OrbitalBuildCostFactor;
		c *= f.obj.constructionCostMod;

		cost = ceil(c);
		maintenance = ceil(_design.total(HV_MaintainCost));

		AllocateConstruction::update(ai, f);
	}

	void construct(AI& ai, Factory@ f) {
		if(local) {
			position = f.obj.position;
			vec2d offset = random2d(f.obj.radius + 10.0, f.obj.radius + 100.0);
			position.x += offset.x;
			position.z += offset.y;
		}
		f.obj.buildStation(_design, position);
		AllocateConstruction::construct(ai, f);
	}

	string toString() {
		if(_design is null)
			return "station (design in progress)";
		return "station " + _design.name;
	}
};

class BuildOrbital : AllocateConstruction, IOrbitalConstruction {
	protected const OrbitalModule@ _module;
	double baseLabor = 0.0;
	const Planet@ planet;
	bool local = false;
	vec3d position;

	BuildOrbital() {
	}

	BuildOrbital(const OrbitalModule@ module, const vec3d& position) {
		this.position = position;
		@this._module = module;
		baseLabor = module.laborCost;
	}

	BuildOrbital(const OrbitalModule@ module, bool local) {
		this.local = true;
		@this._module = module;
		baseLabor = module.laborCost;
	}

	BuildOrbital(const OrbitalModule@ module, const Planet@ planet) {
		this.local = true;
		@this.planet = planet;
		@this._module = module;
		baseLabor = module.laborCost;
	}
	
	const OrbitalModule@ get_module() const { return _module; }

	void save(Construction& construction, SaveFile& file) {
		file << baseLabor;
		file << position;
		file << local;
		file.writeIdentifier(SI_Orbital, _module.id);
	}

	void load(Construction& construction, SaveFile& file) {
		file >> baseLabor;
		file >> position;
		file >> local;
		@_module = getOrbitalModule(file.readIdentifier(SI_Orbital));
	}

	double laborCost(AI& ai, Object@ obj) {
		double labor = baseLabor;

		labor *= obj.owner.OrbitalLaborCostFactor;

		if(!local) {
			Region@ reg = getRegion(position);
			Region@ targReg = obj.region;
			if(reg !is null && targReg !is null) {
				int hops = cast<Systems>(ai.systems).tradeDistance(targReg, reg);
				if(hops > 0) {
					double penalty = 1.0 + config::ORBITAL_LABOR_COST_STEP * double(hops);
					baseLabor *= penalty;
				}
			}
		}
		return labor;
	}

	bool tick(AI& ai, Construction& construction, double time) override {
		return AllocateConstruction::tick(ai, construction, time);
	}

	bool canBuild(AI& ai, Factory@ f) override {
		if(_module is null)
			return false;
		if(!f.obj.canBuildOrbitals)
			return false;
		Region@ targReg = f.obj.region;
		if(targReg is null)
			return false;
		if(!local) {
			Region@ reg = getRegion(position);
			if(reg is null)
				return false;
			if(!cast<Systems>(ai.systems).canTrade(targReg, reg))
				return false;
		}
		return true;
	}

	void update(AI& ai, Factory@ f) {
		double c = _module.buildCost;
		c *= f.obj.owner.OrbitalBuildCostFactor;
		c *= f.obj.constructionCostMod;

		cost = ceil(c);
		maintenance = _module.maintenance;

		AllocateConstruction::update(ai, f);
	}

	void construct(AI& ai, Factory@ f) {
		if(local) {
			if (planet !is null) {
				position = planet.position;
				vec2d offset = random2d(planet.OrbitSize * 0.8, planet.OrbitSize * 0.9);
				position.x += offset.x;
				position.z += offset.y;
			}
			else {
				position = f.obj.position;
				//vec2d offset = random2d(f.obj.radius + 10.0, f.obj.radius + 100.0);
				if (f.plAI !is null) {
					vec2d offset = random2d(f.plAI.obj.OrbitSize * 0.8, f.plAI.obj.OrbitSize * 0.9);
					position.x += offset.x;
					position.z += offset.y;
				}
			}
		}
		f.obj.buildOrbital(_module.id, position);
		AllocateConstruction::construct(ai, f);
	}

	string toString() {
		return "orbital " + _module.name;
	}
};

class RetrofitShip : AllocateConstruction {
	Ship@ ship;
	double labor;

	RetrofitShip() {
	}

	RetrofitShip(Ship@ ship) {
		@this.ship = ship;
		labor = ship.getRetrofitLabor();
		cost = ship.getRetrofitCost();
	}

	void save(Construction& construction, SaveFile& file) {
		file << ship;
		file << labor;
	}

	void load(Construction& construction, SaveFile& file) {
		file >> ship;
		file >> labor;
	}

	double laborCost(AI& ai, Object@ obj) {
		return labor;
	}

	bool canBuild(AI& ai, Factory@ f) override {
		if(!f.obj.canBuildShips)
			return false;
		Region@ reg = ship.region;
		return reg !is null && reg is f.obj.region;
	}

	void construct(AI& ai, Factory@ f) {
		ship.retrofitFleetAt(f.obj);
		AllocateConstruction::construct(ai, f);
	}

	string toString() {
		return "retrofit "+ship.name;
	}
};

class BuildConstruction : AllocateConstruction {
	const ConstructionType@ consType;

	BuildConstruction() {
	}

	BuildConstruction(const ConstructionType@ consType) {
		@this.consType = consType;
	}

	void save(Construction& construction, SaveFile& file) {
		file.writeIdentifier(SI_ConstructionType, consType.id);
	}

	void load(Construction& construction, SaveFile& file) {
		@consType = getConstructionType(file.readIdentifier(SI_ConstructionType));
	}

	double laborCost(AI& ai, Object@ obj) {
		if(obj is null)
			return consType.laborCost;
		return consType.getLaborCost(obj);
	}

	bool canBuild(AI& ai, Factory@ f) override {
		return consType.canBuild(f.obj, ignoreCost=true);
	}

	void update(AI& ai, Factory@ f) {
		cost = consType.getBuildCost(f.obj);
		maintenance = consType.getMaintainCost(f.obj);

		AllocateConstruction::update(ai, f);
	}

	void construct(AI& ai, Factory@ f) {
		f.obj.buildConstruction(consType.id);
		AllocateConstruction::construct(ai, f);
	}

	string toString() {
		return "construction "+consType.name;
	}
};

class Factory {
	Object@ obj;
	PlanetAI@ plAI;

	Factory@ exportingTo;

	AllocateConstruction@ active;
	double laborAim = 0.0;
	double laborIncome = 0.0;

	double idleSince = 0.0;
	double storedLabor = 0.0;
	double laborMaxStorage = 0.0;
	double buildingPenalty = 0.0;

	bool needsSupportLabor = false;
	double waitingSupportLabor = 0.0;
	uint curConstructionType = 0;
	bool valid = true;
	bool significantLabor = true;

	uint backgrounded = 0;
	Asteroid@ bgAsteroid;

	BuildingRequest@ curBuilding;
	ImportData@ curImport;

	void save(Construction& construction, SaveFile& file) {
		construction.planets.saveAI(file, plAI);
		construction.saveConstruction(file, active);
		file << laborAim;
		file << laborIncome;
		file << idleSince;
		file << storedLabor;
		file << laborMaxStorage;
		file << buildingPenalty;
		construction.planets.saveBuildingRequest(file, curBuilding);
		construction.resources.saveImport(file, curImport);
		file << backgrounded;
		file << bgAsteroid;
		file << curConstructionType;
		file << valid;
		file << needsSupportLabor;
		file << waitingSupportLabor;
		construction.saveFactory(file, exportingTo);
	}

	void load(Construction& construction, SaveFile& file) {
		@plAI = construction.planets.loadAI(file);
		@active = construction.loadConstruction(file);
		file >> laborAim;
		file >> laborIncome;
		file >> idleSince;
		file >> storedLabor;
		file >> laborMaxStorage;
		file >> buildingPenalty;
		@curBuilding = construction.planets.loadBuildingRequest(file);
		@curImport = construction.resources.loadImport(file);
		file >> backgrounded;
		file >> bgAsteroid;
		file >> curConstructionType;
		file >> valid;
		file >> needsSupportLabor;
		file >> waitingSupportLabor;
		@exportingTo = construction.loadFactory(file);
	}

	bool get_busy() {
		return active !is null;
	}

	bool get_needsLabor() {
		if(!valid)
			return false;
		if(obj.hasOrderedSupports)
			return true;
		if(active !is null)
			return true;
		if(needsSupportLabor)
			return true;
		if(obj.constructionCount > 0 && curConstructionType != CT_Export)
			return true;
		return false;
	}

	double laborToBear(AI& ai) {
		return laborIncome * ai.behavior.constructionMaxTime + storedLabor;
	}

	bool viable(AI& ai, AllocateConstruction@ alloc) {
		double labor = obj.laborIncome;
		double estTime = (alloc.laborCost(ai, obj) - storedLabor) / labor;
		if(estTime > alloc.maxTime)
			return false;
		return true;
	}

	bool tick(AI& ai, Construction& construction, double time) {
		if(obj is null || !obj.valid || obj.owner !is ai.empire) {
			valid = false;
			return false;
		}

		if(ai.behavior.forbidConstruction) return true;

		uint curCount = obj.constructionCount;
		curConstructionType = 0;
		bool isBackground = false;
		if(curCount != 0) {
			curConstructionType = obj.constructionType;
			isBackground = curConstructionType == CT_Asteroid || curConstructionType == CT_Export;
		}
		if(active !is null) {
			if(curCount <= backgrounded || (curCount == 1 && isBackground)) {
				if(construction.log)
					ai.print("Completed construction of "+active.toString()+" "+backgrounded+" / "+curCount, obj);
				active.completed = true;
				active.completedAt = gameTime;
				@active = null;
				idleSince = gameTime;
				backgrounded = 0;
			}
		}
		else {
			if(curCount < backgrounded) {
				backgrounded = curCount;
			}
		}

		//Background constructibles we don't need to do right now
		if(curCount > 1 && curConstructionType == CT_Asteroid && bgAsteroid !is null) {
			obj.moveConstruction(obj.constructionID[0], -1);
			backgrounded += 1;
		}
		if(curCount > 1 && curConstructionType == CT_Export && exportingTo !is null) {
			obj.cancelConstruction(obj.constructionID[0]);
			@exportingTo = null;
		}
		if(bgAsteroid !is null && (bgAsteroid.owner.valid || curCount == 0)) {
			if(bgAsteroid.owner is ai.empire)
				construction.planets.register(bgAsteroid);
			@bgAsteroid = null;
		}

		//Build warehouse(s) if we've been idle
		laborIncome = obj.laborIncome;
		storedLabor = obj.currentLaborStored;
		laborMaxStorage = obj.laborStorageCapacity;
		significantLabor = laborIncome >= 0.4 * construction.bestLabor && obj.baseLaborIncome > 4.0/60.0;
		if(storedLabor < laborMaxStorage)
			idleSince = gameTime;
		if(active is null && curBuilding is null && plAI !is null && gameTime - idleSince > ai.behavior.laborStoreIdleTimer && ai.behavior.buildLaborStorage && (laborMaxStorage+50) < ai.behavior.laborStoreMaxFillTime * max(obj.baseLaborIncome, laborAim) && significantLabor) {
			auto@ bld = ai.defs.LaborStorage;
			if(bld !is null && buildingPenalty < gameTime) {
				if(construction.log)
					ai.print("Build building "+bld.name+" for labor storage", obj);

				@curBuilding = construction.planets.requestBuilding(plAI, bld);
			}
		}

		//Remove waits on completed labor gains
		if(curBuilding !is null) {
			if(curBuilding.canceled || (curBuilding.built && curBuilding.getProgress() >= 1.0)) {
				if(construction.log)
					ai.print("Building construction for labor finished", obj);
				if(curBuilding.canceled)
					buildingPenalty = gameTime + 60.0;
				@curBuilding = null;
			}
		}
		if(curImport !is null) {
			if(curImport.beingMet) {
				if(construction.log)
					ai.print("Resource import for labor finished", obj);
				@curImport = null;
			}
		}

		//See if we need a new labor gain
		if(laborIncome < laborAim) {
			if(curImport is null && plAI !is null && obj.isPressureSaturated(TR_Labor) && obj.pressureCap < uint(obj.totalPressure) && gameTime > 6.0 * 60.0 && ai.behavior.buildFactoryForLabor) {
				ResourceSpec spec;
				spec.type = RST_Pressure_Level0;
				spec.pressureType = TR_Labor;

				if(construction.log)
					ai.print("Queue resource import for labor", obj);

				@curImport = construction.resources.requestResource(obj, spec, prioritize=true);
			}
			if(curBuilding is null && plAI !is null && ai.behavior.buildLaborStorage) {
				auto@ bld = ai.defs.Factory;
				if(bld !is null && buildingPenalty < gameTime) {
					if(construction.log)
						ai.print("Build building "+bld.name+" for labor", obj);

					@curBuilding = construction.planets.requestBuilding(plAI, bld);
				}
			}
		}

		//See if we should spend our labor on a labor export somewhere else
		if(exportingTo !is null && curConstructionType == CT_Export) {
			if(!exportingTo.valid || (!exportingTo.needsLabor && exportingTo !is construction.primaryFactory)) {
				obj.cancelConstruction(obj.constructionID[0]);
				@exportingTo = null;
			}
		}
		if(ai.behavior.distributeLaborExports) {
			if(curCount == 0 && obj.canExportLabor) {
				uint offset = randomi(0, construction.factories.length-1);
				for(uint i = 0, cnt = construction.factories.length; i < cnt; ++i) {
					auto@ other = construction.factories[(i+offset) % cnt];
					if(other is this)
						continue;
					if(!other.obj.canImportLabor)
						continue;

					//Check if this is currently busy
					if(other !is construction.primaryFactory) {
						if(!other.needsLabor)
							continue;
					}

					obj.exportLaborTo(other.obj);
					@exportingTo = other;
				}
			}
		}

		//See if we should spend our labor trying to build an asteroid
		if(ai.behavior.backgroundBuildAsteroids) {
			if((curCount == 0 || (curConstructionType == CT_Export && curCount == 1)) && storedLabor >= laborMaxStorage * 0.5 && obj.canBuildAsteroids) {
				Asteroid@ roid = construction.getBackgroundAsteroid(this);
				if(roid !is null) {
					uint resCount = roid.getAvailableCount();
					if(resCount != 0) {
						uint bestIndex = 0;
						int bestId = -1;
						double bestWeight = 0.0;

						if(ai.behavior.chooseAsteroidResource) {
							for(uint i = 0; i < resCount; ++i) {
								int resourceId = roid.getAvailable(i);
								double w = asteroidResourceValue(getResource(resourceId));
								if(w > bestWeight) {
									bestWeight = w;
									bestId = resourceId;
									bestIndex = i;
								}
							}
						}
						else {
							bestIndex = randomi(0, resCount-1);
							bestId = roid.getAvailable(bestIndex);
						}

						double laborCost = roid.getAvailableCost(bestIndex);

						Region@ fromReg = obj.region;
						Region@ toReg = roid.region;
						if(fromReg !is null && toReg !is null)
							laborCost *= 1.0 + config::ASTEROID_COST_STEP * double(construction.systems.hopDistance(fromReg, toReg));

						double timeTaken = laborIncome / laborCost;
						if(timeTaken < ai.behavior.constructionMaxTime || storedLabor >= laborMaxStorage * 0.95) {
							@bgAsteroid = roid;
							obj.buildAsteroid(roid, bestId);

							if(construction.log)
								ai.print("Use background labor to mine "+roid.name+" in "+roid.region.name, obj);
						}
					}
				}
			}
		}

		return true;
	}

	void aimForLabor(double labor) {
		if(labor > laborAim)
			laborAim = labor;
	}
};

class Construction : AIComponent {
	array<Factory@> factories;
	Factory@ primaryFactory;
	double noFactoryTimer = 0.0;

	int nextAllocId = 0;
	array<AllocateConstruction@> allocations;

	double totalLabor = 0.0;
	double bestLabor = 0.0;

	BuildOrbital@ buildConsolidate;

	Budget@ budget;
	Planets@ planets;
	Orbitals@ orbitals;
	Resources@ resources;
	Designs@ designs;
	Systems@ systems;

	void create() {
		@budget = cast<Budget>(ai.budget);
		@planets = cast<Planets>(ai.planets);
		@resources = cast<Resources>(ai.resources);
		@designs = cast<Designs>(ai.designs);
		@systems = cast<Systems>(ai.systems);
		@orbitals = cast<Orbitals>(ai.orbitals);
	}

	void save(SaveFile& file) {
		file << nextAllocId;

		uint cnt = allocations.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i)
			saveConstruction(file, allocations[i]);

		cnt = factories.length;
		file << cnt;
		for(uint i = 0; i < cnt; ++i) {
			saveFactory(file, factories[i]);
			factories[i].save(this, file);
		}

		saveFactory(file, primaryFactory);
		file << noFactoryTimer;

		saveConstruction(file, buildConsolidate);
	}

	void load(SaveFile& file) {
		file >> nextAllocId;

		uint cnt = 0;
		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			auto@ alloc = loadConstruction(file);
			if(alloc !is null)
				allocations.insertLast(alloc);
		}

		file >> cnt;
		for(uint i = 0; i < cnt; ++i) {
			Factory@ f = loadFactory(file);
			if(f !is null)
				f.load(this, file);
			else
				Factory().load(this, file);
		}

		@primaryFactory = loadFactory(file);
		file >> noFactoryTimer;

		@buildConsolidate = cast<BuildOrbital>(loadConstruction(file));
	}

	void saveFactory(SaveFile& file, Factory@ f) {
		if(f !is null) {
			file.write1();
			file << f.obj;
		}
		else {
			file.write0();
		}
	}

	Factory@ loadFactory(SaveFile& file) {
		if(!file.readBit())
			return null;

		Object@ obj;
		file >> obj;

		if(obj is null)
			return null;

		for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
			if(factories[i].obj is obj)
				return factories[i];
		}

		Factory f;
		@f.obj = obj;
		factories.insertLast(f);
		return f;
	}

	array<AllocateConstruction@> savedConstructions;
	array<AllocateConstruction@> loadedConstructions;
	void postSave(AI& ai) {
		savedConstructions.length = 0;
	}
	void postLoad(AI& ai) {
		loadedConstructions.length = 0;
	}

	void saveConstruction(SaveFile& file, AllocateConstruction@ alloc) {
		if(alloc is null) {
			file.write0();
			return;
		}

		file.write1();
		file << alloc.id;
		if(alloc.id == -1) {
			storeConstruction(file, alloc);
		}
		else {
			bool found = false;
			for(uint i = 0, cnt = savedConstructions.length; i < cnt; ++i) {
				if(savedConstructions[i] is alloc) {
					found = true;
					break;
				}
			}

			if(!found) {
				storeConstruction(file, alloc);
				savedConstructions.insertLast(alloc);
			}
		}
	}

	AllocateConstruction@ loadConstruction(SaveFile& file) {
		if(!file.readBit())
			return null;

		int id = 0;
		file >> id;
		if(id == -1) {
			AllocateConstruction@ alloc = createConstruction(file);
			alloc.id = id;
			return alloc;
		}
		else {
			for(uint i = 0, cnt = loadedConstructions.length; i < cnt; ++i) {
				if(loadedConstructions[i].id == id)
					return loadedConstructions[i];
			}

			AllocateConstruction@ alloc = createConstruction(file);
			alloc.id = id;
			loadedConstructions.insertLast(alloc);
			return alloc;
		}
	}

	void storeConstruction(SaveFile& file, AllocateConstruction@ alloc) {
		auto@ cls = getClass(alloc);
		auto@ mod = cls.module;

		file << mod.name;
		file << cls.name;
		alloc._save(this, file);
	}

	AllocateConstruction@ createConstruction(SaveFile& file) {
		string modName;
		string clsName;

		file >> modName;
		file >> clsName;

		auto@ mod = getScriptModule(modName);
		if(mod is null) {
			error("ERROR: AI Load could not find module for alloc "+modName+"::"+clsName);
			return null;
		}

		auto@ cls = mod.getClass(clsName);
		if(cls is null) {
			error("ERROR: AI Load could not find class for alloc "+modName+"::"+clsName);
			return null;
		}

		auto@ alloc = cast<AllocateConstruction>(cls.create());
		if(alloc is null) {
			error("ERROR: AI Load could not create class instance for alloc "+modName+"::"+clsName);
			return null;
		}

		alloc._load(this, file);
		return alloc;
	}

	void start() {
		Object@ hw = ai.empire.Homeworld;
		if(hw !is null) {
			Factory f;
			@f.obj = hw;
			@f.plAI = planets.getAI(cast<Planet>(hw));

			factories.insertLast(f);
		}
	}

	Factory@ get(Object@ obj) {
		for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
			if(factories[i].obj is obj)
				return factories[i];
		}
		return null;
	}

	Factory@ registerFactory(Object@ obj) {
		for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
			if(factories[i].obj is obj)
				return factories[i];
		}
		Factory f;
		@f.obj = obj;
		factories.insertLast(f);
		return f;
	}

	Factory@ getFactory(Region@ region) {
		Factory@ best;
		double bestLabor = 0;
		for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
			if(factories[i].obj.region !is region)
				continue;
			double l = factories[i].obj.laborIncome;
			if(l > bestLabor) {
				bestLabor = l;
				@best = factories[i];
			}
		}
		return best;
	}

	BuildConstruction@ buildConstruction(const ConstructionType@ type, double priority = 1.0, bool force = false, uint moneyType = BT_Development) {
		//Potentially build a flagship
		BuildConstruction f(type);
		f.moneyType = moneyType;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	BuildFlagship@ buildFlagship(const Design@ dsg, double priority = 1.0, bool force = false) {
		//Potentially build a flagship
		BuildFlagship f(dsg);
		f.moneyType = BT_Military;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	BuildFlagship@ buildFlagship(DesignTarget@ target, double priority = 1.0, bool force = false) {
		//Potentially build a flagship
		BuildFlagship f(target);
		f.moneyType = BT_Military;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	BuildStation@ buildStation(const Design@ dsg, const vec3d& position, double priority = 1.0, bool force = false) {
		//Potentially build a flagship
		BuildStation f(dsg, position);
		f.moneyType = BT_Military;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	BuildStation@ buildStation(DesignTarget@ target, const vec3d& position, double priority = 1.0, bool force = false) {
		//Potentially build a flagship
		BuildStation f(target, position);
		f.moneyType = BT_Military;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	BuildOrbital@ buildOrbital(const OrbitalModule@ module, const vec3d& position, double priority = 1.0, bool force = false, uint moneyType = BT_Infrastructure) {
		//Potentially build a flagship
		BuildOrbital f(module, position);
		f.moneyType = moneyType;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	BuildStation@ buildLocalStation(const Design@ dsg, double priority = 1.0, bool force = false) {
		//Potentially build a flagship
		BuildStation f(dsg, local=true);
		f.moneyType = BT_Military;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	BuildStation@ buildLocalStation(DesignTarget@ target, double priority = 1.0, bool force = false) {
		//Potentially build a flagship
		BuildStation f(target, local=true);
		f.moneyType = BT_Military;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	BuildOrbital@ buildLocalOrbital(const OrbitalModule@ module, double priority = 1.0, bool force = false, uint moneyType = BT_Infrastructure) {
		//Potentially build a flagship
		BuildOrbital f(module, local=true);
		f.moneyType = moneyType;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	BuildOrbital@ buildLocalOrbital(const OrbitalModule@ module, Planet@ planet, double priority = 1.0, bool force = false, uint moneyType = BT_Infrastructure) {
		//Potentially build a flagship
		BuildOrbital f(module, planet);
		f.moneyType = moneyType;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	RetrofitShip@ retrofit(Ship@ ship, double priority = 1.0, bool force = false) {
		//Potentially build a flagship
		RetrofitShip f(ship);
		f.moneyType = BT_Military;
		f.priority = priority;
		build(f, force=force);
		return f;
	}

	AllocateConstruction@ build(AllocateConstruction@ alloc, bool force = false) {
		//Add a construction into the potential constructions queue
		if(!force)
			alloc.maxTime = ai.behavior.constructionMaxTime;
		alloc.id = nextAllocId++;
		allocations.insertLast(alloc);

		if(log)
			ai.print("Queue construction: "+alloc.toString());

		return alloc;
	}

	AllocateConstruction@ buildNow(AllocateConstruction@ alloc, Factory@ f) {
		if(f.busy)
			return null;
		if(alloc.alloc !is null)
			budget.applyNow(alloc.alloc);
		start(f, alloc);
		allocations.remove(alloc);
		return alloc;
	}

	void cancel(AllocateConstruction@ alloc) {
		if(alloc.started || (alloc.alloc !is null && alloc.alloc.allocated))
			return; //TODO

		allocations.remove(alloc);
		for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
			if(factories[i].active is alloc)
				@factories[i].active = null;
		}

		if(alloc.alloc !is null)
			budget.remove(alloc.alloc);
	}

	uint factInd = 0;
	void tick(double time) {
		//Manage factories
		if(factories.length != 0) {
			factInd = (factInd+1) % factories.length;
			auto@ f = factories[factInd];
			if(!f.tick(ai, this, time))
				factories.removeAt(factInd);
		}
	}

	void start(Factory@ f, AllocateConstruction@ c) {
		if(ai.behavior.forbidConstruction) {
			cancel(c);
			return;
		}
		//Actually construct something we've allocated budget for
		@f.active = c;
		@c.tryFactory = null;

		c.construct(ai, f);

		if(log)
			ai.print("Construct: "+c.toString(), f.obj);

		for(uint i = 0, cnt = allocations.length; i < cnt; ++i) {
			if(allocations[i].tryFactory is f)
				@allocations[i].tryFactory = null;
		}
	}

	uint plCheck = 0;
	uint orbCheck = 0;
	double consTimer = 0.0;
	void focusTick(double time) {
		//Progress the allocations
		for(uint n = 0, ncnt = allocations.length; n < ncnt; ++n) {
			if(!allocations[n].tick(ai, this, time)) {
				allocations.removeAt(n);
				--n; --ncnt;
			}
		}

		if(ai.behavior.forbidConstruction) return;

		//See if anything we can potentially construct is constructible
		totalLabor = 0.0;
		bestLabor = 0.0;
		for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
			auto@ f = factories[i];
			totalLabor += f.laborIncome;
			if(f.laborIncome > bestLabor)
				bestLabor = f.laborIncome;
		}

		for(uint n = 0, ncnt = allocations.length; n < ncnt; ++n) {
			auto@ alloc = allocations[n];
			if(alloc.tryFactory !is null)
				continue;

			Factory@ bestFact;
			double bestCur = 0.0;

			for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
				auto@ f = factories[i];
				if(f.busy)
					continue;
				if(!alloc.canBuild(ai, f))
					continue;
				if(!f.viable(ai, alloc))
					continue;

				double w = f.laborIncome;
				if(f is primaryFactory)
					w *= 1.5;
				if(f.exportingTo !is null)
					w /= 0.75;

				if(w > bestCur) {
					bestCur = w;
					@bestFact = f;
				}
			}

			if(bestFact !is null) {
				@alloc.tryFactory = bestFact;
				alloc.update(ai, bestFact);
			}
		}

		//Classify our primary factory
		if(primaryFactory is null) {
			//Find our best factory
			Factory@ best;
			double bestWeight = 0.0;
			for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
				auto@ f = factories[i];

				double w = f.laborIncome;
				w += 0.1 * f.laborAim;
				if(f.obj.isPlanet)
					w *= 100.0;
				if(f.obj.isShip)
					w *= 0.1;

				if(w > bestWeight) {
					bestWeight = w;
					@best = f;
				}
			}

			if(best !is null) {
				@primaryFactory = best;
			}
			else {
				noFactoryTimer += time;
				if(noFactoryTimer > 3.0 * 60.0 && ai.defs.Factory !is null) {
					//Just pick our highest level planet and hope for the best
					PlanetAI@ best;
					double bestWeight = 0.0;

					for(uint i = 0, cnt = planets.planets.length; i < cnt; ++i) {
						auto@ plAI = planets.planets[i];
						double w = plAI.obj.level;
						w += 0.5 * plAI.obj.resourceLevel;

						if(w > bestWeight) {
							bestWeight = w;
							@best = plAI;
						}
					}

					if(best !is null) {
						Factory f;
						@f.obj = best.obj;
						@f.plAI = best;

						factories.insertLast(f);
						@primaryFactory = f;
					}

					noFactoryTimer = 0.0;
				}
			}
		}
		else {
			noFactoryTimer = 0.0;
		}

		//Find new factories
		if(planets.planets.length != 0) {
			plCheck = (plCheck+1) % planets.planets.length;
			PlanetAI@ plAI = planets.planets[plCheck];
			if(plAI.obj.laborIncome > 0 && plAI.obj.canBuildShips) {
				if(get(plAI.obj) is null) {
					Factory f;
					@f.obj = plAI.obj;
					@f.plAI = plAI;

					factories.insertLast(f);
				}
			}
		}
		if(orbitals.orbitals.length != 0) {
			orbCheck = (orbCheck+1) % orbitals.orbitals.length;
			OrbitalAI@ orbAI = orbitals.orbitals[orbCheck];
			if(orbAI.obj.hasConstruction && orbAI.obj.laborIncome > 0
					&& !cast<Orbital>(orbAI.obj).hasMaster()) {
				if(get(orbAI.obj) is null) {
					Factory f;
					@f.obj = orbAI.obj;

					factories.insertLast(f);
				}
			}
		}

		//See if we should switch our primary factory
		if(primaryFactory !is null) {
			if(!primaryFactory.valid) {
				@primaryFactory = null;
			}
			else {
				Factory@ best;
				double bestLabor = 0.0;
				double primaryLabor = primaryFactory.laborIncome;
				bool canImport = primaryFactory.obj.canImportLabor;
				for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
					auto@ f = factories[i];
					double checkLabor = f.laborIncome;
					if(f.obj.isShip)
						checkLabor *= 0.1;
					if(f.exportingTo !is primaryFactory && canImport)
						primaryLabor += checkLabor * 0.75;
					if(checkLabor > bestLabor) {
						bestLabor = checkLabor;
						@best = f;
					}
				}

				if(best !is null && bestLabor > 1.5 * primaryLabor)
					@primaryFactory = best;
			}
		}

		//See if we should consolidate at a shipyard
		if(buildConsolidate !is null && buildConsolidate.completed) {
			@buildConsolidate = null;
			consTimer = gameTime + 60.0;
		}
		else if(ai.behavior.consolidateLaborExports && primaryFactory !is null && ai.defs.Shipyard !is null && buildConsolidate is null && !primaryFactory.obj.canImportLabor && consTimer < gameTime) {
			double totalLabor = 0.0, bestLabor = 0.0;
			for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
				double inc = factories[i].obj.baseLaborIncome;
				if(factories[i].obj.canExportLabor)
					totalLabor += inc;
				if(factories[i].laborIncome > bestLabor)
					bestLabor = factories[i].laborIncome;
			}

			if(bestLabor < totalLabor * 0.6) {
				Factory@ bestConsolidate;
				double bestWeight = 0.0;
				for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
					auto@ f = factories[i];
					if(!f.obj.canImportLabor)
						continue;

					double w = f.obj.baseLaborIncome;
					w /= f.obj.position.distanceTo(primaryFactory.obj.position);

					if(w > bestWeight) {
						bestWeight = w;
						@bestConsolidate = f;
					}
				}

				if(bestConsolidate !is null) {
					if(log)
						ai.print("Set shipyard for consolidate.", bestConsolidate.obj.region);
					@primaryFactory = bestConsolidate;
				}
				else {
					Region@ reg = primaryFactory.obj.region;
					if(reg !is null) {
						vec3d pos = reg.position;
						vec2d offset = random2d(reg.radius * 0.4, reg.radius * 0.8);
						pos.x += offset.x;
						pos.z += offset.y;

						if(log)
							ai.print("Build shipyard for consolidate.", reg);

						@buildConsolidate = buildOrbital(ai.defs.Shipyard, pos);
					}
				}
			}
		}
	}

	bool isGettingAsteroid(Asteroid@ asteroid) {
		for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
			if(factories[i].bgAsteroid is asteroid)
				return true;
		}
		return false;
	}

	Asteroid@ getBackgroundAsteroid(Factory& f) {
		double closest = INFINITY;
		Asteroid@ best;
		Region@ reg = f.obj.region;
		if(reg is null)
			return null;

		uint cnt = systems.owned.length;
		uint offset = randomi(0, cnt-1);
		for(uint i = 0, check = min(3, cnt); i < check; ++i) {
			auto@ sys = systems.owned[(i+offset)%cnt];
			double dist = sys.obj.position.distanceToSQ(f.obj.position);
			if(dist > closest)
				continue;
			if(!sys.obj.sharesTerritory(ai.empire, reg))
				continue;

			for(uint n = 0, ncnt = sys.asteroids.length; n < ncnt; ++n) {
				Asteroid@ roid = sys.asteroids[n];
				if(roid.owner.valid)
					continue;
				if(roid.getAvailableCount() == 0)
					continue;
				if(isGettingAsteroid(roid))
					continue;

				closest = dist;
				@best = roid;
				break;
			}
		}

		cnt = systems.outsideBorder.length;
		offset = randomi(0, cnt-1);
		for(uint i = 0, check = min(3, cnt); i < check; ++i) {
			auto@ sys = systems.outsideBorder[(i+offset)%cnt];
			double dist = sys.obj.position.distanceToSQ(f.obj.position);
			if(dist > closest)
				continue;
			if(!sys.obj.sharesTerritory(ai.empire, reg))
				continue;

			for(uint n = 0, ncnt = sys.asteroids.length; n < ncnt; ++n) {
				Asteroid@ roid = sys.asteroids[n];
				if(roid.owner.valid)
					continue;
				if(roid.getAvailableCount() == 0)
					continue;
				if(isGettingAsteroid(roid))
					continue;

				closest = dist;
				@best = roid;
				break;
			}
		}

		return best;
	}
};

double asteroidResourceValue(const ResourceType@ type) {
	if(type is null)
		return 0.0;
	double w = 1.0;
	w += type.level * 10.0;
	w += type.totalPressure;
	if(type.cls !is null)
		w += 5.0;
	return w;
}

AIComponent@ createConstruction() {
	return Construction();
}