Merge pull request #1 from Ikcelaks/Queued_Magic

Queued magic

.gitignore

@@ -9,3 +9,8 @@
 *.hex
 *.bin
 *.uf2
+
+# clangd
+compile_commands.json
+.clangd/
+.cache/

keyboards/moonlander/keymaps/ikcelaks/__init__.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include QMK_KEYBOARD_H
+
+#include "general/custom_keys.h"
+#include "magic_sturdy/__init__.h"

keyboards/moonlander/keymaps/ikcelaks/config.h

@@ -0,0 +1,25 @@
+/* Copyright 2020 ZSA Technology Labs, Inc <@zsa>
+ * Copyright 2020 Jack Humbert <jack.humb@gmail.com>
+ * Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#define ORYX_CONFIGURATOR
+
+// User Added
+#define COMBO_COUNT 10
+#define TAPPING_TOGGLE 2

keyboards/moonlander/keymaps/ikcelaks/general/custom_keys.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "../__init__.h"
+
+enum custom_keycodes {
+    US_MAG1 = SAFE_RANGE,
+    US_MAG2,
+    US_MAG3,
+    US_MAG4,
+    US_D_UND,
+    US_QUOT_S,
+};

keyboards/moonlander/keymaps/ikcelaks/keymap.c

@@ -0,0 +1,135 @@
+/* Copyright 2020 ZSA Technology Labs, Inc <@zsa>
+ * Copyright 2020 Jack Humbert <jack.humb@gmail.com>
+ * Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+
+#include "__init__.h"
+
+#define KC_MAC_UNDO LGUI(KC_Z)
+#define KC_MAC_CUT LGUI(KC_X)
+#define KC_MAC_COPY LGUI(KC_C)
+#define KC_MAC_PASTE LGUI(KC_V)
+#define KC_PC_UNDO LCTL(KC_Z)
+#define KC_PC_CUT LCTL(KC_X)
+#define KC_PC_COPY LCTL(KC_C)
+#define KC_PC_PASTE LCTL(KC_V)
+#define ES_LESS_MAC KC_GRV
+#define ES_GRTR_MAC LSFT(KC_GRV)
+#define ES_BSLS_MAC ALGR(KC_6)
+#define NO_PIPE_ALT KC_GRV
+#define NO_BSLS_ALT KC_EQUAL
+#define LSA_T(kc) MT(MOD_LSFT | MOD_LALT, kc)
+#define BP_NDSH_MAC ALGR(KC_8)
+#define SE_SECT_MAC ALGR(KC_6)
+#define MOON_LED_LEVEL LED_LEVEL
+
+#define C_GUI_ESC LGUI_T(KC_ESC)
+#define C_RSFT_ENT RSFT_T(KC_ENT)
+#define C_LALT_ENT LALT_T(KC_ENT)
+#define C_RCTL_MINS RCTL_T(KC_MINS)
+#define C_LCTL_BSPC LCTL(KC_BSPC)
+
+enum layers {
+    BASE,  // default layer
+    SYMB,  // symbols
+    MDIA,  // media keys
+    NAVI,  // navigation
+};
+
+// clang-format off
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[BASE] = LAYOUT_moonlander(
+        KC_DOT,         KC_1,           KC_2,           KC_3,           KC_4,           KC_5,           KC_EQL,                                         KC_ASTR,        KC_6,           KC_7,           KC_8,           KC_9,           KC_0,           KC_BSPC,
+        KC_TAB,         KC_V,           KC_M,           KC_L,           KC_C,           KC_P,           KC_DQUO,                                        KC_PIPE,        KC_B,           US_MAG1,        KC_U,           KC_O,           KC_COMM,        KC_BSLS,
+        LCTL(KC_BSPC),  KC_S,           KC_T,           KC_R,           KC_D,           KC_Y,           KC_Q,                                           KC_DLR,         KC_F,           KC_N,           KC_E,           KC_A,           KC_I,           C_RCTL_MINS,
+        KC_LSFT,        KC_X,           KC_K,           KC_J,           KC_G,           KC_W,                                                                                   KC_Z,           KC_H,           KC_QUOT,        KC_QUES,        KC_DOT,         C_RSFT_ENT,
+        KC_GRV,         KC_LCTL,        KC_LGUI,        KC_ESC,         TT(NAVI),                       C_LALT_ENT,                                     C_GUI_ESC,                     C_S_T(KC_SLSH),  KC_LALT,        KC_LBRC,        TT(MDIA),       TT(SYMB),
+                                                                        KC_SPC,         KC_BSPC,        KC_DEL,                                         OSL(SYMB),      OSM(MOD_LSFT),      US_MAG2
+    ),
+	[SYMB] = LAYOUT_moonlander(
+        _______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, _______, _______, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11,
+        _______, KC_HASH, KC_AMPR, KC_LCBR, KC_RCBR, KC_PIPE, _______, _______, KC_INS, KC_7, KC_8, KC_9, KC_PMNS, KC_F12,
+        _______, KC_AT, KC_EXLM, KC_LPRN, KC_RPRN, KC_TILD, _______, US_D_UND, KC_PPLS, KC_4, KC_5, KC_6, KC_PAST, _______,
+        _______, KC_PERC, KC_CIRC, KC_LBRC, KC_RBRC, KC_GRV, KC_PSLS, KC_1, KC_2, KC_3, KC_PEQL, _______,
+        _______, _______, _______, _______, _______, _______, _______, KC_0, KC_PCMM, KC_PDOT, KC_PENT, _______,
+        _______, _______, _______, _______, _______, _______
+    ),
+	[MDIA] = LAYOUT_moonlander(
+        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, QK_BOOT,
+        _______, _______, _______, KC_MS_U, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+        _______, _______, KC_MS_L, KC_MS_D, KC_MS_R, _______, _______, _______, _______, _______, _______, _______, _______, KC_MPLY,
+        _______, _______, _______, _______, _______, _______, _______, _______, KC_MPRV, KC_MNXT, _______, _______,
+        XXXXXXX, _______, _______, KC_BTN1, KC_BTN2, _______, _______, KC_VOLU, KC_VOLD, KC_MUTE, _______, XXXXXXX,
+        _______, _______, _______, _______, _______, _______
+    ),
+	[NAVI] = LAYOUT_moonlander(
+        XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
+        XXXXXXX, KC_WH_L, KC_WH_R, LCTL(KC_F), LCTL(KC_R), KC_WH_U, XXXXXXX, XXXXXXX, KC_PGUP, KC_HOME, KC_UP, KC_END, KC_CAPS, XXXXXXX,
+        XXXXXXX, KC_LALT, KC_LGUI, KC_LSFT, KC_LCTL, KC_WH_D, XXXXXXX, XXXXXXX, KC_PGDN, KC_LEFT, KC_DOWN, KC_RGHT, LCTL(KC_DEL), XXXXXXX,
+        XXXXXXX, LCTL(KC_Z), LCTL(KC_X), LCTL(KC_C), LCTL(KC_V), LCTL(KC_A), KC_INS, KC_BSPC, XXXXXXX, KC_DEL, XXXXXXX, XXXXXXX,
+        XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______, _______, _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
+        _______, _______, _______, KC_ENT, KC_TAB, KC_SPC
+    )
+};
+
+const uint16_t PROGMEM combo_RT_12[] = { US_MAG2, OSM(MOD_LSFT), COMBO_END};
+const uint16_t PROGMEM combo_LB_IM[] = { KC_J, KC_G, COMBO_END};
+const uint16_t PROGMEM combo_LB_MR[] = { KC_K, KC_J, COMBO_END};
+const uint16_t PROGMEM combo_LB_RP[] = { KC_X, KC_K, COMBO_END};
+const uint16_t PROGMEM combo_LB_IR[] = { KC_K, KC_G, COMBO_END};
+const uint16_t PROGMEM combo_RB_IM[] = { KC_H, KC_QUOT, COMBO_END};
+const uint16_t PROGMEM combo_RB_MR[] = { KC_QUOT, KC_QUES, COMBO_END};
+const uint16_t PROGMEM combo_RB_RP[] = { KC_QUES, KC_DOT, COMBO_END};
+const uint16_t PROGMEM combo_RB_IR[] = { KC_H, KC_QUES, COMBO_END};
+
+combo_t key_combos[COMBO_COUNT] = {
+    COMBO(combo_RT_12, OSL(SYMB)),
+    COMBO(combo_LB_IM, KC_COLN),
+    COMBO(combo_LB_MR, US_MAG3),
+    COMBO(combo_LB_RP, US_MAG4),
+    COMBO(combo_LB_IR, US_QUOT_S),
+    COMBO(combo_RB_IM, KC_SCLN),
+    COMBO(combo_RB_MR, US_MAG3),
+    COMBO(combo_RB_RP, US_MAG4),
+    COMBO(combo_RB_IR, US_QUOT_S),
+};
+
+extern rgb_config_t rgb_matrix_config;
+
+void keyboard_post_init_user(void) {
+  rgb_matrix_enable();
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+    bool return_value;
+
+    if (sturdy_pr(keycode, record, &return_value))
+        return return_value;
+
+    if (record->event.pressed) {
+        switch (keycode) {
+            case US_D_UND:
+                SEND_STRING(SS_LSFT(SS_TAP(X_4)) SS_DELAY(100) SS_LSFT(SS_TAP(X_MINUS)));
+                return false;
+            case US_QUOT_S:
+                SEND_STRING("'s");
+                return false;
+        }
+    }
+    return true;
+}

keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/__init__.h

@@ -0,0 +1,55 @@
+// Originally from QKekos
+#pragma once
+#include "../__init__.h"
+
+#include "general.h"
+#include "magic_keys.h"
+
+#define single_queue_check(p_key) queue(-1) == p_key
+#define double_queue_check(pp_key, p_key) queue(-2) == pp_key && single_queue_check(p_key)
+#define triple_queue_check(ppp_key, pp_key, p_key) queue(-3) == ppp_key && double_queue_check(pp_key, p_key)
+#define quadruple_queue_check(pppp_key, ppp_key, pp_key, p_key) queue(-4) == pppp_key && triple_queue_check(ppp_key, pp_key, p_key)
+
+#define magic_case_core(trigger, condition, supplement) \
+    case trigger: \
+        if (condition) { \
+            record_send_string(supplement); \
+            return; \
+        } \
+        break
+
+#define magic_switch_core(trigger, body, index) \
+    case trigger: \
+        switch (queue(index)) { \
+            body \
+        } \
+        break
+
+#define magic_case(trigger, supplement) \
+    case trigger: \
+        record_send_string(supplement); \
+        return
+
+#define double_magic_switch(trigger, body) \
+    magic_switch_core(trigger, body, -1)
+
+#define triple_magic_switch(trigger, body) \
+    magic_switch_core(trigger, body, -2)
+
+#define quadruple_magic_switch(trigger, body) \
+    magic_switch_core(trigger, body, -3)
+
+#define quintuple_magic_switch(trigger, body) \
+    magic_switch_core(trigger, body, -4)
+
+#define double_magic_case(trigger, p_key, supplement) \
+    magic_case_core(trigger, single_queue_check(p_key), supplement)
+
+#define triple_magic_case(trigger, pp_key, p_key, supplement) \
+    magic_case_core(trigger, double_queue_check(pp_key, p_key), supplement)
+
+#define quadruple_magic_case(trigger, ppp_key, pp_key, p_key, supplement) \
+    magic_case_core(trigger, triple_queue_check(ppp_key, pp_key, p_key), supplement)
+
+#define quintuple_magic_case(trigger, pppp_key, ppp_key, pp_key, p_key, supplement) \
+    magic_case_core(trigger, quadruple_queue_check(pppp_key, ppp_key, pp_key, p_key), supplement)

keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.c

@@ -0,0 +1,177 @@
+
+#include "../__init__.h"
+
+int mag1_key_count = 0;
+int mag2_key_count = 0;
+int mag3_key_count = 0;
+int mag4_key_count = 0;
+int last_key_pressed_time = 0;
+int prev_key_time;
+
+int prev_keys_queue[PREV_KEYS_QUEUE_SIZE] = {KC_NO};
+deferred_token magic_timeout_token = INVALID_DEFERRED_TOKEN;
+
+uint32_t enqueue_space(uint32_t trigger_time, void *cb_arg) {
+    enqueue(KC_SPC);
+    return 0;
+}
+
+void refresh_token(void) {
+    if (magic_timeout_token != INVALID_DEFERRED_TOKEN)
+        cancel_deferred_exec(magic_timeout_token);
+
+    magic_timeout_token = defer_exec(MAGIC_KEY_TIMEOUT, enqueue_space, NULL);
+}
+
+void record_send_string(const char *str) {
+    for (int i = 0; str[i] != '\0'; i++) {
+        if (65 <= str[i] && str[i] <= 90) enqueue(str[i] - 61);
+        else if (97 <= str[i] && str[i] <= 122) enqueue(str[i] - 93);
+    }
+
+    SEND_STRING(str);
+}
+
+void enqueue(int keycode) {
+    for (int i = 0; i < PREV_KEYS_QUEUE_SIZE - 1; i += 1)
+        prev_keys_queue[i] = prev_keys_queue[i + 1];
+
+    prev_keys_queue[PREV_KEYS_QUEUE_SIZE - 1] = keycode;
+}
+
+void dequeue(void) {
+    set_last_keycode(prev_keys_queue[PREV_KEYS_QUEUE_SIZE - 1]);
+
+     for (int i = PREV_KEYS_QUEUE_SIZE - 1; i > 0; i -= 1)
+        prev_keys_queue[i] = prev_keys_queue[i - 1];
+
+    prev_keys_queue[0] = KC_NO;
+}
+
+void print_queue(void) {
+    uprintf("queue: ");
+
+    for (int i = 0; i < PREV_KEYS_QUEUE_SIZE - 1; i += 1)
+        uprintf("%d, ", prev_keys_queue[i]);
+
+    uprintf("\n");
+}
+
+uint16_t normalize_keycode(uint16_t keycode) {
+    if (IS_QK_MOD_TAP(keycode))   return QK_MOD_TAP_GET_TAP_KEYCODE(keycode);
+    if (IS_QK_LAYER_TAP(keycode)) return QK_LAYER_TAP_GET_TAP_KEYCODE(keycode);
+
+    return keycode;
+}
+
+bool remember_last_key_user(uint16_t keycode, keyrecord_t* record, uint8_t* mods) {
+    keycode = normalize_keycode(keycode);
+
+    switch (keycode) {
+        case KC_BSPC:
+        case KC_LEFT:
+            dequeue();
+            return false;
+    }
+
+    if (
+        (*mods & MOD_MASK_CTRL) &&
+        ((keycode == KC_BSPC && record->tap.count) || (keycode == KC_BSPC))
+    ) keycode = KC_SPC;
+
+    switch (keycode) {
+        case KC_ENT:
+        case KC_TAB:
+        case KC_BSPC:
+        case KC_DQUO:
+        case KC_LPRN:
+        case KC_SPC:
+            keycode = KC_SPC;
+            break;
+
+        case KC_A ... KC_Z:
+            if ((*mods & ~(MOD_MASK_SHIFT)) == 0) {
+                *mods &= ~MOD_MASK_SHIFT;
+            }
+            break;
+
+        case US_MAG1:
+        case US_MAG2:
+        case US_MAG3:
+        case US_MAG4:
+            return false;
+    }
+
+    enqueue(keycode);
+    print_queue();
+    return true;
+}
+
+bool sturdy_pr(uint16_t keycode, keyrecord_t *record, bool *return_value) {
+    *return_value = false;
+    prev_key_time = last_key_pressed_time;
+
+    if (record->event.pressed) {
+        last_key_pressed_time = timer_read();
+        refresh_token();
+
+        if (keycode != US_MAG1) mag1_key_count = 0;
+        else mag1_key_count += 1;
+
+        if (keycode != US_MAG2) mag2_key_count = 0;
+        else mag2_key_count += 1;
+
+        if (keycode != US_MAG4) mag3_key_count = 0;
+        else mag3_key_count += 1;
+
+        if (keycode != US_MAG4) mag4_key_count = 0;
+        else mag4_key_count += 1;
+    }
+
+    switch (keycode) {
+        case US_MAG1:
+            if (record->event.pressed)
+                process_magic_key_1();
+
+            return true;
+
+        case US_MAG2:
+            if (record->event.pressed)
+                process_magic_key_2();
+
+            return true;
+
+        case US_MAG3:
+            if (record->event.pressed)
+                process_magic_key_3();
+
+            return true;
+
+        case US_MAG4:
+            if (record->event.pressed)
+                process_magic_key_4();
+
+            return true;
+
+        // case KC_B:
+        // case KC_Z:
+        // case KC_F:
+        //     return process_double_tap(keycode, record);
+    }
+
+    return false;
+}
+
+// bool process_double_tap(uint16_t keycode, keyrecord_t *record) {
+//     if (
+//         !record->event.pressed ||
+//         highest_layer != STURDY ||
+//         queue(-2) != keycode ||
+//         timer_elapsed(prev_key_time) > (get_tapping_term(keycode, NULL) + 50)
+//     ) return false;
+
+//     dequeue();
+//     process_magic_key();
+
+//     return true;
+// }

keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/general.h

@@ -0,0 +1,32 @@
+// Originally from QKekos
+
+#pragma once
+#include "../__init__.h"
+
+#define PREV_KEYS_QUEUE_SIZE 10
+#define MAGIC_KEY_TIMEOUT 1500
+
+bool sturdy_pr(uint16_t keycode, keyrecord_t *record, bool *return_value);
+bool remember_last_key_user(uint16_t keycode, keyrecord_t* record, uint8_t* mods);
+bool process_double_tap(uint16_t keycode, keyrecord_t *record);
+void record_send_string(const char *str);
+void enqueue(int keycode);
+void dequeue(void);
+void print_queue(void);
+
+uint32_t enqueue_space(uint32_t trigger_time, void *cb_arg);
+void refresh_token(void);
+
+extern int prev_keys_queue[];
+extern int mag1_key_count;
+extern int mag2_key_count;
+extern int mag3_key_count;
+extern int mag4_key_count;
+extern int last_key_pressed_time;
+
+#define queue(i) prev_keys_queue[PREV_KEYS_QUEUE_SIZE + i]
+
+#define record_case(symbol, keycode) \
+    case symbol: \
+        enqueue(keycode); \
+        continue

keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.c

@@ -0,0 +1,251 @@
+
+#include "../__init__.h"
+
+void process_magic_key_1(void) {
+    if (mag1_key_count >= 2) {
+        switch (queue(-4)) {
+            quadruple_magic_case(KC_SPC, KC_A, KC_L, KC_R, "eady");
+            quadruple_magic_case(KC_J,   KC_U, KC_D, KC_G, "ment");
+        }
+
+        switch (queue(-3)) {
+            default: record_send_string("n"); return;
+        }
+    }
+
+    switch (queue(-5)) {
+        quintuple_magic_switch(KC_B,
+            quadruple_magic_case(KC_A, KC_L, KC_L, KC_I, "st");
+            quadruple_magic_case(KC_L, KC_I, KC_V, KC_I, "on");
+        );
+    }
+
+    switch (queue(-4)) {
+        quadruple_magic_case(KC_A, KC_B, KC_E, KC_T, "ment");
+        quadruple_magic_case(KC_V, KC_I, KC_L, KC_I, "on");
+    }
+
+    switch (queue(-3)) {
+        triple_magic_switch(KC_SPC,
+            double_magic_switch(KC_A,
+                magic_case(KC_L, "r");
+                magic_case(KC_N, "other");
+            );
+
+            double_magic_switch(KC_E,
+                magic_case(KC_D, "ge");
+                magic_case(KC_X, "ample");
+            );
+
+            double_magic_case(KC_U, KC_S, "e");
+            double_magic_case(KC_T, KC_I, "me");
+            double_magic_case(KC_I, KC_N, "form");
+        );
+
+        triple_magic_switch(KC_B,
+            double_magic_switch(KC_E,
+                magic_case(KC_T, "ween");
+                magic_case(KC_L, "ieve");
+            );
+
+            double_magic_case(KC_U, KC_D, "ge");
+        );
+
+        triple_magic_switch(KC_V,
+            double_magic_switch(KC_A,
+                magic_case(KC_R, "ious");
+            );
+
+            double_magic_case(KC_I, KC_D, "eo");
+        );
+
+        triple_magic_switch(KC_R,
+            double_magic_case(KC_I, KC_D, "ge");
+            double_magic_case(KC_E, KC_D, "ge");
+        );
+
+        triple_magic_switch(KC_S,
+            double_magic_case(KC_Y, KC_S, "tem");
+        );
+
+        triple_magic_switch(KC_G,
+            double_magic_case(KC_E, KC_N, "ious");
+        );
+
+        triple_magic_switch(KC_D,
+            double_magic_case(KC_I, KC_F, "feren");
+            double_magic_case(KC_E, KC_F, "inite");
+        );
+
+        triple_magic_switch(KC_L,
+            double_magic_case(KC_E, KC_D, "ge");
+            double_magic_case(KC_L, KC_I, "on");
+        );
+
+        triple_magic_case(KC_J, KC_U, KC_D, "g");
+        triple_magic_case(KC_O, KC_B, KC_V, "ious");
+        triple_magic_case(KC_H, KC_I, KC_L, "arious");
+    }
+
+    switch (queue(-2)) {
+        double_magic_switch(KC_SPC,
+            magic_case(KC_T, "han");
+            magic_case(KC_L, "ittle");
+        );
+
+        double_magic_switch(KC_P,
+            magic_case(KC_L, "y");
+            magic_case(KC_A, "ge");
+            magic_case(KC_E, "ople");
+            magic_case(KC_R, "evious");
+        );
+
+        double_magic_case(KC_D, KC_A, "y");
+        double_magic_case(KC_W, KC_A, "y");
+        double_magic_case(KC_B, KC_E, "en");
+        double_magic_case(KC_L, KC_I, "st");
+        double_magic_case(KC_V, KC_I, "sion");
+    }
+
+    switch (queue(-1)) {
+        magic_case(KC_SPC,  "the");
+
+        magic_case(KC_V,   "er");
+        magic_case(KC_S,   "k");
+        magic_case(KC_X,   "es");
+
+        magic_case(KC_M,   "ent");
+        magic_case(KC_T,   "ment");
+        magic_case(KC_K,   "s");
+
+        magic_case(KC_L,   "k");
+        magic_case(KC_R,   "l");
+        magic_case(KC_J,   "ust");
+
+        magic_case(KC_C,   "y");
+        magic_case(KC_D,   "y");
+        magic_case(KC_G,   "y");
+        magic_case(KC_P,   "y");
+        magic_case(KC_Y,   "p");
+        magic_case(KC_W,   "hich");
+        magic_case(KC_Q,   "uestion");
+
+        magic_case(KC_B,   "efore");
+        magic_case(KC_F,   "irst");
+        magic_case(KC_Z,   "one");
+        // US_MAG1
+        magic_case(KC_N,   "ion");
+        magic_case(KC_H,   "owever");
+
+        magic_case(KC_U,   "e");
+        magic_case(KC_E,   "u");
+        // KC_QUOT
+
+        magic_case(KC_O,   "a");
+        magic_case(KC_A,   "b");
+        // KC_QUES
+
+        magic_case(KC_COMM, get_last_mods() & MOD_MASK_SHIFT ? "=" : " but");
+        magic_case(KC_I,   "on");
+        magic_case(KC_DOT, get_last_mods() & MOD_MASK_SHIFT ? "=" : "\\");
+        magic_case(KC_MINS, ">");
+    }
+}
+
+void process_magic_key_2(void) {
+    switch (queue(-3)) {
+        triple_magic_switch(KC_SPC,
+            double_magic_case(KC_A, KC_B, "out");
+            double_magic_case(KC_O, KC_X, "ygen");
+        );
+
+        triple_magic_case(KC_A,   KC_N, KC_Y, "way");
+        // triple_magic_case(KC_C,   KC_A, KC_P, "able");
+        // triple_magic_case(KC_U,   KC_N, KC_I, "versity");
+    }
+
+    switch (queue(-2)) {
+        double_magic_switch(KC_SPC,
+            magic_case(KC_I, "ncrease");
+            magic_case(KC_B, "ecause");
+        );
+
+        double_magic_case(KC_F, KC_R, "om");
+        double_magic_case(KC_O, KC_U, "ght");
+    }
+
+    switch (queue(-1)) {
+        magic_case(KC_SPC, "for");
+        magic_case(KC_A,   "nd");
+        magic_case(KC_X,   "er");
+        magic_case(KC_I,   "ng");
+        magic_case(KC_Y,   "ou");
+        magic_case(KC_Q,   "ui");
+        magic_case(KC_J,   "oin");
+        magic_case(KC_W,   "ould");
+        magic_case(KC_C,   "k");
+        magic_case(KC_N,   "f");
+        magic_case(KC_COMMA, " and");
+        case KC_DOT:
+        case KC_QUES:
+        case KC_EXLM:
+        case KC_COLN:
+        case KC_SCLN:
+            unregister_weak_mods(MOD_MASK_CSAG);
+            send_char(' ');
+            add_oneshot_mods(MOD_MASK_SHIFT);
+            enqueue(KC_SPC);
+            return;
+        default: tap_code16(queue(-1)); enqueue(queue(-1));
+    }
+}
+
+void process_magic_key_3(void) {
+    switch (queue(-1)) {
+        magic_case(KC_B, "ecome");
+        magic_case(KC_F, "ollow");
+        magic_case(KC_N, "eighbor");
+        magic_case(KC_H, "owever");
+        magic_case(KC_U, "pgrade");
+        magic_case(KC_O, "ther");
+        magic_case(KC_A, "lready");
+        magic_case(KC_P, "sych");
+        magic_case(KC_I, "'ll");
+        magic_case(KC_K, "now");
+        magic_case(KC_T, "hough");
+        magic_case(KC_L, "ight");
+        magic_case(KC_M, "ight");
+        magic_case(KC_R, "ight");
+        magic_case(KC_J, "udge");
+        magic_case(KC_C, "ould");
+        magic_case(KC_D, "evelop");
+        magic_case(KC_G, "eneral");
+        magic_case(KC_W, "here");
+        magic_case(KC_S, "hould");
+        magic_case(KC_DOT, "org");
+        magic_case(KC_COMM, " however");
+        default: return;
+    }
+}
+
+void process_magic_key_4(void) {
+    switch (queue(-1)) {
+        magic_case(KC_B, "etween");
+        magic_case(KC_N, "umber");
+        magic_case(KC_U, "pdate");
+        magic_case(KC_O, "ught");
+        magic_case(KC_A, "bout");
+        magic_case(KC_P, "rogram");
+        magic_case(KC_I, "'m");
+        magic_case(KC_T, "hrough");
+        magic_case(KC_M, "anage");
+        magic_case(KC_C, "rowd");
+        magic_case(KC_G, "overn");
+        magic_case(KC_W, "orld");
+        magic_case(KC_S, "chool");
+        magic_case(KC_E, "'re");
+        magic_case(KC_DOT, "com");
+        magic_case(KC_COMM, " since");
+        default: return;
+    }
+}

keyboards/moonlander/keymaps/ikcelaks/magic_sturdy/magic_keys.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "../__init__.h"
+
+void process_magic_key_1(void);
+void process_magic_key_2(void);
+void process_magic_key_3(void);
+void process_magic_key_4(void);

keyboards/moonlander/keymaps/ikcelaks/rules.mk

@@ -0,0 +1,11 @@
+# Set any rules.mk overrides for your specific keymap here.
+# See rules at https://docs.qmk.fm/#/config_options?id=the-rulesmk-file
+CONSOLE_ENABLE = no
+COMMAND_ENABLE = no
+SPACE_CADET_ENABLE = no
+COMBO_ENABLE = yes
+REPEAT_KEY_ENABLE = yes
+DEFERRED_EXEC_ENABLE = yes
+
+SRC += magic_sturdy/general.c
+SRC += magic_sturdy/magic_keys.c

qmk.json

@@ -1,4 +1,6 @@
 {
     "userspace_version": "1.0",
-    "build_targets": []
+    "build_targets": [
-}
+        ["moonlander", "ikcelaks"]
+    ]
+}

users/ikcelaks/ikcelaks.c

@@ -0,0 +1,5 @@
+#include "ikcelaks.h"
+
+void my_custom_function(void) {
+
+}

users/ikcelaks/ikcelaks.h

@@ -0,0 +1,8 @@
+#ifndef USERSPACE
+#define USERSPACE
+
+#include "quantum.h"
+
+void my_custom_function(void);
+
+#endif

users/ikcelaks/readme.md

@@ -0,0 +1,14 @@
+Copyright <year> <name> <email> @<github_username>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

users/ikcelaks/rules.mk

@@ -0,0 +1 @@
+SRC += ikcelaks.c