Invaders Face (#210)

* invaders face: Initial commit, fully functional so far

* invaders face: silence compiler warning

* invaders face: prevent involuntary restarts when the game is over and save some bytes on flags

---------

Co-authored-by: joeycastillo <joeycastillo@utexas.edu>

4 files changed, 518 insertions, 0 deletions

diff --git a/movement/make/Makefile b/movement/make/Makefile
index a18c7064..dec3ffab 100644
--- a/movement/make/Makefile
+++ b/movement/make/Makefile
@@ -104,6 +104,7 @@ SRCS += \
   ../watch_faces/complication/habit_face.c \
   ../watch_faces/clock/repetition_minute_face.c \
   ../watch_faces/complication/timer_face.c \
+  ../watch_faces/complication/invaders_face.c \
 # New watch faces go above this line.
 
 # Leave this line at the bottom of the file; it has all the targets for making your project.
diff --git a/movement/movement_faces.h b/movement/movement_faces.h
index 568c817c..50b084d3 100644
--- a/movement/movement_faces.h
+++ b/movement/movement_faces.h
@@ -80,6 +80,7 @@
 #include "habit_face.h"
 #include "repetition_minute_face.h"
 #include "timer_face.h"
+#include "invaders_face.h"
 // New includes go above this line.
 
 #endif // MOVEMENT_FACES_H_
diff --git a/movement/watch_faces/complication/invaders_face.c b/movement/watch_faces/complication/invaders_face.c
new file mode 100644
index 00000000..c3b13c68
--- /dev/null
+++ b/movement/watch_faces/complication/invaders_face.c
@@ -0,0 +1,434 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Andreas Nebinger
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+// Emulator only: need time() to seed the random number generator
+#if __EMSCRIPTEN__
+#include <time.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include "watch_private_display.h"
+#include "invaders_face.h"
+
+#define INVADERS_FACE_WAVES_PER_STAGE 9 // number of waves per stage (there are two stages)
+#define INVADERS_FACE_WAVE_INVADERS 16  // number of invaders attacking per wave
+
+static const uint8_t _defense_lines_segdata[3][2] = {{2, 12}, {2, 11}, {0, 11}};
+static const uint8_t _bonus_points_segdata[4][2] = {{2, 7}, {2, 8}, {2, 9}, {0, 10}};
+static const uint8_t _bonus_points_helper[] = {1, 5, 9, 11, 15, 19, 21, 25, 29};
+
+static const int8_t _sound_seq_game_start[] = {BUZZER_NOTE_A6, 1, BUZZER_NOTE_A7, 3, -2, 1, BUZZER_NOTE_REST, 10, BUZZER_NOTE_A6, 1, BUZZER_NOTE_A7, 3, -2, 1, 0};
+static const int8_t _sound_seq_shot_hit[] = {BUZZER_NOTE_A6, 1, BUZZER_NOTE_A7, 2, 0};
+static const int8_t _sound_seq_shot_miss[] = {BUZZER_NOTE_A7, 1, 0};
+static const int8_t _sound_seq_ufo_hit[] = {BUZZER_NOTE_A6, 1, BUZZER_NOTE_A7, 2, -2, 1, 0};
+static const int8_t _sound_seq_def_gone[] = {BUZZER_NOTE_A6, 1, BUZZER_NOTE_A7, 3, -2, 3, BUZZER_NOTE_REST, 40, BUZZER_NOTE_A6, 1, BUZZER_NOTE_A7, 3, -2, 4, 0};
+static const int8_t _sound_seq_next_wave[] = {BUZZER_NOTE_A6, 2, BUZZER_NOTE_A7, 2, BUZZER_NOTE_REST, 8, BUZZER_NOTE_A6, 2, BUZZER_NOTE_A7, 2, -2, 1,
+                                              BUZZER_NOTE_REST, 32, 
+                                              BUZZER_NOTE_A6, 2, BUZZER_NOTE_A7, 2, BUZZER_NOTE_REST, 8, BUZZER_NOTE_A6, 2, BUZZER_NOTE_A7, 2, -2, 1, 0};
+static const int8_t _sound_seq_game_over[] = {BUZZER_NOTE_A6, 1, BUZZER_NOTE_A7, 3, -2, 11, 0};
+
+typedef enum {
+    invaders_state_activated,
+    invaders_state_pre_game,
+    invaders_state_playing,
+    invaders_state_in_wave_break,
+    invaders_state_pre_next_wave,
+    invaders_state_next_wave,
+    invaders_state_game_over
+} invaders_current_state_t;
+
+typedef struct {
+    bool ufo_next : 1;                  // indicates whether next invader is a ufo
+    bool inv_checking : 1;              // flag to indicate whether we are currently moving invaders (to prevent race conditions)
+    bool suspend_buttons : 1;           // used while playing the game over sequence to prevent involuntary immediate restarts
+} invaders_signals_t;
+
+static int8_t _invaders[6];             // array of current invaders values (-1 = empty, 10 = ufo)
+static uint8_t _wave_invaders[INVADERS_FACE_WAVE_INVADERS]; // all invaders for the current wave. (Predefined to save cpu cycles when playing.)
+static invaders_current_state_t _current_state;
+static uint8_t _defense_lines;          // number of defense lines which have been broken in the current wave
+static uint8_t _aim;                    // current "aim" digit
+static uint8_t _invader_idx;            // index of next invader attacking in current wave (0 to 15)
+static uint8_t _wave_position;          // current position of first invader. When > 6 the defense is broken
+static uint8_t _wave_tick_freq;         // number of ticks passing until the next invader is inserted
+static uint8_t _ticks;                  // counts the ticks
+static uint8_t _bonus_countdown;        // ticks countdown until the bonus point indicator is cleared
+static uint8_t _waves;                  // counts the waves (_wave_tick_freq decreases slowly depending on _wave value)
+static uint8_t _shots_in_wave;          // number of shots in current wave. If 30 is reached, the game is over
+static uint8_t _invaders_shot;          // number of sucessfully shot invaders in current wave
+static uint8_t _invaders_shot_sum;      // current sum of invader digits shot (needed to determine if a ufo is coming)
+static invaders_signals_t _signals;     // holds severals flags
+static uint16_t _score;                 // score of the current game
+
+/// @brief return a random number. 0 <= return_value < num_values
+static inline uint8_t _get_rand_num(uint8_t num_values) {
+#if __EMSCRIPTEN__
+    return rand() % num_values;
+#else
+    return arc4random_uniform(num_values);
+#endif
+}
+
+/// @brief callback function to re-enable light and alarm buttons after playing a sound sequence
+static inline void _resume_buttons() {
+    _signals.suspend_buttons = false;
+}
+
+/// @brief play a sound sequence if the game is in beepy mode
+static inline void _play_sequence(invaders_state_t *state, int8_t *sequence) {
+    if (state->sound_on) watch_buzzer_play_sequence((int8_t *)sequence, NULL);
+}
+
+/// @brief draw the remaining defense lines
+static void _display_defense_lines() {
+    watch_display_character(' ', 1);
+    for (uint8_t i = 0; i < 3 - _defense_lines; i++) watch_set_pixel(_defense_lines_segdata[i][0], _defense_lines_segdata[i][1]);
+}
+
+/** @brief draw label followed by the given score value 
+ * @param label string displayed in the upper left corner
+ * @param score score to display
+ */
+static void _display_score(char *label, uint16_t score) {
+    watch_display_character(label[0], 0);
+    watch_display_character(label[1], 1);
+    char buf[10];
+    sprintf(buf, "  %06d", (score * 10));
+    watch_display_string(buf, 2);
+}
+
+/// @brief draw an invader at the given position
+static inline void _display_invader(int8_t invader, uint8_t position) {
+    switch (invader) {
+    case 10:
+        watch_display_character('n', position);
+        break;
+    case -1:
+        watch_display_character(' ', position);
+        break;
+    default:
+        watch_display_character(invader + 48, position);
+        break;
+    }
+}
+
+/// @brief game over: show score and set state
+static void _game_over(invaders_state_t *state) {
+    _display_score("GO", _score);
+    _current_state = invaders_state_game_over;
+    movement_request_tick_frequency(1);
+    _signals.suspend_buttons = true;
+    if (state->sound_on) watch_buzzer_play_sequence((int8_t *)_sound_seq_game_over, _resume_buttons);
+    // save current score to highscore, if applicable
+    if (_score > state->highscore) state->highscore = _score;
+}
+
+/// @brief initialize the current wave
+static void _init_wave() {
+    uint8_t i;
+    if (_current_state == invaders_state_in_wave_break) {
+        _invader_idx = _invaders_shot;
+    } else {
+        _invader_idx = _invaders_shot = _invaders_shot_sum = _defense_lines = _shots_in_wave = 0;
+    }
+    // pre-fill invaders
+    for (i = _invader_idx; i < INVADERS_FACE_WAVE_INVADERS; i++) _wave_invaders[i] = _get_rand_num(10);
+    // init invaders field
+    for (i = 1; i < 6; i++) _invaders[i] = -1;
+    _invaders[0] = _wave_invaders[_invader_idx];
+    _wave_position = _aim = _bonus_countdown = 0;
+    _signals.ufo_next = _signals.inv_checking = _signals.suspend_buttons = false;
+    _current_state = invaders_state_playing;
+    // determine wave speed
+    _wave_tick_freq = 6 - ((_waves % INVADERS_FACE_WAVES_PER_STAGE) + 1) / 2;
+    if (_waves >= INVADERS_FACE_WAVES_PER_STAGE) _wave_tick_freq--;
+    // clear display
+    watch_display_string("        ", 2);
+    watch_display_character('0', 0);
+    _display_defense_lines();
+    // draw first invader
+    watch_display_character(_wave_invaders[_invader_idx] + 48, 9);
+}
+
+/** @brief move invaders and add a new one, if necessary
+ * @returns true, if invaders have reached position 6, false otherwise
+ */
+static bool _move_invaders() {
+    if (_wave_position == 5) return true;
+    _signals.inv_checking = true;
+    if (_invaders[_wave_position] >= 0) _wave_position++;
+    int8_t i;
+    // move invaders
+    for (i = _wave_position; i > 0; i--) _invaders[i] = _invaders[i - 1];
+    if (_invader_idx < INVADERS_FACE_WAVE_INVADERS - 1) {
+        // add invader
+        _invader_idx++;
+        if (_signals.ufo_next) {
+            _invaders[0] = 10;
+            _signals.ufo_next = false;
+        } else {
+            _invaders[0] = _wave_invaders[_invader_idx];
+        }
+    } else {
+        // just add an empty invader slot
+        _invaders[0] = -1;
+    }
+    // update display
+    for (i = 0; i <= _wave_position; i++) {
+        _display_invader(_invaders[i], 9 - i);
+    }
+    _signals.inv_checking = false;
+    return false;
+}
+
+void invaders_face_setup(movement_settings_t *settings, uint8_t watch_face_index, void ** context_ptr) {
+    (void) settings;
+    (void) watch_face_index;
+    if (*context_ptr == NULL) {
+        *context_ptr = malloc(sizeof(invaders_state_t));
+        memset(*context_ptr, 0, sizeof(invaders_state_t));
+        invaders_state_t *state = (invaders_state_t *)*context_ptr;
+        // default: sound on
+        state->sound_on = true;
+    }
+#if __EMSCRIPTEN__
+    // simulator only: seed the randon number generator
+    time_t t;
+    srand((unsigned) time(&t));
+#endif
+}
+
+void invaders_face_activate(movement_settings_t *settings, void *context) {
+    (void) settings;
+    (void) context;
+    _current_state = invaders_state_activated;
+    _signals.suspend_buttons = false;
+}
+
+bool invaders_face_loop(movement_event_t event, movement_settings_t *settings, void *context) {
+    invaders_state_t *state = (invaders_state_t *)context;
+
+    switch (event.event_type) {
+        case EVENT_ACTIVATE:
+            // show highscore
+            _display_score("GA", state->highscore);
+            break;
+        case EVENT_TICK:
+            _ticks++;
+            switch (_current_state) {
+                case invaders_state_in_wave_break:
+                case invaders_state_pre_game:
+                case invaders_state_next_wave:
+                    // wait 2 secs to start the first round
+                    if (_ticks >= 2) {
+                        _ticks = 0;
+                        _init_wave();
+                        _current_state = invaders_state_playing;
+                        movement_request_tick_frequency(4);
+                    }
+                    break;
+                case invaders_state_playing:
+                    // game is playing
+                    if (_ticks >= _wave_tick_freq) {
+                        _ticks = 0;
+                        if (_move_invaders()) {
+                            // invaders broke through
+                            if (_defense_lines < 2) {
+                                // start current wave over
+                                _defense_lines++;
+                                _display_defense_lines();
+                                _display_score("GA", _score);
+                                _current_state = invaders_state_in_wave_break;
+                                movement_request_tick_frequency(1);
+                                _play_sequence(state, (int8_t *)_sound_seq_def_gone);
+                            } else {
+                                // game over
+                                _game_over(state);
+                            }
+                        }
+                    }
+                    // handle bonus points indicators
+                    if (_bonus_countdown) {
+                        _bonus_countdown--;
+                        if (!_bonus_countdown) {
+                            watch_display_character(' ', 2);
+                            watch_display_character(' ', 3);
+                        }
+                    }
+                    break;
+                case invaders_state_pre_next_wave:
+                    if (_ticks >= 3) {
+                        // switch to next wave
+                        _ticks = 0;
+                        movement_request_tick_frequency(1);
+                        _display_score("GA", _score);
+                        watch_set_pixel(1, 9);
+                        watch_display_character((_waves % INVADERS_FACE_WAVES_PER_STAGE) + 49, 3);
+                        _current_state = invaders_state_next_wave;
+                        _waves++;
+                        if (_waves == INVADERS_FACE_WAVES_PER_STAGE * 2) _waves = 0;
+                        _play_sequence(state, (int8_t *)_sound_seq_next_wave);
+                    }
+                default:
+                    break;
+            }
+            break;
+        case EVENT_LIGHT_BUTTON_DOWN:
+            if (!_signals.suspend_buttons) {
+                if (_current_state == invaders_state_playing) {
+                    // cycle the aim
+                    _aim = (_aim + 1) % 11;
+                    _display_invader(_aim, 0);
+                } else if (_current_state == invaders_state_activated || _current_state == invaders_state_game_over) {
+                    // just illuminate the LED
+                    movement_illuminate_led();
+                }
+            }
+            break;
+        case EVENT_LIGHT_LONG_PRESS:
+            if ((_current_state == invaders_state_activated || _current_state == invaders_state_game_over) && !_signals.suspend_buttons) {
+                // switch between beepy and silent mode
+                state->sound_on = !state->sound_on;
+                watch_buzzer_play_note(BUZZER_NOTE_A7, state->sound_on ? 65 : 25);
+            }
+            break;
+        case EVENT_ALARM_BUTTON_DOWN:
+            if (!_signals.suspend_buttons) {
+                switch (_current_state) {
+                    case invaders_state_game_over:
+                    case invaders_state_activated:
+                        // initialize the game
+                        _waves = 0;
+                        _score = 0;
+                        movement_request_tick_frequency(1);
+                        _ticks = 0;
+                        _current_state = invaders_state_pre_game;
+                        _play_sequence(state, (int8_t *)_sound_seq_game_start);
+                        break;
+                    case invaders_state_playing: {
+                        // "shoot"
+                        _shots_in_wave++;
+                        if (_shots_in_wave == 30) {
+                            // max number of shots reached: game over
+                            _game_over(state);
+                        } else {
+                            // wait if we are currently deleting an invader
+                            while (_signals.inv_checking);
+                            // proceed
+                            _signals.inv_checking = true;
+                            bool skip = false;
+                            for (int8_t i = _wave_position; i >= 0 && !skip; i--) {
+                                // if (_invaders[i] == -1) break;
+                                if (_invaders[i] == _aim) {
+                                    // invader is shot
+                                    skip = true;
+                                    _invaders_shot++;
+                                    _play_sequence(state, _aim == 10 ? (int8_t *)_sound_seq_ufo_hit : (int8_t *)_sound_seq_shot_hit);
+                                    if (_invaders_shot == INVADERS_FACE_WAVE_INVADERS) {
+                                        // last invader shot: wave sucessfully completed
+                                        watch_display_character(' ', 9 - _wave_position);
+                                        _ticks = 0;
+                                        _current_state = invaders_state_pre_next_wave;
+                                        _signals.inv_checking = false;
+                                    } else {
+                                        // check for ufo appearance
+                                        if (_aim && _aim < 10) {
+                                            _invaders_shot_sum = (_invaders_shot_sum + _aim) % 10;
+                                            if (_invaders_shot_sum == 0) _signals.ufo_next = true;
+                                        }
+                                        // remove invader
+                                        if (_wave_position == 0 || i == 5) {
+                                            _invaders[i] = -1;
+                                        } else {
+                                            for (uint8_t j = i; j < _wave_position; j++) {
+                                                _invaders[j] = _invaders[j + 1];
+                                                _display_invader(_invaders[j], 9 - j);
+                                            }
+                                        }
+                                        watch_display_character(' ', 9 - _wave_position);
+                                        if (_wave_position) _wave_position--;
+                                        // update score
+                                        if (_aim == 10) {
+                                            // ufo shot. The original game uses a ridiculously complicated scoring system here...
+                                            uint8_t bonus_points = 0;
+                                            uint8_t j;
+                                            for (j = 0; j < sizeof(_bonus_points_helper) && !bonus_points; j++) {
+                                                if (_shots_in_wave == _bonus_points_helper[j]) {
+                                                    bonus_points = 30;
+                                                } else if (_shots_in_wave - 1 == _bonus_points_helper[j]) {
+                                                    bonus_points = 20;
+                                                }
+                                            }
+                                            if (!bonus_points) bonus_points = 10;
+                                            bonus_points += (6 - i);
+                                            if ((_waves >= INVADERS_FACE_WAVES_PER_STAGE) && i) bonus_points += (6 - i);
+                                            _score += bonus_points;
+                                            // represent bonus points by bars
+                                            for (j = 0; j < (bonus_points / 10); j++) watch_set_pixel(_bonus_points_segdata[j][0], _bonus_points_segdata[j][1]);
+                                            _bonus_countdown = 9;
+                                        } else {
+                                            // regular invader
+                                            _score += (6 - _wave_position) * (_waves >= INVADERS_FACE_WAVES_PER_STAGE ? 2 : 1);
+                                        }
+                                    }
+                                }
+                            }
+                            if (!skip) _play_sequence(state, (int8_t *)_sound_seq_shot_miss);
+                            _signals.inv_checking = false;
+                        }
+                        break;
+                    }    
+                    default:
+                        break;
+                }
+            }
+            break;
+        case EVENT_TIMEOUT:
+            movement_move_to_face(0);
+            break;
+        default:
+            // Movement's default loop handler will step in for any cases you don't handle above:
+            // * EVENT_LIGHT_BUTTON_DOWN lights the LED
+            // * EVENT_MODE_BUTTON_UP moves to the next watch face in the list
+            // * EVENT_MODE_LONG_PRESS returns to the first watch face (or skips to the secondary watch face, if configured)
+            // You can override any of these behaviors by adding a case for these events to this switch statement.
+            return movement_default_loop_handler(event, settings);
+    }
+
+    // return true if the watch can enter standby mode. Generally speaking, you should always return true.
+    // Exceptions:
+    //  * If you are displaying a color using the low-level watch_set_led_color function, you should return false.
+    //  * If you are sounding the buzzer using the low-level watch_set_buzzer_on function, you should return false.
+    // Note that if you are driving the LED or buzzer using Movement functions like movement_illuminate_led or
+    // movement_play_alarm, you can still return true. This guidance only applies to the low-level watch_ functions.
+    return true;
+}
+
+void invaders_face_resign(movement_settings_t *settings, void *context) {
+    (void) settings;
+    (void) context;
+    _current_state = invaders_state_game_over;
+}
+
diff --git a/movement/watch_faces/complication/invaders_face.h b/movement/watch_faces/complication/invaders_face.h
new file mode 100644
index 00000000..59126dd5
--- /dev/null
+++ b/movement/watch_faces/complication/invaders_face.h
@@ -0,0 +1,82 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Andreas Nebinger
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef INVADERS_FACE_H_
+#define INVADERS_FACE_H_
+
+#include "movement.h"
+
+/*
+ * Remake of the "famous" Casio Number Invaders Game
+ *
+ * This is an authentic remake of the invaders game, found on the Casio
+ * calculator wristwatch CA-85 or CA-851. There were also some calculators
+ * sold with this game, like MG-880.
+ * 
+ * How to play:
+ * 
+ * Press the alarm button to start the game.
+ * "Invaders" (just digits, tbh) will start coming in from the right hand side.
+ * Press the light button to "aim". The digit on the top of the display cycles
+ * from 0 to 9. If your aiming digit is identical to one of the invaders,
+ * press the alarm button to "shoot". The corresponding invader will disappear.
+ * If the invaders reach beneath the very first position, you loose one defense 
+ * line. When all three defense lines are gone, the game is over.
+ * Also: If you shoot more than 29 times per round, you loose the game.
+ * Good to know: There are 16 invaders per wave. There is a short break between
+ * waves.
+ * 
+ * What are the "n" invaders? Ufos!
+ * 
+ * Whenever the sum of all invaders shot is divisible by 10 the next invader 
+ * will be an ufo, represented by the n-symbol. Shooting a ufo gets you extra
+ * points. Example: shoot 2, 5, 3 --> ufo next
+ * 
+ * As for points: the earlier you shoot an invader, the more points you get.
+ *
+ * Anything else? Long pressing the light button toggles sound on or off. (Not
+ * while playing.)
+ * 
+ */
+
+typedef struct {
+    uint16_t highscore;
+    bool sound_on;
+} invaders_state_t;
+
+void invaders_face_setup(movement_settings_t *settings, uint8_t watch_face_index, void ** context_ptr);
+void invaders_face_activate(movement_settings_t *settings, void *context);
+bool invaders_face_loop(movement_event_t event, movement_settings_t *settings, void *context);
+void invaders_face_resign(movement_settings_t *settings, void *context);
+
+#define invaders_face ((const watch_face_t){ \
+    invaders_face_setup, \
+    invaders_face_activate, \
+    invaders_face_loop, \
+    invaders_face_resign, \
+    NULL, \
+})
+
+#endif // INVADERS_FACE_H_
+