[Keymap Removal] Preonic and related keymaps. (#22689)

3 files changed, 0 insertions, 633 deletions

diff --git a/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/ocean_dream.c b/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/ocean_dream.c
deleted file mode 100644
index d2d452d03d..0000000000
--- a/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/ocean_dream.c
+++ /dev/null
@@ -1,533 +0,0 @@
-// Copyright 2022 Jose Pablo Ramirez (@jpe230)
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "ocean_dream.h"
-#include "quantum.h"
-#include "print.h"
-
-// Calculated Parameters
-#define TWINKLE_PROBABILITY_MODULATOR 100 / TWINKLE_PROBABILITY                             // CALCULATED: Don't Touch
-#define TOTAL_STARS STARS_PER_LINE *NUMBER_OF_STAR_LINES                                    // CALCULATED: Don't Touch
-#define OCEAN_ANIMATION_MODULATOR NUMBER_OF_FRAMES / OCEAN_ANIMATION_SPEED                  // CALCULATED: Don't Touch
-#define SHOOTING_STAR_ANIMATION_MODULATOR NUMBER_OF_FRAMES / SHOOTING_STAR_ANIMATION_SPEED  // CALCULATED: Don't Touch
-#define STAR_ANIMATION_MODULATOR NUMBER_OF_FRAMES / STAR_ANIMATION_SPEED                    // CALCULATED: Don't Touch
-
-uint8_t    animation_counter       = 0;  // global animation counter.
-bool       is_calm                 = false;
-uint32_t   starry_night_anim_timer = 0;
-uint32_t   starry_night_anim_sleep = 0;
-static int current_wpm             = 0;
-
-static uint8_t increment_counter(uint8_t counter, uint8_t max) {
-    counter++;
-    if (counter >= max) {
-        return 0;
-    } else {
-        return counter;
-    }
-}
-
-#ifdef ENABLE_WAVE
-static uint8_t decrement_counter(uint8_t counter, uint8_t max) {
-    counter--;
-    if (counter < 0 || counter > max) {
-        return max;
-    } else {
-        return counter;
-    }
-}
-#endif
-
-#ifdef ENABLE_MOON  // region
-#    ifndef STATIC_MOON
-uint8_t  moon_animation_frame   = 0;  // keeps track of current moon frame
-uint16_t moon_animation_counter = 0;  // counts how many frames to wait before animating moon to next frame
-#    endif
-
-#    ifdef STATIC_MOON
-static const char PROGMEM moon[6] = {
-    0x18, 0x7E, 0xFF, 0xC3, 0x81, 0x81,
-};
-#    endif
-
-#    ifndef STATIC_MOON
-static const char PROGMEM moon_animation[14][8] = {
-    // clang-format off
-    { 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, },
-    { 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0x42, 0x00, },
-    { 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xC3, 0x00, 0x00, },
-    { 0x3C, 0x7E, 0xFF, 0xFF, 0xC3, 0x81, 0x00, 0x00, },
-    { 0x3C, 0x7E, 0xFF, 0xC3, 0x81, 0x00, 0x00, 0x00, },
-    { 0x3C, 0x7E, 0xC3, 0x81, 0x81, 0x00, 0x00, 0x00, },
-    { 0x3C, 0x42, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00, },
-    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
-    { 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x42, 0x3C, },
-    { 0x00, 0x00, 0x00, 0x81, 0x81, 0xC3, 0x7E, 0x3C, },
-    { 0x00, 0x00, 0x00, 0x81, 0xC3, 0xFF, 0x7E, 0x3C, },
-    { 0x00, 0x00, 0x81, 0xC3, 0xFF, 0xFF, 0x7E, 0x3C, },
-    { 0x00, 0x00, 0xC3, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, },
-    { 0x00, 0x42, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, },
-    // clang-format on
-};
-#    endif
-
-static void draw_moon(void) {
-#    ifdef STATIC_MOON
-    oled_set_cursor(MOON_COLUMN, MOON_LINE);
-    oled_write_raw_P(moon, 6);
-#    endif
-#    ifndef STATIC_MOON
-    moon_animation_counter = increment_counter(moon_animation_counter, ANIMATE_MOON_EVERY_N_FRAMES);
-    if (moon_animation_counter == 0) {
-        moon_animation_frame = increment_counter(moon_animation_frame, 14);
-        oled_set_cursor(MOON_COLUMN, MOON_LINE);
-        oled_write_raw_P(moon_animation[moon_animation_frame], 8);
-    }
-#    endif
-}
-#endif  // endregion
-
-#ifdef ENABLE_WAVE  // region
-uint8_t starry_night_wave_frame_width_counter = 31;
-uint8_t rough_waves_frame_counter             = 0;
-
-// clang-format off
-static const char PROGMEM ocean_top[8][32] = {
-    // still ocean
-    {
-        0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-        0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-        0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-        0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    },
-    // small ripples
-    {
-        0x20, 0x60, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-        0x20, 0x60, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-        0x20, 0x60, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-        0x20, 0x60, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    },
-    // level 2 ripples
-    {
-        0x20, 0x60, 0x40, 0x40, 0x20, 0x60, 0x40, 0x40,
-        0x20, 0x60, 0x40, 0x40, 0x20, 0x60, 0x40, 0x40,
-        0x20, 0x60, 0x40, 0x40, 0x20, 0x60, 0x40, 0x40,
-        0x20, 0x60, 0x40, 0x40, 0x20, 0x60, 0x40, 0x40,
-    },
-    // level 3 waves
-    {
-        0x40, 0x20, 0x10, 0x20, 0x40, 0x40, 0x40, 0x40,
-        0x40, 0x20, 0x10, 0x20, 0x40, 0x40, 0x40, 0x40,
-        0x40, 0x20, 0x10, 0x20, 0x40, 0x40, 0x40, 0x40,
-        0x40, 0x20, 0x10, 0x20, 0x40, 0x40, 0x40, 0x40,
-    },
-    {
-        0x40, 0x40, 0x20, 0x10, 0x28, 0x50, 0x40, 0x40,
-        0x40, 0x40, 0x20, 0x10, 0x28, 0x50, 0x40, 0x40,
-        0x40, 0x40, 0x20, 0x10, 0x28, 0x50, 0x40, 0x40,
-        0x40, 0x40, 0x20, 0x10, 0x28, 0x50, 0x40, 0x40,
-    },
-    {
-        0x40, 0x40, 0x40, 0x20, 0x10, 0x30, 0x70, 0x60,
-        0x40, 0x40, 0x40, 0x20, 0x10, 0x30, 0x70, 0x60,
-        0x40, 0x40, 0x40, 0x20, 0x10, 0x30, 0x70, 0x60,
-        0x40, 0x40, 0x40, 0x20, 0x10, 0x30, 0x70, 0x60,
-    },
-};
-static const char PROGMEM ocean_bottom[8][32] = {
-    // still ocean
-    {
-        0x00, 0x40, 0x40, 0x41, 0x01, 0x01, 0x01, 0x21,
-        0x20, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x44,
-        0x44, 0x40, 0x40, 0x00, 0x00, 0x08, 0x08, 0x00,
-        0x01, 0x01, 0x01, 0x00, 0x40, 0x40, 0x00, 0x00,
-    },
-    // small ripples
-    {
-        0x00, 0x00, 0x40, 0x40, 0x01, 0x01, 0x01, 0x20,
-        0x20, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04,
-        0x40, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
-        0x00, 0x01, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00,
-    },
-    // level 2 ripples
-    {
-        0x00, 0x00, 0x40, 0x40, 0x01, 0x01, 0x01, 0x20,
-        0x20, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04,
-        0x40, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
-        0x00, 0x01, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00,
-    },
-    // level 3 waves
-    {
-        0x00, 0x40, 0x40, 0x42, 0x42, 0x03, 0x11, 0x11,
-        0x20, 0x20, 0x00, 0x00, 0x08, 0x0C, 0x0C, 0x04,
-        0x05, 0x41, 0x41, 0x21, 0x20, 0x00, 0x00, 0x08,
-        0x0A, 0x0A, 0x0B, 0x41, 0x41, 0x41, 0x41, 0x00,
-    },
-    {
-        0x10, 0x10, 0x00, 0x80, 0x84, 0xC4, 0x02, 0x06,
-        0x84, 0x44, 0xC0, 0x80, 0x80, 0x20, 0x20, 0x10,
-        0x08, 0x12, 0x91, 0x81, 0x42, 0x40, 0x00, 0x00,
-        0x10, 0x12, 0x22, 0x22, 0x24, 0x04, 0x84, 0x80,
-    },
-    {
-        0x08, 0x80, 0x80, 0x82, 0x82, 0x03, 0x21, 0x21,
-        0x10, 0x10, 0x00, 0x00, 0x04, 0x04, 0x0C, 0x08,
-        0x09, 0x41, 0x42, 0x22, 0x20, 0x00, 0x00, 0x08,
-        0x0A, 0x0A, 0x0B, 0x41, 0x43, 0x42, 0x42, 0x00,
-    },
-};
-// clang-format on
-
-static void animate_waves(void) {
-    starry_night_wave_frame_width_counter = decrement_counter(starry_night_wave_frame_width_counter, WIDTH - 1);  // only 3 frames for last wave type
-    rough_waves_frame_counter             = increment_counter(rough_waves_frame_counter, 3);                      // only 3 frames for last wave type
-
-    void draw_ocean(uint8_t frame, uint16_t offset, uint8_t byte_index) {
-        oled_write_raw_byte(pgm_read_byte(ocean_top[frame] + byte_index), offset);
-        oled_write_raw_byte(pgm_read_byte(ocean_bottom[frame] + byte_index), offset + WIDTH);
-    }
-
-    for (int i = 0; i < WIDTH; ++i) {
-        uint16_t offset     = OCEAN_LINE * WIDTH + i;
-        uint8_t  byte_index = starry_night_wave_frame_width_counter + i;
-        if (byte_index >= WIDTH) {
-            byte_index = byte_index - WIDTH;
-        }
-        if (is_calm || current_wpm <= WAVE_CALM) {
-            draw_ocean(0, offset, byte_index);
-        } else if (current_wpm <= WAVE_HEAVY_STORM) {
-            draw_ocean(1, offset, byte_index);
-        } else if (current_wpm <= WAVE_HURRICANE) {
-            draw_ocean(2, offset, byte_index);
-        } else {
-            draw_ocean(3 + rough_waves_frame_counter, offset, byte_index);
-        }
-    }
-}
-#endif  // endregion
-
-#ifdef ENABLE_ISLAND  // region
-uint8_t island_frame_1 = 0;
-
-// clang-format off
-// only use 46 bytes (first 18 are blank, so we don't write them, makes it smaller and we can see the shooting stars properly!)
-
-// To save space and allow the shooting stars to be seen, only draw the tree on every frame.
-// Tree is only 14bytes wide so we save 108 bytes on just the first row. Second row, the
-// first 18 bytes is always the same piece of land, so only store that once, which saves 90 bytes
-static const char PROGMEM islandRightTop[6][14] = {
-    {0x84, 0xEC, 0x6C, 0x3C, 0xF8, 0xFE, 0x3F, 0x6B, 0xDB, 0xB9, 0x30, 0x40, 0x00, 0x00,},
-    {0x80, 0xC3, 0xEE, 0x7C, 0xB8, 0xFC, 0xFE, 0x6F, 0xDB, 0x9B, 0xB2, 0x30, 0x00, 0x00,},
-    {0x00, 0xC0, 0xEE, 0x7F, 0x3D, 0xF8, 0xFC, 0x7E, 0x57, 0xDB, 0xDB, 0x8A, 0x00, 0x00,},
-    {0x00, 0xC0, 0xE6, 0x7F, 0x3B, 0xF9, 0xFC, 0xFC, 0xB6, 0xB3, 0x33, 0x61, 0x00, 0x00,},
-    {0x00, 0x00, 0x00, 0x00, 0x80, 0xEE, 0xFF, 0xFB, 0xF9, 0xFC, 0xDE, 0xB6, 0xB6, 0x24,},
-    {0x00, 0x00, 0x00, 0x00, 0xC0, 0xEE, 0xFE, 0xFF, 0xFB, 0xFD, 0xEE, 0xB6, 0xB6, 0x92,},
-};
-static const char PROGMEM islandRightBottom[6][14] = {
-    {0x41, 0x40, 0x60, 0x3E, 0x3F, 0x23, 0x20, 0x60, 0x41, 0x43, 0x40, 0x40, 0x40, 0x80,},
-    {0x40, 0x41, 0x60, 0x3E, 0x3F, 0x23, 0x20, 0x60, 0x40, 0x40, 0x41, 0x41, 0x40, 0x80,},
-    {0x40, 0x40, 0x61, 0x3D, 0x3F, 0x27, 0x21, 0x60, 0x40, 0x40, 0x40, 0x40, 0x40, 0x80,},
-    {0x40, 0x43, 0x61, 0x3C, 0x3F, 0x27, 0x21, 0x60, 0x41, 0x43, 0x43, 0x42, 0x40, 0x80,},
-    {0x40, 0x40, 0x60, 0x3C, 0x3F, 0x27, 0x23, 0x63, 0x44, 0x40, 0x41, 0x41, 0x41, 0x81,},
-    {0x40, 0x40, 0x60, 0x3C, 0x3F, 0x27, 0x23, 0x63, 0x42, 0x42, 0x41, 0x41, 0x41, 0x80,},
-};
-static const char PROGMEM islandLeft[18] = {
-    0x80, 0x40, 0x40, 0x40, 0x40, 0x60,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x60, 0x40, 0x40,
-};
-// clang-format on
-
-static void animate_island(void) {
-    if (animation_counter == 0) {
-        island_frame_1 = increment_counter(island_frame_1, 2);
-    }
-
-    void draw_island_parts(uint8_t frame) {
-        oled_set_cursor(ISLAND_COLUMN + 3, ISLAND_LINE);
-        oled_write_raw_P(islandRightTop[frame], 14);
-        oled_set_cursor(ISLAND_COLUMN + 0, ISLAND_LINE + 1);
-        oled_write_raw_P(islandLeft, 18);
-        oled_set_cursor(ISLAND_COLUMN + 3, ISLAND_LINE + 1);
-        oled_write_raw_P(islandRightBottom[frame], 14);
-    }
-
-    if (is_calm || current_wpm < ISLAND_CALM) {
-        draw_island_parts(0);
-    } else if (current_wpm >= ISLAND_CALM && current_wpm < ISLAND_HEAVY_STORM) {
-        draw_island_parts(island_frame_1 + 1);
-    } else if (current_wpm >= ISLAND_HEAVY_STORM && current_wpm < ISLAND_HURRICANE) {
-        draw_island_parts(island_frame_1 + 2);
-    } else {
-        draw_island_parts(island_frame_1 + 4);
-    }
-}
-#endif  // endregion
-
-#ifdef ENABLE_STARS  // region
-bool stars_setup = false;  // only setup stars once, then we just twinkle them
-struct Coordinate {
-    int  x;
-    int  y;
-    bool exists;
-};
-
-struct Coordinate stars[TOTAL_STARS];  // tracks all stars/coordinates
-
-/**
- * Setup all the initial stars on the screen
- * This function divides the screen into regions based on STARS_PER_LINE and NUMBER_OF_STAR_LINES
- * where each line is made up of 8x8 pixel groups, that are populated by a single star.
- *
- * Not sure how this function will work with larger or smaller screens.
- * It should be fine, as long as the screen width is a multiple of 8
- */
-static void setup_stars(void) {
-    // For every line, split the line into STARS_PER_LINE, find a random point in that region, and turn the pixel on
-    // 36% probability it will not be added
-    // (said another way, 80% chance it will start out lit in the x direction, then 80% chance it will start out lit in the y direction = 64% probability it will start out lit at all)
-    for (int line = 0; line < NUMBER_OF_STAR_LINES; ++line) {
-        for (int column_group = 0; column_group < STARS_PER_LINE; ++column_group) {
-            uint8_t rand_column = rand() % 10;
-            uint8_t rand_row    = rand() % 10;
-            if (rand_column < 8 && rand_row < 8) {
-                int column_adder = column_group * 8;
-                int line_adder   = line * 8;
-                int x            = rand_column + column_adder;
-                int y            = rand_row + line_adder;
-                oled_write_pixel(x, y, true);
-                stars[column_group + (line * STARS_PER_LINE)].x      = x;
-                stars[column_group + (line * STARS_PER_LINE)].y      = y;
-                stars[column_group + (line * STARS_PER_LINE)].exists = true;
-            } else {
-                stars[column_group + (line * STARS_PER_LINE)].exists = false;
-            }
-        }
-    }
-    stars_setup = true;
-}
-
-/**
- * Twinkle the stars (move them one pixel in any direction) with a probability of 50% to twinkle any given star
- */
-static void twinkle_stars(void) {
-    for (int line = 0; line < NUMBER_OF_STAR_LINES; ++line) {
-        for (int column_group = 0; column_group < STARS_PER_LINE; ++column_group) {
-            struct Coordinate star = stars[column_group + (line * STARS_PER_LINE)];
-
-            // skip stars that were never added
-            if (!star.exists) {
-                continue;
-            }
-            if (rand() % TWINKLE_PROBABILITY_MODULATOR == 0) {
-                oled_write_pixel(star.x, star.y, false);  // black out pixel
-
-                // don't allow stars to leave their own region
-                if (star.x == (column_group * 8)) {                     // star is the farthest left it can go in its region
-                    star.x++;                                           // move it right immediately
-                } else if (star.x == (((column_group + 1) * 8) - 1)) {  // star is farthest right it can go in its region
-                    star.x--;                                           // move it left immediately
-                }
-                if (star.y == (line * 8)) {                     // star is the farthest up it can go in its region
-                    star.y++;                                   // move it down immediately
-                } else if (star.y == (((line + 1) * 8) - 1)) {  // star is farthest down it can go in its region
-                    star.y--;                                   // move it up immediately
-                }
-
-                // now decide direction
-                int new_x;
-                int x_choice = rand() % 3;
-                if (x_choice == 0) {
-                    new_x = star.x - 1;
-                } else if (x_choice == 1) {
-                    new_x = star.x + 1;
-                } else {
-                    new_x = star.x;
-                }
-
-                int new_y;
-                int y_choice = rand() % 3;
-                if (y_choice == 0) {
-                    new_y = star.y - 1;
-                } else if (y_choice == 1) {
-                    new_y = star.y + 1;
-                } else {
-                    new_y = star.y;
-                }
-
-                star.x = new_x;
-                star.y = new_y;
-                oled_write_pixel(new_x, new_y, true);
-            }
-
-            stars[column_group + (line * STARS_PER_LINE)] = star;
-        }
-    }
-}
-
-/**
- * Setup the stars and then animate them on subsequent frames
- */
-static void animate_stars(void) {
-    if (!stars_setup) {
-        setup_stars();
-    } else {
-        twinkle_stars();
-    }
-}
-#endif  // endregion
-
-#ifdef ENABLE_SHOOTING_STARS  // region
-bool shooting_stars_setup = false;  // only setup shooting stars array once with defaults
-
-struct ShootingStar {
-    int  x_1;
-    int  y_1;
-    int  x_2;
-    int  y_2;
-    bool running;
-    int  frame;
-    int  delay;
-};
-
-struct ShootingStar shooting_stars[MAX_NUMBER_OF_SHOOTING_STARS];  // tracks all the shooting stars
-
-static void setup_shooting_star(struct ShootingStar *shooting_star) {
-    int column_to_start = rand() % (WIDTH / 2);
-    int row_to_start    = rand() % (HEIGHT - 48);  // shooting_stars travel diagonally 1 down, 1 across. So the lowest a shooting_star can start and not 'hit' the ocean is 32 above the ocean.
-
-    shooting_star->x_1     = column_to_start;
-    shooting_star->y_1     = row_to_start;
-    shooting_star->x_2     = column_to_start + 1;
-    shooting_star->y_2     = row_to_start + 1;
-    shooting_star->running = true;
-    shooting_star->frame++;
-    shooting_star->delay = rand() % SHOOTING_STAR_DELAY;
-}
-
-static void move_shooting_star(struct ShootingStar *shooting_star) {
-    oled_write_pixel(shooting_star->x_1, shooting_star->y_1, false);
-    oled_write_pixel(shooting_star->x_2, shooting_star->y_2, false);
-
-    shooting_star->x_1++;
-    shooting_star->y_1++;
-    shooting_star->x_2++;
-    shooting_star->y_2++;
-    shooting_star->frame++;
-
-    oled_write_pixel(shooting_star->x_1, shooting_star->y_1, true);
-    oled_write_pixel(shooting_star->x_2, shooting_star->y_2, true);
-}
-
-static void finish_shooting_star(struct ShootingStar *shooting_star) {
-    oled_write_pixel(shooting_star->x_1, shooting_star->y_1, false);
-    oled_write_pixel(shooting_star->x_2, shooting_star->y_2, false);
-    shooting_star->running = false;
-    shooting_star->frame   = 0;
-}
-
-static void animate_shooting_star(struct ShootingStar *shooting_star) {
-    if (shooting_star->frame > SHOOTING_STAR_FRAMES) {
-        finish_shooting_star(shooting_star);
-        return;
-    } else if (!shooting_star->running) {
-        setup_shooting_star(shooting_star);
-    } else {
-        if (shooting_star->delay == 0) {
-            move_shooting_star(shooting_star);
-        } else {
-            shooting_star->delay--;
-        }
-    }
-}
-
-static void animate_shooting_stars(void) {
-    if (is_calm) {
-        return;
-    }
-    if (!shooting_stars_setup) {
-        for (int i = 0; i < MAX_NUMBER_OF_SHOOTING_STARS; ++i) {
-            shooting_stars[i].running = false;
-        }
-        shooting_stars_setup = true;
-    }
-    /**
-     * Fixes issue with stars that were falling _while_ the
-     * wpm dropped below the condition for them to keep falling
-     */
-    void end_extra_stars(uint8_t starting_index) {
-        for (int shooting_star_index = starting_index; shooting_star_index < MAX_NUMBER_OF_SHOOTING_STARS; ++shooting_star_index) {
-            struct ShootingStar shooting_star = shooting_stars[shooting_star_index];
-            if (shooting_star.running) {
-                finish_shooting_star(&shooting_star);
-                shooting_stars[shooting_star_index] = shooting_star;
-            }
-        }
-    }
-
-    int number_of_shooting_stars = current_wpm / SHOOTING_STAR_WPM_INCREMENT;
-    number_of_shooting_stars     = (number_of_shooting_stars > MAX_NUMBER_OF_SHOOTING_STARS) ? MAX_NUMBER_OF_SHOOTING_STARS : number_of_shooting_stars;
-
-    if (number_of_shooting_stars == 0) {
-        // make sure all shooting_stars are ended
-        end_extra_stars(0);
-    } else {
-        for (int shooting_star_index = 0; shooting_star_index < number_of_shooting_stars; ++shooting_star_index) {
-            struct ShootingStar shooting_star = shooting_stars[shooting_star_index];
-            animate_shooting_star(&shooting_star);
-            shooting_stars[shooting_star_index] = shooting_star;
-        }
-        end_extra_stars(number_of_shooting_stars);
-    }
-}
-#endif  // endregion
-
-/**
- * Main rendering function
- *
- * Calls all different animations at different rates
- */
-void render_stars(void) {
-    //    // animation timer
-    if (timer_elapsed32(starry_night_anim_timer) > STARRY_NIGHT_ANIM_FRAME_DURATION) {
-        starry_night_anim_timer = timer_read32();
-        current_wpm             = get_current_wpm();
-
-#ifdef ENABLE_ISLAND
-        animate_island();
-#endif
-
-#ifdef ENABLE_SHOOTING_STARS
-        if (animation_counter % SHOOTING_STAR_ANIMATION_MODULATOR == 0) {
-            animate_shooting_stars();
-        }
-#endif
-
-#ifdef ENABLE_STARS
-        // TODO offsetting the star animation from the wave animation would look better,
-        // but if I do that, then the stars appear in the water because
-        // the ocean animation has to wait a bunch of frames to overwrite it.
-        // Possible solutions:
-        // 1. Only draw stars to the top of the island/ocean.
-        // 2. Draw ocean every frame, only move ocean on frames matching modulus
-        // Problems:
-        // 1. What if someone wants to move the island up a bit, or they want to have the stars reflect in the water?
-        // 2. More cpu intensive. And I'm already running out of cpu as it is...
-        if (animation_counter % STAR_ANIMATION_MODULATOR == 0) {
-            animate_stars();
-        }
-#endif
-
-#ifdef ENABLE_WAVE
-        if (animation_counter % OCEAN_ANIMATION_MODULATOR == 0) {
-            animate_waves();
-        }
-#endif
-
-#ifdef ENABLE_MOON
-        draw_moon();
-#endif
-
-        animation_counter = increment_counter(animation_counter, NUMBER_OF_FRAMES);
-    }
-}
diff --git a/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/ocean_dream.h b/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/ocean_dream.h
deleted file mode 100644
index 8d3c505c33..0000000000
--- a/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/ocean_dream.h
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2022 Jose Pablo Ramirez (@jpe230)
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-#include "quantum.h"
-
-/**
- * Features:
- * You can turn on and off features in this section
- */
-#define ENABLE_MOON            // Uses 182 bytes
-#define ENABLE_WAVE            // Uses 844 bytes
-#define ENABLE_SHOOTING_STARS  // Uses 872 bytes
-#define ENABLE_ISLAND
-#define ENABLE_STARS  // Uses 606 bytes
-
-/**
- * Global Settings
- */
-#define STARRY_NIGHT_ANIM_FRAME_DURATION 30  // how long each frame lasts in ms
-#define NUMBER_OF_FRAMES 20                  // Self explanatory. Probably shouldn't touch this, not sure how stuff will work if it's changed. If changed should be multiple of 1, 2, 3, 4, and 5
-#define WIDTH OLED_DISPLAY_HEIGHT            // for vertical displays
-#define HEIGHT OLED_DISPLAY_WIDTH            // for vertical displays
-
-/**
- * Moon Parameters
- */
-#define MOON_LINE 4    // the line you want the moon to appear at
-#define MOON_COLUMN 4  // the column you want the moon to appear at
-//#define STATIC_MOON  // uncomment this to make the moon a static image, no animation
-#ifndef STATIC_MOON
-#    define ANIMATE_MOON_EVERY_N_FRAMES 100  // animate the moon every n frames
-#endif
-
-/**
- * Wave Parameters
- */
-#define OCEAN_LINE 14        // Line you want to render the ocean starting at (best at oled_max_lines() - 2)
-#define WAVE_CALM 20         // render calm ocean under this WPM and ripple ocean at this WPM
-#define WAVE_HEAVY_STORM 40  // render medium ocean at this WPM
-#define WAVE_HURRICANE 60    // render heavy waves above this WPM
-// What number of frames you want to animate the ocean at.
-// Should be equal to or smaller than NUMBER_OF_FRAMES, e.g. 30, would animate on every other frame, 20, every third frame, etc
-// Don't set equal to 0.
-#define OCEAN_ANIMATION_SPEED 1
-
-/**
- * Shooting Star Parameters
- */
-#define SHOOTING_STAR_DELAY 12           // delay modulus for time between shooting stars. Decides number of frames to delay, e.g. 12 means 0-11 frames of delay between each shooting star
-#define SHOOTING_STAR_FRAMES 16          // how many 2 pixel frames per shooting star. Increment this for longer shooting stars
-#define MAX_NUMBER_OF_SHOOTING_STARS 12  // maximum number of shooting stars that can be on screen at the same time
-#define SHOOTING_STAR_WPM_INCREMENT 10   // every n WPM increase, add an extra star, up to MAX_NUMBER_OF_SHOOTING_STARS, e.g. an increment of 5 would result in 1 shooting star at 5-9wpm, 2 at 10-14, etc.
-// What number of frames you want to animate the shooting stars at.
-// Should be equal to or smaller than NUMBER_OF_FRAMES, e.g. 30, would animate on every other frame, 20, every third frame, etc
-// Don't set equal to 0.
-#define SHOOTING_STAR_ANIMATION_SPEED 30
-
-/**
- * Star Parameters
- */
-#define STARS_PER_LINE 4         // number of stars per line (for a display that is 128x32, this would be 4 stars spread out evenly over the 32byte width, one every 8 bytes)
-#define NUMBER_OF_STAR_LINES 16  // number of lines to fill up with stars (for a display that is 128x32, 16 bytes are filled with the ocean animation, so that leaves 112 pixels left over. The number of lines depends on your OLED_FONT_HEIGHT)
-#define TWINKLE_PROBABILITY 25   // probability that any star twinkles on a given frame
-// What number of frames you want to animate the stars at.
-// Should be equal to or smaller than NUMBER_OF_FRAMES, e.g. 20, would animate on every frame, 10, every other frame, etc
-// Don't set equal to 0.
-#define STAR_ANIMATION_SPEED 1
-
-/**
- * Island Parameters
- */
-#define ISLAND_LINE 12         // line that the island starts at. Island is 2 lines tall
-#define ISLAND_COLUMN 0        // column that the island starts at
-#define ISLAND_CALM 20         // WPM at which the palm tree calmly moves
-#define ISLAND_HEAVY_STORM 40  // WPM at which the heavy storm occurs
-#define ISLAND_HURRICANE 60    // WPM at which THE HURRICANE STARTS
-
-/*
- * DON'T TOUCH
- */
-
-extern bool is_calm;
-
-// timers
-extern uint32_t starry_night_anim_timer;
-extern uint32_t starry_night_anim_sleep;
-
-void render_stars(void);
diff --git a/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/oled_slave_handler.c b/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/oled_slave_handler.c
deleted file mode 100644
index 31166b3b43..0000000000
--- a/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/oled_slave_handler.c
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2022 Jose Pablo Ramirez (@jpe230)
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "jpe230.h"
-#include "ocean_dream.h"
-
-void render_slave_oled(void) {
-    render_stars();
-}
-
-oled_rotation_t rotate_slave(oled_rotation_t rotation) {return OLED_ROTATION_270;}