第22章：悲剧的异常处理——亚里士多德的净化机制

class TragicHero {
    int pride = 100;
    int divineThreshold = 1000;

    void amplifyPride(int success) {
        pride *= success;  // 指数增长
        if (pride > divineThreshold) {
            throw new HubrisException("凡人妄图比肩神明");
        }
        amplifyPride(success + 1);  // 无终止条件的递归
    }
}

class Decision {
    Information knowledge = null;  // 未初始化的认知

    void makeChoice() {
        // 基于空知识做决策
        if (knowledge.isTrue()) {  // NullPointerException
            executeAction();
        }
    }
}

class Fate {
    final String prophecy = "你将杀父娶母";  // final不可修改

    boolean tryToEscape(String action) {
        // 所有逃避行为都会导向预言的实现
        return prophecy.willHappen();  // 总是返回true
    }
}

class ComplexTragedy {
    List<TragicFlaw> flaws = [
        new Hubris(0.7),      // 70%的傲慢
        new Ignorance(0.5),   // 50%的无知  
        new Fate(0.3)         // 30%的命运
    ];

    float calculateTragicProbability() {
        return 1 - flaws.stream()
            .map(f -> 1 - f.severity)
            .reduce(1, (a, b) -> a * b);
        // 概率叠加，趋近必然
    }
}

class Peripeteia {
    enum State { RISING, PEAK, FALLING, CRASHED }
    State currentState = State.RISING;

    void checkTrigger(Event event) {
        if (currentState == State.PEAK && 
            event.type == EventType.REVELATION) {
            throw new ReversalException();
        }
    }
}

class CascadeEffect {
    void reversal() throws TragicException {
        try {
            personalLife.crash();      // 个人层面崩溃
        } catch (Exception e) {
            familyRelations.break();   // 家庭关系破裂
            throw e;  // 继续向上传播
        } finally {
            socialStatus.destroy();    // 社会地位丧失
            kingdom.fall();            // 国家陷入混乱
        }
    }
}

class ReversalSpeed {
    void suddenReversal() {
        // 瞬间逆转：一个场景内完成
        state = State.PEAK;
        state = State.CRASHED;  // 断崖式下跌
    }

    void gradualReversal() {
        // 渐进逆转：多个场景逐步恶化
        for (int i = 100; i >= 0; i -= 10) {
            fortune = i;
            Thread.sleep(scene_duration);
        }
    }
}

class Discovery {
    Truth revealTruth(Source source) {
        switch(source) {
            case MESSENGER:
                return externalRevelation();  // 外部信息
            case EVIDENCE:  
                return physicalProof();       // 物证
            case DEDUCTION:
                return logicalReasoning();    // 推理
            case MEMORY:
                return suddenRecollection();  // 记忆
            case DIVINE:
                return oracleRevelation();    // 神谕
        }
    }
}

class PerfectTragedy {
    void climax() {
        synchronized(this) {
            // 原子操作：发现和逆转必须同时完成
            Truth truth = discover();
            State newState = reverse();

            // 认知和命运的双重转变
            protagonist.knowledge = truth;
            protagonist.fortune = newState;
        }
    }
}

class CognitiveRestructuring {
    void processDiscovery(Truth truth) {
        // 第一阶段：否认
        if (canDeny(truth)) {
            return;  // 拒绝接受
        }

        // 第二阶段：重新解释过去
        List<Event> past = memory.getAllEvents();
        for (Event e : past) {
            e.meaning = reinterpret(e, truth);
        }

        // 第三阶段：理解现在
        currentSituation = reevaluate(truth);

        // 第四阶段：预见未来
        future = extrapolate(truth);  // 通常是毁灭
    }
}

class Catharsis {
    EmotionBuffer audience = new EmotionBuffer();

    void accumulate(Scene scene) {
        audience.add(new Pity(scene.suffering));
        audience.add(new Fear(scene.danger));

        if (audience.isFull()) {
            triggerRelease();  // 触发净化
        }
    }

    void triggerRelease() {
        // 情感的集中释放
        while (!audience.isEmpty()) {
            Emotion e = audience.pop();
            e.release();  // 释放情感
        }

        // 重置到平静状态
        audience.reset();
    }
}

