Update app.py

app.py

@@ -1,9 +1,8 @@
-# app.py
 import gradio as gr
 import random
 import time
 
-# ---------------- Config / Data ----------------
+# ---------------- Cấu hình dữ liệu ----------------
 MONSTERS = [
     {"id":"slime","name":"Slime","base_hp":30,"xp":10,"gold":5, "arise":0.7},
     {"id":"goblin","name":"Goblin","base_hp":45,"xp":18,"gold":12, "arise":0.5},
@@ -27,13 +26,11 @@ CARDS_POOL = [
     {"name":"Mana Bloom","desc":"Tăng mana regen","apply": lambda s: s.update({"mana_regen": s.get("mana_regen",0.0)+0.5})},
 ]
 
-# ---------------- Helpers ----------------
+# ---------------- Hàm phụ trợ ----------------
 def choose_monster_for_floor(floor):
-    """Scale monster by floor: higher floor -> rarer monsters"""
     pool = []
     for m in MONSTERS:
         weight = 1.0
-        # basic scaling: dragons/kings rarer but appear at high floors
         if m["id"] in ("slime","goblin"):
             weight = max(1.0, 6 - floor//2)
         else:
@@ -50,35 +47,29 @@ def choose_monster_for_floor(floor):
 
 def fmt_status(state):
     p = state["player"]
-    s = f"Cấp {p['level']} · HP {p['hp']}/{p['hp_max']} · XP {p['xp']}/{p['xp_needed']} · Vàng {p['gold']} · Pet: {p['pet']['name'] if p['pet'] else 'Không'}"
-    return s
+    return f"Cấp {p['level']} · HP {p['hp']}/{p['hp_max']} · XP {p['xp']}/{p['xp_needed']} · Vàng {p['gold']} · Pet: {p['pet']['name'] if p['pet'] else 'Không'}"
 
 def add_log(state, text):
     state["log"].append(f"[{time.strftime('%H:%M:%S')}] {text}")
-    if len(state["log"])>200: state["log"].pop(0)
+    if len(state["log"]) > 200:
+        state["log"].pop(0)
 
-# ---------------- Initialize state ----------------
 def default_state():
     return {
-        "player":{
+        "player": {
             "level":1, "xp":0, "hp_max":100, "hp":100, "attack":10, "gold":50,
             "hp_regen":0.0, "mana":50, "mana_max":50,
             "xp_needed":100, "skills":[], "pet": None
         },
-        "dungeon": {
-            "in_dungeon": False,
-            "dungeon_name": None,
-            "floor": 0,
-            "monster": None,
-        },
-        "farm": {
-            "plots": [],  # each: {"seed_id":..., "ready_at":time_offset, "mutated":False, "quality":...}
-        },
+        "dungeon": {"in_dungeon": False, "dungeon_name": None, "floor": 0, "monster": None},
+        "farm": {"plots": []},
         "shop": {"seeds": SEEDS},
         "log": [],
+        "inventory": [],
+        "pending_cards": []
     }
 
-# ---------------- Game actions ----------------
+# ---------------- Game logic ----------------
 def start_dungeon(state, dungeon_name):
     state["dungeon"]["in_dungeon"] = True
     state["dungeon"]["dungeon_name"] = dungeon_name
@@ -91,48 +82,34 @@ def start_dungeon(state, dungeon_name):
 
 def attack(state):
     if not state["dungeon"]["in_dungeon"]:
-        add_log(state, "Bạn chưa vào phó bản. Vui lòng chọn 'Chọn phó bản'.")
+        add_log(state, "Bạn chưa vào phó bản.")
         return fmt_status(state), "\n".join(state["log"][-10:])
     m = state["dungeon"]["monster"]
     p = state["player"]
-    # pet assists
-    pet_bonus = 0
-    if p["pet"]:
-        pet_bonus = p["pet"]["attack"]//2
+    pet_bonus = p["pet"]["attack"]//2 if p["pet"] else 0
     dmg = random.randint(max(1,p["attack"]-3), p["attack"]+3) + pet_bonus
     m["hp"] -= dmg
-    add_log(state, f"Bạn tấn công {m['name']} gây {dmg} sát thương. (Pet +{pet_bonus})")
+    add_log(state, f"Tấn công {m['name']} gây {dmg} sát thương. (Pet +{pet_bonus})")
     if m["hp"] <= 0:
         xp = m["xp"] + state["dungeon"]["floor"]*2
         gold = m["gold"] + state["dungeon"]["floor"]
         p["xp"] += xp
         p["gold"] += gold
-        add_log(state, f"{m['name']} bị hạ! +{xp} XP, +{gold} gold.")
-        # chance to arise as pet (on boss floors)
-        if state["dungeon"]["floor"] == 10:
-            ar = m.get("arise", 0.0)
-            if random.random() < ar:
-                pet = {"name": f"Pet {m['name']}", "attack": max(3, m["base_hp"]//10), "tier":"common"}
-                p["pet"] = pet
-                add_log(state, f"✨ {m['name']} đã arise! Trở thành pet của bạn: {pet['name']}")
-        # next floor
+        add_log(state, f"{m['name']} bị hạ! +{xp} XP, +{gold} vàng.")
+        if state["dungeon"]["floor"] == 10 and random.random() < m.get("arise", 0.0):
+            pet = {"name": f"Pet {m['name']}", "attack": max(3, m["base_hp"]//10), "tier":"common"}
+            p["pet"] = pet
+            add_log(state, f"✨ {m['name']} đã arise! Trở thành pet: {pet['name']}")
         if state["dungeon"]["floor"] >= 10:
-            # finished dungeon
             add_log(state, f"Hoàn thành phó bản {state['dungeon']['dungeon_name']}! Về thị trấn.")
-            state["dungeon"]["in_dungeon"] = False
-            state["dungeon"]["monster"] = None
-            state["dungeon"]["floor"] = 0
-            # back to town: minor heal
+            state["dungeon"] = {"in_dungeon": False, "dungeon_name": None, "floor": 0, "monster": None}
             p["hp"] = min(p["hp_max"], p["hp"] + 20)
         else:
-            # go to next floor
             state["dungeon"]["floor"] += 1
             m2 = choose_monster_for_floor(state["dungeon"]["floor"])
-            m2["hp"] = m2["base_hp"] + state["player"]["level"]*3 + state["dungeon"]["floor"]*2
+            m2["hp"] = m2["base_hp"] + p["level"]*3 + state["dungeon"]["floor"]*2
             state["dungeon"]["monster"] = m2
-            add_log(state, f"Bước sang tầng {state['dungeon']['floor']}. Quái: {m2['name']}")
-        # check level up
-        level_up_msgs = ""
+            add_log(state, f"Tầng {state['dungeon']['floor']}: Quái {m2['name']}")
         while p["xp"] >= p["xp_needed"]:
             p["xp"] -= p["xp_needed"]
             p["level"] += 1
@@ -140,189 +117,20 @@ def attack(state):
             p["attack"] += 2
             p["hp"] = p["hp_max"]
             p["xp_needed"] = int(p["xp_needed"] * 1.4)
-            add_log(state, f"⭐ Bạn đã lên cấp {p['level']}! Chọn 1 thẻ bài.")
-            level_up_msgs += "LEVEL_UP\n"
+            add_log(state, f"⭐ Lên cấp {p['level']}! Chọn 1 thẻ bài.")
         return fmt_status(state), "\n".join(state["log"][-12:])
     else:
-        # monster attacks back
-        mdmg = random.randint(max(1, m["xp"]//6), max(1, m["xp"]//4))
-        # small scale with floor
-        mdmg = int(mdmg + state["dungeon"]["floor"]/2)
+        mdmg = random.randint(max(1, m["xp"]//6), max(1, m["xp"]//4)) + int(state["dungeon"]["floor"]/2)
         p["hp"] -= mdmg
         add_log(state, f"{m['name']} phản công gây {mdmg} sát thương!")
         if p["hp"] <= 0:
-            add_log(state, "⚠️ Bạn đã tử vong! Quay về thị trấn và mất 10% vàng.")
+            add_log(state, "⚠️ Bạn đã tử vong! Mất 10% vàng.")
             p["hp"] = int(p["hp_max"]*0.6)
             p["gold"] = max(0, int(p["gold"]*0.9))
-            state["dungeon"]["in_dungeon"] = False
-            state["dungeon"]["monster"] = None
-            state["dungeon"]["floor"] = 0
+            state["dungeon"] = {"in_dungeon": False, "dungeon_name": None, "floor": 0, "monster": None}
         return fmt_status(state), "\n".join(state["log"][-12:])
 
 def choose_card_flow(state):
-    # produce 3 random cards (copies)
     pick = random.sample(CARDS_POOL, 3)
     state["pending_cards"] = pick
-    add_log(state, "Hiện 3 thẻ bài ngẫu nhiên - chọn 1 thẻ để áp dụng.")
-    return [f"{c['name']}: {c['desc']}" for c in pick], "\n".join(state["log"][-8:])
-
-def apply_card(state, idx):
-    pick = state.get("pending_cards")
-    if not pick or idx<0 or idx>=len(pick):
-        return "Không có thẻ để chọn.", "\n".join(state["log"][-6:])
-    card = pick[idx]
-    # apply card effect by calling its lambda (we store callable in pool)
-    # Note: CARDS_POOL entries have apply: lambda s: s.update(...)
-    # Here pick's item is same object
-    try:
-        card["apply"](state["player"])
-        state["player"]["skills"].append(card["name"])
-    except Exception as e:
-        add_log(state, f"Lỗi khi áp dụng thẻ: {e}")
-    add_log(state, f"Bạn chọn thẻ: {card['name']}. Hiệu ứng đã áp dụng.")
-    state["pending_cards"] = []
-    return fmt_status(state), "\n".join(state["log"][-8:])
-
-# ---------------- Farming ----------------
-def plant_seed(state, seed_id):
-    seeds = state["shop"]["seeds"]
-    s = next((x for x in seeds if x["id"]==seed_id), None)
-    if not s:
-        return "Hạt giống không hợp lệ.", "\n".join(state["log"][-8:])
-    player = state["player"]
-    if player["gold"] < s["cost"]:
-        return "Không đủ vàng để mua hạt.", "\n".join(state["log"][-8:])
-    player["gold"] -= s["cost"]
-    # simulate grow_time by storing a counter (we'll use integer tick simulation)
-    plot = {"seed_id": seed_id, "seed_name": s["name"], "grow_time": s["grow_time"], "remaining": s["grow_time"], "mutated": False, "quality":1}
-    state["farm"]["plots"].append(plot)
-    add_log(state, f"Mua và trồng {s['name']}. Thời gian chờ: {s['grow_time']} tick.")
-    return f"Trồng {s['name']} thành công.", "\n".join(state["log"][-8:])
-
-def tick_grow(state):
-    # called when user 'waits' or acts: reduce remaining for each plot
-    for p in state["farm"]["plots"]:
-        if p["remaining"]>0:
-            p["remaining"] -= 1
-            if p["remaining"]<=0:
-                # finish, determine mutation by seed base mut_rate
-                seed = next((x for x in SEEDS if x["name"]==p["seed_name"] or x["id"]==p["seed_id"]), None)
-                base = seed["mut_rate"] if seed else 0.05
-                if random.random() < base:
-                    p["mutated"] = True
-                    p["quality"] = random.randint(2,4)
-                    add_log(state, f"🌱 Cây {p['seed_name']} biến dị! Chất lượng {p['quality']}.")
-                else:
-                    p["mutated"] = False
-                    p["quality"] = 1
-                    add_log(state, f"🌿 Cây {p['seed_name']} thu hoạch bình thường.")
-    return "Đã tiến hành 1 tick thời gian.", "\n".join(state["log"][-8:])
-
-def harvest_plot(state, idx):
-    if idx<0 or idx>=len(state["farm"]["plots"]):
-        return "Không có ô trồng này.", "\n".join(state["log"][-8:])
-    plot = state["farm"]["plots"].pop(idx)
-    reward_xp = 5 * plot["quality"]
-    # mutated gives special item (mutation fruit)
-    if plot["mutated"]:
-        item = {"type":"mutation","power":plot["quality"], "name":f"Mutation {plot['seed_name']}"}
-        state.setdefault("inventory", []).append(item)
-        add_log(state, f"Thu hoạch: {plot['seed_name']} (Mutation!). Đã nhận 1 Mutation.")
-    else:
-        state["player"]["gold"] += 8*plot["quality"]
-        add_log(state, f"Thu hoạch: {plot['seed_name']}. Nhận {8*plot['quality']} vàng.")
-    state["player"]["xp"] += reward_xp
-    add_log(state, f"Nhận thêm +{reward_xp} XP từ thu hoạch.")
-    return fmt_status(state), "\n".join(state["log"][-10:])
-
-def feed_mutation(state, inv_idx):
-    inv = state.get("inventory", [])
-    if inv_idx<0 or inv_idx>=len(inv):
-        return "Không có item này.", "\n".join(state["log"][-8:])
-    item = inv.pop(inv_idx)
-    if item["type"]!="mutation":
-        return "Chỉ có Mutation mới cho ăn.", "\n".join(state["log"][-8:])
-    # feeding: add XP scaled by power and chance to learn skill
-    gain_xp = item["power"] * 25
-    state["player"]["xp"] += gain_xp
-    learned = False
-    if random.random() < 0.25 * item["power"]:
-        new_skill = f"MutSkill_{random.randint(100,999)}"
-        state["player"]["skills"].append(new_skill)
-        learned = True
-        add_log(state, f"🎉 Nhân vật học được kỹ năng mới từ mutation: {new_skill}!")
-    add_log(state, f"Bạn cho nhân vật ăn {item['name']} -> +{gain_xp} XP. {'(Learned skill!)' if learned else ''}")
-    return fmt_status(state), "\n".join(state["log"][-8:])
-
-# ---------------- Shop ----------------
-def buy_seed(state, seed_id):
-    s = next((x for x in SEEDS if x["id"]==seed_id), None)
-    if not s:
-        return "Hạt không hợp lệ.", "\n".join(state["log"][-6:])
-    if state["player"]["gold"] < s["cost"]:
-        return "Không đủ vàng.", "\n".join(state["log"][-6:])
-    state["player"]["gold"] -= s["cost"]
-    state.setdefault("seed_bag", []).append(s)
-    add_log(state, f"Mua {s['name']} x1.")
-    return f"Mua {s['name']} thành công.", "\n".join(state["log"][-6:])
-
-# ---------------- UI / Gradio ----------------
-with gr.Blocks(title="Adias: Arise & Mutation (Demo)") as demo:
-    gr.Markdown("## 🏞️ Adias — Arise & Mutation (Mini demo)")
-    # state
-    state = gr.State(default_state())
-
-    col1 = gr.Column(scale=2)
-    col2 = gr.Column(scale=1)
-
-    with gr.Row():
-        with col1:
-            gr.Markdown("### 🔹 Thị Trấn (Menu)")
-            dungeon_select = gr.Dropdown([ "Slime Cave","Goblin Den","Elf Forest","Dragon Lair","King's Trial" ], label="Chọn phó bản")
-            start_btn = gr.Button("🗡️ Vào phó bản")
-            attack_btn = gr.Button("⚔️ Tấn công (Trong dungeon)")
-            tick_btn = gr.Button("⏳ Thời gian trôi 1 tick (farm)")
-            harvest_btn = gr.Button("🌾 Thu hoạch ô đầu")
-            cards_btn = gr.Button("🃏 Lấy 3 thẻ bài (nếu có lvl up)")
-            buy_seed_btn = gr.Button("🛒 Mua Hạt Thường (10 gold)")
-            buy_spark_btn = gr.Button("🛒 Mua Hạt Sét (30 gold)")
-            buy_glow_btn = gr.Button("🛒 Mua Hạt Lấp Lánh (60 gold)")
-            feed_btn = gr.Button("🍎 Cho ăn Mutation (ô 0 trong inventory)")
-
-            status_box = gr.Textbox(label="Trạng thái", lines=1, interactive=False)
-            log_box = gr.Textbox(label="Log", lines=12, interactive=False)
-            inv_box = gr.Textbox(label="Inventory (index: item)", lines=3, interactive=False)
-
-        with col2:
-            gr.Markdown("### 🧾 Hồ sơ nhân vật")
-            panel = gr.HTML("<div id='panel'></div>")
-            stats_box = gr.Textbox(label="Thông tin nhân vật", lines=8, interactive=False)
-
-    # callbacks
-    def refresh_ui(state):
-        st = fmt_status(state)
-        status = st
-        logs = "\n".join(state["log"][-12:])
-        inv = state.get("inventory", [])
-        inv_text = "\n".join([f"{i}. {it['name']} (power {it.get('power')})" for i,it in enumerate(inv)]) if inv else "Rỗng"
-        stats = f"Cấp: {state['player']['level']}\nHP: {state['player']['hp']}/{state['player']['hp_max']}\nATK: {state['player']['attack']}\nGold: {state['player']['gold']}\nSkills: {', '.join(state['player']['skills']) if state['player']['skills'] else 'None'}\nPet: {state['player']['pet']['name'] if state['player']['pet'] else 'Không'}"
-        return status, logs, inv_text, stats
-
-    start_btn.click(lambda s, d: start_dungeon(s, d), inputs=[state, dungeon_select], outputs=[status_box, log_box])
-    attack_btn.click(lambda s: attack(s), inputs=[state], outputs=[status_box, log_box])
-    tick_btn.click(lambda s: tick_grow(s), inputs=[state], outputs=[status_box, log_box])
-    harvest_btn.click(lambda s: harvest_plot(s, 0), inputs=[state], outputs=[status_box, log_box])
-    cards_btn.click(lambda s: choose_card_flow(s), inputs=[state], outputs=[gr.Dropdown.update(choices=[]), log_box])  # placeholder
-    buy_seed_btn.click(lambda s: buy_seed(s, "basic"), inputs=[state], outputs=[log_box, status_box])
-    buy_spark_btn.click(lambda s: buy_seed(s, "spark"), inputs=[state], outputs=[log_box, status_box])
-    buy_glow_btn.click(lambda s: buy_seed(s, "glow"), inputs=[state], outputs=[log_box, status_box])
-    feed_btn.click(lambda s: feed_mutation(s, 0), inputs=[state], outputs=[status_box, log_box])
-
-    # small refresh button to show state
-    refresh = gr.Button("🔄 Refresh UI")
-    refresh.click(lambda s: refresh_ui(s), inputs=[state], outputs=[status_box, log_box, inv_box, stats_box])
-
-    # initial fill
-    demo.load(lambda s: refresh_ui(s), inputs=[state], outputs=[status_box, log_box, inv_box, stats_box])
-
-demo.launch()
+    add_log(state, "