diff --git a/pets/hridyas_catgame/README.md b/pets/hridyas_catgame/README.md
new file mode 100644
index 00000000..fff7fbba
--- /dev/null
+++ b/pets/hridyas_catgame/README.md
@@ -0,0 +1,19 @@
+# Hridya's cat game
+
+Pet game where you take care of your cat.
+
+You send it to sleep / play with it / feed it / cure it from sickness.
+
+Controls for port.py:
+- Button 1: Feed
+- Button 2: Cure
+- Button 3: Play, long press for sleep
+
+On main.py:
+- 1: Feed
+- 2: Cure
+- 3: Play
+- 4: Sleep
+
+Hope you like it :D
+
diff --git a/pets/hridyas_catgame/candy.png b/pets/hridyas_catgame/candy.png
new file mode 100644
index 00000000..81758df5
Binary files /dev/null and b/pets/hridyas_catgame/candy.png differ
diff --git a/pets/hridyas_catgame/catdead.bmp b/pets/hridyas_catgame/catdead.bmp
new file mode 100644
index 00000000..695628ec
Binary files /dev/null and b/pets/hridyas_catgame/catdead.bmp differ
diff --git a/pets/hridyas_catgame/catdead.png b/pets/hridyas_catgame/catdead.png
new file mode 100644
index 00000000..d2497894
Binary files /dev/null and b/pets/hridyas_catgame/catdead.png differ
diff --git a/pets/hridyas_catgame/cathappy.bmp b/pets/hridyas_catgame/cathappy.bmp
new file mode 100644
index 00000000..1c60e478
Binary files /dev/null and b/pets/hridyas_catgame/cathappy.bmp differ
diff --git a/pets/hridyas_catgame/cathappy.png b/pets/hridyas_catgame/cathappy.png
new file mode 100644
index 00000000..da91fae3
Binary files /dev/null and b/pets/hridyas_catgame/cathappy.png differ
diff --git a/pets/hridyas_catgame/cathungry.bmp b/pets/hridyas_catgame/cathungry.bmp
new file mode 100644
index 00000000..d0493d49
Binary files /dev/null and b/pets/hridyas_catgame/cathungry.bmp differ
diff --git a/pets/hridyas_catgame/cathungry.png b/pets/hridyas_catgame/cathungry.png
new file mode 100644
index 00000000..af3c4b64
Binary files /dev/null and b/pets/hridyas_catgame/cathungry.png differ
diff --git a/pets/hridyas_catgame/catsick.bmp b/pets/hridyas_catgame/catsick.bmp
new file mode 100644
index 00000000..fd760a79
Binary files /dev/null and b/pets/hridyas_catgame/catsick.bmp differ
diff --git a/pets/hridyas_catgame/catsick.png b/pets/hridyas_catgame/catsick.png
new file mode 100644
index 00000000..d51be727
Binary files /dev/null and b/pets/hridyas_catgame/catsick.png differ
diff --git a/pets/hridyas_catgame/food_icon.bmp b/pets/hridyas_catgame/food_icon.bmp
new file mode 100644
index 00000000..0304c55d
Binary files /dev/null and b/pets/hridyas_catgame/food_icon.bmp differ
diff --git a/pets/hridyas_catgame/food_icon.png b/pets/hridyas_catgame/food_icon.png
new file mode 100644
index 00000000..63e00382
Binary files /dev/null and b/pets/hridyas_catgame/food_icon.png differ
diff --git a/pets/hridyas_catgame/game.py b/pets/hridyas_catgame/game.py
new file mode 100644
index 00000000..e018e936
--- /dev/null
+++ b/pets/hridyas_catgame/game.py
@@ -0,0 +1,290 @@
+import displayio
+from blinka_displayio_pygamedisplay import PyGameDisplay
+import pygame
+import time
+import random
+
+class PetGame:
+    def __init__(self):
+        pygame.init()
+        self.display = PyGameDisplay(width=128, height=128)
+        pygame.display.set_caption("Virtual Pet")
+        
+        self.screen = pygame.display.get_surface()
+        
+        self.main_group = displayio.Group()
+        self.display.show(self.main_group)
+
+        self.background_group = displayio.Group()
+        self.pet_group = displayio.Group()
+        self.candy_group = displayio.Group()
+        self.ui_group = displayio.Group()
+        self.status_bars_group = displayio.Group()
+        
+        self.main_group.append(self.background_group)
+        self.main_group.append(self.pet_group)
+        self.main_group.append(self.candy_group)
+        self.main_group.append(self.status_bars_group)
+        self.main_group.append(self.ui_group)
+
+        self.stats = {
+            "hunger": 100,
+            "health": 100,
+            "happiness": 100,
+            "energy": 100
+        }
+        self.candy_count = 5
+        self.state = "idle"
+        self.is_sleeping = False
+        self.last_stats_update = time.monotonic()
+        self.stats_update_interval = 5.0
+        self.candy_display_time = 2.0
+        self.candies_visible = False
+        self.candy_timestamp = 0
+
+        self._create_background()
+        self._load_pet_sprites()
+        self._load_candy_sprites()
+        self._create_ui()
+        self._create_status_bars()
+    
+    def _create_background(self):
+        bg_bitmap = displayio.Bitmap(128, 128, 1)
+        bg_palette = displayio.Palette(1)
+        bg_palette[0] = 0xADAFE5
+        background = displayio.TileGrid(bg_bitmap, pixel_shader=bg_palette)
+        self.background_group.append(background)
+        floor_bitmap = displayio.Bitmap(128, 38, 1)
+        floor_palette = displayio.Palette(1)
+        floor_palette[0] = 0x6B4226
+        floor = displayio.TileGrid(floor_bitmap, pixel_shader=floor_palette, y=90)
+        self.background_group.append(floor)
+
+    def _load_pet_sprites(self):
+        try:
+            self.pet_states = {
+                "idle": displayio.OnDiskBitmap("cathappy.png"),
+                "happy": displayio.OnDiskBitmap("cathappy.png"),
+                "hungry": displayio.OnDiskBitmap("cathungry.png"),
+                "sick": displayio.OnDiskBitmap("catsick.png"),
+                "sleeping": displayio.OnDiskBitmap("cathappy.png"),
+                "dead": displayio.OnDiskBitmap("catdead.png")
+            }
+            self.pet_sprite = displayio.TileGrid(
+                self.pet_states["idle"],
+                pixel_shader=self.pet_states["idle"].pixel_shader,
+                x=48,
+                y=48
+            )
+            self.pet_group.append(self.pet_sprite)
+        except Exception as e:
+            print(f"Error loading pet sprites: {e}")
+            raise
+
+    def _load_candy_sprites(self):
+        try:
+            self.candy_bitmap = displayio.OnDiskBitmap("candy.png")
+        except Exception as e:
+            print(f"Error loading candy sprites: {e}")
+            raise
+
+    def _create_status_bars(self):
+        hunger_bg = displayio.Bitmap(50, 10, 1)
+        hunger_bg_palette = displayio.Palette(1)
+        hunger_bg_palette[0] = 0x666666
+        self.hunger_bg = displayio.TileGrid(hunger_bg, pixel_shader=hunger_bg_palette, x=5, y=5)
+        
+        self.hunger_bar_bitmap = displayio.Bitmap(48, 8, 1)
+        hunger_palette = displayio.Palette(1)
+        hunger_palette[0] = 0x00FF00
+        self.hunger_bar = displayio.TileGrid(self.hunger_bar_bitmap, 
+                                        pixel_shader=hunger_palette, 
+                                        x=6, y=6)
+        
+        self.status_bars_group.append(self.hunger_bg)
+        self.status_bars_group.append(self.hunger_bar)
+        
+        self.update_status_bars()
+
+    def _create_ui(self):
+        try:
+            self.ui_icons = {
+                "FOOD": displayio.OnDiskBitmap("food_icon.png"),
+                "MED": displayio.OnDiskBitmap("medicine_icon.png"),
+                "SLEEP": displayio.OnDiskBitmap("sleep_icon.png"),
+                "PLAY": displayio.OnDiskBitmap("play_icon.png")
+            }
+            
+            self.buttons = {}
+            positions = [(100, 10), (100, 36), (100, 62), (100, 88)]
+            
+            for pos, (label, icon) in zip(positions, self.ui_icons.items()):
+                button = displayio.TileGrid(
+                    icon,
+                    pixel_shader=icon.pixel_shader,
+                    x=pos[0],
+                    y=pos[1]
+                )
+                self.ui_group.append(button)
+                self.buttons[label] = pygame.Rect(pos[0], pos[1], 16, 16)
+                
+        except Exception as e:
+            print(f"Error creating UI: {e}")
+            raise
+
+    def update_status_bars(self):
+        bar_width = int((48 * self.stats["hunger"]) / 100)
+        for x in range(48):
+            for y in range(8):
+                if x < bar_width:
+                    self.hunger_bar_bitmap[x, y] = 0
+                else:
+                    self.hunger_bar_bitmap[x, y] = 1
+
+    def show_candies(self):
+        if not self.candies_visible and self.candy_count > 0:
+            while len(self.candy_group) > 0:
+                self.candy_group.pop()
+            
+            candy_positions = [
+                (60, 40),
+                (36, 62),
+                (84, 62),
+                (60, 84)
+            ]
+            
+            for base_pos in candy_positions:
+                offset_x = random.randint(-5, 5)
+                offset_y = random.randint(-5, 5)
+                candy = displayio.TileGrid(
+                    self.candy_bitmap,
+                    pixel_shader=self.candy_bitmap.pixel_shader,
+                    x=base_pos[0] + offset_x,
+                    y=base_pos[1] + offset_y
+                )
+                self.candy_group.append(candy)
+            
+            self.candies_visible = True
+            self.candy_timestamp = time.monotonic()
+            self.candy_count -= 1
+            self.update_status_bars()
+
+    def hide_candies(self):
+        while len(self.candy_group) > 0:
+            self.candy_group.pop()
+        self.candies_visible = False
+
+    def update_stats(self):
+        current_time = time.monotonic()
+        stats_updated = False
+        
+        if current_time - self.last_stats_update > self.stats_update_interval:
+            if not self.is_sleeping:
+                self.stats["hunger"] = max(0, self.stats["hunger"] - 2)
+                self.stats["happiness"] = max(0, self.stats["happiness"] - 1)
+                self.stats["energy"] = max(0, self.stats["energy"] - 2)
+                
+                if self.stats["hunger"] < 30:
+                    self.stats["health"] = max(0, self.stats["health"] - 2)
+                
+                if self.stats["energy"] < 20:
+                    self.stats["health"] = max(0, self.stats["health"] - 1)
+            else:
+                self.stats["energy"] = min(100, self.stats["energy"] + 4)
+                if self.stats["energy"] >= 100:
+                    self.is_sleeping = False
+                    
+            self.last_stats_update = current_time
+            stats_updated = True
+
+        if self.candies_visible and current_time - self.candy_timestamp > self.candy_display_time:
+            self.hide_candies()
+            
+        if stats_updated:
+            self.update_status_bars()
+
+    def update_state(self):
+        if self.stats["health"] <= 0:
+            return "dead"
+        elif self.is_sleeping:
+            return "sleeping"
+        elif self.stats["hunger"] < 30:
+            return "hungry"
+        elif self.stats["health"] < 50:
+            return "sick"
+        elif self.stats["happiness"] < 30:
+            return "hungry"
+        elif self.stats["happiness"] > 80:
+            return "happy"
+        return "idle"
+
+    def handle_input(self, pos):
+        if self.state == "dead":
+            return
+            
+        x, y = pos
+        for label, rect in self.buttons.items():
+            if rect.collidepoint(x, y):
+                self.activate_button(label)
+
+    def activate_button(self, label):
+        if self.state == "dead":
+            return
+        if label == "FOOD" and not self.is_sleeping and self.candy_count > 0:
+            self.stats["hunger"] = min(100, self.stats["hunger"] + 30)
+            self.show_candies()
+            self.update_status_bars()
+        elif label == "MED" and not self.is_sleeping:
+            self.stats["health"] = min(100, self.stats["health"] + 20)
+        elif label == "PLAY" and not self.is_sleeping:
+            self.stats["happiness"] = min(100, self.stats["happiness"] + 25)
+            self.stats["energy"] = max(0, self.stats["energy"] - 10)
+        elif label == "SLEEP":
+            self.is_sleeping = not self.is_sleeping
+
+    def run(self):
+        clock = pygame.time.Clock()
+        running = True
+        self.display.refresh()
+        pygame.display.flip()
+        
+        while running:
+            time.sleep(0.1)
+            
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    running = False
+                elif event.type == pygame.MOUSEBUTTONDOWN:
+                    self.handle_input(event.pos)
+                elif event.type == pygame.KEYDOWN:
+                    if event.key == pygame.K_1:
+                        self.activate_button("FOOD")
+                    elif event.key == pygame.K_2:
+                        self.activate_button("MED")
+                    elif event.key == pygame.K_3:
+                        self.activate_button("SLEEP")
+                    elif event.key == pygame.K_4:
+                        self.activate_button("PLAY")
+
+            self.update_stats()
+            new_state = self.update_state()
+            
+            if new_state != self.state:
+                self.state = new_state
+                self.pet_group.pop()
+                new_pet = displayio.TileGrid(
+                    self.pet_states[self.state],
+                    pixel_shader=self.pet_states[self.state].pixel_shader,
+                    x=48,
+                    y=62
+                )
+                self.pet_group.append(new_pet)
+            
+            self.display.refresh()
+            pygame.display.flip()
+
+        pygame.quit()
+
+if __name__ == "__main__":
+    game = PetGame()
+    game.run()
\ No newline at end of file
diff --git a/pets/hridyas_catgame/main.py b/pets/hridyas_catgame/main.py
new file mode 100644
index 00000000..9820850d
--- /dev/null
+++ b/pets/hridyas_catgame/main.py
@@ -0,0 +1,199 @@
+import displayio
+from blinka_displayio_pygamedisplay import PyGameDisplay
+import pygame
+import time
+
+class PetGame:
+    def __init__(self):
+        pygame.init()
+        self.display = PyGameDisplay(width=128, height=128)
+        pygame.display.set_caption("Virtual Pet")
+        
+        self.screen = pygame.display.get_surface()
+        
+        self.main_group = displayio.Group()
+        self.display.show(self.main_group)
+
+        self.background_group = displayio.Group()
+        self.pet_group = displayio.Group()
+        self.ui_group = displayio.Group()
+        self.main_group.append(self.background_group)
+        self.main_group.append(self.pet_group)
+        self.main_group.append(self.ui_group)
+
+        self._create_background()
+        self._load_pet_sprites()
+        self._create_ui()
+
+        self.stats = {
+            "hunger": 100,
+            "health": 100,
+            "happiness": 100,
+            "energy": 100
+        }
+        self.state = "idle"
+        self.is_sleeping = False
+        self.last_stats_update = time.monotonic()
+        self.stats_update_interval = 5.0
+
+    def _create_background(self):
+        bg_bitmap = displayio.Bitmap(128, 128, 1)
+        bg_palette = displayio.Palette(1)
+        bg_palette[0] = 0xADAFE5
+        background = displayio.TileGrid(bg_bitmap, pixel_shader=bg_palette)
+        self.background_group.append(background)
+        floor_bitmap = displayio.Bitmap(128, 38, 1)
+        floor_palette = displayio.Palette(1)
+        floor_palette[0] = 0x6B4226
+        floor = displayio.TileGrid(floor_bitmap, pixel_shader=floor_palette, y=90)
+        self.background_group.append(floor)
+
+    def _load_pet_sprites(self):
+        try:
+            self.pet_states = {
+                "idle": displayio.OnDiskBitmap("cathappy.bmp"),
+                "happy": displayio.OnDiskBitmap("cathappy.bmp"),
+                "hungry": displayio.OnDiskBitmap("cathungry.bmp"),
+                "sick": displayio.OnDiskBitmap("catsick.bmp"),
+                "sleeping": displayio.OnDiskBitmap("cathappy.bmp"),
+                "dead": displayio.OnDiskBitmap("catdead.bmp")
+            }
+            self.pet_sprite = displayio.TileGrid(
+                self.pet_states["idle"],
+                pixel_shader=self.pet_states["idle"].pixel_shader,
+                x=48,
+                y=48
+            )
+            self.pet_group.append(self.pet_sprite)
+        except Exception as e:
+            print(f"Error loading pet sprites: {e}")
+            raise
+
+    def _create_ui(self):
+        try:
+            self.ui_icons = {
+                "FOOD": displayio.OnDiskBitmap("food_icon.bmp"),
+                "MED": displayio.OnDiskBitmap("medicine_icon.bmp"),
+                "SLEEP": displayio.OnDiskBitmap("sleep_icon.bmp"),
+                "PLAY": displayio.OnDiskBitmap("play_icon.bmp")
+            }
+            
+            self.buttons = {}
+            positions = [(100, 10), (100, 36), (100, 62), (100, 88)]
+            
+            for pos, (label, icon) in zip(positions, self.ui_icons.items()):
+                button = displayio.TileGrid(
+                    icon,
+                    pixel_shader=icon.pixel_shader,
+                    x=pos[0],
+                    y=pos[1]
+                )
+                self.ui_group.append(button)
+                self.buttons[label] = pygame.Rect(pos[0], pos[1], 16, 16)
+                
+        except Exception as e:
+            print(f"Error creating UI: {e}")
+            raise
+
+    def update_stats(self):
+        current_time = time.monotonic()
+        if current_time - self.last_stats_update > self.stats_update_interval:
+            if not self.is_sleeping:
+                self.stats["hunger"] = max(0, self.stats["hunger"] - 2)
+                self.stats["happiness"] = max(0, self.stats["happiness"] - 1)
+                self.stats["energy"] = max(0, self.stats["energy"] - 2)
+                
+                if self.stats["hunger"] < 30:
+                    self.stats["health"] = max(0, self.stats["health"] - 2)
+                
+                if self.stats["energy"] < 20:
+                    self.stats["health"] = max(0, self.stats["health"] - 1)
+            else:
+                self.stats["energy"] = min(100, self.stats["energy"] + 4)
+                if self.stats["energy"] >= 100:
+                    self.is_sleeping = False
+                    
+            self.last_stats_update = current_time
+
+    def update_state(self):
+        if self.stats["health"] <= 0:
+            return "dead"
+        elif self.is_sleeping:
+            return "sleeping"
+        elif self.stats["hunger"] < 30:
+            return "hungry"
+        elif self.stats["health"] < 50:
+            return "sick"
+        elif self.stats["happiness"] < 30:
+            return "hungry"
+        elif self.stats["happiness"] > 80:
+            return "happy"
+        return "idle"
+
+    def handle_input(self, pos):
+        if self.state == "dead":
+            return
+            
+        x, y = pos
+        for label, rect in self.buttons.items():
+            if rect.collidepoint(x, y):
+                self.activate_button(label)
+
+    def activate_button(self, label):
+        if self.state == "dead":
+            return
+        if label == "FOOD" and not self.is_sleeping:
+            self.stats["hunger"] = min(100, self.stats["hunger"] + 30)
+        elif label == "MED" and not self.is_sleeping:
+            self.stats["health"] = min(100, self.stats["health"] + 20)
+        elif label == "PLAY" and not self.is_sleeping:
+            self.stats["happiness"] = min(100, self.stats["happiness"] + 25)
+            self.stats["energy"] = max(0, self.stats["energy"] - 10)
+        elif label == "SLEEP":
+            self.is_sleeping = not self.is_sleeping
+
+    def run(self):
+        clock = pygame.time.Clock()
+        running = True
+        self.display.refresh()
+        pygame.display.flip()
+        
+        while running:
+            time.sleep(0.1)
+            
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    running = False
+                elif event.type == pygame.MOUSEBUTTONDOWN:
+                    self.handle_input(event.pos)
+                elif event.type == pygame.KEYDOWN:
+                    if event.key == pygame.K_1:
+                        self.activate_button("FOOD")
+                    elif event.key == pygame.K_2:
+                        self.activate_button("MED")
+                    elif event.key == pygame.K_3:
+                        self.activate_button("SLEEP")
+                    elif event.key == pygame.K_4:
+                        self.activate_button("PLAY")
+
+            self.update_stats()
+            new_state = self.update_state()
+            
+            if new_state != self.state:
+                self.state = new_state
+                self.pet_group.pop()
+                new_pet = displayio.TileGrid(
+                    self.pet_states[self.state],
+                    pixel_shader=self.pet_states[self.state].pixel_shader,
+                    x=48,
+                    y=48
+                )
+                self.pet_group.append(new_pet)
+                self.display.refresh()
+                pygame.display.flip()
+
+        pygame.quit()
+
+if __name__ == "__main__":
+    game = PetGame()
+    game.run()
diff --git a/pets/hridyas_catgame/medicine_icon.bmp b/pets/hridyas_catgame/medicine_icon.bmp
new file mode 100644
index 00000000..001d2f05
Binary files /dev/null and b/pets/hridyas_catgame/medicine_icon.bmp differ
diff --git a/pets/hridyas_catgame/medicine_icon.png b/pets/hridyas_catgame/medicine_icon.png
new file mode 100644
index 00000000..8fcffb84
Binary files /dev/null and b/pets/hridyas_catgame/medicine_icon.png differ
diff --git a/pets/hridyas_catgame/play_icon.bmp b/pets/hridyas_catgame/play_icon.bmp
new file mode 100644
index 00000000..5c1cea99
Binary files /dev/null and b/pets/hridyas_catgame/play_icon.bmp differ
diff --git a/pets/hridyas_catgame/play_icon.png b/pets/hridyas_catgame/play_icon.png
new file mode 100644
index 00000000..4f3aaeb3
Binary files /dev/null and b/pets/hridyas_catgame/play_icon.png differ
diff --git a/pets/hridyas_catgame/port.py b/pets/hridyas_catgame/port.py
new file mode 100644
index 00000000..73518f7c
--- /dev/null
+++ b/pets/hridyas_catgame/port.py
@@ -0,0 +1,194 @@
+import time
+import board
+import displayio
+import digitalio
+from adafruit_display_text import label
+import terminalio
+
+display = board.DISPLAY
+
+main_group = displayio.Group()
+display.show(main_group)
+
+class Buttons:
+    def __init__(self):
+        self.btn_a = digitalio.DigitalInOut(board.BUTTON_A)
+        self.btn_a.switch_to_input(pull=digitalio.Pull.DOWN)
+        self.btn_b = digitalio.DigitalInOut(board.BUTTON_B)
+        self.btn_b.switch_to_input(pull=digitalio.Pull.DOWN)
+        self.btn_c = digitalio.DigitalInOut(board.BUTTON_C)
+        self.btn_c.switch_to_input(pull=digitalio.Pull.DOWN)
+        
+        self.last_press = time.monotonic()
+        self.debounce = 0.3
+
+    def check_press(self, button):
+        if time.monotonic() - self.last_press > self.debounce:
+            if button.value:
+                self.last_press = time.monotonic()
+                return True
+        return False
+
+buttons = Buttons()
+
+class VirtualPet:
+    def __init__(self):
+        self.background_group = displayio.Group()
+        self.pet_group = displayio.Group()
+        self.ui_group = displayio.Group()
+        
+        main_group.append(self.background_group)
+        main_group.append(self.pet_group)
+        main_group.append(self.ui_group)
+        
+        self._create_background()
+        self._load_pet_sprites()
+        self._create_status_bar()
+
+        self.stats = {
+            "hunger": 100,
+            "health": 100,
+            "happiness": 100,
+            "energy": 100
+        }
+        self.state = "idle"
+        self.is_sleeping = False
+        self.last_stats_update = time.monotonic()
+        self.stats_update_interval = 5.0
+        
+        self.c_pressed = False
+        self.c_press_start = 0
+        self.long_press_duration = 1.0
+
+    def _create_background(self):
+        color_bitmap = displayio.Bitmap(display.width, display.height, 1)
+        color_palette = displayio.Palette(1)
+        color_palette[0] = 0xADAFE5
+        bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette)
+        self.background_group.append(bg_sprite)
+        floor_bitmap = displayio.Bitmap(display.width, 30, 1)
+        floor_palette = displayio.Palette(1)
+        floor_palette[0] = 0x6B4226
+        floor = displayio.TileGrid(floor_bitmap, pixel_shader=floor_palette, y=display.height-30)
+        self.background_group.append(floor)
+
+    def _load_pet_sprites(self):
+        self.pet_states = {
+            "idle": "cathappy.bmp",
+            "happy": "cathappy.bmp",
+            "hungry": "cathungry.bmp",
+            "sick": "catsick.bmp",
+            "sleeping": "cathungry.bmp",
+            "dead": "catdead.bmp"
+        }
+        self.current_pet = displayio.OnDiskBitmap(self.pet_states["idle"])
+        self.pet_sprite = displayio.TileGrid(
+            self.current_pet,
+            pixel_shader=self.current_pet.pixel_shader,
+            x=display.width//2 - 16,
+            y=display.height//2 - 16
+        )
+        self.pet_group.append(self.pet_sprite)
+
+    def _create_status_bar(self):
+        self.status_label = label.Label(
+            font=terminalio.FONT,
+            text="H:100 Hl:100 Ha:100 E:100",
+            color=0xFFFFFF,
+            x=4,
+            y=display.height - 8
+        )
+        self.ui_group.append(self.status_label)
+
+    def update_pet_sprite(self, state):
+        self.pet_group.remove(self.pet_sprite)
+        self.current_pet = displayio.OnDiskBitmap(self.pet_states[state])
+        self.pet_sprite = displayio.TileGrid(
+            self.current_pet,
+            pixel_shader=self.current_pet.pixel_shader,
+            x=display.width//2 - 16,
+            y=display.height//2 - 16
+        )
+        self.pet_group.append(self.pet_sprite)
+
+    def update_stats(self):
+        current_time = time.monotonic()
+        if current_time - self.last_stats_update > self.stats_update_interval:
+            if not self.is_sleeping:
+                self.stats["hunger"] = max(0, self.stats["hunger"] - 2)
+                self.stats["happiness"] = max(0, self.stats["happiness"] - 1)
+                self.stats["energy"] = max(0, self.stats["energy"] - 2)
+                
+                if self.stats["hunger"] < 30:
+                    self.stats["health"] = max(0, self.stats["health"] - 2)
+                
+                if self.stats["energy"] < 20:
+                    self.stats["health"] = max(0, self.stats["health"] - 1)
+            else:
+                self.stats["energy"] = min(100, self.stats["energy"] + 4)
+                if self.stats["energy"] >= 100:
+                    self.is_sleeping = False
+                    
+            self.last_stats_update = current_time
+            self._update_status()
+
+    def _update_status(self):
+        self.status_label.text = (
+            f"H:{self.stats['hunger']} Hl:{self.stats['health']} "
+            f"Ha:{self.stats['happiness']} E:{self.stats['energy']}"
+        )
+
+    def check_state(self):
+        if self.stats["health"] <= 0:
+            return "dead"
+        if self.is_sleeping:
+            return "sleeping"
+        if self.stats["hunger"] < 30:
+            return "hungry"
+        if self.stats["health"] < 50:
+            return "sick"
+        if self.stats["happiness"] < 30:
+            return "hungry"
+        if self.stats["happiness"] > 80:
+            return "happy"
+        return "idle"
+
+    def handle_input(self):
+        if buttons.check_press(buttons.btn_a) and not self.is_sleeping:
+            self.stats["hunger"] = min(100, self.stats["hunger"] + 30)
+                
+        if buttons.check_press(buttons.btn_b) and not self.is_sleeping:
+            self.stats["health"] = min(100, self.stats["health"] + 20)
+        
+        if buttons.btn_c.value:
+            if not self.c_pressed:
+                self.c_pressed = True
+                self.c_press_start = time.monotonic()
+            else:
+                if (time.monotonic() - self.c_press_start >= 
+                    self.long_press_duration):
+                    self.is_sleeping = not self.is_sleeping
+                    self.c_pressed = False
+        else:
+            if self.c_pressed:
+                if (time.monotonic() - self.c_press_start < 
+                    self.long_press_duration):
+                    if not self.is_sleeping:
+                        self.stats["happiness"] = min(100, self.stats["happiness"] + 25)
+                        self.stats["energy"] = max(0, self.stats["energy"] - 10)
+                self.c_pressed = False
+
+    def run(self):
+        while True:
+            self.handle_input()
+            self.update_stats()
+            
+            new_state = self.check_state()
+            if new_state != self.state:
+                self.state = new_state
+                self.update_pet_sprite(self.state)
+            
+            time.sleep(0.1)
+
+pet_game = VirtualPet()
+pet_game.run()
diff --git a/pets/hridyas_catgame/sleep_icon.bmp b/pets/hridyas_catgame/sleep_icon.bmp
new file mode 100644
index 00000000..4eec0fdc
Binary files /dev/null and b/pets/hridyas_catgame/sleep_icon.bmp differ
diff --git a/pets/hridyas_catgame/sleep_icon.png b/pets/hridyas_catgame/sleep_icon.png
new file mode 100644
index 00000000..3b32c68b
Binary files /dev/null and b/pets/hridyas_catgame/sleep_icon.png differ