--- a/GNUmakefile	Sat Oct 15 21:19:25 2022 +0200
+++ b/GNUmakefile	Sat Oct 15 21:24:17 2022 +0200
@@ -44,7 +44,7 @@
                         -Ilibmlk-util \
                         -Ilibmlk-core \
                         -Ilibmlk-ui \
-                        -Isrc/libmlk-rpg \
+                        -Ilibmlk-rpg \
                         -I. \
                         $(SDL2_INCS) \
                         $(SDL2_IMAGE_INCS) \
@@ -254,59 +254,59 @@
 # {{{ libmlk-rpg
 
 LIBMLK_RPG :=           libmlk-rpg.a
-LIBMLK_RPG_SRCS :=      src/libmlk-rpg/rpg/battle-bar-default.c \
-                        src/libmlk-rpg/rpg/battle-bar.c \
-                        src/libmlk-rpg/rpg/battle-entity-state-attacking.c \
-                        src/libmlk-rpg/rpg/battle-entity-state-blinking.c \
-                        src/libmlk-rpg/rpg/battle-entity-state-moving.c \
-                        src/libmlk-rpg/rpg/battle-entity-state-normal.c \
-                        src/libmlk-rpg/rpg/battle-entity-state.c \
-                        src/libmlk-rpg/rpg/battle-entity.c \
-                        src/libmlk-rpg/rpg/battle-indicator.c \
-                        src/libmlk-rpg/rpg/battle-message.c \
-                        src/libmlk-rpg/rpg/battle-state-ai.c \
-                        src/libmlk-rpg/rpg/battle-state-attacking.c \
-                        src/libmlk-rpg/rpg/battle-state-check.c \
-                        src/libmlk-rpg/rpg/battle-state-closing.c \
-                        src/libmlk-rpg/rpg/battle-state-item.c \
-                        src/libmlk-rpg/rpg/battle-state-lost.c \
-                        src/libmlk-rpg/rpg/battle-state-menu.c \
-                        src/libmlk-rpg/rpg/battle-state-opening.c \
-                        src/libmlk-rpg/rpg/battle-state-rendering.c \
-                        src/libmlk-rpg/rpg/battle-state-selection.c \
-                        src/libmlk-rpg/rpg/battle-state-victory.c \
-                        src/libmlk-rpg/rpg/battle-state.c \
-                        src/libmlk-rpg/rpg/battle.c \
-                        src/libmlk-rpg/rpg/character.c \
-                        src/libmlk-rpg/rpg/equipment.c \
-                        src/libmlk-rpg/rpg/inventory.c \
-                        src/libmlk-rpg/rpg/item.c \
-                        src/libmlk-rpg/rpg/map-file.c \
-                        src/libmlk-rpg/rpg/map.c \
-                        src/libmlk-rpg/rpg/message.c \
-                        src/libmlk-rpg/rpg/property.c \
-                        src/libmlk-rpg/rpg/quest.c \
-                        src/libmlk-rpg/rpg/rpg.c \
-                        src/libmlk-rpg/rpg/save.c \
-                        src/libmlk-rpg/rpg/selection.c \
-                        src/libmlk-rpg/rpg/spell.c \
-                        src/libmlk-rpg/rpg/team.c \
-                        src/libmlk-rpg/rpg/tileset-file.c \
-                        src/libmlk-rpg/rpg/tileset.c \
-                        src/libmlk-rpg/rpg/walksprite.c
+LIBMLK_RPG_SRCS :=      libmlk-rpg/mlk/rpg/battle-bar-default.c \
+                        libmlk-rpg/mlk/rpg/battle-bar.c \
+                        libmlk-rpg/mlk/rpg/battle-entity-state-attacking.c \
+                        libmlk-rpg/mlk/rpg/battle-entity-state-blinking.c \
+                        libmlk-rpg/mlk/rpg/battle-entity-state-moving.c \
+                        libmlk-rpg/mlk/rpg/battle-entity-state-normal.c \
+                        libmlk-rpg/mlk/rpg/battle-entity-state.c \
+                        libmlk-rpg/mlk/rpg/battle-entity.c \
+                        libmlk-rpg/mlk/rpg/battle-indicator.c \
+                        libmlk-rpg/mlk/rpg/battle-message.c \
+                        libmlk-rpg/mlk/rpg/battle-state-ai.c \
+                        libmlk-rpg/mlk/rpg/battle-state-attacking.c \
+                        libmlk-rpg/mlk/rpg/battle-state-check.c \
+                        libmlk-rpg/mlk/rpg/battle-state-closing.c \
+                        libmlk-rpg/mlk/rpg/battle-state-item.c \
+                        libmlk-rpg/mlk/rpg/battle-state-lost.c \
+                        libmlk-rpg/mlk/rpg/battle-state-menu.c \
+                        libmlk-rpg/mlk/rpg/battle-state-opening.c \
+                        libmlk-rpg/mlk/rpg/battle-state-rendering.c \
+                        libmlk-rpg/mlk/rpg/battle-state-selection.c \
+                        libmlk-rpg/mlk/rpg/battle-state-victory.c \
+                        libmlk-rpg/mlk/rpg/battle-state.c \
+                        libmlk-rpg/mlk/rpg/battle.c \
+                        libmlk-rpg/mlk/rpg/character.c \
+                        libmlk-rpg/mlk/rpg/equipment.c \
+                        libmlk-rpg/mlk/rpg/inventory.c \
+                        libmlk-rpg/mlk/rpg/item.c \
+                        libmlk-rpg/mlk/rpg/map-file.c \
+                        libmlk-rpg/mlk/rpg/map.c \
+                        libmlk-rpg/mlk/rpg/message.c \
+                        libmlk-rpg/mlk/rpg/property.c \
+                        libmlk-rpg/mlk/rpg/quest.c \
+                        libmlk-rpg/mlk/rpg/rpg.c \
+                        libmlk-rpg/mlk/rpg/save.c \
+                        libmlk-rpg/mlk/rpg/selection.c \
+                        libmlk-rpg/mlk/rpg/spell.c \
+                        libmlk-rpg/mlk/rpg/team.c \
+                        libmlk-rpg/mlk/rpg/tileset-file.c \
+                        libmlk-rpg/mlk/rpg/tileset.c \
+                        libmlk-rpg/mlk/rpg/walksprite.c
 LIBMLK_RPG_OBJS :=      $(LIBMLK_RPG_SRCS:.c=.o)
 LIBMLK_RPG_DEPS :=      $(LIBMLK_RPG_SRCS:.c=.d)
 
-LIBMLK_RPG_DATA_SRCS := src/libmlk-rpg/assets/sql/character-load.sql \
-                        src/libmlk-rpg/assets/sql/character-save.sql \
-                        src/libmlk-rpg/assets/sql/init.sql \
-                        src/libmlk-rpg/assets/sql/property-load.sql \
-                        src/libmlk-rpg/assets/sql/property-remove.sql \
-                        src/libmlk-rpg/assets/sql/property-save.sql \
-                        src/libmlk-rpg/assets/sql/quest-remove.sql \
-                        src/libmlk-rpg/assets/sql/quest-save.sql \
-                        src/libmlk-rpg/assets/sql/quest-step-load.sql \
-                        src/libmlk-rpg/assets/sql/quest-step-save.sql
+LIBMLK_RPG_DATA_SRCS := libmlk-rpg/assets/sql/character-load.sql \
+                        libmlk-rpg/assets/sql/character-save.sql \
+                        libmlk-rpg/assets/sql/init.sql \
+                        libmlk-rpg/assets/sql/property-load.sql \
+                        libmlk-rpg/assets/sql/property-remove.sql \
+                        libmlk-rpg/assets/sql/property-save.sql \
+                        libmlk-rpg/assets/sql/quest-remove.sql \
+                        libmlk-rpg/assets/sql/quest-save.sql \
+                        libmlk-rpg/assets/sql/quest-step-load.sql \
+                        libmlk-rpg/assets/sql/quest-step-save.sql
 LIBMLK_RPG_DATA_OBJS := $(addsuffix .h,$(basename $(LIBMLK_RPG_DATA_SRCS)))
 
 $(LIBMLK_RPG_DATA_OBJS): BCC_OPTS := -cs0

--- a/examples/example-action/example-action.c	Sat Oct 15 21:19:25 2022 +0200
+++ b/examples/example-action/example-action.c	Sat Oct 15 21:24:17 2022 +0200
@@ -38,8 +38,8 @@
 #include <mlk/ui/theme.h>
 #include <mlk/ui/ui.h>
 
-#include <rpg/message.h>
-#include <rpg/rpg.h>
+#include <mlk/rpg/message.h>
+#include <mlk/rpg/rpg.h>
 
 #include <assets/sprites/chest.h>
 #include <assets/sprites/people.h>

--- a/examples/example-message/example-message.c	Sat Oct 15 21:19:25 2022 +0200
+++ b/examples/example-message/example-message.c	Sat Oct 15 21:24:17 2022 +0200
@@ -32,8 +32,8 @@
 #include <mlk/ui/theme.h>
 #include <mlk/ui/ui.h>
 
-#include <rpg/message.h>
-#include <rpg/rpg.h>
+#include <mlk/rpg/message.h>
+#include <mlk/rpg/rpg.h>
 
 #define W       (1280)
 #define H       (720)

--- a/examples/example/character-john.c	Sat Oct 15 21:19:25 2022 +0200
+++ b/examples/example/character-john.c	Sat Oct 15 21:24:17 2022 +0200
@@ -16,7 +16,7 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <rpg/character.h>
+#include <mlk/rpg/character.h>
 
 #include "character-john.h"
 #include "spell-fire.h"

--- a/examples/example/spell-fire.c	Sat Oct 15 21:19:25 2022 +0200
+++ b/examples/example/spell-fire.c	Sat Oct 15 21:24:17 2022 +0200
@@ -25,11 +25,11 @@
 
 #include <mlk/ui/align.h>
 
