Initial commit

1 files changed, 1184 insertions, 0 deletions

diff --git a/src/ei.c b/src/ei.c
new file mode 100644
index 0000000..da2331e
--- /dev/null
+++ b/src/ei.c
@@ -0,0 +1,1184 @@
+/*
+ * Copyright (c) 2024 Richard Braun.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted.
+ *
+ * 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.
+ *
+ *
+ * Embedded invaders.
+ */
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "eetg.h"
+#include "ei.h"
+#include "macros.h"
+
+#define EI_NR_LIVES 3
+
+#define EI_ALIEN_STARTING_ROW 3
+
+#define EI_PLAYER_MISSILE_SPEED 25
+#define EI_ALIENS_SPEED 10
+#define EI_ALIEN_MISSILE_SPEED 10
+#define EI_FIRST_ALIEN_MISSILE_DELAY 2
+#define EI_UFO_SPEED 10
+
+#define EI_SCORE_MISSILE 40
+#define EI_SCORE_ALIENS0 30
+#define EI_SCORE_ALIENS12 20
+#define EI_SCORE_ALIENS34 10
+#define EI_SCORE_UFO_BASE 100
+
+#define EI_TITLE_SPRITE                                                     \
+" _____                                                   _____ \n"         \
+"( ___ )-------------------------------------------------( ___ )\n"         \
+" |   |                                                   |   | \n"         \
+" |   |        ____      __          __   __       __     |   | \n"         \
+" |   |       / __/_ _  / /  ___ ___/ /__/ /__ ___/ /     |   | \n"         \
+" |   |      / _//  ' \\/ _ \\/ -_) _  / _  / -_) _  /      |   | \n"       \
+" |   |     /___/_/_/_/_.__/\\__/\\_,_/\\_,_/\\__/\\_,_/       |   | \n"    \
+" |   |           _                  __                   |   | \n"         \
+" |   |          (_)__ _  _____ ____/ /__ _______         |   | \n"         \
+" |   |         / / _ \\ |/ / _ `/ _  / -_) __(_-<         |   | \n"        \
+" |   |        /_/_//_/___/\\_,_/\\_,_/\\__/_/ /___/         |   | \n"      \
+" |   |                                                   |   | \n"         \
+" |___|                                                   |___| \n"         \
+"(_____)-------------------------------------------------(_____)\n"
+
+#define EI_HELP_SPRITE      \
+"       s = left     \n"    \
+"       f = right    \n"    \
+"   space = shoot    \n"
+
+#define EI_START_SPRITE     \
+"Press SPACE to start\n"    \
+"Press X to leave    \n"
+
+#define EI_PLAYER_SPRITE "/-^-\\\n"
+
+#define EI_BUNKER_SPRITE    \
+"  ###  \n"                 \
+" ##### \n"                 \
+"#######\n"                 \
+"##   ##\n"
+
+#define EI_ALIENS0_SPRITE_1     ",^,\n"
+#define EI_ALIENS0_SPRITE_2     ".-.\n"
+#define EI_ALIENS12_SPRITE_1    "-O_\n"
+#define EI_ALIENS12_SPRITE_2    "_O-\n"
+#define EI_ALIENS34_SPRITE_1    "/^\\\n"
+#define EI_ALIENS34_SPRITE_2    "-^-\n"
+
+#define EI_STATUS_SPRITE_FORMAT "SCORE: %08d   Lives: %d\n"
+
+#define EI_END_TITLE_SPRITE                                 \
+"  ________   __  _______         ____ _   _________ \n"    \
+" / ___/ _ | /  |/  / __/        / __ \\ | / / __/ _ \\\n"  \
+"/ (_ / __ |/ /|_/ / _/         / /_/ / |/ / _// , _/\n"    \
+"\\___/_/ |_/_/  /_/___/         \\____/|___/___/_/|_| \n"
+
+#define EI_TYPE_TITLE           0
+#define EI_TYPE_HELP            1
+#define EI_TYPE_START           2
+#define EI_TYPE_PLAYER          3
+#define EI_TYPE_PLAYER_MISSILE  4
+#define EI_TYPE_BUNKER          5
+#define EI_TYPE_ALIEN           6
+#define EI_TYPE_ALIEN_MISSILE   7
+#define EI_TYPE_UFO             8
+#define EI_TYPE_STATUS          9
+#define EI_TYPE_END_TITLE       10
+
+static const char *
+ei_get_group_sprite1(size_t group)
+{
+    const char *sprite;
+
+    if (group == 0) {
+        sprite = EI_ALIENS0_SPRITE_1;
+    } else if ((group == 1) || (group == 2)) {
+        sprite = EI_ALIENS12_SPRITE_1;
+    } else {
+        sprite = EI_ALIENS34_SPRITE_1;
+    }
+
+    return sprite;
+}
+
+static const char *
+ei_get_group_sprite2(size_t group)
+{
+    const char *sprite;
+
+    if (group == 0) {
+        sprite = EI_ALIENS0_SPRITE_2;
+    } else if ((group == 1) || (group == 2)) {
+        sprite = EI_ALIENS12_SPRITE_2;
+    } else {
+        sprite = EI_ALIENS34_SPRITE_2;
+    }
+
+    return sprite;
+}
+
+static int
+ei_get_group_color(size_t group)
+{
+    int color;
+
+    if (group == 0) {
+        color = EETG_COLOR_RED;
+    } else if ((group == 1) || (group == 2)) {
+        color = EETG_COLOR_GREEN;
+    } else {
+        color = EETG_COLOR_BLUE;
+    }
+
+    return color;
+}
+
+static struct eetg_object *
+ei_get_object(struct eetg_object *object1,
+              struct eetg_object *object2,
+              int type)
+{
+    struct eetg_object *object = NULL;
+
+    assert(object1);
+    assert(object2);
+
+    if (eetg_object_get_type(object1) == type) {
+        object = object1;
+    } else if (eetg_object_get_type(object2) == type) {
+        object = object2;
+    }
+
+    return object;
+}
+
+static bool
+ei_has_type(const struct eetg_object *object1,
+            const struct eetg_object *object2,
+            int type)
+{
+    return (eetg_object_get_type(object1) == type)
+           || (eetg_object_get_type(object2) == type);
+}
+
+static void
+ei_bunker_reset_sprite(struct ei_bunker *bunker)
+{
+    assert(bunker);
+
+    snprintf(bunker->sprite, sizeof(bunker->sprite), "%s", EI_BUNKER_SPRITE);
+}
+
+static void
+ei_bunker_init(struct ei_bunker *bunker)
+{
+    assert(bunker);
+
+    ei_bunker_reset_sprite(bunker);
+
+    eetg_object_init(&bunker->object, EI_TYPE_BUNKER, bunker->sprite);
+    eetg_object_set_color(&bunker->object, EETG_COLOR_CYAN);
+}
+
+static struct ei_bunker *
+ei_bunker_get(struct eetg_object *object)
+{
+    assert(eetg_object_get_type(object) == EI_TYPE_BUNKER);
+
+    return structof(object, struct ei_bunker, object);
+}
+
+static struct eetg_object *
+ei_bunker_get_object(struct ei_bunker *bunker)
+{
+    assert(bunker);
+
+    return &bunker->object;
+}
+
+static bool
+ei_bunker_damage(struct ei_bunker *bunker, int x, int y)
+{
+    char *sprite;
+    int index;
+
+    assert(bunker);
+
+    index = eetg_object_get_cell(&bunker->object, x, y);
+
+    sprite = (char *)eetg_object_get_sprite(&bunker->object);
+
+    sprite[index] = ' ';
+
+    return eetg_object_is_empty(&bunker->object);
+}
+
+static void
+ei_alien_init(struct ei_alien *alien, const char *sprite, int color)
+{
+    assert(alien);
+
+    eetg_object_init(&alien->object, EI_TYPE_ALIEN, sprite);
+    eetg_object_set_color(&alien->object, color);
+}
+
+static struct ei_alien *
+ei_alien_get(struct eetg_object *object)
+{
+    assert(eetg_object_get_type(object) == EI_TYPE_ALIEN);
+
+    return structof(object, struct ei_alien, object);
+}
+
+static struct eetg_object *
+ei_alien_get_object(struct ei_alien *alien)
+{
+    assert(alien);
+
+    return &alien->object;
+}
+
+static bool
+ei_alien_is_dead(const struct ei_alien *alien)
+{
+    assert(alien);
+
+    return (eetg_object_get_world(&alien->object) == NULL);
+}
+
+static int
+ei_alien_get_x(const struct ei_alien *alien)
+{
+    assert(alien);
+
+    return eetg_object_get_x(&alien->object);
+}
+
+static int
+ei_alien_get_width(const struct ei_alien *alien)
+{
+    assert(alien);
+
+    return eetg_object_get_width(&alien->object);
+}
+
+static bool
+ei_alien_move_down(struct ei_alien *alien)
+{
+    struct eetg_object *object;
+    bool game_over = false;
+    int y;
+
+    assert(alien);
+
+    object = &alien->object;
+
+    y = eetg_object_get_y(object) + 1;
+
+    eetg_object_move(object, eetg_object_get_x(object), y);
+
+    if (y >= (EETG_ROWS - 1)) {
+        game_over = true;
+    }
+
+    return game_over;
+}
+
+static void
+ei_alien_move_left(struct ei_alien *alien)
+{
+    struct eetg_object *object;
+
+    assert(alien);
+
+    object = &alien->object;
+
+    eetg_object_move(object, eetg_object_get_x(object) - 1,
+                     eetg_object_get_y(object));
+}
+
+static void
+ei_alien_move_right(struct ei_alien *alien)
+{
+    struct eetg_object *object;
+
+    assert(alien);
+
+    object = &alien->object;
+
+    eetg_object_move(object, eetg_object_get_x(object) + 1,
+                     eetg_object_get_y(object));
+}
+
+static void
+ei_alien_group_init(struct ei_alien_group *group, const char *sprite1,
+                    const char *sprite2, int color)
+{
+    assert(group);
+    assert(sprite1);
+    assert(strlen(sprite1) == (EI_ALIEN_WIDTH + 1));
+    assert(sprite2);
+    assert(strlen(sprite2) == (EI_ALIEN_WIDTH + 1));
+
+    group->sprites[0] = sprite1;
+    group->sprites[1] = sprite2;
+    group->sprite_index = 0;
+
+    memcpy(group->sprite, group->sprites[group->sprite_index],
+           sizeof(group->sprite));
+
+    for (size_t i = 0; i < ARRAY_SIZE(group->aliens); i++) {
+        ei_alien_init(&group->aliens[i], group->sprite, color);
+    }
+}
+
+static void
+ei_alien_group_attach(struct ei_alien_group *group,
+                      struct eetg_world *world, int y)
+{
+    int x = 0;
+
+    assert(group);
+
+    for (size_t i = 0; i < ARRAY_SIZE(group->aliens); i++) {
+        struct ei_alien *alien = &group->aliens[i];
+
+        eetg_world_add(world, ei_alien_get_object(alien), x, y);
+
+        x += EI_ALIEN_WIDTH;
+    }
+}
+
+static bool
+ei_alien_group_has_alien(const struct ei_alien_group *group,
+                         const struct ei_alien *alien)
+{
+    bool alien_present = false;
+    const struct ei_alien *end;
+
+    assert(group);
+
+    end = &group->aliens[ARRAY_SIZE(group->aliens)];
+
+    if ((alien >= group->aliens) && (alien < end)) {
+        alien_present = true;
+    }
+
+    return alien_present;
+}
+
+static struct ei_alien *
+ei_alien_group_get(struct ei_alien_group *group, size_t index)
+{
+    assert(group);
+    assert(index < ARRAY_SIZE(group->aliens));
+
+    return &group->aliens[index];
+}
+
+static void
+ei_alien_group_twerk(struct ei_alien_group *group)
+{
+    assert(group);
+
+    group->sprite_index = (group->sprite_index + 1) & 1;
+    memcpy(group->sprite, group->sprites[group->sprite_index],
+           sizeof(group->sprite));
+}
+
+static bool
+ei_alien_group_move_down(struct ei_alien_group *group)
+{
+    bool game_over = false;
+
+    ei_alien_group_twerk(group);
+
+    for (size_t i = 0; i < ARRAY_SIZE(group->aliens); i++) {
+        struct ei_alien *alien = &group->aliens[i];
+
+        if (!ei_alien_is_dead(alien)) {
+            bool tmp;
+
+            tmp = ei_alien_move_down(alien);
+
+            if (tmp) {
+                game_over = true;
+            }
+        }
+    }
+
+    return game_over;
+}
+
+static bool
+ei_alien_group_move_left(struct ei_alien_group *group)
+{
+    bool border_reached = false;
+
+    ei_alien_group_twerk(group);
+
+    for (size_t i = 0; i < ARRAY_SIZE(group->aliens); i++) {
+        struct ei_alien *alien = &group->aliens[i];
+
+        if (!ei_alien_is_dead(alien)) {
+            ei_alien_move_left(alien);
+
+            if (!border_reached && (ei_alien_get_x(alien) == 0)) {
+                border_reached = true;
+            }
+        }
+    }
+
+    return border_reached;
+}
+
+static bool
+ei_alien_group_move_right(struct ei_alien_group *group)
+{
+    bool border_reached = false;
+
+    ei_alien_group_twerk(group);
+
+    for (size_t i = ARRAY_SIZE(group->aliens) - 1;
+         i < ARRAY_SIZE(group->aliens); i--) {
+        struct ei_alien *alien = &group->aliens[i];
+
+        if (!ei_alien_is_dead(alien)) {
+            ei_alien_move_right(alien);
+
+            if (!border_reached) {
+                int x;
+
+                x = ei_alien_get_x(alien) + ei_alien_get_width(alien) - 1;
+
+                if (x == (EETG_COLUMNS - 1)) {
+                    border_reached = true;
+                }
+            }
+        }
+    }
+
+    return border_reached;
+}
+
+static struct ei_alien_group *
+ei_game_find_alien_group(struct ei_game *game, struct ei_alien *alien)
+{
+    struct ei_alien_group *group = NULL;
+
+    assert(alien);
+
+    for (size_t i = 0; i < ARRAY_SIZE(game->aliens); i++) {
+        struct ei_alien_group *tmp = &game->aliens[i];
+
+        if (ei_alien_group_has_alien(tmp, alien)) {
+            group = tmp;
+            break;
+        }
+    }
+
+    return group;
+}
+
+static void
+ei_game_add_bunkers(struct ei_game *game)
+{
+    int x = 6;
+
+    assert(game);
+
+    for (size_t i = 0; i < ARRAY_SIZE(game->bunkers); i++) {
+        struct ei_bunker *bunker = &game->bunkers[i];
+
+        ei_bunker_reset_sprite(bunker);
+        eetg_world_add(&game->world, ei_bunker_get_object(bunker), x, 17);
+
+        x += 20;
+    }
+}
+
+static void
+ei_game_add_aliens(struct ei_game *game)
+{
+    assert(game);
+
+    for (size_t i = 0; i < ARRAY_SIZE(game->aliens); i++) {
+        struct ei_alien_group *group = &game->aliens[i];
+
+        ei_alien_group_attach(group, &game->world,
+                              EI_ALIEN_STARTING_ROW + (i * 2));
+    }
+}
+
+static void
+ei_game_update_status(struct ei_game *game)
+{
+    assert(game);
+
+    snprintf(game->status_sprite, sizeof(game->status_sprite),
+             EI_STATUS_SPRITE_FORMAT, game->score, game->nr_lives);
+}
+
+static void
+ei_game_prepare(struct ei_game *game)
+{
+    assert(game);
+
+    eetg_world_clear(&game->world);
+
+    game->state = EI_STATE_PREPARED;
+}
+
+static void
+ei_game_start(struct ei_game *game)
+{
+    assert(game);
+
+    eetg_world_clear(&game->world);
+
+    eetg_world_add(&game->world, &game->player, 37, 23);
+
+    ei_game_add_bunkers(game);
+    ei_game_add_aliens(game);
+
+    eetg_world_add(&game->world, &game->status, 26, 0);
+
+    game->player_missile_counter_reload = EI_FPS / EI_PLAYER_MISSILE_SPEED;
+    game->player_missile_counter = game->player_missile_counter_reload;
+    game->aliens_speed_counter_reload = EI_FPS / EI_ALIENS_SPEED;
+    game->aliens_speed_counter = game->aliens_speed_counter_reload;
+    game->first_alien_missile_counter = EI_FPS * EI_FIRST_ALIEN_MISSILE_DELAY;
+    game->alien_missile_counter_reload = EI_FPS / EI_ALIEN_MISSILE_SPEED;
+    game->ufo_counter_reload = EI_FPS / EI_UFO_SPEED;
+    game->nr_dead_aliens = 0;
+
+    game->aliens_move_left = false;
+    game->aliens_move_down = false;
+
+    game->state = EI_STATE_PLAYING;
+}
+
+static void
+ei_game_kill_alien(struct ei_game *game, struct ei_alien *alien)
+{
+    int group, score;
+
+    assert(alien);
+
+    group = ei_game_find_alien_group(game, alien) - game->aliens;
+
+    if (group == 0) {
+        score = EI_SCORE_ALIENS0;
+    } else if ((group == 1) || (group == 2)) {
+        score = EI_SCORE_ALIENS12;
+    } else {
+        score = EI_SCORE_ALIENS34;
+    }
+
+    game->score += score;
+
+    ei_game_update_status(game);
+
+    eetg_world_remove(&game->world, ei_alien_get_object(alien));
+
+    game->nr_dead_aliens++;
+
+    if (game->nr_dead_aliens == (EI_NR_ALIEN_GROUPS * EI_ALIEN_GROUP_SIZE)) {
+        ei_game_prepare(game);
+    } else {
+        int aliens_speed;
+
+        aliens_speed = game->nr_dead_aliens / 2;
+
+        if (aliens_speed < (EI_FPS / 5)) {
+            aliens_speed = EI_FPS / 5;
+        } else if (aliens_speed > ((EI_FPS * 4) / 5)) {
+            aliens_speed = ((EI_FPS * 4) / 5);
+        }
+
+        game->aliens_speed_counter_reload = EI_FPS / aliens_speed;
+    }
+}
+
+static void
+ei_game_damage_bunker(struct ei_game *game, struct ei_bunker *bunker,
+                      int x, int y)
+{
+    bool destroyed;
+
+    destroyed = ei_bunker_damage(bunker, x, y);
+
+    if (destroyed) {
+        eetg_world_remove(&game->world, ei_bunker_get_object(bunker));
+    }
+}
+
+static void
+ei_game_terminate(struct ei_game *game)
+{
+    assert(game);
+
+    eetg_world_clear(&game->world);
+
+    eetg_world_add(&game->world, &game->end_title, 12, 10);
+    eetg_world_add(&game->world, &game->status, 26, 6);
+    eetg_world_add(&game->world, &game->start, 30, 20);
+
+    game->state = EI_STATE_GAME_OVER;
+}
+
+static void
+ei_game_kill_player(struct ei_game *game, bool game_over)
+{
+    assert(game);
+    assert(game->nr_lives > 0);
+
+    game->nr_lives--;
+
+    ei_game_update_status(game);
+
+    if (game_over || (game->nr_lives == 0))
+    {
+        ei_game_terminate(game);
+    }
+}
+
+static void
+ei_game_handle_player_missile_collision(struct ei_game *game,
+                                        struct eetg_object *missile,
+                                        struct eetg_object *object,
+                                        int x, int y)
+{
+    assert(game);
+
+    eetg_world_remove(&game->world, missile);
+
+    if (eetg_object_get_type(object) == EI_TYPE_BUNKER) {
+        ei_game_damage_bunker(game, ei_bunker_get(object), x, y);
+    } else if (eetg_object_get_type(object) == EI_TYPE_ALIEN_MISSILE) {
+        game->score += EI_SCORE_MISSILE;
+        eetg_world_remove(&game->world, object);
+    } else if (eetg_object_get_type(object) == EI_TYPE_ALIEN) {
+        ei_game_kill_alien(game, ei_alien_get(object));
+    } else if (eetg_object_get_type(object) == EI_TYPE_UFO) {
+        game->score += EI_SCORE_UFO_BASE * ((eetg_rand() % 5) + 1);
+        eetg_world_remove(&game->world, object);
+    }
+}
+
+static void
+ei_game_handle_alien_collision(struct ei_game *game,
+                               struct eetg_object *object,
+                               int x, int y)
+{
+    if (eetg_object_get_type(object) == EI_TYPE_BUNKER) {
+        ei_game_damage_bunker(game, ei_bunker_get(object), x, y);
+    } else if (eetg_object_get_type(object) == EI_TYPE_PLAYER) {
+        ei_game_kill_player(game, true);
+    }
+}
+
+static void
+ei_game_handle_alien_missile_collision(struct ei_game *game,
+                                       struct eetg_object *missile,
+                                       struct eetg_object *object,
+                                       int x, int y)
+{
+    assert(game);
+
+    if (eetg_object_get_type(object) == EI_TYPE_ALIEN) {
+        return;
+    }
+
+    eetg_world_remove(&game->world, missile);
+
+    if (eetg_object_get_type(object) == EI_TYPE_BUNKER) {
+        ei_game_damage_bunker(game, ei_bunker_get(object), x, y);
+    } else if (eetg_object_get_type(object) == EI_TYPE_PLAYER) {
+        ei_game_kill_player(game, false);
+    }
+}
+
+static void
+ei_game_handle_collision(struct eetg_object *object1,
+                         struct eetg_object *object2,
+                         int x, int y, void *arg)
+{
+    if (ei_has_type(object1, object2, EI_TYPE_PLAYER_MISSILE)) {
+        struct eetg_object *missile, *other;
+
+        missile = ei_get_object(object1, object2, EI_TYPE_PLAYER_MISSILE);
+        other = (object1 == missile) ? object2 : object1;
+
+        ei_game_handle_player_missile_collision(arg, missile, other, x, y);
+    } else if (ei_has_type(object1, object2, EI_TYPE_ALIEN)) {
+        struct eetg_object *alien, *other;
+
+        alien = ei_get_object(object1, object2, EI_TYPE_ALIEN);
+        other = (object1 == alien) ? object2 : object1;
+
+        ei_game_handle_alien_collision(arg, other, x, y);
+    } else if (ei_has_type(object1, object2, EI_TYPE_ALIEN_MISSILE)) {
+        struct eetg_object *missile, *other;
+
+        missile = ei_get_object(object1, object2, EI_TYPE_ALIEN_MISSILE);
+        other = (object1 == missile) ? object2 : object1;
+
+        ei_game_handle_alien_missile_collision(arg, missile, other, x, y);
+    }
+}
+
+static void
+ei_game_reset_history(struct ei_game *game)
+{
+    assert(game);
+
+    game->score = 0;
+    game->nr_lives = EI_NR_LIVES;
+
+    ei_game_update_status(game);
+}
+
+static bool
+ei_game_process_intro_input(struct ei_game *game, char c)
+{
+    assert(game);
+
+    if (c == 'x') {
+        return true;
+    }
+
+    if (c != ' ') {
+        return false;
+    }
+
+    ei_game_reset_history(game);
+    ei_game_prepare(game);
+
+    return false;
+}
+
+static bool
+ei_game_process_game_input(struct ei_game *game, char c)
+{
+    assert(game);
+
+    if (c == 'x') {
+        return true;
+    }
+
+    if (c == 's') {
+        struct eetg_object *player_object = &game->player;
+        int x;
+
+        x = eetg_object_get_x(player_object);
+
+        if (x > 0) {
+            eetg_object_move(player_object, x - 1,
+                             eetg_object_get_y(player_object));
+        }
+    } else if (c == 'f') {
+        struct eetg_object *player_object = &game->player;
+        int x, width;
+
+        x = eetg_object_get_x(player_object);
+        width = eetg_object_get_width(player_object);
+
+        if ((x + width) < EETG_COLUMNS) {
+            eetg_object_move(player_object, x + 1,
+                             eetg_object_get_y(player_object));
+        }
+    } else if (c == ' ') {
+        struct eetg_object *player_missile = &game->player_missile;
+
+        if (eetg_object_get_world(player_missile) == NULL) {
+            struct eetg_object *player_object = &game->player;
+            int x, y;
+
+            x = eetg_object_get_x(player_object);
+            y = eetg_object_get_y(player_object);
+
+            eetg_world_add(&game->world, player_missile, x + 2, y - 1);
+
+            game->player_missile_counter = game->player_missile_counter_reload;
+        }
+    }
+
+    return false;
+}
+
+static void
+ei_game_process_player_missile(struct ei_game *game)
+{
+    int x, y;
+
+    assert(game);
+
+    if (eetg_object_get_world(&game->player_missile) == NULL) {
+        return;
+    }
+
+    assert(game->player_missile_counter > 0);
+    game->player_missile_counter--;
+
+    if (game->player_missile_counter != 0) {
+        return;
+    }
+
+    game->player_missile_counter = game->player_missile_counter_reload;
+
+    x = eetg_object_get_x(&game->player_missile);
+    y = eetg_object_get_y(&game->player_missile) - 1;
+
+    if (y == 0) {
+        eetg_world_remove(&game->world, &game->player_missile);
+    } else {
+        eetg_object_move(&game->player_missile, x, y);
+    }
+}
+
+static struct ei_alien *
+ei_game_select_firing_alien(struct ei_game *game)
+{
+    struct ei_alien *alien = NULL;
+    int nr_firing_aliens = 0;
+
+    assert(game);
+
+    for (size_t i = 0; i < EI_ALIEN_GROUP_SIZE; i++) {
+        for (size_t j = 0; j < ARRAY_SIZE(game->aliens); j++) {
+            struct ei_alien *tmp = ei_alien_group_get(&game->aliens[j], i);
+
+            if (!ei_alien_is_dead(tmp)) {
+                nr_firing_aliens++;
+                break;
+            }
+        }
+    }
+
+    if (nr_firing_aliens > 0) {
+        int index;
+
+        index = eetg_rand() % nr_firing_aliens;
+
+        for (size_t i = ARRAY_SIZE(game->aliens) - 1;
+             i < ARRAY_SIZE(game->aliens); i--) {
+            struct ei_alien *tmp = ei_alien_group_get(&game->aliens[i], index);
+
+            if (!ei_alien_is_dead(tmp)) {
+                alien = tmp;
+                break;
+            }
+        }
+    }
+
+    return alien;
+}
+
+static void
+ei_game_process_alien_missile(struct ei_game *game)
+{
+    assert(game);
+
+    if (game->first_alien_missile_counter != 0) {
+        assert(game->first_alien_missile_counter > 0);
+        game->first_alien_missile_counter--;
+        return;
+    }
+
+    if (eetg_object_get_world(&game->alien_missile) != NULL) {
+        assert(game->alien_missile_counter > 0);
+        game->alien_missile_counter--;
+
+        if (game->alien_missile_counter == 0) {
+            int x, y;
+
+            game->alien_missile_counter = game->alien_missile_counter_reload;
+
+            x = eetg_object_get_x(&game->alien_missile);
+            y = eetg_object_get_y(&game->alien_missile);
+
+            if (y == EETG_ROWS) {
+                eetg_world_remove(&game->world, &game->alien_missile);
+            } else {
+                eetg_object_move(&game->alien_missile, x, y + 1);
+            }
+        }
+    } else {
+        struct ei_alien *alien;
+        int x, y;
+
+        alien = ei_game_select_firing_alien(game);
+
+        if (alien) {
+            x = eetg_object_get_x(&alien->object);
+            y = eetg_object_get_y(&alien->object);
+
+            eetg_world_add(&game->world, &game->alien_missile, x, y + 1);
+
+            game->alien_missile_counter = game->alien_missile_counter_reload;
+        }
+    }
+}
+
+static void
+ei_game_process_aliens(struct ei_game *game)
+{
+    assert(game);
+    assert(game->aliens_speed_counter > 0);
+
+    game->aliens_speed_counter--;
+
+    if (game->aliens_speed_counter != 0) {
+        return;
+    }
+
+    game->aliens_speed_counter = game->aliens_speed_counter_reload;
+
+    if (game->aliens_move_down) {
+        for (size_t i = ARRAY_SIZE(game->aliens) - 1;
+             i < ARRAY_SIZE(game->aliens); i--) {
+            bool game_over;
+
+            game_over = ei_alien_group_move_down(&game->aliens[i]);
+
+            if (game_over) {
+                ei_game_terminate(game);
+            }
+        }
+
+        game->aliens_move_down = false;
+
+        if (eetg_object_get_world(&game->ufo) == NULL) {
+            int n;
+
+            n = eetg_rand() % 3;
+
+            if (n == 0) {
+                int x;
+
+                n = eetg_rand() % 2;
+
+                if (n == 0) {
+                    x = EETG_COLUMNS;
+                    game->ufo_moves_left = true;
+                } else {
+                    x = -eetg_object_get_width(&game->ufo);
+                    game->ufo_moves_left = false;
+                }
+
+                eetg_world_add(&game->world, &game->ufo, x, 2);
+
+                game->ufo_counter = game->ufo_counter_reload;
+            }
+        }
+    } else {
+        bool border_reached = false;
+
+        for (size_t i = 0; i < ARRAY_SIZE(game->aliens); i++) {
+            struct ei_alien_group *group = &game->aliens[i];
+            bool border_reached_by_group;
+
+            if (game->aliens_move_left) {
+                border_reached_by_group = ei_alien_group_move_left(group);
+            } else {
+                border_reached_by_group = ei_alien_group_move_right(group);
+            }
+
+            if (border_reached_by_group) {
+                border_reached = true;
+            }
+        }
+
+        if (border_reached) {
+            game->aliens_move_down = true;
+            game->aliens_move_left = !game->aliens_move_left;
+        }
+    }
+}
+
+static void
+ei_game_process_ufo(struct ei_game *game)
+{
+    struct eetg_object *ufo;
+
+    assert(game);
+
+    ufo = &game->ufo;
+
+    if (eetg_object_get_world(ufo) == NULL) {
+        return;
+    }
+
+    assert(game->ufo_counter > 0);
+
+    game->ufo_counter--;
+
+    if (game->ufo_counter != 0) {
+        return;
+    }
+
+    game->ufo_counter = game->ufo_counter_reload;
+
+    if (game->ufo_moves_left) {
+        int x;
+
+        x = eetg_object_get_x(ufo) - 1;
+
+        if ((x + eetg_object_get_width(ufo)) <= 0) {
+            eetg_world_remove(&game->world, ufo);
+        } else {
+            eetg_object_move(ufo, x, eetg_object_get_y(ufo));
+        }
+    } else {
+        int x;
+
+        x = eetg_object_get_x(ufo) + 1;
+
+        if (x >= EETG_COLUMNS) {
+            eetg_world_remove(&game->world, ufo);
+        } else {
+            eetg_object_move(ufo, x, eetg_object_get_y(ufo));
+        }
+    }
+}
+
+static void
+ei_game_init_bunkers(struct ei_game *game)
+{
+    assert(game);
+
+    for (size_t i = 0; i < ARRAY_SIZE(game->bunkers); i++) {
+        ei_bunker_init(&game->bunkers[i]);
+    }
+}
+
+static void
+ei_game_init_aliens(struct ei_game *game)
+{
+    assert(game);
+
+    for (size_t i = 0; i < ARRAY_SIZE(game->aliens); i++) {
+        struct ei_alien_group *group = &game->aliens[i];
+        const char *sprite1, *sprite2;
+        int color;
+
+        sprite1 = ei_get_group_sprite1(i);
+        sprite2 = ei_get_group_sprite2(i);
+        color = ei_get_group_color(i);
+
+        ei_alien_group_init(group, sprite1, sprite2, color);
+    }
+}
+
+void
+ei_game_init(struct ei_game *game, eetg_write_fn write_fn, void *arg)
+{
+    assert(game);
+
+    game->sync_counter_reload = EI_FPS * 2;
+    game->sync_counter = 1;
+
+    game->state = EI_STATE_INTRO;
+
+    ei_game_reset_history(game);
+
+    eetg_world_init(&game->world, write_fn, arg);
+    eetg_world_register_collision_fn(&game->world,
+                                     ei_game_handle_collision,
+                                     game);
+
+    eetg_object_init(&game->title, EI_TYPE_TITLE, EI_TITLE_SPRITE);
+    eetg_object_set_color(&game->title, EETG_COLOR_BLUE);
+
+    eetg_object_init(&game->help, EI_TYPE_HELP, EI_HELP_SPRITE);
+    eetg_object_set_color(&game->help, EETG_COLOR_RED);
+
+    eetg_object_init(&game->start, EI_TYPE_START, EI_START_SPRITE);
+    eetg_object_set_color(&game->start, EETG_COLOR_RED);
+
+    eetg_object_init(&game->player, EI_TYPE_PLAYER, EI_PLAYER_SPRITE);
+    eetg_object_set_color(&game->player, EETG_COLOR_YELLOW);
+
+    eetg_object_init(&game->player_missile, EI_TYPE_PLAYER_MISSILE, "!\n");
+    eetg_object_set_color(&game->player_missile, EETG_COLOR_WHITE);
+
+    ei_game_init_bunkers(game);
+    ei_game_init_aliens(game);
+
+    eetg_object_init(&game->alien_missile, EI_TYPE_ALIEN_MISSILE, ":\n");
+    eetg_object_set_color(&game->alien_missile, EETG_COLOR_MAGENTA);
+
+    eetg_object_init(&game->ufo, EI_TYPE_UFO, "<o~o>\n");
+    eetg_object_set_color(&game->ufo, EETG_COLOR_MAGENTA);
+
+    eetg_object_init(&game->status, EI_TYPE_STATUS, game->status_sprite);
+    eetg_object_set_color(&game->status, EETG_COLOR_RED);
+
+    eetg_object_init(&game->end_title, EI_TYPE_END_TITLE, EI_END_TITLE_SPRITE);
+    eetg_object_set_color(&game->end_title, EETG_COLOR_WHITE);
+
+    eetg_world_add(&game->world, &game->title, 8, 1);
+    eetg_world_add(&game->world, &game->help, 30, 16);
+    eetg_world_add(&game->world, &game->start, 30, 20);
+}
+
+bool
+ei_game_process(struct ei_game *game, int8_t c)
+{
+    bool sync = false;
+    bool leave = false;
+
+    game->sync_counter--;
+
+    if (game->sync_counter == 0) {
+        sync = true;
+        game->sync_counter = game->sync_counter_reload;
+    }
+
+    eetg_world_render(&game->world, sync);
+
+    switch (game->state) {
+    case EI_STATE_INTRO:
+    case EI_STATE_GAME_OVER:
+        if (c >= 0) {
+            leave = ei_game_process_intro_input(game, (char)c);
+        }
+
+        break;
+    case EI_STATE_PREPARED:
+        ei_game_start(game);
+        break;
+    case EI_STATE_PLAYING:
+        ei_game_process_player_missile(game);
+        ei_game_process_aliens(game);
+        ei_game_process_ufo(game);
+        ei_game_process_alien_missile(game);
+
+        if (c >= 0) {
+            leave = ei_game_process_game_input(game, (char)c);
+        }
+
+        break;
+    }
+
+    return leave;
+}