class PhysiologicalCatharsis {
    void process() {
        // 第一阶段：紧张累积
        heartRate.increase();
        adrenaline.release();
        muscles.tense();

        // 第二阶段：达到峰值
        if (tension >= threshold) {
            // 第三阶段：释放
            tears.flow();        // 哭泣
            breathing.deepen();  // 深呼吸
            endorphins.release(); // 内啡肽
        }

        // 第四阶段：恢复平衡
        parasympathetic.activate();
        calmness.restore();
    }
}

class SocialCatharsis {
    void collectiveExperience() {
        // 共同体验
        List<Individual> audience = theater.getAudience();

        for (Individual person : audience) {
            // 个体净化
            person.experienceCatharsis();

            // 集体共鸣
            person.resonateWith(audience);
        }

        // 社会功能
        society.reinforceValues();    // 强化价值观
        society.releaseAnxiety();     // 释放焦虑
        society.strengthenBonds();    // 加强联系
    }
}

class TragicCausality {
    class CausalNode {
        Event cause;
        Event effect;
        float probability;  // 因果强度
    }

    List<CausalNode> chain = new ArrayList<>();

    void buildChain() {
        // 每个结果成为下一个原因
        chain.add(new CausalNode(
            "傲慢", "挑战命运", 0.9
        ));
        chain.add(new CausalNode(
            "挑战命运", "做出错误选择", 0.95
        ));
        chain.add(new CausalNode(
            "错误选择", "触发灾难", 0.99
        ));
        chain.add(new CausalNode(
            "灾难", "最终毁灭", 1.0
        ));
    }

    float calculateInevitability() {
        return chain.stream()
            .map(node -> node.probability)
            .reduce(1.0f, (a, b) -> a * b);
        // 接近1.0 = 几乎必然
    }
}

class FreeWillParadox {
    Fate predictedFate;

    void tryToEscape() {
        Action avoidance = chooseOpposite(predictedFate);

        // 悖论：避免的行为正是导向命运的路径
        if (avoidance == "离开家乡避免杀父") {
            meetStranger();  // 遇到陌生人
            conflict();      // 发生冲突
            kill();          // 杀死对方
            // 后来发现：陌生人是父亲
        }
    }
}

class AestheticNecessity {
    float measureBeauty(Tragedy tragedy) {
        float necessity = tragedy.getInevitability();
        float surprise = tragedy.getUnexpectedness();

        // 美学价值 = 必然性 × 意外性
        // 最好的悲剧：结局既意外又必然
        return necessity * surprise;
    }

    boolean isAristotlianIdeal() {
        return necessity > 0.9 && surprise > 0.8;
        // 高必然性 + 高意外性 = 理想悲剧
    }
}

// 错误：毫无因果的意外
hero.status = "happy";
randomEvent.kill(hero);  // 突然死亡，无逻辑

// 正确：因果必然的崩溃
hero.flaw = "hubris";
hero.action = challengeFate(hero.flaw);
consequence = inevitable(hero.action);

// 错误：依赖巧合推进剧情
if (random() > 0.99) {
    revealTruth();  // 概率太低，不可信
}

// 正确：通过角色行动导致发现
investigation.pursue();
evidence.accumulate();
truth.reveal();  // 逻辑必然

// 错误：只有痛苦，没有释放
while (true) {
    suffering.increase();
    // 无限循环，没有出口
}

// 正确：痛苦后的净化
suffering.accumulate();
if (suffering >= threshold) {
    catharsis.trigger();
    emotions.reset();
}

// 错误：完美英雄遭遇不幸
hero.flaws = [];  // 没有缺陷
fate.punish(hero);  // 不公平，引发愤怒而非净化

// 正确：有缺陷但值得同情
hero.flaws = ["pride"];  // 可理解的缺陷
hero.virtues = ["courage", "love"];  // 也有美德

// 错误：没有明确的因果闭环
ending = "maybe";  // 含糊不清
audience.confusion++;  // 观众困惑

// 正确：清晰的因果完成
cause.leadTo(effect);
cycle.complete();
meaning.clear();