xhads/source/ui.adb

-- Copyright (c) 2024 - Ognjen 'xolatile' Milan Robovic
--
-- GNU General Public Licence (version 3 or later)

with core;

with ada.strings.unbounded;

use type core.cursor_code;
use type ada.strings.unbounded.unbounded_string;

package body ui is

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

	type element is (
		none,
		main_background,
		--
		corner_upper_left,                  border_upper,                       corner_upper_right,
		border_left,                                                            border_right,
		corner_lower_left,                  border_lower,                       corner_lower_right,
		--
		tiny_corner_upper_left,             tiny_border_upper,                  tiny_corner_upper_right,
		tiny_border_left,                                                       tiny_border_right,
		tiny_corner_lower_left,             tiny_border_lower,                  tiny_corner_lower_right,
		--
		frame_upper_left,                   frame_upper,                        frame_upper_right,
		frame_left,                         frame_middle,                       frame_right,
		frame_lower_left,                   frame_lower,                        frame_lower_right,
		--
		icon_upper_left,                    icon_upper,                         icon_upper_right,
		icon_left,                                                              icon_right,
		icon_lower_left,                    icon_lower,                         icon_lower_right,
		--
		text_upper_left,                    text_upper,                         text_upper_right,
		text_left,                          text_middle,                        text_right,
		text_lower_left,                    text_lower,                         text_lower_right,
		--
		cursor,                             icon,                               overicon,                           icon_selected,
		--
		fill_bar_left,                      fill_bar_horizontal,                fill_bar_right,                     fill_horizontal,
		tiny_fill_bar_left,                 tiny_fill_bar_horizontal,           tiny_fill_bar_right,                tiny_fill_horizontal,
		--
		scroll_bar_lower,                   scroll_bar_middle,                  scroll_bar_upper,
		--
		title_bar_left,                     title_bar_middle,                   title_bar_right,
		--
		check_box_on,                       check_box_off,
		--
		end_turn_button
	);

                                             ------------------------------------------------------------------------------------------

	type rectangle is record
		x, y, width, height : integer;
	end record;

                                             ------------------------------------------------------------------------------------------

	structure_limit : constant natural := 12;

	font_tint : array (style) of core.colour := (
		main   => (127, 127, 127, 255),
		fairy  => (  0, 127, 255, 255),
		dwarf  => (127, 255, 255, 255),
		gnoll  => (255, 255,   0, 255),
		kobold => (255, 127, 255, 255),
		goblin => (  0, 255, 127, 255),
		imp    => (255, 127,   0, 255)
	);

	sprite : array (style, element) of core.sprite;
	font   : array (style)          of core.font;

	structure_array : array (0 .. structure_limit) of structure;

	structure_count : natural := 0;

	monospace : core.font;

	console_message_limit : constant natural := 6;
	console_message_count :          natural := 0;
	--
	console_message_array : array (0 .. console_message_limit - 1) of ada.strings.unbounded.unbounded_string;

                                             ------------------------------------------------------------------------------------------

	procedure draw (index  : in element      := none;
	                x      : in integer      := 0;
	                y      : in integer      := 0;
	                width  : in integer      := 0;
	                height : in integer      := 0) is
	begin
		core.draw (sprite (active, index), x, y, 0, 0, width, height, factor => 1);
	end draw;

                                             ------------------------------------------------------------------------------------------

	procedure draw_horizontally (index : in element; x, y, width : in integer; action : core.pointer := core.idle_skip'access; tint : in core.colour := (others => 255)) is
	begin
		core.draw_horizontally (sprite (active, index), x, y, width, 1, tint);
	end draw_horizontally;

                                             ------------------------------------------------------------------------------------------

	procedure draw_vertically (index : in element; x, y, height : in integer; action : core.pointer := core.idle_skip'access; tint : in core.colour := (others => 255)) is
	begin
		core.draw_vertically (sprite (active, index), x, y, height, 1, tint);
	end draw_vertically;

                                             ------------------------------------------------------------------------------------------

	procedure draw_background (index : in element; x, y, width, height : in integer; action : core.pointer := core.idle_skip'access) is
		base_width  : integer := sprite (active, index).width;
		base_height : integer := sprite (active, index).height;
		crop_width  : integer := width  mod base_width;
		crop_height : integer := height mod base_height;
	begin
		for move_y in 0 .. height / base_height - 1 loop
			for move_x in 0 .. width / base_width - 1 loop
				draw (index, x + move_x * base_width, y + move_y * base_height);
			end loop;
			--
			if width mod base_width > 0 then
				draw (index, x + width - crop_width, y + move_y * base_height, crop_width, base_height);
			end if;
		end loop;
		--
		for move_x in 0 .. width / base_width - 1 loop
			if height mod base_height > 0 then
				draw (index, x + move_x * base_width, y + height - crop_height, base_width, crop_height);
			end if;
		end loop;
		--
		if width mod base_width > 0 and height mod base_height > 0 then
			draw (index, x + width - crop_width, y + height - crop_height, crop_width, crop_height);
		end if;
	end draw_background;

                                             ------------------------------------------------------------------------------------------

	procedure draw_popup_box is
		width  : constant integer := 320;
		height : constant integer := core.icon;
		middle : constant integer := sprite (active, text_middle).width;
		offset : constant integer := 16;
	begin
		draw_background (text_middle, core.cursor.x + middle + offset, core.cursor.y + middle + offset, width - 2 * middle, height - 2 * middle);
		--
		draw_horizontally (text_upper, core.cursor.x + middle + offset,         core.cursor.y + offset,                   width  - 2 * middle);
		draw_horizontally (text_lower, core.cursor.x + middle + offset,         core.cursor.y + height - middle + offset, width  - 2 * middle);
		draw_vertically   (text_left,  core.cursor.x + offset,                  core.cursor.y + middle + offset,          height - 2 * middle);
		draw_vertically   (text_right, core.cursor.x + width - middle + offset, core.cursor.y + middle + offset,          height - 2 * middle);
		--
		draw (text_upper_left,  core.cursor.x + offset,                  core.cursor.y + offset);
		draw (text_upper_right, core.cursor.x + width - middle + offset, core.cursor.y + offset);
		draw (text_lower_left,  core.cursor.x + offset,                  core.cursor.y + height - middle + offset);
		draw (text_lower_right, core.cursor.x + width - middle + offset, core.cursor.y + height - middle + offset);
		--
		ui.write (core.read_text_box, core.cursor.x + 4 + offset, core.cursor.y + 6 + offset);
	end draw_popup_box;

                                             ------------------------------------------------------------------------------------------

	procedure draw_structure (data : in structure) is
		offset  : constant integer := core.icon / 4;
		orients :          natural := 0;
		--
		frame_data  : rectangle := (others => 0);
		button_data : rectangle := (others => 0);
	begin
		for index in 0 .. data.gui_n - 1 loop
			if data.gui_list (index).kind = gui_orient then
				orients := orients + 1;
			end if;
		end loop;
		--
		frame_data.width   := (if data.resize then 320 else data.width) * (orients + 1) - offset * orients;
		frame_data.height  := (if data.resize then data.gui_n * (core.icon + 2 * offset) + 2 * core.icon else data.height) / (orients + 1) + offset * orients;
		frame_data.x       := (if data.center then (core.window_width  - frame_data.width)  / 2 else data.x);
		frame_data.y       := (if data.center then (core.window_height - frame_data.height) / 2 else data.y);
		button_data.width  := frame_data.width / (orients + 1) - 2 * core.icon;
		button_data.height := core.icon + 2 * offset;
		button_data.x      := frame_data.x + core.icon;
		button_data.y      := frame_data.y + core.icon;
		--
		draw_tiny_menu (frame_data.x, frame_data.y, frame_data.width, frame_data.height);
		draw_title_bar (frame_data.x, frame_data.y, frame_data.width, data.title);
		--
		for x in 0 .. data.gui_n - 1 loop
			case data.gui_list (x).kind is
				when gui_button =>
					draw_button (text        => -(data.gui_list (x).text),
					             description => -(data.gui_list (x).info),
					             icon        => data.gui_list (x).image,
					             x           => button_data.x,
					             y           => button_data.y,
					             width       => button_data.width,
					             height      => button_data.height);
					--
					button_data.y := button_data.y + button_data.height;
				when gui_orient =>
					button_data.x := button_data.x + frame_data.width / (orients + 1) - 2 * core.icon + offset;
					button_data.y := frame_data.y + core.icon;
				when others => null;
			end case;
		end loop;
		--
		if orients > 0 then
			draw_scroll_bar (frame_data.x + frame_data.width - 2 * core.icon, frame_data.y + core.icon, frame_data.height - 2 * core.icon, 4);
		end if;
	end draw_structure;

                                             ------------------------------------------------------------------------------------------

	procedure configure is
		procedure load_ui (index : in style; folder_path : in string) is
		begin
			font (index) := core.import_font (core.folder & "/ui/" & folder_path & "/font.png", 24, 0);
			--
			for this in element loop
				sprite (index, this) := core.import_sprite (core.folder & "/ui/" & folder_path & "/" & core.lowercase (element'image (this)) & ".png", 1, 1);
			end loop;
		end load_ui;
	begin
		monospace := core.import_font (core.folder & "/ui/monospace.png", 15, 0);
		--
		core.echo (core.comment, "Configuring UI components...");
		--
		for index in style loop
			load_ui (index, core.lowercase (style'image (index)));
		end loop;
	end configure;

                                             ------------------------------------------------------------------------------------------

	procedure synchronize is
		use core;
	begin
		prioritize := false;
		--
		for index in 0 .. structure_count - 1 loop
			if signal_mode = structure_array (index).toggle then
				structure_array (index).show := not structure_array (index).show;
			end if;
			--
			if structure_array (index).show then
				draw_structure (structure_array (index));
				--
				prioritize := true;
			end if;
		end loop;
		--
		draw (cursor, core.cursor.x, core.cursor.y);
		--
		if read_text_box /= "--" then
			draw_popup_box;
		end if;
		--
		core.write_text_box ("--");
	end synchronize;

                                             ------------------------------------------------------------------------------------------

	procedure echo (message : in string) is
	begin
		console_message_array (console_message_count) := ada.strings.unbounded.to_unbounded_string (message);
		--
		console_message_count := (console_message_count + 1) mod console_message_limit;
	end echo;

                                             ------------------------------------------------------------------------------------------

	procedure write (text : in string; x, y : in integer; tint : in core.colour := (others => 255); size : in natural := 15; code : in boolean := false) is
	begin
		core.write (text, x, y, tint, (if code then 15 else font (active).scale), (if code then monospace else font (active)));
	end write;

                                             ------------------------------------------------------------------------------------------

	procedure draw_icon (data : in core.sprite; text : in string; x, y : in integer; action : core.pointer := core.idle_skip'access) is
	begin
		draw (icon, x, y);
		--
		core.draw (data, x, y, factor => 1);
		--
		if core.cursor_inside (x, y, core.icon / core.zoom, core.icon / core.zoom) then
			prioritize := true;
			--
			draw (icon_selected, x, y);
			--
			core.write_help_box (text);
			--
			if core.cursor_mode = core.cursor_left then
				action.all;
				core.cursor_mode := core.cursor_none;
			end if;
		end if;
	end draw_icon;

                                             ------------------------------------------------------------------------------------------

	procedure draw_overicon (data : in core.sprite; text : in string; x, y : in integer; action : core.pointer := core.idle_skip'access) is
	begin
		core.draw (data, x, y, factor => 1);
		--
		draw (overicon, x, y);
	end draw_overicon;

                                             ------------------------------------------------------------------------------------------

	procedure draw_sprite (data : in core.sprite; text : in string; x, y, offset : in integer; action : core.pointer := core.idle_skip'access) is
	begin
		core.draw (data, x + offset, y + offset, factor => 1);
		--
		draw_icon_menu (x, y, data.width + 2 * offset, data.height + 2 * offset);
		--
		if core.cursor_inside (x, y, (data.width + 2 * offset) / core.zoom, (data.height + 2 * offset) / core.zoom) then
			prioritize := true;
			--
			core.write_help_box (text);
			--
			if core.cursor_mode = core.cursor_left then
				action.all;
				core.cursor_mode := core.cursor_none;
			end if;
		end if;
	end draw_sprite;

                                             ------------------------------------------------------------------------------------------

	procedure draw_text_box (x, y, width, height : in integer) is
		middle : constant integer := sprite (active, text_middle).width;
	begin
		draw_background (text_middle, x + middle, y + middle, width - 2 * middle, height - 2 * middle);
		--
		draw_horizontally (text_upper, x + middle,         y,                   width  - 2 * middle);
		draw_horizontally (text_lower, x + middle,         y + height - middle, width  - 2 * middle);
		draw_vertically   (text_left,  x,                  y + middle,          height - 2 * middle);
		draw_vertically   (text_right, x + width - middle, y + middle,          height - 2 * middle);
		--
		draw (text_upper_left,  x,                  y);
		draw (text_upper_right, x + width - middle, y);
		draw (text_lower_left,  x,                  y + height - middle);
		draw (text_lower_right, x + width - middle, y + height - middle);
	end draw_text_box;

                                             ------------------------------------------------------------------------------------------

	procedure draw_help_box (x, y, width, height : in integer; action : core.pointer := core.idle_skip'access) is
		offset : constant integer := sprite (active, text_middle).width;
	begin
		if core.cursor_inside (x, y, width, height) then
			prioritize := true;
		end if;
		--
		draw_background (text_middle, x + offset, y + offset, width - 2 * offset, height - 2 * offset);
		--
		draw_horizontally (text_upper, x + offset,         y,                   width  - 2 * offset);
		draw_horizontally (text_lower, x + offset,         y + height - offset, width  - 2 * offset);
		draw_vertically   (text_left,  x,                  y + offset,          height - 2 * offset);
		draw_vertically   (text_right, x + width - offset, y + offset,          height - 2 * offset);
		--
		draw (text_upper_left,  x,                  y);
		draw (text_upper_right, x + width - offset, y);
		draw (text_lower_left,  x,                  y + height - offset);
		draw (text_lower_right, x + width - offset, y + height - offset);
		--
		ui.write (core.read_help_box, (core.icon - font (active).scale) / 2 + x + 4, (core.icon - font (active).scale) / 2 + y);
		--
		core.write_help_box ("--");
	end draw_help_box;

                                             ------------------------------------------------------------------------------------------

	procedure draw_frame (description : in string; x, y, width, height : in integer; action : core.pointer := core.idle_skip'access) is
		offset_x : constant integer := sprite (active, frame_middle).width;
		offset_y : constant integer := sprite (active, frame_middle).height;
	begin
		if height < core.icon or width < core.icon then
			return;
		end if;
		--
		draw_background (frame_middle, x + offset_x, y + offset_y, width - 2 * offset_x, height - 2 * offset_y);
		--
		draw_horizontally (frame_upper, x + offset_x,         y,                     width  - 2 * offset_x);
		draw_horizontally (frame_lower, x + offset_x,         y + height - offset_y, width  - 2 * offset_x);
		draw_vertically   (frame_left,  x,                    y + offset_y,          height - 2 * offset_y);
		draw_vertically   (frame_right, x + width - offset_x, y + offset_y,          height - 2 * offset_y);
		--
		draw (frame_upper_left,  x,                                                    y);
		draw (frame_upper_right, x + width - sprite (active, frame_upper_right).width, y);
		draw (frame_lower_left,  x,                                                    y + height - sprite (active, frame_lower_left).height);
		draw (frame_lower_right, x + width - sprite (active, frame_lower_right).width, y + height - sprite (active, frame_lower_right).height);
		--
		if core.cursor_inside (x, y, width / core.zoom, height / core.zoom) then
			prioritize := true;
			--
			core.write_help_box (description);
			--
			if core.cursor_mode = core.cursor_left then
				action.all;
				core.cursor_mode := core.cursor_none;
			end if;
		end if;
	end draw_frame;

                                             ------------------------------------------------------------------------------------------

	procedure draw_button (text, description : in string; icon : in core.sprite; x, y, width, height : in integer; action : core.pointer := core.idle_skip'access) is
		offset  : constant integer := core.icon / 4;
	begin
		draw_frame (description, x, y, width, height);
		draw_icon  (icon, description, x + offset, y + offset);
		--
		ui.write (text,
		          x + offset + (core.icon - font (active).scale) / 2 + core.icon,
		          y + offset + (core.icon - font (active).scale) / 2,
		          (if core.cursor_inside (x, y, width / core.zoom, height / core.zoom) then font_tint (active) else (others => 255)));
		--
		if core.cursor_inside (x, y, width / core.zoom, height / core.zoom) then
			prioritize := true;
			--
			if core.cursor_mode = core.cursor_left then
				action.all;
				core.cursor_mode := core.cursor_none;
			end if;
		end if;
	end draw_button;

                                             ------------------------------------------------------------------------------------------

	procedure draw_check_box (x, y : in integer; on : in out boolean; text : in string) is
	begin
		draw ((if on then check_box_on else check_box_off), x, y);
		--
		ui.write (text, x + sprite (active, check_box_on).width, y);
		--
		if  core.cursor_mode = core.cursor_left
		and core.cursor_inside (x, y, sprite (active, check_box_on).width / core.zoom, sprite (active, check_box_on).height / core.zoom) then
			on               := not on;
			core.cursor_mode := core.cursor_none;
		end if;
	end draw_check_box;

                                             ------------------------------------------------------------------------------------------

	procedure draw_title_bar (x, y, width : in integer; title : in string) is
		middle_width : constant integer := width - sprite (active, title_bar_left).width - sprite (active, title_bar_right).width;
		offset       : constant integer := (sprite (active, title_bar_middle).height - font (active).scale) / 2;
	begin
		if core.cursor_inside (x, y, width / core.zoom, sprite (active, title_bar_left).height / core.zoom) then
			prioritize := true;
		end if;
		--
		draw (title_bar_left,  x,                                                        y - sprite (active, title_bar_left).height);
		draw (title_bar_right, x + middle_width + sprite (active, title_bar_left).width, y - sprite (active, title_bar_right).height);
		--
		draw_horizontally (title_bar_middle, x + sprite (active, title_bar_left).width, y - sprite (active, title_bar_middle).height, middle_width);
		--
		ui.write (title, x + sprite (active, title_bar_left).width, y - font (active).scale - 4, tint => font_tint (active));
	end draw_title_bar;

                                             ------------------------------------------------------------------------------------------

	procedure draw_fill_bar (x, y, width : in integer; fill : in float) is
		middle_width : constant integer := width - sprite (active, fill_bar_left).width - sprite (active, fill_bar_right).width;
		fill_width   : constant integer := integer (float (middle_width) * fill);
	begin
		draw (fill_bar_left,  x,                                                       y - sprite (active, fill_bar_left).height);
		draw (fill_bar_right, x + middle_width + sprite (active, fill_bar_left).width, y - sprite (active, fill_bar_right).height);
		--
		draw_horizontally (fill_bar_horizontal, x + sprite (active, fill_bar_left).width, y - sprite (active, fill_bar_horizontal).height, middle_width);
		draw_horizontally (fill_horizontal,     x + sprite (active, fill_bar_left).width, y - sprite (active, fill_bar_horizontal).height, fill_width);
	end draw_fill_bar;

                                             ------------------------------------------------------------------------------------------

	procedure draw_tiny_fill_bar (x, y, width : in integer; fill : in float; tint : in core.colour) is
		middle_width : constant integer := width - sprite (active, tiny_fill_bar_left).width - sprite (active, tiny_fill_bar_right).width;
		fill_width   : constant integer := integer (float (middle_width) * fill);
	begin
		draw (tiny_fill_bar_left,  x,                                                            y - sprite (active, tiny_fill_bar_left).height);
		draw (tiny_fill_bar_right, x + middle_width + sprite (active, tiny_fill_bar_left).width, y - sprite (active, tiny_fill_bar_left).height);
		--
		draw_horizontally (tiny_fill_bar_horizontal, x + sprite (active, tiny_fill_bar_left).width, y - sprite (active, tiny_fill_bar_horizontal).height, middle_width);
		--
		draw_horizontally (index => tiny_fill_horizontal,
		                   x     => x + sprite (active, tiny_fill_bar_left).width,
		                   y     => y - sprite (active, tiny_fill_bar_horizontal).height,
		                   width => fill_width,
		                   tint  => tint);
	end draw_tiny_fill_bar;

                                             ------------------------------------------------------------------------------------------

	procedure draw_scroll_bar (x, y, height, offset : in integer) is
		middle_height : constant integer := height - sprite (active, scroll_bar_upper).height - sprite (active, scroll_bar_lower).height;
	begin
		draw (scroll_bar_upper, x, y);
		draw (scroll_bar_lower, x, y + middle_height + sprite (active, scroll_bar_upper).height);
		--
		draw_vertically (scroll_bar_middle, x, y + sprite (active, scroll_bar_upper).height, middle_height);
	end draw_scroll_bar;

                                             ------------------------------------------------------------------------------------------

	procedure draw_menu (x, y, width, height : in integer) is
		offset : constant integer := sprite (active, none).width;
	begin
		if core.cursor_inside (x, y, width / core.zoom, height / core.zoom) then
			prioritize := true;
		end if;
		--
		declare upper : constant integer := width  - sprite (active, corner_upper_left).width   - sprite (active, corner_upper_right).width;
		        lower : constant integer := width  - sprite (active, corner_lower_left).width   - sprite (active, corner_lower_right).width;
		        left  : constant integer := height - sprite (active, corner_upper_left).height  - sprite (active, corner_lower_left).height;
		        right : constant integer := height - sprite (active, corner_upper_right).height - sprite (active, corner_lower_right).height;
		begin
			draw_horizontally (border_upper, x + sprite (active, corner_upper_left).width,    y,                                                 upper);
			draw_horizontally (border_lower, x + sprite (active, corner_lower_left).width,    y + height - sprite (active, border_lower).height, lower);
			draw_vertically   (border_left,  x,                                               y + sprite (active, corner_upper_left).height,     left);
			draw_vertically   (border_right, x + width - sprite (active, border_right).width, y + sprite (active, corner_upper_right).height,    right);
		end;
		--
		draw (corner_upper_left,  x,                                                     y);
		draw (corner_upper_right, x + width - sprite (active, corner_upper_right).width, y);
		draw (corner_lower_left,  x,                                                     y + height - sprite (active, corner_lower_left).height);
		draw (corner_lower_right, x + width - sprite (active, corner_lower_right).width, y + height - sprite (active, corner_lower_right).height);
	end draw_menu;

                                             ------------------------------------------------------------------------------------------

	procedure draw_tiny_menu (x, y, width, height : in integer) is
		offset : constant integer := sprite (active, none).width;
	begin
		if core.cursor_inside (x, y, width / core.zoom, height / core.zoom) then
			prioritize := true;
		end if;
		--
		draw_background (main_background, x + offset, y + offset, width - 2 * offset, height - 2 * offset);
		--
		declare upper : constant integer := width  - sprite (active, tiny_corner_upper_left).width   - sprite (active, tiny_corner_upper_right).width;
		        lower : constant integer := width  - sprite (active, tiny_corner_lower_left).width   - sprite (active, tiny_corner_lower_right).width;
		        left  : constant integer := height - sprite (active, tiny_corner_upper_left).height  - sprite (active, tiny_corner_lower_left).height;
		        right : constant integer := height - sprite (active, tiny_corner_upper_right).height - sprite (active, tiny_corner_lower_right).height;
		begin
			draw_horizontally (tiny_border_upper, x + sprite (active, tiny_corner_upper_left).width,    y,                                                      upper);
			draw_horizontally (tiny_border_lower, x + sprite (active, tiny_corner_lower_left).width,    y + height - sprite (active, tiny_border_lower).height, lower);
			draw_vertically   (tiny_border_left,  x,                                                    y + sprite (active, tiny_corner_upper_left).height,     left);
			draw_vertically   (tiny_border_right, x + width - sprite (active, tiny_border_right).width, y + sprite (active, tiny_corner_upper_right).height,    right);
		end;
		--
		draw (tiny_corner_upper_left,  x,                                                          y);
		draw (tiny_corner_upper_right, x + width - sprite (active, tiny_corner_upper_right).width, y);
		draw (tiny_corner_lower_left,  x,                                                          y + height - sprite (active, tiny_corner_lower_left).height);
		draw (tiny_corner_lower_right, x + width - sprite (active, tiny_corner_lower_right).width, y + height - sprite (active, tiny_corner_lower_right).height);
	end draw_tiny_menu;

                                             ------------------------------------------------------------------------------------------

	procedure draw_icon_menu (x, y, width, height : in integer) is
		offset_x : constant integer := sprite (active, icon_upper_left).width;
		offset_y : constant integer := sprite (active, icon_upper_left).height;
	begin
		if core.cursor_inside (x, y, width / core.zoom, height / core.zoom) then
			prioritize := true;
		end if;
		--
		if height < 2 * sprite (active, icon_upper_left).height
		or width  < 2 * sprite (active, icon_upper_left).width then
			return;
		end if;
		--
		draw_horizontally (icon_upper, x + offset_x,         y,                     width  - 2 * offset_x);
		draw_horizontally (icon_lower, x + offset_x,         y + height - offset_y, width  - 2 * offset_x);
		draw_vertically   (icon_left,  x,                    y + offset_y,          height - 2 * offset_y);
		draw_vertically   (icon_right, x + width - offset_x, y + offset_y,          height - 2 * offset_y);
		--
		draw (icon_upper_left,  x,                                                   y);
		draw (icon_upper_right, x + width - sprite (active, icon_upper_right).width, y);
		draw (icon_lower_left,  x,                                                   y + height - sprite (active, icon_lower_left).height);
		draw (icon_lower_right, x + width - sprite (active, icon_lower_right).width, y + height - sprite (active, icon_lower_right).height);
	end draw_icon_menu;

                                             ------------------------------------------------------------------------------------------

	procedure draw_end_turn_button (x, y : in integer) is
	begin
		draw (end_turn_button, x, y);
		--
		if core.cursor_inside (x, y, sprite (active, end_turn_button).width, sprite (active, end_turn_button).height) and core.cursor_mode = core.cursor_left then
			core.end_turn    := true;
			core.cursor_mode := core.cursor_none;
			--
			echo ("-- Turn --");
		end if;
	end draw_end_turn_button;

                                             ------------------------------------------------------------------------------------------

	procedure draw_state_box (x, y : in integer) is
	begin
		ui.write ("Cursor X:"       & core.cursor.x'image,       x, y +   0);
		ui.write ("Cursor Y:"       & core.cursor.y'image,       x, y +  32);
		ui.write ("Cursor Mode:"    & core.cursor_mode'image,    x, y +  64);
		ui.write ("Camera X:"       & core.camera.x'image,       x, y +  96);
		ui.write ("Camera Y:"       & core.camera.y'image,       x, y + 128);
		ui.write ("Global Time:"    & core.global_time'image,    x, y + 160);
		ui.write ("Gameplay Time:"  & core.gameplay_time'image,  x, y + 192);
		ui.write ("Animation Time:" & core.animation_time'image, x, y + 224);
		ui.write ("Framerate:"      & core.framerate'image,      x, y + 256);
	end draw_state_box;

                                             ------------------------------------------------------------------------------------------

	procedure draw_console_box (x, y, width, height : in integer) is
		offset                : constant integer := 8;
		font_width            : constant integer := 9;
		font_height           : constant integer := 15;
		characters_per_width  : constant integer := width  / font_width;
		characters_per_height : constant integer := height / font_height;
	begin
		draw_text_box (x, y, width, height);
		--
		for index in 0 .. console_message_limit - 1 loop
			ui.write (text => ada.strings.unbounded.to_string (console_message_array ((index + console_message_count) mod console_message_limit)),
			          x    => x + offset,
			          y    => y + offset + index * font_height,
			          size => 15,
			          code => true);
		end loop;
	end draw_console_box;

                                             ------------------------------------------------------------------------------------------

	procedure add_structure (data : in structure) is
	begin
		structure_array (structure_count)          := data;
		structure_array (structure_count).gui_list := new gui_array (0 .. structure_array (structure_count).gui_n - 1);
		structure_array (structure_count).gui_n    := 0;
		--
		core.increment (structure_count);
	end add_structure;

                                             ------------------------------------------------------------------------------------------

	procedure add_structure_button (icon : in core.sprite; name : in core.unstring; text : in core.unstring) is
		index : natural renames structure_array (structure_count - 1).gui_n;
	begin
		structure_array (structure_count - 1).gui_list (index).kind   := gui_button;
		structure_array (structure_count - 1).gui_list (index).text   := name;
		structure_array (structure_count - 1).gui_list (index).info   := text;
		structure_array (structure_count - 1).gui_list (index).number := 0;
		structure_array (structure_count - 1).gui_list (index).image  := icon;
		--
		core.increment (index);
	end add_structure_button;

                                             ------------------------------------------------------------------------------------------

	procedure add_structure_orient is
		index : natural renames structure_array (structure_count - 1).gui_n;
	begin
		structure_array (structure_count - 1).gui_list (index).kind := gui_orient;
		--
		core.increment (index);
	end add_structure_orient;

                                             ------------------------------------------------------------------------------------------

	procedure write_ada_code (text : in core.string_box_data; x, y : in integer) is
		word : ada.strings.unbounded.unbounded_string := ada.strings.unbounded.to_unbounded_string ("");
		--
		buffer :          character   := ' ';
		width  : constant integer     := 9;
		height : constant integer     := 15;
		length :          natural     := 1;
		offset :          core.vector := (x, y);
		subset :          natural     := 0;
	begin
		loop
			buffer   := ada.strings.unbounded.element (text.text, length);
			offset.x := offset.x + width;
			--
			exit when buffer = character'val (0);
			--
			case buffer is
				when character'val (9)  => offset.x := offset.x + 2 * width;
				when character'val (10) => offset.y := offset.y + 1 * height; offset.x := x;
				when ':' | ';' | '.' | ',' | '=' | '<' | '>' =>
					ui.write (buffer & "", offset.x, offset.y, (63, 127, 255, 255), height, code => true);
				when '+' | '*' | '/' | '|' | '&' =>
					ui.write (buffer & "", offset.x, offset.y, (63, 63, 255, 255), height, code => true);
				when '(' | ')' | ''' =>
					ui.write (buffer & "", offset.x, offset.y, (63, 255, 255, 255), height, code => true);
				when '"' =>
					ui.write (buffer & "", offset.x, offset.y, (127, 63, 127, 255), height, code => true);
					offset.x := offset.x + width;
					loop
						core.increment (length);
						buffer := ada.strings.unbounded.element (text.text, length);
						ui.write (buffer & "", offset.x, offset.y, (127, 63, 127, 255), height, code => true);
						offset.x := offset.x + width;
						exit when buffer = '"';
					end loop;
						offset.x := offset.x - width;
				when '-' =>
					if ada.strings.unbounded.element (text.text, length + 1) = '-' then
						ui.write (buffer & "", offset.x, offset.y, (127, 127, 127, 255), height, code => true);
						offset.x := offset.x + width;
						loop
							core.increment (length);
							buffer := ada.strings.unbounded.element (text.text, length);
							ui.write (buffer & "", offset.x, offset.y, (127, 127, 127, 255), height, code => true);
							offset.x := offset.x + width;
							exit when buffer = character'val (10);
						end loop;
						core.decrement (length);
					else
						ui.write (buffer & "", offset.x, offset.y, (63, 63, 255, 255), height, code => true);
					end if;
				when '0' .. '9' =>
					loop
						ui.write (buffer & "", offset.x, offset.y, (127, 63, 255, 255), height, code => true);
						core.increment (length);
						buffer := ada.strings.unbounded.element (text.text, length);
						exit when buffer = ' ' or buffer = ';' or buffer = ')' or buffer = ',';
						offset.x := offset.x + width;
					end loop;
					core.decrement (length);
				when 'a' .. 'z' | 'A' .. 'Z' =>
					word := ada.strings.unbounded.to_unbounded_string (buffer & "");
					subset := 1;
					loop
						buffer := ada.strings.unbounded.element (text.text, length + subset);
						exit when buffer = ' ' or buffer = '.' or buffer = '(' or buffer = ')' or buffer = ',' or buffer = ';' or buffer = '''
							or buffer = character'val (9) or buffer = character'val (10);
						word := word & ada.strings.unbounded.to_unbounded_string (buffer & "");
						core.increment (subset);
					end loop;
					if word = "type" or word = "begin" or word = "end" or word = "when" or word = "others" or word = "procedure" or word = "function"
					or word = "package" or word = "body" or word = "if" or word = "then" or word = "else" or word = "elsif" or word = "case" or word = "is"
					or word = "and" or word = "or" or word = "xor" or word = "exit" or word = "constant" or word = "access" or word = "range"
					or word = "subtype" or word = "array" or word = "in" or word = "out" or word = "return" or word = "for" or word = "with"
					or word = "loop" or word = "while" or word = "of" or word = "null" or word = "record" or word = "use" or word = "mod" or word = "new"
					or word = "aliased" or word = "all" then
						ui.write (ada.strings.unbounded.to_string (word), offset.x, offset.y, (255, 255, 0, 255), height, code => true);
					else
						ui.write (ada.strings.unbounded.to_string (word), offset.x, offset.y, (others => 255), height, code => true);
					end if;
					offset.x := offset.x + (subset - 1) * width;
					length := length + subset - 1;
				when others =>
					ui.write (buffer & "", offset.x, offset.y, (others => 255), height, code => true);
			end case;
			--
			core.increment (length);
		end loop;
	end write_ada_code;

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

end ui;