地下城与卷轴

; 这段汇编的意思是：把数值 100 放进寄存器 AX（相当于暂存格）
MOV AX, 100

; 再把 AX 的值搬进内存地址 0x1000
MOV [0x1000], AX

; 跳转到 0x2000 继续执行
JMP 0x2000

int hp = 100;      /* 在内存里划一块地方，名字叫 hp，初始值 100 */
int gold = 30;     /* 再来一块，叫 gold */

hp = hp - 15;      /* 被蝙蝠咬了 15 点血 —— 本质是改内存里的数字 */

hp = 100      # 不需要写类型，Python 自己猜
gold = 30
hp -= 15      # 偷懒写法，等价于 hp = hp - 15
print("勇者剩余生命：", hp)   # 勇者剩余生命：85

print("勇者走进了幽暗的地牢……")
print("前方有一个岔路口。")
print("（游戏结束）")   # 玩家：就这？？

hp = 100
escaped = False          # 是否逃出地牢

# 主循环：只要活着且没逃出去，就一直玩
while hp > 0 and not escaped:
    print("\n你站在岔路口。向左(1)是宝箱，向右(2)是怪物的低吼声。")
    choice = input("输入 1 或 2：")

    if choice == "1":
        print("你发现了一个宝箱！获得 20 金币。")
        gold = 30 + 20
    elif choice == "2":
        print("一只蝙蝠扑了过来！你损失 15 点生命。")
        hp -= 15
    else:
        print("指令无效，你愣了一下。")     # 防呆：处理非法输入

    if hp <= 0:
        print("勇者倒下了……游戏结束。")

print("—— 游戏结束 ——")

def attack(attacker, defender):
    """一次攻击：造成伤害，并返回实际伤害值。"""
    damage = attacker["atk"] - defender["def"]
    if damage < 1:
        damage = 1                # 至少掉 1 点血
    defender["hp"] -= damage
    return damage

bat     = {"name": "蝙蝠",   "hp": 20, "atk": 8,  "def": 1}
goblin  = {"name": "哥布林", "hp": 40, "atk": 10, "def": 3}

dmg1 = attack(player, bat)      # 勇者打蝙蝠
dmg2 = attack(goblin, player)   # 哥布林打勇者
print(f"{bat['name']} 受到 {dmg1} 点伤害！")
print(f"你受到 {dmg2} 点伤害，剩余 HP：{player['hp']}")

def explore_cave(depth):
    """回声洞穴：每一层都套着一个更小的洞。"""
    if depth == 0:                       # 地基：最深处，到底了
        print("  你摸到了洞穴最深处，捡到一颗发光的石头！")
        return 1

    print("  进入洞穴第", depth, "层……")
    treasure = explore_cave(depth - 1)   # 先探索更深的洞
    print("  回到第", depth, "层，带上战利品返回。")
    return treasure + 1

total = explore_cave(3)                  # 从第 3 层开始往下钻
print("共收获", total, "件宝物")

inventory = ["小药水", "木剑"]        # 背包：一列同类物品
inventory.append("生锈的钥匙")         # 捡到东西，塞进背包
item = inventory.pop()                 # 拿出最后一件（钥匙）
print("背包里有：", inventory)         # ['小药水', '木剑']
print("你拿出了：", item)              # 你拿出了：生锈的钥匙

# Python 里最朴素的「结构体」：一个 dict（字典）
player = {"name": "勇者阿哲", "hp": 100, "atk": 12, "def": 5,
          "pos": (3, 5), "gold": 30, "inventory": []}

def attack(attacker, defender):
    damage = attacker["atk"] - defender["def"]
    defender["hp"] -= max(damage, 1)      # 现在只传一个「人」，不用传 8 个参数！

player2 = player                          # 注意：这只是引用的复制

struct Player {
    char  name[32];   /* 名字，32 字节 */
    int   hp;         /* 血量 */
    int   atk;        /* 攻击力 */
    int   def;        /* 防御力 */
};                    /* 这些字段在内存里是挨着排的 */

struct Player p = {"阿哲", 100, 12, 5};
p.hp -= 15;           /* 直接用 . 访问字段 */

struct Monster {
    int hp;
    struct Monster *next;   /* 指针：下一个怪物的地址 */
};

struct Monster m1 = {20, NULL};
struct Monster m2 = {40, NULL};
m1.next = &m2;              /* m1 后面接上 m2（& 表示取地址） */

/* 顺着链表走一圈 */
for (struct Monster *cur = &m1; cur != NULL; cur = cur->next) {
    printf("发现怪物，HP=%d\n", cur->hp);
}

class Player:
    def __init__(self, name):        # 构造方法：出生时自动调用
        self.name = name
        self.hp = 100                # 一出生就有完整属性
        self.atk = 12
        self.def = 5
        self.inventory = []
        self._secret = "不能告诉别人"   # 下划线 = 私有，约定别碰

    def take_damage(self, amount):   # 方法：玩家的行为
        self.hp -= max(amount - self.def, 1)
        if self.hp < 0:
            self.hp = 0

    def heal(self, amount):
        self.hp = min(self.hp + amount, 100)   # 不能超过上限

    def __del__(self):               # 析构方法：对象消亡前的清理（Python 里很少用到）
        pass