-#include <rpg/battle-state-check.h>
-#include <rpg/battle-state-rendering.h>
-#include <rpg/battle.h>
-#include <rpg/character.h>
-#include <rpg/spell.h>
+#include <mlk/rpg/battle-state-check.h>
+#include <mlk/rpg/battle-state-rendering.h>
+#include <mlk/rpg/battle.h>
+#include <mlk/rpg/character.h>
+#include <mlk/rpg/spell.h>
 
 #include "registry.h"
 #include "spell-fire.h"

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/assets/sql/character-load.sql	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,30 @@
+--
+-- character-load.sql -- load a character data
+--
+-- Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--
+
+SELECT hp
+     , mp
+     , level
+     , team_order
+     , bonus_hp
+     , bonus_mp
+     , bonus_atk
+     , bonus_def
+     , bonus_agt
+     , bonus_luck
+  FROM character
+ WHERE name = ?

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/assets/sql/character-save.sql	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,44 @@
+--
+-- character-save.sql -- save or replace character
+--
+-- Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--
+
+INSERT OR REPLACE INTO character(
+	name,
+	hp,
+	mp,
+	level,
+	team_order,
+	bonus_hp,
+	bonus_mp,
+	bonus_atk,
+	bonus_def,
+	bonus_agt,
+	bonus_luck
+)
+VALUES(
+	?,
+	?,
+	?,
+	?,
+	?,
+	?,
+	?,
+	?,
+	?,
+	?,
+	?
+)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/assets/sql/init.sql	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,55 @@
+--
+-- init.sql -- initialize database
+--
+-- Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--
+
+BEGIN EXCLUSIVE TRANSACTION;
+
+CREATE TABLE IF NOT EXISTS property(
+	id              INTEGER PRIMARY KEY AUTOINCREMENT,
+	key             TEXT NOT NULL UNIQUE,
+	value           TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS character(
+	name            TEXT PRIMARY KEY,
+	hp              INTEGER NOT NULL,
+	mp              INTEGER NOT NULL,
+	level           INTEGER NOT NULL,
+	team_order      INTEGER DEFAULT -1,
+	bonus_hp        INTEGER DEFAULT 0,
+	bonus_mp        INTEGER DEFAULT 0,
+	bonus_atk       INTEGER DEFAULT 0,
+	bonus_def       INTEGER DEFAULT 0,
+	bonus_agt       INTEGER DEFAULT 0,
+	bonus_luck      INTEGER DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS quest(
+	name            TEXT PRIMARY KEY
+);
+
+CREATE TABLE IF NOT EXISTS quest_step(
+	name            TEXT PRIMARY KEY,
+	percent         INTEGER DEFAULT 0,
+	quest_name      TEXT NOT NULL,
+	FOREIGN KEY(quest_name) REFERENCES quest(name)
+);
+
+INSERT OR IGNORE INTO property(key, value) VALUES ('molko.create-date', strftime('%s','now'));
+INSERT OR IGNORE INTO property(key, value) VALUES ('molko.update-date', strftime('%s','now'));
+
+COMMIT;

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/assets/sql/property-load.sql	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,21 @@
+--
+-- property-load.sql -- get a property
+--
+-- Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--
+
+SELECT value
+  FROM property
+ WHERE key = ?

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/assets/sql/property-remove.sql	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,21 @@
+--
+-- property-remove.sql -- remove a property
+--
+-- Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--
+
+DELETE
+  FROM property
+ WHERE key = ?

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/assets/sql/property-save.sql	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,26 @@
+--
+-- property-save.sql -- set a property
+--
+-- Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--
+
+INSERT OR REPLACE INTO property(
+	key,
+	value
+)
+VALUES(
+	?,
+	?
+)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/assets/sql/quest-remove.sql	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,21 @@
+--
+-- quest-remove.sql -- remove a quest entirely
+--
+-- Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--
+
+DELETE
+  FROM quest
+ WHERE name = ?

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/assets/sql/quest-save.sql	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,24 @@
+--
+-- quest-save.sql -- create parent quest entry
+--
+-- Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--
+
+INSERT INTO quest(
+	name
+)
+VALUES(
+	?
+)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/assets/sql/quest-step-load.sql	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,21 @@
+--
+-- quest-step-load.sql -- remove a quest entirely
+--
+-- Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--
+
+SELECT percent
+  FROM quest_step
+ WHERE name = ?

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/assets/sql/quest-step-save.sql	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,27 @@
+--
+-- quest-step-save.sql -- save a quest step
+--
+-- Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--
+
+INSERT INTO quest_step(
+	quest_name,
+	name,
+	percent
+) VALUES(
+	?,
+	?,
+	?
+)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-bar-default.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,693 @@
+/*
+ * battle-bar-default.c -- default battle status bar and menu implementation
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <mlk/core/alloc.h>
+#include <mlk/core/event.h>
+#include <mlk/core/font.h>
+#include <mlk/core/sprite.h>
+#include <mlk/core/trace.h>
+#include <mlk/core/util.h>
+#include <mlk/core/window.h>
+
+#include <mlk/ui/align.h>
+#include <mlk/ui/theme.h>
+
+#include "battle-bar-default.h"
+#include "battle-bar.h"
+#include "battle-state-item.h"
+#include "battle-state-selection.h"
+#include "battle.h"
+#include "character.h"
+#include "inventory.h"
+#include "item.h"
+#include "spell.h"
+
+#define THEME(bar) ((bar)->theme ? (bar)->theme : theme_default())
+
+struct geo {
+	int x, y;
+	unsigned int w, h;
+};
+
+static inline void
+dimensions(struct geo geo[2], const struct battle_bar_default *bar)
+{
+	/* 0 == main menu */
+	geo[0].w = bar->w * 0.2;
+	geo[0].h = bar->h;
+	geo[0].x = bar->x + (bar->w / 2) - (geo[0].w / 2);
+	geo[0].y = window.h - bar->h;
+
+	/* 1 == status frame */
+	geo[1].x = geo[0].x + geo[0].w;
+	geo[1].y = geo[0].y;
+	geo[1].w = (bar->w - geo[0].w) / 2;
+	geo[1].h = bar->h;
+}
+
+/*
+ * The following validate_* functions are called when the user has validated a
+ * selection depending on the current menu (e.g. Magic, Items).
+ *
+ * They change the battle state to the appropriate one.
+ */
+
+static void
+validate_attack(struct battle_bar_default *bar, struct battle *bt, const struct selection *sel)
+{
+	(void)bar;
+
+	struct character *target;
+
+	if (sel->index_side == 0)
+		target = bt->enemies[sel->index_character]->ch;
+	else
+		target = bt->team[sel->index_character]->ch;
+
+	battle_attack(bt, battle_current(bt)->ch, target);
+}
+
+static void
+validate_magic(struct battle_bar_default *bar, struct battle *bt, const struct selection *sel)
+{
+	struct character *source = battle_current(bt)->ch;
+	const struct spell *spell = source->spells[bar->grid.selected];
+
+	battle_cast(bt, source, spell, sel);
+}
+
+static void
+validate_item(struct battle_bar_default *bar, struct battle *bt, const struct selection *sel)
+{
+	struct inventory_slot *slot;
+	struct battle_entity *source, *target;
+
+	if (bar->grid.selected >= INVENTORY_ITEM_MAX)
+		return;
+	if (!(slot = &bt->inventory->items[bar->grid.selected]))
+		return;
+
+	source = battle_current(bt);
+	target = sel->index_side == 0
+		? bt->enemies[sel->index_character]
+		: bt->team[sel->index_character];
+
+	/* TODO: battle_use? */
+	battle_state_item(bt, source, target, slot);
+}
+
+/*
+ * The following functions are used to switch to the battle selection state
+ * using the appropriate selector algorithm. For example, an item can only be
+ * used on a unique target while a spell can have multiple choices.
+ */
+
+static void
+switch_selection_attack(struct battle_bar_default *bar, struct battle *bt)
+{
+	struct selection sel = {
+		.allowed_kinds = SELECTION_KIND_ONE,
+		.allowed_sides = SELECTION_SIDE_ENEMY,
+		.index_side = 0
+	};
+
+	/* Disable handling anymore. */
+	bar->state = BATTLE_BAR_DEFAULT_STATE_NONE;
+
+	selection_first(&sel, bt);
+	battle_state_selection(bt, &sel);
+}
+
+static void
+switch_selection_spell(struct battle_bar_default *bar, struct battle *bt)
+{
+	const struct character *ch = battle_current(bt)->ch;
+	const struct spell *sp = ch->spells[bar->grid.selected];
+	struct selection sel = {0};
+
+	if (bar->grid.selected > CHARACTER_SPELL_MAX)
+		return;
+	if (!(sp = ch->spells[bar->grid.selected]) || sp->mp > (unsigned int)ch->mp)
+		return;
+
+	/* Use the spell selection algorithm to fill default values. */
+	spell_select(sp, bt, &sel);
+	battle_state_selection(bt, &sel);
+
+	/* A cursor should be present. */
+	if (!sprite_ok(BATTLE_THEME(bt)->sprites[THEME_SPRITE_CURSOR]))
+		tracef("battle: no cursor sprite in theme");
+}
+
+static void
+switch_selection_item(struct battle *bt)
+{
+	const struct selection slt = {
+		.allowed_kinds = SELECTION_KIND_ONE,
+		.allowed_sides = SELECTION_SIDE_TEAM | SELECTION_SIDE_ENEMY,
+		.index_side = 1,
+		.index_character = battle_index(bt)
+	};
+
+	battle_state_selection(bt, &slt);
+}
+
+/*
+ * The following functions actually draw the bar and their components depending
+ * on the current selected menu.
+ */
+
+static void
+draw_help(const struct battle_bar_default *bar, const char *what)
+{
+	struct label label = {0};
+	unsigned int lw = 0, lh = 0;
+
+	label.flags = LABEL_FLAGS_SHADOW;
+	label.text = what;
+	label_query(&label, &lw, &lh);
+	label.x = bar->grid.x + (bar->grid.w / 2) - (lw / 2);
+	label.y = bar->grid.y - lh - THEME(bar)->padding;
+	label_draw(&label);
+}
+
+static void
+draw_spell_help(const struct battle_bar_default *bar, const struct battle *bt)
+{
+	const struct character *ch = battle_current(bt)->ch;
+	const struct spell *sp;
+
+	if (bar->grid.selected >= CHARACTER_SPELL_MAX)
+		return;
+	if (!(sp = ch->spells[bar->grid.selected]))
+		return;
+
+	draw_help(bar, sp->description);
+}
+
+static void
+draw_item_help(const struct battle_bar_default *bar, const struct battle *bt)
+{
+	const struct inventory_slot *slot;
+
+	if (bar->grid.selected >= INVENTORY_ITEM_MAX)
+		return;
+
+	slot = &bt->inventory->items[bar->grid.selected];
+
+	if (!slot->item)
+		return;
+
+	draw_help(bar, slot->item->description);
+}
+
+static void
+draw_status_character_stats(const struct battle_bar_default *bar,
+                            const struct character *ch,
+                            int x,
+                            int y,
+                            unsigned int h)
+{
+	const struct theme *theme = THEME(bar);
+	struct label label;
+	unsigned int spacing, lw, lh;
+	char line[64];
+
+	/* Compute spacing between elements. */
+	spacing = h - (font_height(theme->fonts[THEME_FONT_INTERFACE]) * 3);
+	spacing /= 4;
+
+	/* Reuse the same label. */
+	label.theme = theme;
+	label.text = line;
+	label.flags = LABEL_FLAGS_SHADOW;
+
+	/* Name. */
+	snprintf(line, sizeof (line), "%s", ch->name);
+	label_query(&label, &lw, &lh);
+	label.x = x + theme->padding;
+	label.y = y + spacing;
+	label_draw(&label);
+
+	/* HP. */
+	snprintf(line, sizeof (line), "%d/%u", ch->hp, ch->hpmax);
+	label_query(&label, &lw, &lh);
+	label.x = x + theme->padding;
+	label.y = label.y + lh + spacing;
+	label_draw(&label);
+
+	/* MP. */
+	snprintf(line, sizeof (line), "%d/%u", ch->mp, ch->mpmax);
+	label_query(&label, &lw, &lh);
+	label.x = x + theme->padding;
+	label.y = label.y + lh + spacing;
+	label_draw(&label);
+
+	/* Status. */
+	/* TODO: list all status. */
+}
+
+static void
+draw_status_character(const struct battle_bar_default *bar,
+                      const struct battle *bt,
+                      const struct character *ch,
+                      const struct geo *geo,
+                      unsigned int index)
+{
+	int x, y;
+	unsigned int w, h;
+
+	/* Compute bounding box for rendering. */
+	w = geo->w / bt->teamsz;
+	h = geo->h;
+	x = geo->x + (index * w);
+	y = geo->y;
+
+	draw_status_character_stats(bar, ch, x, y, h);
+}
+
+static void
+draw_status_characters(const struct battle_bar_default *bar,
+                       const struct battle *bt,
+                       const struct geo *geo)
+{
+	const struct battle_entity *et;
+	unsigned int index = 0;
+
+	BATTLE_TEAM_FOREACH(bt, et) {
+		if (character_ok(et->ch))
+			draw_status_character(bar, bt, et->ch, geo, index);
+
+		++index;
+	}
+}
+
+static void
+draw_status(const struct battle_bar_default *bar, const struct battle *bt, const struct geo *geo)
+{
+	frame_draw(&(const struct frame) {
+		.x = geo->x,
+		.y = geo->y,
+		.w = geo->w,
+		.h = geo->h
+	});
+
+	draw_status_characters(bar, bt, geo);
+}
+
+static void
+draw_menu(const struct battle_bar_default *bar, const struct geo *geo)
+{
+	struct {
+		unsigned int w, h;
+		enum align align;
+		struct label label;
+	} buttons[] = {
+		{
+			.align = ALIGN_TOP,
+			.label = {
+				.text = "Attack",
+				.flags = LABEL_FLAGS_SHADOW
+			}
+		},
+		{
+			.align = ALIGN_RIGHT,
+			.label = {
+				.text = "Magic",
+				.flags = LABEL_FLAGS_SHADOW
+			}
+		},
+		{
+			.align = ALIGN_BOTTOM,
+			.label = {
+				.text = "Objects",
+				.flags = LABEL_FLAGS_SHADOW
+			}
+		},
+		{
+			.align = ALIGN_LEFT,
+			.label = {
+				.text = "Special",
+				.flags = LABEL_FLAGS_SHADOW
+			}
+		}
+	};
+
+	const struct theme *theme = THEME(bar);
+	int bx, by;
+	unsigned int bw, bh;
+
+	/* Compute bounding box with margins removed. */
+	bx = geo->x + theme->padding;
+	by = geo->y + theme->padding;
+	bw = geo->w - theme->padding * 2;
+	bh = geo->h - theme->padding * 2;
+
+	/* Draw menu frame. */
+	frame_draw(&(const struct frame) {
+		.x = geo->x,
+		.y = geo->y,
+		.w = geo->w,
+		.h = geo->h
+	});
+
+	for (size_t i = 0; i < UTIL_SIZE(buttons); ++i) {
+		buttons[i].label.theme = theme;
+
+		label_query(&buttons[i].label, &buttons[i].w, &buttons[i].h);
+
+		/* Change theme if it's selected. */
+		if ((size_t)bar->menu == i)
+			buttons[i].label.flags |=  LABEL_FLAGS_SELECTED;
+		else
+			buttons[i].label.flags &= ~LABEL_FLAGS_SELECTED;
+
+		align(buttons[i].align,
+		    &buttons[i].label.x, &buttons[i].label.y, buttons[i].w, buttons[i].h,
+		    bx, by, bw, bh);
+		label_draw(&buttons[i].label);
+	}
+}
+
+/*
+ * This function is called only in the first level of the bar menu: selecting
+ * one of the Attack, Magic, Item and Special items.
+ */
+static void
+handle_keydown_menu(struct battle_bar_default *bar, struct battle *bt, const union event *ev)
+{
+	(void)bt;
+
+	switch (ev->key.key) {
+	case KEY_UP:
+		bar->menu = BATTLE_BAR_DEFAULT_MENU_ATTACK;
+		break;
+	case KEY_RIGHT:
+		bar->menu = BATTLE_BAR_DEFAULT_MENU_MAGIC;
+		break;
+	case KEY_DOWN:
+		bar->menu = BATTLE_BAR_DEFAULT_MENU_ITEM;
+		break;
+	case KEY_LEFT:
+		bar->menu = BATTLE_BAR_DEFAULT_MENU_SPECIAL;
+		break;
+	case KEY_ENTER:
+		/*
+		 * At this step, attack does not require opening the sub menu so
+		 * we change selection state immediately if needed.
+		 */
+		switch (bar->menu) {
+		case BATTLE_BAR_DEFAULT_MENU_ATTACK:
+			switch_selection_attack(bar, bt);
+			break;
+		case BATTLE_BAR_DEFAULT_MENU_ITEM:
+			battle_bar_default_open_item(bar, bt);
+			break;
+		case BATTLE_BAR_DEFAULT_MENU_MAGIC:
+			battle_bar_default_open_magic(bar, bt, battle_current(bt)->ch);
+			break;
+		default:
+			break;
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+/*
+ * This function is called when we're selecting a submenu entry from Items
+ * and Magic.
+ */
+static void
+handle_keydown_grid(struct battle_bar_default *bar, struct battle *bt, const union event *ev)
+{
+	/* Go back to main menu if I press escape. */
+	if (ev->key.key == KEY_ESCAPE)
+		bar->state = BATTLE_BAR_DEFAULT_STATE_MENU;
+	else if (gridmenu_handle(&bar->grid, ev)) {
+		switch (bar->menu) {
+		case BATTLE_BAR_DEFAULT_MENU_MAGIC:
+			switch_selection_spell(bar, bt);
+			break;
+		case BATTLE_BAR_DEFAULT_MENU_ITEM:
+			switch_selection_item(bt);
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+static void
+handle_keydown(struct battle_bar_default *bar, struct battle *bt, const union event *ev)
+{
+	assert(ev->type == EVENT_KEYDOWN);
+
+	static void (*handlers[])(struct battle_bar_default *, struct battle *, const union event *) = {
+		[BATTLE_BAR_DEFAULT_STATE_MENU] = handle_keydown_menu,
+		[BATTLE_BAR_DEFAULT_STATE_GRID] = handle_keydown_grid
+	};
+
+	if (handlers[bar->state])
+		handlers[bar->state](bar, bt, ev);
+}
+
+#if 0
+
+static void
+handle_clickdown(struct battle_bar_default *bar, struct battle *bt, const union event *ev)
+{
+	assert(ev->type == EVENT_CLICKDOWN);
+
+	(void)bar;
+	(void)bt;
+
+	switch (bar->state) {
+	case BATTLE_BAR_DEFAULT_STATE_MENU:
+		/* We are selecting a main menu entry. */
+		/* TODO: implement click here too. */
+		break;
+	case BATTLE_BAR_DEFAULT_STATE_SUB:
+		/* We are in the sub menu (objects/spells). */
+		if (bar->sub_grid.state == GRIDMENU_STATE_ACTIVATED)
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+#endif
+
+static void
+self_start(struct battle_bar *bar, struct battle *bt)
+{
+	(void)bt;
+
+	battle_bar_default_start(bar->data);
+}
+
+static void
+self_select(struct battle_bar *bar, struct battle *bt, const struct selection *sel)
+{
+	battle_bar_default_select(bar->data, bt, sel);
+}
+
+static void
+self_handle(struct battle_bar *bar, struct battle *bt, const union event *ev)
+{
+	battle_bar_default_handle(bar->data, bt, ev);
+}
+
+static void
+self_draw(const struct battle_bar *bar, const struct battle *bt)
+{
+	battle_bar_default_draw(bar->data, bt);
+}
+
+void
+battle_bar_default_init(struct battle_bar_default *bar)
+{
+	assert(bar);
+
+	struct geo geo[2];
+
+	memset(bar, 0, sizeof (*bar));
+
+	bar->w = window.w;
+	bar->h = window.h * 0.12;
+	bar->x = 0;
+	bar->y = window.h - bar->h;
+
+	dimensions(geo, bar);
+
+	gridmenu_init(&bar->grid, 2, 2, NULL, 0);
+	gridmenu_resize(&bar->grid, bar->x, geo[0].y, geo[1].w, bar->h);
+	bar->grid.theme = bar->theme;
+}
+
+void
+battle_bar_default_open_magic(struct battle_bar_default *bar, const struct battle *bt, struct character *ch)
+{
+	assert(bar);
+	assert(bt);
+	assert(ch);
+
+	(void)bt;
+
+	bar->items = alloc_rearray0(bar->items, bar->itemsz,
+	    CHARACTER_SPELL_MAX, sizeof (*bar->items));
+	bar->itemsz = CHARACTER_SPELL_MAX;
+	bar->state = BATTLE_BAR_DEFAULT_STATE_GRID;
+
+	for (size_t i = 0; i < CHARACTER_SPELL_MAX; ++i)
+		if (ch->spells[i])
+			bar->items[i] = ch->spells[i]->name;
+
+	bar->grid.items = bar->items;
+	bar->grid.itemsz = bar->itemsz;
+}
+
+void
+battle_bar_default_open_item(struct battle_bar_default *bar, const struct battle *bt)
+{
+	assert(bar);
+	assert(bt);
+
+	/* TODO: not implemented yet. */
+	(void)bar;
+	(void)bt;
+#if 0
+	for (size_t i = 0; i < INVENTORY_ITEM_MAX; ++i) {
+		if (bt->inventory->items[i].item) {
+			snprintf(bar->sub_items[i], sizeof (bar->sub_items[i]), "%-16s %u",
+			    bt->inventory->items[i].item->name, bt->inventory->items[i].amount);
+			bar->sub_grid.menu[i] = bar->sub_items[i];
+		}
+	}
+
+	bar->state = BATTLE_BAR_DEFAULT_STATE_GRID;
+#endif
+}
+
+void
+battle_bar_default_start(struct battle_bar_default *bar)
+{
+	assert(bar);
+
+	bar->menu = BATTLE_BAR_DEFAULT_MENU_ATTACK;
+	bar->state = BATTLE_BAR_DEFAULT_STATE_MENU;
+}
+
+/*
+ * Apply the battle selection for the current menu item. This function is called
+ * from the battle-state-selection state when the user validated the selection.
+ */
+void
+battle_bar_default_select(struct battle_bar_default *bar, struct battle *bt, const struct selection *sel)
+{
+	assert(bar);
+	assert(bt);
+	assert(sel);
+
+	static void (*validate[])(struct battle_bar_default *, struct battle *, const struct selection *) = {
+		[BATTLE_BAR_DEFAULT_MENU_ATTACK]        = validate_attack,
+		[BATTLE_BAR_DEFAULT_MENU_ITEM]          = validate_item,
+		[BATTLE_BAR_DEFAULT_MENU_MAGIC]         = validate_magic,
+		[BATTLE_BAR_DEFAULT_MENU_SPECIAL]       = NULL
+	};
+
+	if (validate[bar->menu])
+		validate[bar->menu](bar, bt, sel);
+}
+
+void
+battle_bar_default_handle(struct battle_bar_default *bar, struct battle *bt, const union event *ev)
+{
+	assert(bar);
+	assert(bt);
+	assert(ev);
+
+	static void (*handlers[])(struct battle_bar_default *, struct battle *, const union event *) = {
+		[EVENT_KEYDOWN] = handle_keydown,
+		[EVENT_NUM] = NULL
+	};
+
+	if (handlers[ev->type])
+		handlers[ev->type](bar, bt, ev);
+}
+
+void
+battle_bar_default_draw(const struct battle_bar_default *bar, const struct battle *bt)
+{
+	assert(bar);
+	assert(bt);
+
+	struct geo geo[2];
+
+	dimensions(geo, bar);
+	draw_menu(bar, &geo[0]);
+	draw_status(bar, bt, &geo[1]);
+
+	if (bar->state == BATTLE_BAR_DEFAULT_STATE_GRID) {
+		switch (bar->menu) {
+		case BATTLE_BAR_DEFAULT_MENU_MAGIC:
+			draw_spell_help(bar, bt);
+			break;
+		case BATTLE_BAR_DEFAULT_MENU_ITEM:
+			draw_item_help(bar, bt);
+			break;
+		default:
+			break;
+		}
+	}
+
+	/* Sub menu is only shown if state is set to it. */
+	if (bar->state == BATTLE_BAR_DEFAULT_STATE_GRID)
+		gridmenu_draw(&bar->grid);
+}
+
+void
+battle_bar_default_finish(struct battle_bar_default *bar)
+{
+	assert(bar);
+
+	free(bar->items);
+	memset(bar, 0, sizeof (*bar));
+}
+
+void
+battle_bar_default(struct battle_bar_default *self, struct battle_bar *bar)
+{
+	assert(self);
+	assert(bar);
+
+	memset(bar, 0, sizeof (*bar));
+
+	bar->data = self;
+	bar->start = self_start;
+	bar->select = self_select;
+	bar->handle = self_handle;
+	bar->draw = self_draw;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-bar-default.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,93 @@
+/*
+ * battle-bar-default.h -- default battle status bar and menu implementation
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_BAR_DEFAULT_H
+#define MLK_RPG_BATTLE_BAR_DEFAULT_H
+
+#include <mlk/core/core.h>
+
+#include <mlk/ui/gridmenu.h>
+
+struct battle;
+struct battle_bar;
+struct character;
+struct selection;
+struct theme;
+
+union event;
+
+enum battle_bar_default_menu {
+	BATTLE_BAR_DEFAULT_MENU_ATTACK,
+	BATTLE_BAR_DEFAULT_MENU_MAGIC,
+	BATTLE_BAR_DEFAULT_MENU_ITEM,
+	BATTLE_BAR_DEFAULT_MENU_SPECIAL
+};
+
+enum battle_bar_default_state {
+	BATTLE_BAR_DEFAULT_STATE_NONE,
+	BATTLE_BAR_DEFAULT_STATE_MENU,
+	BATTLE_BAR_DEFAULT_STATE_GRID
+};
+
+struct battle_bar_default {
+	int x;
+	int y;
+	unsigned int w;
+	unsigned int h;
+	struct theme *theme;
+	enum battle_bar_default_state state;
+	enum battle_bar_default_menu menu;
+
+	/* Private fields. */
+	const char **items;
+	size_t itemsz;
+	struct gridmenu grid;
+};
+
+CORE_BEGIN_DECLS
+
+void
+battle_bar_default_init(struct battle_bar_default *);
+
+void
+battle_bar_default_open_magic(struct battle_bar_default *, const struct battle *, struct character *);
+
+void
+battle_bar_default_open_item(struct battle_bar_default *, const struct battle *);
+
+void
+battle_bar_default_start(struct battle_bar_default *);
+
+void
+battle_bar_default_select(struct battle_bar_default *, struct battle *, const struct selection *);
+
+void
+battle_bar_default_handle(struct battle_bar_default *, struct battle *, const union event *);
+
+void
+battle_bar_default_draw(const struct battle_bar_default *, const struct battle *);
+
+void
+battle_bar_default_finish(struct battle_bar_default *);
+
+void
+battle_bar_default(struct battle_bar_default *, struct battle_bar *);
+
+CORE_END_DECLS
+
+#endif /* !MLK_RPG_BATTLE_BAR_DEFAULT_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-bar.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,84 @@
+/*
+ * battle-bar.c -- abstract battle bar
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+
+#include "battle-bar.h"
+
+void
+battle_bar_start(struct battle_bar *bar, struct battle *bt)
+{
+	assert(bar);
+	assert(bt);
+
+	if (bar->start)
+		bar->start(bar, bt);
+}
+
+void
+battle_bar_select(struct battle_bar *bar, struct battle *bt, const struct selection *sel)
+{
+	assert(bar);
+	assert(bt);
+	assert(sel);
+
+	if (bar->select)
+		bar->select(bar, bt, sel);
+
+}
+
+void
+battle_bar_handle(struct battle_bar *bar, struct battle *bt, const union event *ev)
+{
+	assert(bar);
+	assert(bt);
+	assert(ev);
+
+	if (bar->handle)
+		bar->handle(bar, bt, ev);
+}
+
+void
+battle_bar_update(struct battle_bar *bar, struct battle *bt, unsigned int ticks)
+{
+	assert(bar);
+	assert(bt);
+
+	if (bar->update)
+		bar->update(bar, bt, ticks);
+}
+
+void
+battle_bar_draw(const struct battle_bar *bar, const struct battle *bt)
+{
+	assert(bar);
+	assert(bt);
+
+	if (bar->draw)
+		bar->draw(bar, bt);
+}
+
+void
+battle_bar_finish(struct battle_bar *bar, struct battle *bt)
+{
+	assert(bar);
+	assert(bt);
+
+	if (bar->finish)
+		bar->finish(bar, bt);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-bar.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,61 @@
+/*
+ * battle-bar.h -- abstract battle bar
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_BAR_H
+#define MLK_RPG_BATTLE_BAR_H
+
+#include <mlk/core/core.h>
+
+struct battle;
+struct selection;
+
+union event;
+
+struct battle_bar {
+	void *data;
+	void (*start)(struct battle_bar *, struct battle *);
+	void (*select)(struct battle_bar *, struct battle *, const struct selection *);
+	void (*handle)(struct battle_bar *, struct battle *, const union event *);
+	void (*update)(struct battle_bar *, struct battle *, unsigned int);
+	void (*draw)(const struct battle_bar *, const struct battle *);
+	void (*finish)(struct battle_bar *, struct battle *);
+};
+
+CORE_BEGIN_DECLS
+
+void
+battle_bar_start(struct battle_bar *, struct battle *);
+
+void
+battle_bar_select(struct battle_bar *, struct battle *, const struct selection *);
+
+void
+battle_bar_handle(struct battle_bar *, struct battle *, const union event *);
+
+void
+battle_bar_update(struct battle_bar *, struct battle *, unsigned int);
+
+void
+battle_bar_draw(const struct battle_bar *, const struct battle *);
+
+void
+battle_bar_finish(struct battle_bar *, struct battle *);
+
+CORE_END_DECLS
+
+#endif /* !MLK_RPG_BATTLE_BAR_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity-state-attacking.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,101 @@
+/*
+ * battle-entity-state-attacking.h -- the entity is attacking
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include <mlk/core/alloc.h>
+#include <mlk/core/animation.h>
+#include <mlk/core/panic.h>
+#include <mlk/core/sprite.h>
+
+#include "battle-entity-state-attacking.h"
+#include "battle-entity-state.h"
+#include "battle-entity.h"
+
+struct self {
+	struct battle_entity_state_attacking data;
+	struct battle_entity_state state;
+};
+
+static int
+update(struct battle_entity_state *st, struct battle_entity *et, unsigned int ticks)
+{
+	(void)et;
+
+	return battle_entity_state_attacking_update(st->data, ticks);
+}
+
+static void
+draw(const struct battle_entity_state *st, const struct battle_entity *et)
+{
+	battle_entity_state_attacking_draw(st->data, et);
+}
+
+static void
+finish(struct battle_entity_state *st, struct battle_entity *et)
+{
+	(void)et;
+
+	free(st->data);
+}
+
+void
+battle_entity_state_attacking_init(struct battle_entity_state_attacking *atk, const struct sprite *which)
+{
+	assert(atk);
+	assert(sprite_ok(which));
+
+	animation_init(&atk->anim, which, 100);
+	animation_start(&atk->anim);
+}
+
+int
+battle_entity_state_attacking_update(struct battle_entity_state_attacking *atk, unsigned int ticks)
+{
+	assert(atk);
+
+	return animation_update(&atk->anim, ticks);
+}
+
+void
+battle_entity_state_attacking_draw(const struct battle_entity_state_attacking *atk, const struct battle_entity *et)
+{
+	assert(atk);
+	assert(battle_entity_ok(et));
+
+	animation_draw(&atk->anim, et->x, et->y);
+}
+
+void
+battle_entity_state_attacking(struct battle_entity *et, const struct sprite *which)
+{
+	assert(battle_entity_ok(et));
+	assert(sprite_ok(which));
+
+	struct self *self;
+
+	self = alloc_new0(sizeof (*self));
+	self->state.data = self;
+	self->state.update = update;
+	self->state.draw = draw;
+	self->state.finish = finish;
+
+	battle_entity_state_attacking_init(&self->data, which);
+	battle_entity_switch(et, &self->state);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity-state-attacking.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,43 @@
+/*
+ * battle-entity-state-attacking.c -- the entity is attacking
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_ENTITY_STATE_ATTACKING_H
+#define MLK_RPG_BATTLE_ENTITY_STATE_ATTACKING_H
+
+#include <mlk/core/animation.h>
+
+struct battle_entity;
+struct sprite;
+
+struct battle_entity_state_attacking {
+	struct animation anim;
+};
+
+void
+battle_entity_state_attacking_init(struct battle_entity_state_attacking *, const struct sprite *);
+
+int
+battle_entity_state_attacking_update(struct battle_entity_state_attacking *, unsigned int);
+
+void
+battle_entity_state_attacking_draw(const struct battle_entity_state_attacking *, const struct battle_entity *);
+
+void
+battle_entity_state_attacking(struct battle_entity *, const struct sprite *);
+
+#endif /* !MLK_RPG_BATTLE_ENTITY_STATE_ATTACKING_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity-state-blinking.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,97 @@
+/*
+ * battle-entity-state-blinking.c -- the entity is blinking
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include <mlk/core/alloc.h>
+#include <mlk/core/panic.h>
+#include <mlk/core/sprite.h>
+#include <mlk/core/texture.h>
+
+#include "battle-entity-state-blinking.h"
+#include "battle-entity-state.h"
+#include "battle-entity.h"
+#include "character.h"
+
+#define TRANSPARENT     (150)
+#define OPAQUE          (255)
+
+struct self {
+	struct battle_entity_state_blinking data;
+	struct battle_entity_state state;
+};
+
+static int
+update(struct battle_entity_state *st, struct battle_entity *et, unsigned int ticks)
+{
+	(void)et;
+
+	return battle_entity_state_blinking_update(st->data, ticks);
+}
+
+static void
+finish(struct battle_entity_state *st, struct battle_entity *et)
+{
+	(void)et;
+
+	free(st->data);
+}
+
+void
+battle_entity_state_blinking_init(struct battle_entity_state_blinking *blk, struct battle_entity *et)
+{
+	assert(blk);
+	assert(battle_entity_ok(et));
+
+	blk->tex = et->ch->sprites[CHARACTER_SPRITE_NORMAL]->texture;
+	texture_set_alpha_mod(blk->tex, TRANSPARENT);
+}
+
+int
+battle_entity_state_blinking_update(struct battle_entity_state_blinking *blk, unsigned int ticks)
+{
+	assert(blk);
+
+	blk->elapsed += ticks;
+
+	if (blk->elapsed >= 80) {
+		blk->count += 1;
+		blk->elapsed = 0;
+	}
+
+	texture_set_alpha_mod(blk->tex, blk->count % 2 == 0 ? TRANSPARENT : OPAQUE);
+
+	return blk->count >= 3;
+}
+
+void
+battle_entity_state_blinking(struct battle_entity *et)
+{
+	assert(battle_entity_ok(et));
+
+	struct self *self;
+
+	self = alloc_new0(sizeof (*self));
+	self->state.data = self;
+	self->state.update = update;
+	self->state.finish = finish;
+
+	battle_entity_state_blinking_init(&self->data, et);
+	battle_entity_switch(et, &self->state);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity-state-blinking.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,40 @@
+/*
+ * battle-entity-state-blinking.h -- the entity is blinking
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_ENTITY_STATE_BLINKING_H
+#define MLK_RPG_BATTLE_ENTITY_STATE_BLINKING_H
+
+struct battle_entity;
+struct texture;
+
+struct battle_entity_state_blinking {
+	struct texture *tex;
+	unsigned int elapsed;
+	unsigned int count;
+};
+
+void
+battle_entity_state_blinking_init(struct battle_entity_state_blinking *, struct battle_entity *et);
+
+int
+battle_entity_state_blinking_update(struct battle_entity_state_blinking *, unsigned int);
+
+void
+battle_entity_state_blinking(struct battle_entity *);
+
+#endif /* !MLK_RPG_BATTLE_ENTITY_STATE_BLINKING_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity-state-moving.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,129 @@
+/*
+ * battle-entity-state-moving.c -- the entity is moving
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+#include <math.h>
+#include <stdlib.h>
+
+#include <mlk/core/alloc.h>
+#include <mlk/core/panic.h>
+
+#include "battle-entity-state-moving.h"
+#include "battle-entity-state.h"
+#include "battle-entity.h"
+#include "character.h"
+#include "walksprite.h"
+
+#define SPEED 800
+#define SEC   1000
+#define WALK  40
+
+struct self {
+	struct battle_entity_state_moving data;
+	struct battle_entity_state state;
+};
+
+static inline unsigned int
+orientation(const struct battle_entity_state_moving *mv, const struct battle_entity *et)
+{
+	/* TODO: support diagonal. */
+	/* See: walksprite definitions. */
+	return mv->x < et->x ? 6 : 2;
+}
+
+static int
+update(struct battle_entity_state *st, struct battle_entity *et, unsigned int ticks)
+{
+	return battle_entity_state_moving_update(st->data, et, ticks);
+}
+
+static void
+draw(const struct battle_entity_state *st, const struct battle_entity *et)
+{
+	battle_entity_state_moving_draw(st->data, et);
+}
+
+static void
+finish(struct battle_entity_state *st, struct battle_entity *et)
+{
+	(void)et;
+
+	free(st->data);
+}
+
+void
+battle_entity_state_moving_init(struct battle_entity_state_moving *mv, struct battle_entity *et, int dstx, int dsty)
+{
+	assert(mv);
+	assert(battle_entity_ok(et));
+
+	walksprite_init(&mv->ws, et->ch->sprites[CHARACTER_SPRITE_NORMAL], 40);
+	mv->x = dstx;
+	mv->y = dsty;
+}
+
+int
+battle_entity_state_moving_update(struct battle_entity_state_moving *mv, struct battle_entity *et, unsigned int ticks)
+{
+	assert(mv);
+	assert(battle_entity_ok(et));
+
+	int step_x, step_y, delta_x, delta_y;
+
+	delta_x = mv->x < et->x ? -1 : +1;
+	delta_y = mv->y < et->y ? -1 : +1;
+	step_x = fmin(SPEED * ticks / SEC, abs(et->x - mv->x));
+	step_y = fmin(SPEED * ticks / SEC, abs(et->y - mv->y));
+
+	et->x += delta_x * step_x;
+	et->y += delta_y * step_y;
+
+	if (et->x != mv->x || et->y != mv->y)
+		walksprite_update(&mv->ws, ticks);
+	else
+		walksprite_reset(&mv->ws);
+
+	return et->x == mv->x && et->y == mv->y;
+}
+
+void
+battle_entity_state_moving_draw(const struct battle_entity_state_moving *mv, const struct battle_entity *et)
+{
+	assert(mv);
+	assert(battle_entity_ok(et));
+
+	/* TODO: compute orientation. */
+	walksprite_draw(&mv->ws, orientation(mv, et), et->x, et->y);
+}
+
+void
+battle_entity_state_moving(struct battle_entity *et, int dstx, int dsty)
+{
+	assert(battle_entity_ok(et));
+
+	struct self *self;
+
+	self = alloc_new0(sizeof (*self));
+	self->state.data = self;
+	self->state.update = update;
+	self->state.draw = draw;
+	self->state.finish = finish;
+
+	battle_entity_state_moving_init(&self->data, et, dstx, dsty);
+	battle_entity_switch(et, &self->state);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity-state-moving.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,44 @@
+/*
+ * battle-entity-state-moving.h -- the entity is moving
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_ENTITY_STATE_MOVING_H
+#define MLK_RPG_BATTLE_ENTITY_STATE_MOVING_H
+
+#include <mlk/rpg/walksprite.h>
+
+struct battle_entity;
+
+struct battle_entity_state_moving {
+	struct walksprite ws;
+	int x;
+	int y;
+};
+
+void
+battle_entity_state_moving_init(struct battle_entity_state_moving *, struct battle_entity *, int, int);
+
+int
+battle_entity_state_moving_update(struct battle_entity_state_moving *, struct battle_entity *, unsigned int);
+
+void
+battle_entity_state_moving_draw(const struct battle_entity_state_moving *, const struct battle_entity *);
+
+void
+battle_entity_state_moving(struct battle_entity *, int, int);
+
+#endif /* !MLK_RPG_BATTLE_ENTITY_STATE_MOVING_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity-state-normal.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,36 @@
+/*
+ * battle-entity-state-normal.c -- the entity is normal
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+
+#include "battle-entity-state-normal.h"
+#include "battle-entity-state.h"
+#include "battle-entity.h"
+
+/* TODO: animate characters when they are inactive. */
+
+void
+battle_entity_state_normal(struct battle_entity *et)
+{
+	assert(battle_entity_ok(et));
+
+	/* Not needed yet. */
+	static struct battle_entity_state st;
+
+	battle_entity_switch(et, &st);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity-state-normal.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,28 @@
+/*
+ * battle-entity-state-normal.h -- the entity is normal
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_ENTITY_STATE_NORMAL_H
+#define MLK_RPG_BATTLE_ENTITY_STATE_NORMAL_H
+
+struct battle_entity;
+
+void
+battle_entity_state_normal(struct battle_entity *);
+
+#endif /* !MLK_RPG_BATTLE_ENTITY_STATE_NORMAL_H */
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity-state.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,55 @@
+/*
+ * battle-entity-state.c -- abstract battle entity state
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+
+#include "battle-entity.h"
+#include "battle-entity-state.h"
+
+int
+battle_entity_state_update(struct battle_entity_state *st, struct battle_entity *et, unsigned int ticks)
+{
+	assert(st);
+	assert(battle_entity_ok(et));
+
+	if (st->update)
+		return st->update(st, et, ticks);
+
+	return 1;
+}
+
+void
+battle_entity_state_draw(const struct battle_entity_state *st, const struct battle_entity *et)
+{
+	assert(st);
+	assert(battle_entity_ok(et));
+
+	if (st->draw)
+		st->draw(st, et);
+	else
+		battle_entity_draw_sprite(et);
+}
+
+void
+battle_entity_state_finish(struct battle_entity_state *st, struct battle_entity *et)
+{
+	assert(battle_entity_ok(et));
+
+	if (st->finish)
+		st->finish(st, et);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity-state.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,47 @@
+/*
+ * battle-entity-state.h -- abstract battle entity state
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_ENTITY_STATE_H
+#define MLK_RPG_BATTLE_ENTITY_STATE_H
+
+#include <mlk/core/core.h>
+
+struct battle_entity;
+struct sprite;
+
+struct battle_entity_state {
+	void *data;
+	int (*update)(struct battle_entity_state *, struct battle_entity *, unsigned int);
+	void (*draw)(const struct battle_entity_state *, const struct battle_entity *);
+	void (*finish)(struct battle_entity_state *, struct battle_entity *);
+};
+
+CORE_BEGIN_DECLS
+
+int
+battle_entity_state_update(struct battle_entity_state *, struct battle_entity *, unsigned int);
+
+void
+battle_entity_state_draw(const struct battle_entity_state *, const struct battle_entity *);
+
+void
+battle_entity_state_finish(struct battle_entity_state *, struct battle_entity *);
+
+CORE_END_DECLS
+
+#endif /* !MLK_RPG_BATTLE_ENTITY_STATE_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,119 @@
+/*
+ * battle-entity.c -- in game battle entity
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+
+#include <mlk/core/sprite.h>
+#include <mlk/core/texture.h>
+
+#include <mlk/ui/theme.h>
+
+#include "battle.h"
+#include "battle-entity.h"
+#include "battle-entity-state.h"
+#include "battle-entity-state-normal.h"
+#include "character.h"
+
+static void
+draw_name(const struct battle_entity *et, const struct battle *bt)
+{
+	struct label label = et->name;
+
+	label.theme = BATTLE_THEME(bt);
+
+	if (et == battle_current(bt))
+		label.flags |=  LABEL_FLAGS_SELECTED;
+	else
+		label.flags &= ~LABEL_FLAGS_SELECTED;
+
+	label_draw(&label);
+}
+
+void
+battle_entity_init(struct battle_entity *et)
+{
+	assert(et);
+
+	character_reset(et->ch);
+	texture_set_alpha_mod(et->ch->sprites[CHARACTER_SPRITE_NORMAL]->texture, 255);
+
+	battle_entity_state_normal(et);
+}
+
+int
+battle_entity_ok(const struct battle_entity *et)
+{
+	return et && character_ok(et->ch);
+}
+
+void
+battle_entity_switch(struct battle_entity *et, struct battle_entity_state *st)
+{
+	assert(et);
+	assert(st);
+
+	if (et->state)
+		battle_entity_state_finish(et->state, et);
+
+	et->state = st;
+}
+
+int
+battle_entity_update(struct battle_entity *et, unsigned int ticks)
+{
+	assert(et);
+
+	return battle_entity_state_update(et->state, et, ticks);
+}
+
+void
+battle_entity_draw_sprite(const struct battle_entity *et)
+{
+	struct sprite *sprite = et->ch->sprites[CHARACTER_SPRITE_NORMAL];
+	int row;
+
+	/*
+	 * Ennemies are usually defined with a single image as such the
+	 * sprite may contain only one cell/row. Otherwise if the user
+	 * have provided a structured sprite, use appropriate row.
+	 */
+	if (sprite->nrows >= 6)
+		row = 6;
+	else
+		row = 0;
+
+	sprite_draw(sprite, row, 0, et->x, et->y);
+}
+
+void
+battle_entity_draw(const struct battle_entity *et, const struct battle *bt)
+{
+	assert(et);
+	assert(bt);
+
+	draw_name(et, bt);
+	battle_entity_state_draw(et->state, et);
+}
+
+void
+battle_entity_finish(struct battle_entity *et)
+{
+	assert(et);
+
+	battle_entity_state_finish(et->state, et);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-entity.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,63 @@
+/*
+ * battle-entity.h -- in game battle entity
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_ENTITY_H
+#define MLK_RPG_BATTLE_ENTITY_H
+
+#include <mlk/core/core.h>
+
+#include <mlk/ui/label.h>
+
+struct battle;
+struct battle_entity_state;
+struct character;
+
+struct battle_entity {
+	struct character *ch;
+	int x;
+	int y;
+	struct label name;
+	struct battle_entity_state *state;
+};
+
+CORE_BEGIN_DECLS
+
+void
+battle_entity_init(struct battle_entity *);
+
+int
+battle_entity_ok(const struct battle_entity *);
+
+void
+battle_entity_switch(struct battle_entity *, struct battle_entity_state *);
+
+int
+battle_entity_update(struct battle_entity *, unsigned int);
+
+void
+battle_entity_draw(const struct battle_entity *, const struct battle *);
+
+void
+battle_entity_draw_sprite(const struct battle_entity *);
+
+void
+battle_entity_finish(struct battle_entity *);
+
+CORE_END_DECLS
+
+#endif /* !MLK_RPG_BATTLE_ENTITY_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-indicator.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,134 @@
+/*
+ * battle-indicator.c -- drawable for rendering a hp/mp count usage
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <mlk/core/color.h>
+#include <mlk/core/font.h>
+#include <mlk/core/panic.h>
+
+#include <mlk/ui/theme.h>
+
+#include "battle-indicator.h"
+
+#define THEME(bti)      ((bti)->theme ? (bti)->theme : theme_default())
+#define STEP            (2)
+#define DELAY           (5)
+
+static inline unsigned int
+inc(int cmp, int tgt)
+{
+	return tgt > cmp ? fmin(cmp + STEP, tgt) : fmax(cmp - STEP, tgt);
+}
+
+static inline int
+colored(const struct battle_indicator *bti)
+{
+	/* Only check r, g, b and ignore alpha. */
+	return COLOR_R(bti->cur) == COLOR_R(bti->color) &&
+	       COLOR_G(bti->cur) == COLOR_G(bti->color) &&
+	       COLOR_B(bti->cur) == COLOR_B(bti->color);
+}
+
+void
+battle_indicator_start(struct battle_indicator *bti)
+{
+	assert(bti);
+
+	char buf[128];
+	const struct theme *theme = THEME(bti);
+
+	snprintf(buf, sizeof (buf), "%u", bti->amount);
+
+	bti->cur = 0xffffffff;
+	bti->elapsed = 0;
+	bti->alpha = 250;
+
+	if (font_render(theme->fonts[THEME_FONT_INTERFACE], &bti->tex[0], buf, bti->cur) < 0||
+	    font_render(theme->fonts[THEME_FONT_INTERFACE], &bti->tex[1], buf, 0x000000ff) < 0)
+		panic();
+}
+
+int
+battle_indicator_completed(const struct battle_indicator *bti)
+{
+	assert(battle_indicator_ok(bti));
+
+	return colored(bti) && bti->alpha == 0;
+}
+
+int
+battle_indicator_ok(const struct battle_indicator *bti)
+{
+	return bti && texture_ok(&bti->tex[0]) && texture_ok(&bti->tex[1]);
+}
+
+int
+battle_indicator_update(struct battle_indicator *bti, unsigned int ticks)
+{
+	assert(battle_indicator_ok(bti));
+
+	bti->elapsed += ticks;
+
+	if (bti->elapsed > DELAY) {
+		bti->elapsed = 0;
+
+		if (!colored(bti)) {
+			/* Update colors first. */
+			bti->cur = COLOR_HEX(
+			    inc(COLOR_R(bti->cur), COLOR_R(bti->color)),
+			    inc(COLOR_G(bti->cur), COLOR_G(bti->color)),
+			    inc(COLOR_B(bti->cur), COLOR_B(bti->color)),
+			    255
+			);
+
+			texture_set_color_mod(&bti->tex[0], bti->cur);
+		} else {
+			/* Update alpha next. */
+			bti->alpha -= 10;
+
+			texture_set_alpha_mod(&bti->tex[0], bti->alpha);
+			texture_set_alpha_mod(&bti->tex[1], bti->alpha);
+		}
+	}
+
+	return battle_indicator_completed(bti);
+}
+
+void
+battle_indicator_draw(const struct battle_indicator *bti, int x, int y)
+{
+	assert(battle_indicator_ok(bti));
+
+	texture_draw(&bti->tex[1], x + 1, y + 1);
+	texture_draw(&bti->tex[0], x, y);
+}
+
+void
+battle_indicator_finish(struct battle_indicator *bti)
+{
+	assert(bti);
+
+	texture_finish(&bti->tex[0]);
+	texture_finish(&bti->tex[1]);
+
+	memset(bti, 0, sizeof (*bti));
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-indicator.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,62 @@
+/*
+ * battle-indicator.h -- drawable for rendering a hp/mp count usage
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_INDICATOR_H
+#define MLK_RPG_BATTLE_INDICATOR_H
+
+#include <mlk/core/core.h>
+#include <mlk/core/texture.h>
+
+#define BATTLE_INDICATOR_HP_COLOR (0xa5303000)
+#define BATTLE_INDICATOR_MP_COLOR (0xa23e8c00)
+
+struct theme;
+
+struct battle_indicator {
+	unsigned int color;
+	unsigned int amount;
+	const struct theme *theme;
+	unsigned int cur;
+	unsigned int elapsed;
+	unsigned int alpha;
+	struct texture tex[2];
+};
+
+CORE_BEGIN_DECLS
+
+void
+battle_indicator_start(struct battle_indicator *);
+
+int
+battle_indicator_completed(const struct battle_indicator *);
+
+int
+battle_indicator_ok(const struct battle_indicator *);
+
+int
+battle_indicator_update(struct battle_indicator *, unsigned int);
+
+void
+battle_indicator_draw(const struct battle_indicator *, int, int);
+
+void
+battle_indicator_finish(struct battle_indicator *);
+
+CORE_END_DECLS
+
+#endif /* !MLK_RPG_BATTLE_INDICATOR_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-message.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,69 @@
+/*
+ * battle-message.c -- automatic top center message in battle
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+
+#include <mlk/core/window.h>
+
+#include <mlk/ui/align.h>
+#include <mlk/ui/frame.h>
+#include <mlk/ui/label.h>
+
+#include "battle-message.h"
+
+#define DELAY 1500
+
+int
+battle_message_update(struct battle_message *msg, unsigned int ticks)
+{
+	assert(msg);
+
+	msg->elapsed += ticks;
+
+	return msg->elapsed >= DELAY;
+}
+
+void
+battle_message_draw(const struct battle_message *msg)
+{
+	assert(msg);
+
+	struct frame f = {0};
+	struct label l = {0};
+	unsigned int lw = 0, lh = 0;
+
+	/* Prepare message frame. */
+	f.w = window.w / 3;
+	f.h = window.h / 15;
+	f.theme = msg->theme;
+
+	/* Center on top. */
+	align(ALIGN_TOP, &f.x, &f.y, f.w, f.h, 0, 20, window.w, window.h);
+
+	/* Prepare message label box. */
+	l.text = msg->text;
+	l.flags = LABEL_FLAGS_SHADOW;
+	l.theme = msg->theme;
+	label_query(&l, &lw, &lh);
+
+	/* Align the text in the box. */
+	align(ALIGN_CENTER, &l.x, &l.y, lw, lh, f.x, f.y, f.w, f.h);
+
+	frame_draw(&f);
+	label_draw(&l);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-message.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,42 @@
+/*
+ * battle-message.h -- automatic top center message in battle
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_MESSAGE_H
+#define MLK_RPG_BATTLE_MESSAGE_H
+
+#include <mlk/core/core.h>
+
+struct theme;
+
+struct battle_message {
+	const char *text;
+	struct theme *theme;
+	unsigned int elapsed;
+};
+
+CORE_BEGIN_DECLS
+
+int
+battle_message_update(struct battle_message *, unsigned int);
+
+void
+battle_message_draw(const struct battle_message *);
+
+CORE_END_DECLS
+
+#endif /* !MLK_RPG_BATTLE_MESSAGE_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-state-ai.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,92 @@
+/*
+ * battle-state-ai.c -- battle state (enemy is playing)
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include <mlk/core/alloc.h>
+
+#include "battle-state-ai.h"
+#include "battle-state.h"
+#include "battle.h"
+#include "character.h"
+
+static int
+update(struct battle_state *st, struct battle *bt, unsigned int ticks)
+{
+	(void)st;
+	(void)ticks;
+
+	battle_state_ai_update(bt);
+
+	return 0;
+}
+
+static void
+draw(const struct battle_state *st, const struct battle *bt)
+{
+	(void)st;
+
+	battle_state_ai_draw(bt);
+}
+
+static void
+finish(struct battle_state *st, struct battle *bt)
+{
+	(void)bt;
+
+	free(st);
+}
+
+void
+battle_state_ai_update(struct battle *bt)
+{
+	assert(battle_ok(bt));
+
+	struct character *ch = battle_current(bt)->ch;
+
+	/*
+	 * Immediately invoke the enemy exec strategy and put the battle state
+	 * to check.
+	 */
+	character_exec(ch, bt);
+}
+
+void
+battle_state_ai_draw(const struct battle *bt)
+{
+	assert(battle_ok(bt));
+
+	battle_draw_component(bt, BATTLE_COMPONENT_ALL);
+}
+
+void
+battle_state_ai(struct battle *bt)
+{
+	assert(bt);
+
+	struct battle_state *self;
+
+	self = alloc_new0(sizeof (*self));
+	self->data = bt;
+	self->update = update;
+	self->draw = draw;
+	self->finish = finish;
+
+	battle_switch(bt, self);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-state-ai.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,33 @@
+/*
+ * battle-state-ai.h -- battle state (enemy is playing)
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_STATE_AI_H
+#define MLK_RPG_BATTLE_STATE_AI_H
+
+struct battle;
+
+void
+battle_state_ai_update(struct battle *);
+
+void
+battle_state_ai_draw(const struct battle *);
+
+void
+battle_state_ai(struct battle *);
+
+#endif /* !MLK_RPG_BATTLE_STATE_AI_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-state-attacking.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,176 @@
+/*
+ * battle-state-attacking.c -- battle state (entity is moving for attacking)
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include <mlk/core/alloc.h>
+#include <mlk/core/panic.h>
+#include <mlk/core/sprite.h>
+
+#include "battle-entity-state-attacking.h"
+#include "battle-entity-state-blinking.h"
+#include "battle-entity-state-moving.h"
+#include "battle-entity-state-normal.h"
+#include "battle-entity-state.h"
+#include "battle-state-attacking.h"
+#include "battle-state-check.h"
+#include "battle-state.h"
+#include "battle.h"
+#include "character.h"
+
+struct self {
+	struct battle_state_attacking data;
+	struct battle_state state;
+};
+
+static void
+damage(const struct battle_entity *source, struct battle_entity *target, struct battle *bt)
+{
+	(void)source;
+
+	/* TODO: math calculation here.*/
+	target->ch->hp -= 50;
+
+	if (target->ch->hp < 0)
+		target->ch->hp = 0;
+
+	battle_indicator_hp(bt, target->ch, 50);
+}
+
+static int
+update(struct battle_state *st, struct battle *bt, unsigned int ticks)
+{
+	battle_state_attacking_update(st->data, bt, ticks);
+
+	return 0;
+}
+
+static void
+draw(const struct battle_state *st, const struct battle *bt)
+{
+	battle_state_attacking_draw(st->data, bt);
+}
+
+static void
+finish(struct battle_state *st, struct battle *bt)
+{
+	(void)bt;
+
+	free(st->data);
+}
+
+void
+battle_state_attacking_init(struct battle_state_attacking *atk,
+                            struct battle_entity *source,
+                            struct battle_entity *target)
+{
+	assert(atk);
+	assert(battle_entity_ok(source));
+	assert(battle_entity_ok(target));
+
+	int x, y;
+
+	/* Starts this state with advancing. */
+	atk->source = source;
+	atk->target = target;
+	atk->origin_x = source->x;
+	atk->origin_y = source->y;
+
+	/* We go to the enemy. */
+	x = target->x + target->ch->sprites[CHARACTER_SPRITE_NORMAL]->cellw;
+	y = target->y;
+
+	/* If it is an enemy we don't move it but blink instead. */
+	if (source->ch->exec) {
+		atk->status = BATTLE_STATE_ATTACKING_BLINKING;
+		battle_entity_state_blinking(source);
+	} else
+		battle_entity_state_moving(source, x, y);
+}
+
+void
+battle_state_attacking_update(struct battle_state_attacking *atk, struct battle *bt, unsigned int ticks)
+{
+	assert(atk);
+	assert(bt);
+
+	battle_update_component(bt, ticks, BATTLE_COMPONENT_ALL);
+
+	if (!battle_entity_update(atk->source, 0))
+		return;
+
+	switch (atk->status) {
+	case BATTLE_STATE_ATTACKING_ADVANCING:
+		/*
+		 * Current entity state is battle-entity-state-moving but it is
+		 * already updated from the game itself so pass 0 just to check
+		 * if it has finished moving.
+		 */
+		atk->status = BATTLE_STATE_ATTACKING_DAMAGING;
+
+		/* TODO: determine sprite to use about equipment. */
+		battle_entity_state_attacking(atk->source, atk->source->ch->sprites[CHARACTER_SPRITE_SWORD]);
+		break;
+	case BATTLE_STATE_ATTACKING_DAMAGING:
+		/* Move back to original position. */
+		atk->status = BATTLE_STATE_ATTACKING_RETURNING;
+		damage(atk->source, atk->target, bt);
+		battle_entity_state_moving(atk->source, atk->origin_x, atk->origin_y);
+		break;
+	case BATTLE_STATE_ATTACKING_RETURNING:
+	case BATTLE_STATE_ATTACKING_BLINKING:
+		/* Just wait. */
+		battle_entity_state_normal(atk->source);
+		damage(atk->source, atk->target, bt);
+		battle_state_check(bt);
+		break;
+	default:
+		break;
+	}
+}
+
+void
+battle_state_attacking_draw(const struct battle_state_attacking *atk, const struct battle *bt)
+{
+	assert(atk);
+	assert(battle_ok(bt));
+
+	(void)atk;
+
+	battle_draw_component(bt, BATTLE_COMPONENT_ALL);
+}
+
+void
+battle_state_attacking(struct battle_entity *source, struct battle_entity *target, struct battle *bt)
+{
+	assert(battle_entity_ok(source));
+	assert(battle_entity_ok(target));
+	assert(bt);
+
+	struct self *self;
+
+	self = alloc_new0(sizeof (*self));
+	self->state.data = self;
+	self->state.update = update;
+	self->state.draw = draw;
+	self->state.finish = finish;
+
+	battle_state_attacking_init(&self->data, source, target);
+	battle_switch(bt, &self->state);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-state-attacking.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,57 @@
+/*
+ * battle-state-attacking.h -- battle state (entity is moving for attacking)
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_STATE_ATTACKING_H
+#define MLK_RPG_BATTLE_STATE_ATTACKING_H
+
+struct battle;
+struct battle_entity;
+
+enum battle_state_attacking_status {
+	/* For team. */
+	BATTLE_STATE_ATTACKING_ADVANCING,
+	BATTLE_STATE_ATTACKING_DAMAGING,
+	BATTLE_STATE_ATTACKING_RETURNING,
+
+	/* For enemies. */
+	BATTLE_STATE_ATTACKING_BLINKING,
+};
+
+struct battle_state_attacking {
+	enum battle_state_attacking_status status;
+	struct battle_entity *source;
+	struct battle_entity *target;
+	int origin_x;
+	int origin_y;
+};
+
+void
+battle_state_attacking_init(struct battle_state_attacking *,
+                            struct battle_entity *,
+                            struct battle_entity *);
+
+void
+battle_state_attacking_update(struct battle_state_attacking *, struct battle *, unsigned int);
+
+void
+battle_state_attacking_draw(const struct battle_state_attacking *, const struct battle *);
+
+void
+battle_state_attacking(struct battle_entity *, struct battle_entity *, struct battle *);
+
+#endif /* !#define MLK_RPG_BATTLE_STATE_ATTACKING_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-state-check.c	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,207 @@
+/*
+ * battle-state-check.c -- battle state (check status)
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <mlk/core/alloc.h>
+#include <mlk/core/panic.h>
+#include <mlk/core/sprite.h>
+#include <mlk/core/texture.h>
+#include <mlk/core/trace.h>
+
+#include "battle-state-check.h"
+#include "battle-state-lost.h"
+#include "battle-state-victory.h"
+#include "battle-state.h"
+#include "battle.h"
+#include "character.h"
+
+struct fadeout {
+	struct character *ch;
+	int x;
+	int y;
+	struct drawable dw;
+	unsigned int alpha;
+	unsigned int elapsed;
+};
+
+static int
+fadeout_update(struct drawable *dw, unsigned int ticks)
+{
+	struct fadeout *fade = dw->data;
+
+	fade->elapsed += ticks;
+
+	if (fade->elapsed >= 8) {
+		fade->elapsed = 0;
+
+		if (fade->alpha == 0)
+			return 1;
+
+		fade->alpha -= 10;
+	}
+
+	return 0;
+}
+
+static void
+fadeout_draw(struct drawable *dw)
+{
+	const struct fadeout *fade = dw->data;
+	struct sprite *sprite = fade->ch->sprites[CHARACTER_SPRITE_NORMAL];
+
+	texture_set_alpha_mod(sprite->texture, fade->alpha);
+	sprite_draw(sprite, 0, 0, fade->x, fade->y);
+	texture_set_alpha_mod(sprite->texture, 255);
+}
+
+static void
+fadeout_finish(struct drawable *dw)
+{
+	free(dw->data);
+}
+
+static void
+fadeout(struct battle *bt, struct battle_entity *et)
+{
+	struct fadeout *fade;
+
+	if (!bt->effects) {
+		tracef("can't create a fadeout effect without a drawable_stack");
+		return;
+	}
+
+	fade = alloc_new0(sizeof (*fade));
+	fade->ch = et->ch;
+	fade->x = et->x;
+	fade->y = et->y;
+	fade->alpha = 250;
+	fade->dw.data = fade;
+	fade->dw.draw = fadeout_draw;
+	fade->dw.update = fadeout_update;
+	fade->dw.finish = fadeout_finish;
+
+	if (drawable_stack_add(bt->effects, &fade->dw) < 0)
+		free(fade);
+}
+
+static int
+is_dead(const struct battle *bt)
+{
+	const struct battle_entity *et;
+
+	BATTLE_TEAM_FOREACH(bt, et) {
+		if (!character_ok(et->ch))
+			continue;
+		if (et->ch->hp > 0)
+			return 0;
+	}
+
+	return 1;
+}
+
+static int
+is_won(const struct battle *bt)
+{
+	const struct battle_entity *et;
+
+	BATTLE_ENEMY_FOREACH(bt, et)
+		if (character_ok(et->ch))
+			return 0;
+
+	return 1;
+}
+
+static void
+clean(struct battle *bt)
+{
+	for (size_t i = 0; i < bt->enemiesz; ++i) {
+		if (bt->enemies[i] && character_ok(bt->enemies[i]->ch) && bt->enemies[i]->ch->hp == 0) {
+			fadeout(bt, bt->enemies[i]);
+			bt->enemies[i] = NULL;
+		}
+	}
+}
+
+static int
+update(struct battle_state *st, struct battle *bt, unsigned int ticks)
+{
+	(void)st;
+	(void)ticks;
+
+	battle_state_check_update(bt);
+
+	return 0;
+}
+
+static void
+draw(const struct battle_state *st, const struct battle *bt)
+{
+	(void)st;
+
+	battle_state_check_draw(bt);
+}
+
+static void
+finish(struct battle_state *st, struct battle *bt)
+{
+	(void)bt;
+
+	free(st);
+}
+
+void
+battle_state_check_update(struct battle *bt)
+{
+	assert(battle_ok(bt));
+
+	clean(bt);
+
+	if (is_dead(bt))
+		battle_state_lost(bt);
+	else if (is_won(bt))
+		battle_state_victory(bt);
+	else
+		battle_next(bt);
+}
+
+void
+battle_state_check_draw(const struct battle *bt)
+{
+	assert(battle_ok(bt));
+
+	battle_draw_component(bt, BATTLE_COMPONENT_ALL);
+}
+
+void
+battle_state_check(struct battle *bt)
+{
+	assert(battle_ok(bt));
+
+	struct battle_state *self;
+
+	self = alloc_new0(sizeof (*self));
+	self->data = bt;
+	self->update = update;
+	self->draw = draw;
+	self->finish = finish;
+
+	battle_switch(bt, self);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libmlk-rpg/mlk/rpg/battle-state-check.h	Sat Oct 15 21:24:17 2022 +0200
@@ -0,0 +1,33 @@
+/*
+ * battle-state-check.h -- battle state (check status)
+ *
+ * Copyright (c) 2020-2022 David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MLK_RPG_BATTLE_STATE_CHECK_H
+#define MLK_RPG_BATTLE_STATE_CHECK_H
+
+struct battle;
+
+void
+battle_state_check_update(struct battle *);
+
+void
+battle_state_check_draw(const struct battle *);
+
+void
+battle_state_check(struct battle *);
+
+#endif /* !MLK_RPG_BATTLE_STATE_CHECK_H */