removed legacy LED blinking

semestralka1/src/assets/background_frame.h

@@ -1,4 +1,4 @@
-// background_dark_inverted.h
+// src/assets/background_frame.h
 #pragma once
 
 static const char *BACKGROUND_MASK[] = {

semestralka1/src/assets/character_frames.h

@@ -0,0 +1,54 @@
+// src/assets/character_frames.h
+
+#pragma once
+
+// Player frame 1
+static const char *CHARACTER_MASK_FRAME_1[] = {
+    ".....a@$..",
+    ".....7PF..",
+    "..yaM@@__y",
+    "..@.y@FFF~",
+    "..._$M@_..",
+    "yaa@~.`@y.",
+    "........@r"
+};
+
+// Player frame 2
+static const char *CHARACTER_MASK_FRAME_2[] = {
+    ".g@$",
+    ".7PF",
+    "y@$.",
+    "0@F.",
+    "4@$.",
+    "y$@.",
+    "u@.."
+};
+
+// Player frame 3 (triggered)
+static const char *CHARACTER_MASK_FRAME_3[] = {
+    ".._$@.",
+    ".$By`.",
+    "4@$@@a",
+    "aa@W@."
+};
+
+enum class CharacterFrame {
+    Walk1 = 0,
+    Walk2,
+    Crawl1,
+    COUNT // number of frames, must stay last
+};
+
+// Combine frames for easy access
+static const char **PLAYER_FRAMES[] = {
+    CHARACTER_MASK_FRAME_1, // Walk1
+    CHARACTER_MASK_FRAME_2, // Walk1
+    CHARACTER_MASK_FRAME_3  // Crawl1
+};
+
+static const int CHARACTER_FRAME_COUNT = static_cast<int>(CharacterFrame::COUNT);
+
+// Height per frame
+static const int CHARACTER_HEIGHT_1 = sizeof(CHARACTER_MASK_FRAME_1) / sizeof(CHARACTER_MASK_FRAME_1[0]);
+static const int CHARACTER_HEIGHT_2 = sizeof(CHARACTER_MASK_FRAME_2) / sizeof(CHARACTER_MASK_FRAME_2[0]);
+static const int CHARACTER_HEIGHT_3 = sizeof(CHARACTER_MASK_FRAME_3) / sizeof(CHARACTER_MASK_FRAME_3[0]);

semestralka1/src/game/animation.cpp

@@ -0,0 +1,16 @@
+// src/game/animation.cpp
+#include "animation.h"
+
+AnimationController::AnimationController() {
+  anim_timer.start();
+}
+
+bool AnimationController::tick(int speed) {
+  if (anim_timer.elapsed_time() >= ANIMATION_TICK) {
+    // speed determines scroll steps per tick
+    shift += speed;
+    anim_timer.reset();
+    return true;
+  }
+  return false;
+}

semestralka1/src/game/animation.h

@@ -0,0 +1,20 @@
+// src/game/animation.h
+#pragma once
+#include "mbed.h"
+
+constexpr auto ANIMATION_TICK = 170ms;
+
+class AnimationController {
+private:
+  Timer anim_timer;
+  int shift = 0;
+
+public:
+  AnimationController();
+  
+  // Update animation, returns true if redraw needed
+  bool tick(int speed);
+  
+  // Getters
+  int get_shift() const { return shift; }
+};

semestralka1/src/game/state.cpp

@@ -0,0 +1,38 @@
+// src/game/state.cpp
+#include "state.h"
+
+void WalkingState::update() {
+  // stop crawling after duration
+  if (current_state == PlayerState::Crawl1 &&
+      state_timer.elapsed_time() >= CRAWL_DURATION) {
+    current_state = PlayerState::Walk1;
+    state_timer.stop();
+  }
+}
+
+void WalkingState::start_crawl() {
+  current_state = PlayerState::Crawl1;
+  state_timer.reset();
+  state_timer.start();
+}
+
+void WalkingState::toggle_walk_frame() {
+  if (current_state == PlayerState::Walk1) {
+    current_state = PlayerState::Walk2;
+  } else if (current_state == PlayerState::Walk2) {
+    current_state = PlayerState::Walk1;
+  }
+}
+
+CharacterFrame WalkingState::get_character_frame() const {
+  switch (current_state) {
+  case PlayerState::Walk1:
+    return CharacterFrame::Walk1;
+  case PlayerState::Walk2:
+    return CharacterFrame::Walk2;
+  case PlayerState::Crawl1:
+    return CharacterFrame::Crawl1;
+  default:
+    return CharacterFrame::Walk1;
+  }
+}

semestralka1/src/game/state.h

@@ -0,0 +1,27 @@
+// src/game/state.h
+#pragma once
+#include "mbed.h"
+#include "../assets/character_frames.h"
+
+constexpr auto CRAWL_DURATION = 300ms;
+
+enum class PlayerState { Walk1, Walk2, Crawl1 };
+
+class WalkingState {
+private:
+  PlayerState current_state = PlayerState::Walk1;
+  Timer state_timer;
+
+public:
+  // MOVED FROM loop.cpp
+  // Update state (handles crawl timeout)
+  void update();
+  
+  // State transitions
+  void start_crawl();
+  void toggle_walk_frame();
+  
+  // Getters
+  PlayerState get_state() const { return current_state; }
+  CharacterFrame get_character_frame() const;
+};

semestralka1/src/hardware/uart.cpp

@@ -0,0 +1,49 @@
+// src/hardware/uart.cpp
+#include "uart.h"
+#include <cstring>
+
+UartReader::UartReader(BufferedSerial &serial) : serial_port(serial) {
+  memset(rx_buffer, 0, sizeof(rx_buffer));
+  memset(message, 0, sizeof(message));
+}
+
+UartEvent UartReader::poll() {
+  bool changed = false;
+  bool triggered = false;
+
+  // cita spravu z uartu
+  if (serial_port.readable()) {
+    memset(rx_buffer, 0, sizeof(rx_buffer));
+    ssize_t num = serial_port.read(rx_buffer, sizeof(rx_buffer) - 1);
+    if (num > 0) {
+      strncpy(message, rx_buffer, sizeof(message) - 1);
+      message_active = true;
+      changed = true;
+      triggered = true;
+    }
+  }
+
+  // casovac na 1s zobrazenia spravy
+  if (!timer_started) {
+    msg_timer.start();
+    timer_started = true;
+  }
+
+  // po jednu sekundu sa sprava zobrazi
+  if (message_active && msg_timer.elapsed_time() > MESSAGE_DISPLAY_DURATION) {
+    message_active = false;
+    memset(message, 0, sizeof(message));
+    msg_timer.reset();
+    changed = true;
+  }
+
+  if (triggered)
+    return UartEvent::Triggered;
+  if (changed)
+    return UartEvent::MessageUpdate;
+  return UartEvent::NoChange;
+}
+
+const char* UartReader::get_message() const {
+  return message_active ? message : nullptr;
+}

semestralka1/src/hardware/uart.h

@@ -0,0 +1,35 @@
+// src/hardware/uart.h
+#pragma once
+#include "mbed.h"
+#include <cstddef>
+
+constexpr size_t UART_BUFFER_SIZE = 64;
+constexpr auto MESSAGE_DISPLAY_DURATION = 1s;
+
+enum class UartEvent {
+  NoChange = 0,      // No new data
+  MessageUpdate = 1, // Message changed (received or expired)
+  Triggered = 2      // New message received (trigger action)
+};
+
+class UartReader {
+private:
+  BufferedSerial &serial_port;
+  
+  char rx_buffer[UART_BUFFER_SIZE];
+  char message[UART_BUFFER_SIZE];
+  bool message_active = false;
+  
+  Timer msg_timer;
+  bool timer_started = false;
+
+public:
+  UartReader(BufferedSerial &serial);
+  
+  // Poll for UART events
+  UartEvent poll();
+  
+  // Get current message (nullptr if no active message)
+  const char* get_message() const;
+  bool has_message() const { return message_active; }
+};

semestralka1/src/main.cpp

@@ -1,7 +1,7 @@
 // main.cpp
 
 #include "mbed.h"
-#include "background_dark_inverted.h"
+#include "assets/background_frame.h"
 #include "render/loop.h"
 
 #define TARGET_TX_PIN USBTX

semestralka1/src/render/background.cpp

@@ -1,6 +1,6 @@
 // src/render/background.cpp
 
-#include "../background_dark_inverted.h"
+#include "../assets/background_frame.h"
 #include <cstdio>
 #include <cstring>
 

semestralka1/src/render/loop.cpp

@@ -1,169 +1,65 @@
 // src/render/loop.cpp
 #include "loop.h"
-#include "../background_dark_inverted.h"
+#include "../assets/background_frame.h"
 #include "player_positioning.h"
 #include "background.h"
 #include "mbed.h"
 #include "player.h"
-#include "player_mask.h"
-#include <cstring>
+#include "../game/state.h"
+#include "../game/animation.h"
+#include "../hardware/uart.h"
+#include "../assets/character_frames.h"
 
 extern BufferedSerial serial_port;
 extern DigitalOut led;
 
 // Constants
-constexpr size_t BUFFER_SIZE = 64;
-constexpr auto CRAWL_DURATION = 300ms;
-constexpr auto ANIMATION_TICK = 170ms;
-constexpr auto MESSAGE_DISPLAY_DURATION = 1s;
 constexpr int PLAYER_X = 9;
 constexpr int PLAYER_Y = 6;
 
-enum class PlayerState { Walk1, Walk2, Crawl1 };
-
-struct WalkingState {
-  PlayerState current_state = PlayerState::Walk1;
-  Timer state_timer;
-};
-
-static char rx_buffer[BUFFER_SIZE];
-static char message[BUFFER_SIZE];
-static bool message_active = false;
-
 void draw_mask(const char *unused_filename, int shift, const char *text);
 
-// Returns:
-// 0 = no change - walk1
-// 1 = normal redraw - walk2
-// 2 = button triggered - crawl1
-static int read_uart() {
-  bool changed = false;
-  bool triggered = false;
-
-  // cita spravu z uartu
-  if (serial_port.readable()) {
-    memset(rx_buffer, 0, sizeof(rx_buffer));
-    ssize_t num = serial_port.read(rx_buffer, sizeof(rx_buffer) - 1);
-    if (num > 0) {
-      led = !led; // toogle ledky
-      strncpy(message, rx_buffer, sizeof(message) - 1);
-      message_active = true;
-      changed = true;
-      triggered = true;
-    }
-  }
-
-  // casovac na 1s zobrazenia spravy
-  static Timer msg_timer;
-  static bool timer_started = false;
-  if (!timer_started) {
-    msg_timer.start();
-    timer_started = true;
-  }
-
-  // po jednu sekundu sa sprava zobrazi
-  if (message_active && msg_timer.elapsed_time() > MESSAGE_DISPLAY_DURATION) {
-    message_active = false;
-    memset(message, 0, sizeof(message));
-    msg_timer.reset();
-    changed = true;
-  }
-
-  if (triggered)
-    return 2; // LED toggled press
-  if (changed)
-    return 1;
-  return 0;
-}
-
-static bool update_animation(Timer &anim_timer, int &shift, int speed) {
-  if (anim_timer.elapsed_time() >= ANIMATION_TICK) {
-    // speed determines scroll steps per tick
-    shift += speed;
-    anim_timer.reset();
-    return true;
-  }
-  return false;
-}
-
-static int get_player_frame(PlayerState state) {
-  switch (state) {
-  case PlayerState::Walk1:
-    return 0;
-  case PlayerState::Walk2:
-    return 1;
-  case PlayerState::Crawl1:
-    return 2;
-  default:
-    return 0;
-  }
-}
-
-static void update_player_state(WalkingState &state) {
-  // stop crawling
-  if (state.current_state == PlayerState::Crawl1 &&
-      state.state_timer.elapsed_time() >= CRAWL_DURATION) {
-    state.current_state = PlayerState::Walk1;
-    state.state_timer.stop();
-  }
-}
-
-static void toggle_walk_frame(WalkingState &state) {
-  if (state.current_state == PlayerState::Walk1) {
-    state.current_state = PlayerState::Walk2;
-  } else if (state.current_state == PlayerState::Walk2) {
-    state.current_state = PlayerState::Walk1;
-  }
-}
-
-static void start_crawl(WalkingState &state) {
-  state.current_state = PlayerState::Crawl1;
-  state.state_timer.reset();
-  state.state_timer.start();
-}
-
 void render_loop(int speed) {
   WalkingState player_state;
+  AnimationController animation;
+  UartReader uart(serial_port);
 
-  Timer anim_timer;
-  anim_timer.start();
-  int shift = 0;
-
-  PlayerPosition pos = {PLAYER_X, PLAYER_Y};
+  CharacterPosition pos = {PLAYER_X, PLAYER_Y};
 
   const char *bg_file = "background_dark_inverted.txt";
   bool need_redraw = false;
 
   while (true) {
     need_redraw = false;
-    int uart_state = read_uart(); // returns 0/1/2
+    UartEvent uart_event = uart.poll();
 
-    if (uart_state == 1) {
+    if (uart_event == UartEvent::MessageUpdate) {
       need_redraw = true;
     }
 
-    if (uart_state == 2) {
+    if (uart_event == UartEvent::Triggered) {
       // start crawl frame for x time
-      start_crawl(player_state);
+      player_state.start_crawl();
       need_redraw = true;
     }
 
     // Check if crawl duration expired
-    update_player_state(player_state);
+    player_state.update();
 
-    if (update_animation(anim_timer, shift, speed)) {
+    if (animation.tick(speed)) {
       need_redraw = true;
     }
 
     if (need_redraw) {
-      draw_mask(bg_file, shift, message_active ? message : nullptr);
-      int player_frame = get_player_frame(player_state.current_state);
-      PlayerPosition draw_pos = get_aligned_frame_position(pos, player_frame);
-      draw_player(draw_pos.x, draw_pos.y, player_frame);
+      draw_mask(bg_file, animation.get_shift(), uart.get_message());
+      CharacterFrame player_frame = player_state.get_character_frame();
+
+      CharacterPosition draw_pos = get_aligned_frame_position(pos, player_frame);
+      draw_character(draw_pos.x, draw_pos.y, player_frame);
 
       // alternate between frame 0 and 1 when not crawling
-      if (player_state.current_state != PlayerState::Crawl1) {
-        toggle_walk_frame(player_state);
+      if (player_state.get_state() != PlayerState::Crawl1) {
+	player_state.toggle_walk_frame();
       }
 
       ThisThread::sleep_for(50ms);

semestralka1/src/render/player.cpp

@@ -1,25 +1,33 @@
 // src/render/player.cpp
-
 #include "player.h"
-#include "player_mask.h"
+#include "../assets/character_frames.h"
 #include <cstdio>
 
-void draw_player(int x, int y, int frame_index) {
-    if (frame_index < 0 || frame_index >= PLAYER_FRAME_COUNT)
+void draw_character(int x, int y, CharacterFrame frame) {
+    int frame_index = static_cast<int>(frame);
+    if (frame_index < 0 || frame_index >= CHARACTER_FRAME_COUNT)
         frame_index = 0; // fallback safety
 
-    const char **sprite = PLAYER_FRAMES[frame_index];
-    int sprite_height = 0;
-    if (frame_index == 0)
-        sprite_height = PLAYER_MASK_LINES_FRAME_1;
-    else if (frame_index == 1)
-        sprite_height = PLAYER_MASK_LINES_FRAME_2;
-    else
-        sprite_height = PLAYER_MASK_LINES_FRAME_3;
+    const char **character = PLAYER_FRAMES[frame_index];
 
-    // Draw the sprite starting from (x, y)
-    for (int i = 0; i < sprite_height; i++) {
-        printf("\033[%d;%dH%s", y + i + 1, x + 1, sprite[i]);
+    int character_height = 0;
+    switch (frame) {
+    case CharacterFrame::Walk1:
+        character_height = CHARACTER_HEIGHT_1;
+        break;
+    case CharacterFrame::Walk2:
+        character_height = CHARACTER_HEIGHT_2;
+        break;
+    case CharacterFrame::Crawl1:
+        character_height = CHARACTER_HEIGHT_3;
+        break;
+    default:
+        character_height = CHARACTER_HEIGHT_1;
+        break;
+    }
+
+    for (int i = 0; i < character_height; i++) {
+        printf("\033[%d;%dH%s", y + i + 1, x + 1, character[i]);
     }
     fflush(stdout);
 }

semestralka1/src/render/player.h

@@ -1,5 +1,6 @@
 // src/render/player.h
 #pragma once
+#include "../assets/character_frames.h"
 
 // Draw the player object starting at given (x, y)
-void draw_player(int x, int y, int frame_index);
+void draw_character(int x, int y, CharacterFrame frame);

semestralka1/src/render/player_mask.h

@@ -1,50 +0,0 @@
-// src/render/player_mask.h
-
-#pragma once
-
-// Player frame 1
-static const char *PLAYER_MASK_FRAME_1[] = {
-    ".....a@$..",
-    ".....7PF..",
-    "..yaM@@__y",
-    "..@.y@FFF~",
-    "..._$M@_..",
-    "yaa@~.`@y.",
-    "........@r"
-};
-
-// Player frame 2
-static const char *PLAYER_MASK_FRAME_2[] = {
-    ".g@$",
-    ".7PF",
-    "y@$.",
-    "0@F.",
-    "4@$.",
-    "y$@.",
-    "u@.."
-};
-
-// Player frame 3 (triggered)
-static const char *PLAYER_MASK_FRAME_3[] = {
-    ".._$@.",
-    ".$By`.",
-    "4@$@@a",
-    "aa@W@."
-};
-
-// Combine frames for easy access
-static const char **PLAYER_FRAMES[] = {
-    PLAYER_MASK_FRAME_1, // 0
-    PLAYER_MASK_FRAME_2, // 1
-    PLAYER_MASK_FRAME_3  // 2 (triggered)
-};
-
-static const int PLAYER_FRAME_COUNT = sizeof(PLAYER_FRAMES) / sizeof(PLAYER_FRAMES[0]);
-
-// Line counts per frame
-static const int PLAYER_MASK_LINES_FRAME_1 =
-    sizeof(PLAYER_MASK_FRAME_1) / sizeof(PLAYER_MASK_FRAME_1[0]);
-static const int PLAYER_MASK_LINES_FRAME_2 =
-    sizeof(PLAYER_MASK_FRAME_2) / sizeof(PLAYER_MASK_FRAME_2[0]);
-static const int PLAYER_MASK_LINES_FRAME_3 =
-    sizeof(PLAYER_MASK_FRAME_3) / sizeof(PLAYER_MASK_FRAME_3[0]);

semestralka1/src/render/player_positioning.cpp

@@ -1,24 +1,25 @@
 // src/render/player_positioning.cpp
 #include "player_positioning.h"
-#include "../background_dark_inverted.h"
+#include "../assets/background_frame.h"
 #include <cstdio>
 
 // Convert a pivot coordinate (bottom-left) to the top-left draw position
-PlayerPosition get_aligned_frame_position(PlayerPosition base, int frame_index) {
-    if (frame_index < 0 || frame_index >= PLAYER_FRAME_COUNT)
+CharacterPosition get_aligned_frame_position(CharacterPosition base, CharacterFrame frame) {
+    int frame_index = static_cast<int>(frame);
+    if (frame_index < 0 || frame_index >= CHARACTER_FRAME_COUNT)
         frame_index = 0;
 
-    int sprite_height = 0;
+    int character_height = 0;
     if (frame_index == 0)
-        sprite_height = PLAYER_MASK_LINES_FRAME_1;
+        character_height = CHARACTER_HEIGHT_1;
     else if (frame_index == 1)
-        sprite_height = PLAYER_MASK_LINES_FRAME_2;
+        character_height = CHARACTER_HEIGHT_2;
     else
-        sprite_height = PLAYER_MASK_LINES_FRAME_3;
+        character_height = CHARACTER_HEIGHT_3;
 
-    PlayerPosition draw_pos;
+    CharacterPosition draw_pos;
     draw_pos.x = base.x;
-    draw_pos.y = (VIEW_HEIGHT - base.y) - sprite_height;
+    draw_pos.y = (VIEW_HEIGHT - base.y) - character_height;
 
     return draw_pos;
 }

semestralka1/src/render/player_positioning.h

@@ -1,11 +1,12 @@
 // src/render/player_positioning.h
 #pragma once
-#include "player_mask.h"
+#include "../assets/background_frame.h"
+#include "../assets/character_frames.h"
 
-struct PlayerPosition {
+struct CharacterPosition {
     int x;
     int y;
 };
 
 // Calculates drawing position relative to bottom-left pivot
-PlayerPosition get_aligned_frame_position(PlayerPosition base, int frame_index);
+CharacterPosition get_aligned_frame_position(CharacterPosition base, CharacterFrame frame);