# 使用：new 一个勇者出来
hero = Player("阿哲")
hero.take_damage(15)
print(hero.name, "剩余 HP：", hero.hp)   # 阿哲 剩余 HP：89

# main.py —— 游戏入口
from player import Player
from monster import Monster
from map import load_map

hero = Player("阿哲")
dungeon = load_map("dungeon_1.txt")
print("勇者", hero.name, "踏入了", dungeon.name)

class Monster:
    def __init__(self, name, hp, atk):
        self.name = name
        self.hp = hp
        self.atk = atk

    def attack(self, target):        # 公共逻辑：所有怪物都会攻击
        target.take_damage(self.atk)
        return f"{self.name} 发动攻击！"

    def roar(self):                  # 虚方法：子类各自实现
        return "……（安静的威胁）"

class Goblin(Monster):               # 哥布林 继承 怪物
    def roar(self):
        return "呜咕噜——！"

class Dragon(Monster):               # 恶龙 继承 怪物
    def roar(self):
        return "吼————！！！（整座地牢都在震）"

# 多态：同一句代码，不同对象做出不同行为
for m in [Goblin("小绿", 40, 10), Dragon("红莲", 300, 25)]:
    print(m.name, "说：", m.roar())     # 小绿说：呜咕噜——！ / 红莲说：吼————！！！

template <typename T>        // T 是「类型参数」
class Backpack {
    T items[10];            // 不管 T 是药水、钥匙还是符文石，都能装
    int count = 0;
public:
    void put(const T &it) { items[count++] = it; }
};

Backpack<Potion>  bag1;      // 装药水的包
Backpack<Key>    bag2;      // 装钥匙的包

struct Monster *m = malloc(sizeof(struct Monster));  /* 借钱 */
m->hp = 40;
/* ……打怪中…… */
free(m);          /* 还钱！忘了这行 = 内存泄漏 */

struct Monster { hp: i32 }

fn fight(mut m: Monster) {      // 怪物被「移动」进函数，成了唯一主人
    m.hp -= 10;
    println!("剩余 HP: {}", m.hp);
}                               // 函数结束，m 自动释放——不用手动 free

fn main() {
    let goblin = Monster { hp: 40 };
    fight(goblin);              // 所有权转移（move）
    // println!("{}", goblin.hp); // 编译错误！goblin 已经不属于你了
}

def load_save(path):
    try:
        with open(path, "r", encoding="utf-8") as f:
            data = json.load(f)            # 可能抛：文件不存在 / 格式错误
        return data
    except FileNotFoundError:
        print("没有找到存档，从新游戏开始。")
        return new_game()
    except json.JSONDecodeError:
        print("存档已损坏……我们为你保留了一个旧备份。")
        return load_save(path + ".bak")    # 优雅降级：读备份
    finally:
        print("存档系统就绪。")            # 无论成败都会执行（收尾）

# 断言：开发期自检，血量不可能是负数
assert 0 <= hero.hp <= hero.max_hp, f"血量异常：{hero.hp}"

fn find_player(save: &Save) -> Option<&Player> {
    save.players.iter().find(|p| p.name == "阿哲")
    // 找到返回 Some(&p)，找不到返回 None —— 没有「空指针」这一说
}

fn read_save(path: &str) -> Result<Save, String> {
    // Ok(数据) 或者 Err("文件损坏") —— 调用者必须处理两种可能
    ...
}

import threading, time

lock = threading.Lock()          # 锁：同一时间只许一个人碰 hp

def music_loop():
    while True:
        print("🎵 地牢主题曲……")
        time.sleep(5)            # 播 5 秒，期间游戏线程照常响应

def damage(hp, amount):
    with lock:                   # 加锁：改血量期间别人不许动
        hp[0] -= amount
        return hp[0]

t = threading.Thread(target=music_loop, daemon=True)
t.start()                        # 音乐线程启动，主线程继续跑游戏

hp = [100]
print("勇者剩余 HP：", damage(hp, 15))   # 85
# 玩家输入照常响应，音乐在后台放——互不打扰

import asyncio

async def upload_save():
    print("开始上传存档……")
    await asyncio.sleep(2)       # 假装网络 IO 等 2 秒
    print("上传完成！")
    return "ok"

async def main():
    task = asyncio.create_task(upload_save())  # 后台挂起上传
    print("玩家继续探索地牢……")               # 不等网络，游戏照跑
    print("捡到一件装备！")
    await task                                  # 最后等上传收尾

asyncio.run(main())

from functools import reduce

backpack = [
    {"name": "小药水",   "type": "potion",   "value": 10},
    {"name": "铁剑",     "type": "weapon",   "value": 50},
    {"name": "大药水",   "type": "potion",   "value": 25},
    {"name": "护符",     "type": "trinket",  "value": 80},
]

# filter：筛选出所有药水（只关心"筛"，不关心"怎么循环"）
potions = list(filter(lambda it: it["type"] == "potion", backpack))

# map：给每件装备 +10 点价值（逐个变换）
boosted = list(map(lambda it: {**it, "value": it["value"] + 10}, backpack))

