Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,269 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+import cv2
 import streamlit as st
+import numpy as np
+import time
+import random
+import mediapipe as mp
+import math
+
+# Declare all global variables upfront
+global last_spawn_time
+last_spawn_time = 0  # Initialize the global variable before any other usage
+
+
+@st.cache_data
+def load_image(path):
+    img = cv2.imread(path, cv2.IMREAD_UNCHANGED)
+    if img is None:
+        raise FileNotFoundError(f"Image not found or invalid at path: {path}")
+    return img  # Keep in BGRA format
+
+
+# Load images
+apple_img = load_image("apple.png")
+banana_img = load_image("banana.png")
+watermelon_img = load_image("watermelon.png")
+bomb_img = load_image("bomb.png")
+
+# Define fruit properties
+fruit_map = {
+    "apple": {"img": apple_img, "points": 100, "size": 40, "color": (0, 0, 255)},
+    "banana": {"img": banana_img, "points": 150, "size": 50, "color": (0, 255, 255)},
+    "watermelon": {"img": watermelon_img, "points": 200, "size": 70, "color": (0, 255, 0)},
+}
+
+# Constants and Variables
+SLASH_LENGTH = 15
+LIVES = 3
+SPAWN_INTERVAL = 1.2
+
+fruits, splashes, explosions = [], [], []
+score, lives = 0, LIVES
+last_slice_time = 0
+slash_points = []
+slash_color = (255, 255, 255)
+combo_count, combo_multiplier = 0, 1
+combo_time_limit = 2
+combo_message = ""
+
+mp_hands = mp.solutions.hands
+hands = mp_hands.Hands(
+    static_image_mode=False,
+    max_num_hands=1,
+    model_complexity=1,
+    min_detection_confidence=0.5,
+)
+
+
+def overlay_image_alpha(background, overlay, pos, overlay_size):
+    x, y = pos
+    overlay = cv2.resize(overlay, overlay_size)
+
+    # Ensure the overlay image has an alpha channel
+    if overlay.shape[2] != 4:
+        raise ValueError(f"Overlay image must have 4 channels but has {overlay.shape[2]}!")
+
+    b, g, r, a = cv2.split(overlay)
+    overlay_rgb = cv2.merge((b, g, r))
+    mask = a / 255.0  # Normalize alpha channel
+
+    h, w = overlay.shape[:2]
+
+    # Validate dimensions to avoid out-of-bounds errors
+    if x < 0 or y < 0 or y + h > background.shape[0] or x + w > background.shape[1]:
+        # Do not overlay if it goes out of bounds
+        return
+
+    roi = background[y:y + h, x:x + w]
+    for c in range(3):
+        roi[:, :, c] = (1.0 - mask) * roi[:, :, c] + mask * overlay_rgb[:, :, c]
+
+    background[y:y + h, x:x + w] = roi
+
+
+def distance(a, b):
+    return int(math.hypot(a[0] - b[0], a[1] - b[1]))
+
+
+def spawn_fruit():
+    x = random.randint(50, 600)
+    is_bomb = random.random() < 0.2
+    fruit = {
+        "pos": [x, 600],
+        "vel": [random.randint(-4, 4), -random.randint(13, 18)],
+        "size": 40,
+        "bomb": is_bomb,
+        "img": bomb_img if is_bomb else None,
+        "points": 0,
+        "color": (255, 255, 255),
+    }
+    if not is_bomb:
+        kind = random.choice(list(fruit_map.keys()))
+        f = fruit_map[kind]
+        fruit.update({"img": f["img"], "points": f["points"], "size": f["size"], "color": f["color"], "kind": kind})
+    else:
+        fruit["kind"] = "bomb"
+    fruits.append(fruit)
+
+
+def move_fruits():
+    global lives
+    for fruit in fruits[:]:
+        fruit["vel"][1] += 0.5
+        fruit["pos"][0] += fruit["vel"][0]
+        fruit["pos"][1] += fruit["vel"][1]
+        if fruit["pos"][1] > 700:
+            if not fruit["bomb"]:
+                lives -= 1
+            fruits.remove(fruit)
+
+
+def add_splash(pos, color):
+    for _ in range(10):
+        splashes.append({
+            "pos": [pos[0] + random.randint(-10, 10), pos[1] + random.randint(-10, 10)],
+            "vel": [random.uniform(-3, 3), random.uniform(-3, 3)],
+            "radius": random.randint(3, 6),
+            "color": color,
+            "life": 15,
+        })
+
+
+def add_explosion(pos):
+    for _ in range(30):
+        explosions.append({
+            "pos": [pos[0], pos[1]],
+            "vel": [random.uniform(-5, 5), random.uniform(-5, 5)],
+            "radius": random.randint(5, 10),
+            "color": (255, 255, 255),
+            "life": 20,
+        })
+
+
+def update_effects(img):
+    for s in splashes[:]:
+        s["pos"][0] += s["vel"][0]
+        s["pos"][1] += s["vel"][1]
+        s["life"] -= 1
+        alpha = s["life"] / 15
+        cv2.circle(img, (int(s["pos"][0]), int(s["pos"][1])), s["radius"], tuple(int(c * alpha) for c in s["color"]),
+                   -1)
+        if s["life"] <= 0:
+            splashes.remove(s)
+
+    for e in explosions[:]:
+        e["pos"][0] += e["vel"][0]
+        e["pos"][1] += e["vel"][1]
+        e["life"] -= 1
+        alpha = e["life"] / 20
+        cv2.circle(img, (int(e["pos"][0]), int(e["pos"][1])), e["radius"], tuple(int(c * alpha) for c in e["color"]),
+                   -1)
+        if e["life"] <= 0:
+            explosions.remove(e)
+
+
+def check_slices(index_pos):
+    global score, lives, slash_color, combo_count, combo_multiplier, combo_message, last_slice_time
+    combo_scored = False
+    for fruit in fruits[:]:
+        d = distance(index_pos, fruit["pos"])
+        if d < fruit["size"]:
+            if fruit["bomb"]:
+                lives -= 1
+                add_explosion(fruit["pos"])
+                fruits.clear()
+                splashes.clear()
+                return
+            else:
+                score += fruit["points"] * combo_multiplier
+                add_splash(fruit["pos"], fruit["color"])
+                fruits.remove(fruit)
+                combo_scored = True
+    if combo_scored:
+        if time.time() - last_slice_time <= combo_time_limit:
+            combo_count += 1
+            combo_multiplier = 1 + (combo_count // 2)
+            combo_message = f"{combo_multiplier}x Combo!"
+        else:
+            combo_count = 1
+            combo_multiplier = 1
+            combo_message = ""
+        last_slice_time = time.time()
+
+
+def draw_fruits(img):
+    for fruit in fruits:
+        if fruit.get("img") is None or fruit.get("size") is None:
+            continue  # Skip if image or size is invalid
+
+        x, y = int(fruit["pos"][0]), int(fruit["pos"][1])
+        size = fruit["size"] * 2
+        overlay_image_alpha(img, fruit["img"], (x - size // 2, y - size // 2), (size, size))
+
+
+def draw_slash(img, index_pos):
+    global slash_points
+    slash_points.append(index_pos)
+    if len(slash_points) > SLASH_LENGTH:
+        slash_points.pop(0)
+    if len(slash_points) > 1:
+        pts = np.array(slash_points, np.int32).reshape((-1, 1, 2))
+        cv2.polylines(img, [pts], False, slash_color, 15)
+
+
+def draw_ui(img, fps):
+    h, w = img.shape[:2]
+    cv2.putText(img, f"Score: {score}", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)
+    cv2.putText(img, f"Lives: {lives}", (10, 90), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+    cv2.putText(img, f"FPS: {int(fps)}", (w - 120, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+    if combo_message:
+        cv2.putText(img, combo_message, (w // 3, 90), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 255, 0), 3)
+
+
+# Streamlit UI
+st.title("Fruit Ninja in Streamlit 🍉")
+run_game = st.button("Start Game")
+frame_placeholder = st.empty()
+
+if run_game:
+    cap = cv2.VideoCapture(0)
+    prev_time = time.time()
+    last_spawn_time = time.time()  # Global variable used here
+
+    while cap.isOpened() and lives > 0:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        frame = cv2.flip(frame, 1)
+        frame = cv2.convertScaleAbs(frame, alpha=1.2, beta=30)  # Improve brightness and contrast
+
+        h, w, _ = frame.shape
+        img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = hands.process(img_rgb)
+
+        index_pos = None
+        if results.multi_hand_landmarks:
+            lm = results.multi_hand_landmarks[0].landmark[8]
+            index_pos = (int(lm.x * w), int(lm.y * h))
+            check_slices(index_pos)
+            draw_slash(frame, index_pos)
+
+        # Spawn fruit
+        if time.time() - last_spawn_time > SPAWN_INTERVAL:
+            spawn_fruit()
+            last_spawn_time = time.time()
+
+        move_fruits()
+        draw_fruits(frame)
+        update_effects(frame)
+
+        curr_time = time.time()
+        fps = 1 / (curr_time - prev_time)
+        prev_time = curr_time
+        draw_ui(frame, fps)
+
+        frame_placeholder.image(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), channels="RGB")
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+    cap.release()
+    st.write("Game Over! Your score:", score)