# reduce：把背包总价值汇总成一个数
total = reduce(lambda acc, it: acc + it["value"], backpack, 0)

print("药水：", [p["name"] for p in potions])     # ['小药水', '大药水']
print("总价值：", total)                          # 165

def potion_factory(base_heal):
    """返回一个闭包：它记住了 base_heal 这个"环境"。"""
    def make(level):
        return {"name": f"治疗药水 Lv{level}",
                "heal": base_heal * level}      # 闭包"偷看"外面的 base_heal
    return make

small_factory = potion_factory(20)   # 小作坊：基础回复 20
big_factory   = potion_factory(50)   # 大作坊：基础回复 50

print(small_factory(2))   # {'name': '治疗药水 Lv2', 'heal': 40}
print(big_factory(1))     # {'name': '治疗药水 Lv1', 'heal': 50}
# 同一个函数，因为记住的环境不同，行为就不同——这就是闭包

def log(fn):
    """装饰器：包装函数，调用前自动写日志。"""
    def wrapper(*args, **kwargs):
        result = fn(*args, **kwargs)
        print(f"[战报] {fn.__name__} 被调用 → 结果: {result}")
        return result
    return wrapper

@log
def attack(name, dmg):
    return f"{name} 造成 {dmg} 点伤害！"

@log
def pick_item(item):
    return f"捡到了 {item}！"

attack("勇者阿哲", 18)     # [战报] attack 被调用 → 结果: 勇者阿哲 造成 18 点伤害！
pick_item("生锈的钥匙")    # [战报] pick_item 被调用 → 结果: 捡到了生锈的钥匙！
# 17 个函数？每行上面加 @log 就行，一处都不用改内部代码

// C 宏：编译期就展开成代码（简单粗暴的"代码生成"）
#define MAX_HP 100
#define HEAL(p, n) ((p).hp = ((p).hp + (n) > MAX_HP) ? MAX_HP : (p).hp + (n))

# 反射：运行时检查/修改自身结构
skills = ["火球术", "治疗术", "嘲讽"]
hero.learn = lambda s: skills.append(s)     # 运行时给对象"装"新技能
print(hasattr(hero, "attack"))              # True —— 运行时问"你有没有 attack"
print([s for s in dir(hero) if not s.startswith("_")])  # 把对象里外看个遍

#####
#@..#
#.M.#    # = 墙壁   . = 地砖   @ = 勇者   M = 怪物   G = 金币   E = 出口
#..G#
#####E

def parse_map(text):
    tiles = {"#": "wall", ".": "floor", "@": "player",
             "M": "monster", "G": "gold", "E": "exit"}
    grid, player, monsters = [], None, []
    for y, line in enumerate(text.strip().splitlines()):
        row = []
        for x, ch in enumerate(line.strip()):
            row.append(tiles.get(ch, "floor"))
            if ch == "@": player = (x, y)
            if ch == "M": monsters.append((x, y))
        grid.append(row)
    return grid, player, monsters

# 用！朋友现在只要会用记事本画图，就能设计关卡
grid, player, monsters = parse_map("""#####
#@..#
#.M.#
#..G#
#####E""")
print("勇者出生点：", player)          # (1, 1)
print("怪物位置：", monsters)          # [(3, 2)]
print("该格是什么：", grid[2][1])      # floor

-- 排行榜：按通关层数排序取前 10
SELECT name, floor, gold
FROM players
ORDER BY floor DESC, gold DESC
LIMIT 10;

import re

cmd = "向北走并捡起生锈的钥匙"
moves = re.findall(r"(向北|向南|向东|向西)走", cmd)      # ['向北']
items = re.findall(r"捡起(.+?)(?:并|$)", cmd)            # ['生锈的钥匙']
print(moves, items)   # ['向北'] ['生锈的钥匙']

import openai

def talk_to_merchant(player_hp, gold):
    prompt = f"""
你是一位地牢里的神秘商人，说话神秘又幽默。
当前玩家：生命 {player_hp}，金币 {gold}。
规则：每次只回复一句话，不超过 30 字，必须推销一件物品。
"""
    resp = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "system", "content": prompt},
                  {"role": "user", "content": "你好，商人！"}]
    )
    return resp.choices[0].message.content
    # 输出可能是："嘿嘿，来的正是时候——我这有一瓶回血药水，只卖你 50 金币。"

# 伪代码：Agent 的思考-行动循环
def game_guide_agent(user_question):
    plan = llm.plan(user_question)                 # 1. Agent 规划："需要查攻略 + 读当前存档"
    docs = rag.search(user_question)               # 2. RAG：从攻略库里检索相关资料
    save = mcp.call("read_save", "slot1")          # 3. MCP：调用工具读玩家存档
    answer = llm.generate(plan, docs, save)        # 4. 综合生成建议
    return answer

# 玩家问："恶龙怎么打？"
# → Agent 查攻略库（RAG）：恶龙弱火、第三回合会喷火
# → MCP 读存档：你 50 级、有火球术、防御 300
# → 回答："你现在的配置可以硬刚！开局先放火球术……"