main.py

# 没有银弹。
# 天下没有免费的午餐。
# 不要在地上建立天国。

from yi import book_scene
from yi import yi_scene
from yi import common_scene
from yi import pen
import pygame

from yi.common_scene import ChoiceNode, title_font
from yi.common_scene import screen

def try_yi():
    set_scene(yi_scene.scene)
    yi_scene.scene.reset()

def init_button(choice_node_, scene_):
    if isinstance(choice_node_, common_scene.ChoiceNode):
        for i in range(len(choice_node_.nodes)):
            choice_node_.button(scene_, i)


class TransitionScene(yi_scene.game_basic.Scene):
    def __init__(self, surface, next_scene, duration=(0.5, 1.5, 1.5), side_effect=None):
        yi_scene.game_basic.Scene.__init__(self)
        self.surface = surface
        self.next_scene = next_scene
        self.timer = 0
        self.duration = duration
        if side_effect:
            self.side_effect = side_effect
        else:
            self.side_effect = lambda: None

    def update(self, dt):
        self.timer += dt
        if self.timer > sum(self.duration):
            set_scene(self.next_scene)
            self.side_effect()

    def draw(self):
        screen.fill("black")
        if self.timer < self.duration[0]:
            self.surface.set_alpha(255 * (self.timer / self.duration[0]))
        elif self.timer > sum(self.duration) - self.duration[2]:
            self.surface.set_alpha(255 * ((sum(self.duration) - self.timer) / self.duration[2]))
        else:
            self.surface.set_alpha(255)
        screen.blit(self.surface, (0, 0))


# 构建剧情树

start_texts = ["我们刚刚讲到怎么用小木棍起卦。",
               "顺便——（指黑板）还推导了一下这个随机变量的分布列。\n* 这边儿这个是经典的铜钱起卦法的分布列。",
               "不过这些都不重要，所以你来得正是时候。",
               "现在，你们知道了算卦的原理，对吧，你们觉得自己可以给人算卦了吗？",
               "你现在跑到大街上，随便给人起一卦，然后拿出周易这么一翻——或者你记性好也可以不用翻。",
               "然后你跟他说，你这个事儿，就跟书上说的这句话一样。\n* 这句话什么意思？嘿，天机不可泄露，自个儿琢磨去吧您哪。",
               "对吧，这显然是不合适的。",
               "伟大的马克思告诉我们，哲学家们总是在解释世界，但问题的关键是要改变世界。",
               "——嗯？有什么问题吗？算卦也是讲唯物主义的。",
               "我们说，算卦如何才能算准？你光盯着那木棍儿能算准吗？显然是不行的。",
               "要想算准，你得有情报。",
               "比如说，现在一个男生来找你算卦。\n* 他问你：哎呀，我前几天和我的女朋友闹了点矛盾，现在我们陷入了冷战，大师，我现在该怎么办呢？",
               "现在咱们什么情报都没有，所以怎么办？给个模棱两可的回复对吧。",
               "咱们也可以尝试从他这儿套点情报，比如问问他，他女朋友长什么样子。",
               "好，现在他女朋友来了。\n* 她说：我现在和男朋友关系闹得有点僵，这样下去也不是个事儿，那我该怎么做呢？",
               "现在我们已经知道了她的男朋友是明显地有复合的意愿的。所以我们可以怎么说？",
               "你现在去找他，一定能成功，对吧。",
               "好，现在重点来了。我们算卦是能改变事情的走向的。",
               "假如我们不想让他们复合呢？",
               ]

mid_texts = ["对吧，我们说，他之后可能会尝试跟你和好，但那只是他掩盖他海王行为的手段。你千万不要和他复合，否则会变得非常不幸。",
             "现想说辞有点复杂是不是？现在我们来试一个更程序化的做法。",
             "刚刚我们也讲了怎么安六亲世应，对吧。",
             "哦，你没听见，回去自己翻书，就这本儿。",
             "《增删卜易》开篇讲“四处生合冲克”。说，世爻代表你，别处的爻克你多你就危险，生你多你就安全。",
             "所以你可以怎么做？你如果想让他大胆去做，你就重点说这个生的方面，如果你想让他别这么干，你就强调这个克。",
             "你们没背过地支的合冲刑害表，这个没有关系。五行生克表总该背下来了吧？先简单说说这个就好。",
             ]

def set_yi_return_func(func):
    yi_scene.scene.return_func = func

def set_yi_esc_func(func):
    yi_scene.scene.esc_func = func

def set_node(node_):
    main_scene.current_node = node_
    main_scene.set_main_buttons()

#树兮图兮，易画难书、易观难读兮。何当GUI，可视化编辑兮？
#边点分离，RA不II，可乎？

halt = common_scene.CutsceneNode("\n* 感谢您的游玩。\n* 制作：L.F.Z.小队")
halt.next = halt
date = (yi_scene.basics.DiZhi(yi_scene.random.randint(0, 11)), yi_scene.basics.GanZhi(yi_scene.random.randint(0, 59)))
start_nodes = common_scene.LinearCutscene(*[common_scene.cutscene_str("诛余", t) for t in start_texts])
#start_nodes.nodes[-9].side_effect = lambda : main_scene.animations.append(common_scene.SceneAnimation(0, -200, 1, (lambda x: common_scene.spr_bacon.rect.update(x, 0, common_scene.spr_bacon.rect.width, common_scene.spr_bacon.rect.height)), common_scene.SceneAnimation.quadratic))
mid_nodes = common_scene.LinearCutscene(*[common_scene.cutscene_str("诛余", t) for t in mid_texts])
wrong_node = common_scene.CutsceneNode("诛余：\n* 嗯？你审题没有？我们现在不想让他们复合。", mid_nodes.nodes[0])
not_even_wrong_node = common_scene.CutsceneNode("诛余：\n* 嗯？什么玩意儿？", mid_nodes.nodes[0])
start_node = common_scene.CutsceneNode("诛余：\n* 哦，你来了。")
start_node.side_effect = lambda: main_scene.alert("使用键盘输入姓名。")
book_choice_node = common_scene.ChoiceNode("\n* （这里只有这些书。）", [lambda: read(book_scene.zhou_yi_book), lambda: read(book_scene.zeng_shan_book), None], ["《周易》", "《增删卜易》残卷", "还是算了"])
end_node = common_scene.CutsceneNode("\n* 感谢您体验本demo。\n* 制作：L.F.Z.小队")

pen_scene = pen.PenScene()
pen_scene.esc_func = lambda : set_scene(main_scene)

choice_node = common_scene.ChoiceNode("\n*（干点什么呢？）", [book_choice_node, try_yi, lambda: set_scene(pen_scene), lambda: set_scene(transit_scenes[1])], ["读书", "练习占卜", "玩铅笔", "离开"])
end_node.next = choice_node
free_node = common_scene.CutsceneNode("诛余：\n* 哦？到点了，你们想留下来的话就自便，我要去吃饭了。", choice_node)
free_node.side_effect = lambda : yi_scene.scene.setmode("full") or yi_scene.current_obj.real_world_obj_names.append("我") or yi_scene.current_obj.real_world_obj_names.append("他") or set_yi_return_func(lambda _: yi_scene.scene.alert("没有什么需要提交的。")) or main_scene.set_bg_id(-1) or main_scene.animations.append(common_scene.SceneAnimation(255, 0, 1, (lambda x: tuple(i.set_alpha(x) for i in common_scene.spr_bacon.images)), common_scene.SceneAnimation.linear))
def date_str():
    res = f"诛余：\n* 对了，今天是{date[0].name}月{date[1].name}日。"
    if date[0].value == date[1].di_zhi.value:
        res += f"{date[0].name}属{date[0].wu_xing().name}。"
    elif date[0].wu_xing().value == date[1].di_zhi.wu_xing().value:
        res += f"{date[0].name}属{date[0].wu_xing().name}，{date[1].di_zhi.name}也属{date[1].di_zhi.wu_xing().name}。"
    else:
        res += f"{date[0].name}属{date[0].wu_xing().name}，{date[1].di_zhi.name}属{date[1].di_zhi.wu_xing().name}。"
    res += "按照这个算。"
    return res
date_node = common_scene.CutsceneNode(date_str())
mid_nodes.nodes[-1].next = date_node
try_again_node = common_scene.ChoiceNode("诛余：\n* 再试试吗？", [None, free_node], ["再试试", "不了"])
try_again_node.side_effects[0] = lambda : set_scene(yi_scene.scene) or yi_scene.scene.reset() or set_yi_esc_func(lambda : set_scene(main_scene) or set_node(try_again_node))
try_again_node.side_effects[1] = lambda : main_scene.set_bg_id(0) or main_scene.animations.append(common_scene.SceneAnimation(255, 0, 1, (lambda x: common_scene.spr_vcm02.image.set_alpha(x)))) or main_scene.animations.append(common_scene.SceneAnimation(-300, 0, 1, (lambda x: common_scene.spr_bacon.rect.update(x, 0, common_scene.spr_vcm01.rect.width,common_scene.spr_vcm01.rect.height)), common_scene.SceneAnimation.quadratic))
g1_node = common_scene.CutsceneNode("诛余：\n* 嗯，不错，之后他们就会和好了。", try_again_node)
b1_node = common_scene.CutsceneNode("诛余：\n* 嗯，不错，现在你成功拆散了一对儿小情侣。", try_again_node)
n1_node = common_scene.CutsceneNode("诛余：\n* 嗯，不错，在之后的一段时间里，他们还会保持这种冷战关系。", try_again_node)
w1_node = common_scene.CutsceneNode("诛余：\n* 你这说的什么玩意儿？一点儿说服力都没有。她觉得你是个江湖骗子，然后她生气地走掉了。", try_again_node)
exp1_node = common_scene.ChoiceNode(lambda : f"{main_scene.chr_name}：\n* 嗯，所以……", [w1_node] * 3, ["你应该尽快找你男友和好。", "你应该赶快结束关系。", "你应该再观望观望。"])
try_again_node.nodes[0] = exp1_node

mid_nodes.nodes[3].side_effect = lambda : read(book_scene.zeng_shan_book)
start_nodes.nodes[-9].side_effect = lambda : (common_scene.spr_vcm01.add(main_scene.fg_sprites)
                                        or main_scene.set_bg_id(1)
                                        or main_scene.animations.append(common_scene.SceneAnimation(750, 0, 2, (lambda x: common_scene.spr_vcm01.rect.update(x, 0, common_scene.spr_vcm01.rect.width, common_scene.spr_vcm01.rect.height)), common_scene.SceneAnimation.quadratic))
                                        or main_scene.animations.append(common_scene.SceneAnimation(0, -300, 1, (lambda x: common_scene.spr_bacon.rect.update(x, 0, common_scene.spr_vcm01.rect.width,common_scene.spr_vcm01.rect.height)), common_scene.SceneAnimation.quadratic)))
start_nodes.nodes[-6].side_effect = lambda : main_scene.set_bg_id(2) or common_scene.spr_vcm02.add(main_scene.fg_sprites) or main_scene.animations.append(common_scene.SceneAnimation(0, 255, 1, (lambda x: common_scene.spr_vcm02.image.set_alpha(x)))) or main_scene.animations.append(common_scene.SceneAnimation(0, 750, 2, (lambda x: common_scene.spr_vcm01.rect.update(x, 0, common_scene.spr_vcm01.rect.width, common_scene.spr_vcm01.rect.height)), common_scene.SceneAnimation.quadratic))
def check_res_1(res):
    yi_scene.scene.esc_func = lambda : set_scene(main_scene)
    if res["confidence"] < 3 or "你" not in res:
        exp1_node.nodes = [w1_node] * 3
        yi_scene.scene.esc_func()
        return
    if res["你"] < 1:
        exp1_node.nodes[1] = b1_node
    if res["你"] > 1:
        exp1_node.nodes[0] = g1_node
    if 0 < res["你"] < 2:
        exp1_node.nodes[2] = n1_node
    yi_scene.scene.esc_func()

date_node.next = exp1_node
date_node.side_effect = lambda : yi_scene.scene.setmode("simple") or yi_scene.init_gua_link_nodes(yi_scene.yi_game.FullGuaObj(yi_scene.basics.FullGua(yi_scene.basics.Gua64(yi_scene.random.randint(0, 63)), yi_scene.basics.Gua64(yi_scene.random.randint(0, 63)), date[0], date[1]), ["你"]), "simple") or set_yi_return_func(check_res_1) or set_scene(yi_scene.scene) or set_yi_esc_func(lambda : set_scene(main_scene) or set_node(date_node))
# name_node = common_scene.CutsceneNode(lambda : f"诛余：\n* 嗯，你是{main_scene.chr_name}。", choice_node)
# name_node.side_effect = lambda : main_scene.alert("点击按钮以抉择。")
input_node = common_scene.InputNode("诛余：\n* 先在这儿签个到吧，好拿你那两学分。", start_nodes.nodes[0],
                                    lambda x: main_scene.set_chr_name(x) or len(x) > 0)
book_choice_node.nodes[2] = choice_node
start_node.next = input_node

yi_choice_node = common_scene.ChoiceNode("诛余：\n* 比如说，我们给这个女生算卦，算出来火天大有。那么我们可以怎么说？", [wrong_node, mid_nodes.nodes[0], not_even_wrong_node], ["火在天上，光耀四方，代表你二人内心都光明磊落，可以复合。", "天上有火，这是太阳。太阳东升西落，他对你的感情可能已经衰落了。", "天上的火是太阳。这代表他的真实身份可能是金将军。"])
start_nodes.nodes[-1].next = yi_choice_node

spr_move = lambda spr, a, b, time = 2: common_scene.SceneAnimation(a, b, time, (lambda x: spr.rect.update(x, 0, spr.rect.width, spr.rect.height)), common_scene.SceneAnimation.quadratic)

spr_leave_left = lambda spr: common_scene.SceneAnimation(0, -750, 2, (lambda x: spr.rect.update(x, 0, spr.rect.width, spr.rect.height)), common_scene.SceneAnimation.quadratic)
spr_leave_right = lambda spr: common_scene.SceneAnimation(0, 750, 2, (lambda x: spr.rect.update(x, 0, spr.rect.width, spr.rect.height)), common_scene.SceneAnimation.quadratic)

spr_2_left = lambda spr: common_scene.SceneAnimation(0, -300, 1, (lambda x: spr.rect.update(x, 0, spr.rect.width, spr.rect.height)), common_scene.SceneAnimation.quadratic)
spr_l2c = lambda spr: common_scene.SceneAnimation(-300, 0, 1, (lambda x: spr.rect.update(x, 0, spr.rect.width, spr.rect.height)), common_scene.SceneAnimation.quadratic)

spr_show = lambda spr: common_scene.SceneAnimation(0, 255, 1, (lambda x: spr.image.set_alpha(x)))
spr_disappear = lambda spr: common_scene.SceneAnimation(255, 0, 1, (lambda x: spr.image.set_alpha(x)))

school_intro_text = ["哦，你又来了。",
                     "上周回去读书了吧？会安六亲世应了吧？合冲刑害表背会了吗？十二长生呢？",
                     "读过书——我便考你一考。",
                     "骗你的。现在互联网这么发达，你要用随时查就好。",
                     "当然，我并不鼓励你们在校园内使用手机。\n* 毕竟，对吧，教导主任可是神出鬼没的。",
                     "上周那个场景有点简单是不是？今天我们来想一个更复杂的。",
                     "比如一场政变！这里面，你能造成的影响就复杂多了。",
                     "我们设想这样一个场景：咱们年级有一个班实行“班长独裁制”。\n* 这个班长非常有能力，但是事必躬亲，大权独揽，不给其他同学机会，所以班里同学有一些不满。",
                     "现在你已知这些情报，然后第一个人来找你算卦了。"
                     ]

class AdviceNode(common_scene.ChoiceNode):
    def __init__(self, advice: list[str], texts: list[str], side_effects, next_node):
        self.answer_nodes = [common_scene.CutsceneNode(t, next_node) for t in texts[:-1]]
        self.wrong_node = common_scene.CutsceneNode(texts[-1], next_node)
        self.right_side_effects = side_effects[:-1]
        self.wrong_side_effect = side_effects[-1]
        common_scene.ChoiceNode.__init__(self, lambda : f"{main_scene.chr_name}：\n* 根据卦象……", self.answer_nodes.copy(), advice, side_effects[:-1])

def set_rwo(rwo):
    yi_scene.current_obj.real_world_obj_names = rwo

class CharNode(common_scene.ChoiceNode):
    def __init__(self, text: str, person_desc: str, questions: list[str], answers: list[str], advice_node: AdviceNode, res_func, real_obj):
        desc_node = common_scene.CutsceneNode(f"\n* {person_desc}", self)
        answer_nodes = [common_scene.CutsceneNode(t, self) for t in answers]
        common_scene.ChoiceNode.__init__(self, text, [desc_node] + answer_nodes + [advice_node], ["（打量）"] + questions + ["（起卦）"])
        self.result = {}
        self.res_func = res_func
        self.advice_node = advice_node
        self.side_effects[-1] = (lambda: set_yi_esc_func(lambda : set_scene(main_scene) or set_node(self)) or set_yi_return_func(lambda res: set_scene(main_scene) or self.set_result(res)) or set_scene(yi_scene.scene) or set_rwo(real_obj) or yi_scene.scene.reset())

    def set_result(self, result):
        self.result = result
        res_list = self.res_func(result)
        for i in range(len(self.advice_node.names)):
            if i not in res_list:
                self.advice_node.nodes[i] = self.advice_node.wrong_node
                self.advice_node.side_effects[i] = self.advice_node.wrong_side_effect
            else:
                self.advice_node.nodes[i] = self.advice_node.answer_nodes[i]
                self.advice_node.side_effects[i] = self.advice_node.right_side_effects[i]


    def tree(self, next_):
        for i in range(len(self.advice_node.answer_nodes)):
            self.advice_node.answer_nodes[i].next = next_
        self.advice_node.wrong_node.next = next_
        return self

def compare_func(res, name_self, name_target):
    yi_scene.scene.esc_func = lambda : set_scene(main_scene)
    res_list = []
    if res["confidence"] < 3 or name_self not in res or name_target not in res:
        return res_list
    if res[name_self] - res[name_target] > 0.5:
        res_list.append(0)
    if res[name_self] - res[name_target] < -0.5:
        res_list.append(2)
    if -1 < res[name_self] - res[name_target] < 1:
        res_list.append(1)
    return res_list

def strength_func(res, name_self):
    yi_scene.scene.esc_func = lambda : set_scene(main_scene)
    res_list = []
    if res["confidence"] < 3 or name_self not in res:
        return res_list
    if res[name_self] > 1:
        res_list.append(0)
    if res[name_self] < 1:
        res_list.append(2)
    if 0 < res[name_self] < 2:
        res_list.append(1)
    return res_list

you_func = lambda res: strength_func(res, "你")

res_func_1 = lambda res: compare_func(res, "你", "你的同学")
res_func_2 = lambda res: compare_func(res, "你", "班长")
res_func_3 = lambda res: compare_func(res, "你", "革命党")

school_intro_nodes = common_scene.LinearCutscene(*[common_scene.cutscene_str("诛余", t) for t in school_intro_text])
#try_again_node.nodes[1] = school_intro_nodes.nodes[0]

main_scene = common_scene.main_scene
main_scene.current_node = start_node

bacon_move_aside = lambda: (main_scene.set_fg_spr(common_scene.spr_bacon, common_scene.spr_vcm01), main_scene.animations.append(spr_2_left(common_scene.spr_bacon)), main_scene.animations.append(spr_show(common_scene.spr_vcm01)), main_scene.animations.append(spr_move(common_scene.spr_vcm01, 750, 0)), main_scene.set_bg_id(1))

advice_node_1 = AdviceNode(["你应该坚持你的想法。", "你应该先观望观望。", "你应该立刻改变你的行事，和同学搞好关系。"], ["\n* （第一个人满意地离开了。）"] * 3 + ["\n* （第一个人疑惑地离开了。）"], [lambda: None] * 4, free_node)
char_node_1 = CharNode("第一个人：\n* 我现在因为一些事情，和班里同学闹得有点僵。你说我该怎么解决这个问题呢？", "（他看起来有些犹豫。）", ["为什么会闹僵呢？"], ["第一个人：\n* 我在班级事务的处理上和同学们有些分歧。"], advice_node_1, res_func_1, ["你", "你的同学"])
school_intro_nodes.nodes[-1].next = char_node_1
school_intro_nodes.nodes[-1].side_effect = lambda : yi_scene.scene.setmode("full") or main_scene.set_data('ending_table', [[False, False], [False, False], [False, False]]) or bacon_move_aside()

char_2_pre_node = common_scene.LinearCutscene("诛余：\n* 好，现在第二个人来了。", "第二个人：\n* 我们这个班长，中央集权，独断专行，简直就是封建主义。")
advice_node_2 = AdviceNode(["时机已到，你应该立刻发动革命。", "你应该伺机而动。", "你在未来一段时间先不要革命。"], ["\n* （第二个人满意地离开了。）"] * 3 + ["\n* （第二个人疑惑地离开了。）"], [lambda x=i: main_scene.set_data('suc_2', x) for i in [False, True, True, False]], free_node)
char_node_2 = CharNode("第二个人：\n* 我准备发动革命，推翻班长暴政。你帮我算算，结果如何？", "（他看起来充满自信。）", ["你打算推行什么政策？"], ["第二个人：\n* 我？当然是要搞民主啦。每周发一次陶片之类的……"], advice_node_2, res_func_2, ["你", "班长"])

char_3_pre_node = common_scene.LinearCutscene("诛余：\n* 嗯，然后是第三个人。", "第三个人：\n* 唉，这帮孙子！我为班级做了那么多贡献，他们居然想着推翻我！")
advice_node_3 = AdviceNode(["机不可失，你应该立刻扼杀革命苗头。", "你应该伺机而动。", "革命党势头正旺，现在镇压易遭反噬，暂且绥靖，待其盛极而衰即可。"], ["\n* （第三个人气势汹汹地离开了。）"] * 3 + ["\n* （第三个人觉得你在消遣他，于是把你打了一顿。）"], [lambda x=i: main_scene.set_data('suc_3', x) for i in [False, True, True, False]], free_node)
char_node_3 = CharNode("第三个人：\n* 你帮我算算，我该不该杀鸡儆猴，枪打出头鸟？", "（他看起来五大三粗，义愤填膺。）", ["你……"], ["\n* （他看起来不是很友善，还是不要问问题的好。）"], advice_node_3, res_func_3, ["你", "革命党"])

def res_func_4(res):
    res_list = []
    if res["confidence"] < 3 or "你" not in res or "班长派" not in res or "革命者" not in res:
        return res_list
    if res["班长派"] < res["革命者"]:
        res_list.append(0)
    if res["班长派"] > res["革命者"]:
        res_list.append(1)
    if res["你"] > res["班长派"] and res["你"] > res["革命者"]:
        res_list.append(2)
    return res_list
char_4_pre_node = common_scene.LinearCutscene("诛余：\n* 现在是第四个人。", "诛余：\n* 注意，这是最后一个人了，也就是说这是你改变事情走向的最后机会了。", "第四个人：\n* 我看到班里形势很紧张。统治与被统治阶级之间的矛盾日益尖锐。")
advice_node_4 = AdviceNode(["革命将会胜利，你可以倒向革命者一方。", "革命将会失败，你可以加入班长一派。", "革命将会失败，到时候班长和革命者都不得民意，你要担负起重任。"], ["\n* （第四个人若有所思地离开了。）"] * 3 + ["\n* （第四个人失落地离开了。）"], [lambda x=i: main_scene.set_data('suc_4', x) for i in [False, False, True, False]], free_node)
predict_node_4 = common_scene.ChoiceNode(lambda: f"{main_scene.chr_name}：\n* 我推测……", [advice_node_4] * 3, ["革命会马上爆发。", "革命会在几周之后爆发。", "革命会在几个月之后爆发。"], [(lambda x=i: main_scene.set_data('pred', x)) for i in range(3)])
char_node_4 = CharNode("第四个人：\n* 我想算一算，这个班级该何去何从呢？", "（他看起来忧心忡忡。）", ["你怎么看待班长？", "你怎么看待革命党？"], ["第四个人\n* 我认为班长很有能力，只是行事太过独断了。", "第四个人\n* 我认为他们有点理想主义，在能力方面比不上现在的班长。"], advice_node_4, res_func_4, ["你", "班长派", "革命者"])

school_ending_texts = ["根据你的建议，星星之火可以燎原，革命以迅雷不及掩耳之势爆发了。",
                       "根据你的建议，班长采取铁腕政策镇压了革命。\n* 然后民意发酵，民怨沸腾，革命爆发了。",
                       "根据你的建议，革命党消停了一阵，然后揭竿而起。",
                       "根据你的建议，革命党观察形势，发现班长确实有所收敛。",
                       "但一段时间后班长就恢复原状了。革命党认为时机已到，发动了革命。",
                       "这个时间点差不多是期中考试结束的时候。",
                       "这个时间点差不多是快期末考试的时候。",
                       "这个时间点差不多是排练一二九短剧的时候。",
                       "之后革命党上台，推行新政，班级江河日下。",
                       "同学们发现革命不如不革命，不革命不如反革命，于是投票把革命党赶下台了。",
                       "之后班长重新上台，情况没有什么改变。\n* 但由于之前的各种冲突，班级的成绩下滑了。",
                       "这个时候，最后那个人根据你的建议，发动二次革命，成为新的班长。",
                       "之后这个班一片欣欣向荣的景象。",
                       "根据你的建议，班主任的亲信趁革命没有爆发，拉拢了一批班内的中间派，形成了一股新的势力。",
                       "班里形成了三足鼎立的局势，三方势力互相牵制，革命最终没有爆发。"
                       ]

school_try_again_node_1 = common_scene.CutsceneNode("诛余：\n* 现在你知道这四个人都是谁了。\n* 第一个人是班长派，第二个人是革命者，第三个是班长，第四个是中间派。\n* 现在我们再试一次，这次试试打出不同的结局。")
school_try_again_node_2 = common_scene.CutsceneNode("诛余：\n* 这次再试试另一种结局吧。", None, bacon_move_aside)


advice_node_1_new = AdviceNode(["你应该坚持你的想法，坚定地支持班长。", "你应该先观望观望。", "你应该立刻改变你的行事，和同学搞好关系，顺便建议班长收敛一些。"], ["\n* （第一个人满意地离开了。）"] * 3 + ["\n* （第一个人疑惑地离开了。）"], [lambda x=i: main_scene.set_data('suc_1', x) for i in [False, False, True, False]], free_node)
char_node_1_new = CharNode("第一个人：\n* 我现在因为一些事情，和班里同学闹得有点僵。你说我该怎么解决这个问题呢？", "（他看起来有些犹豫。）", ["为什么会闹僵呢？"], ["第一个人：\n* 我在班级事务的处理上和同学们有些分歧。"], advice_node_1_new, res_func_1, ["你", "你的同学"])
school_try_again_node_1.side_effect = lambda: char_node_1_new.tree(char_node_2.tree(char_node_3.tree(char_node_4))) and bacon_move_aside()

def res_func_4_new(res):
    res_list = []
    if res["confidence"] < 3:
        return res_list
    if "班长派" in res and "革命者" in res and res["班长派"] < res["革命者"]:
        res_list.append(0)
    if "班长派" in res and "革命者" in res and res["班长派"] > res["革命者"]:
        res_list.append(1)
    if "班长派" in res and "革命者" in res and "你" in res and res["你"] > res["班长派"] and res["你"] > res["革命者"]:
        res_list.append(2)
    if "班长派" in res and "革命者" in res and "班主任" in res and res["班主任"] > res["班长派"] and res["班主任"] > res["革命者"]:
        res_list.append(3)
    return res_list

advice_node_4_new = AdviceNode(["你可以倒向革命者一方。", "你可以加入班长一派。", "你要借革命的机会成为新的班长。", "你要帮助一位班主任麾下的“君子”以阻止革命的爆发。"], ["\n* （第四个人若有所思地离开了。）"] * 4 + ["\n* （第四个人失落地离开了。）"], [lambda x=i: main_scene.set_data('suc_4', x) for i in [False, False, True]] + [lambda: main_scene.set_data('suc_45', True)] + [lambda: main_scene.set_data('suc_4', False)], free_node)
predict_node_4_new = common_scene.ChoiceNode(lambda: f"{main_scene.chr_name}：\n* 我推测……", [advice_node_4_new] * 4, ["革命会马上爆发。", "革命会在几周之后爆发。", "革命会在几个月之后爆发。", "革命不会爆发。"], [(lambda x=i: main_scene.set_data('pred', x)) for i in range(4)])
char_node_4_new = CharNode("第四个人：\n* 我想算一算，这个班级该何去何从呢？", "（他看起来忧心忡忡。）", [], [], advice_node_4_new, res_func_4_new, ["你", "班长派", "革命者", "班主任"])

advice_node_5 = AdviceNode(["局势有利于你，你要借班主任之力稳定局势。", "你应该再观望观望局势的发展。", "局势很危险，你切不可轻举妄动。"], ["\n* （大君子若有所思地离开了。）"] * 3 + ["\n* （大君子困惑地离开了。）"], [lambda x=i: main_scene.set_data('suc_5', x) for i in [True, False, False, False]], char_node_4_new)
char_node_5 = CharNode("大君子：\n* 在这个矛盾日益尖锐的班级里，我该如何苟全性命？", "（他看起来是一位君子。）", [], [], advice_node_5, you_func, ["你"])

fifth_texts = ["不错，你差不多达成所有结局了。",
               "现在我们来加入一些新的信息。",
               "现在你知道这个班里有一个君子人物，他和班主任走得非常近。",
               "他也不认可班长的独裁，同时他和革命派的头领有一些私人恩怨。",
               "然后这个人也会来找你算卦。",
               "我们可以尝试扶植他上台。\n* 不过他自己可能把握不住民意，你需要找个人辅佐他。",
               "咱们再来走一遍流程。"
               ]
fifth_nodes = common_scene.LinearCutscene(*[common_scene.cutscene_str("诛余", t) for t in fifth_texts])
fifth_nodes.nodes[-1].side_effect = bacon_move_aside
school_leave_node = common_scene.CutsceneNode("诛余：\n* 时间也差不多了，今天就先到这。\n* 我要讲的也就这些了，之后你们可以在咱们学校自己试试。", halt, lambda: set_scene(transit_scenes[2]))

school_ending_nodes = [common_scene.CutsceneNode(common_scene.cutscene_str("诛余", t)) for t in school_ending_texts]
ens = (school_ending_nodes[10], school_ending_nodes[12], school_ending_nodes[14])

already_full = False
def set_ending(node_pre):
    global already_full
    main_scene.animations.append(spr_l2c(common_scene.spr_bacon)) or main_scene.animations.append(spr_disappear(common_scene.spr_vcm01))
    main_scene.set_bg_id(0)
    se_node = school_ending_nodes[0]
    school_ending_nodes[11].tree(school_ending_nodes[12])
    school_ending_nodes[0].tree(school_ending_nodes[5].tree(school_ending_nodes[8].tree(school_ending_nodes[9])))
    school_ending_nodes[1].tree(school_ending_nodes[7].tree(school_ending_nodes[8]))
    school_ending_nodes[2].tree(school_ending_nodes[7])
    school_ending_nodes[3].tree(school_ending_nodes[4].tree(school_ending_nodes[6].tree(school_ending_nodes[8])))
    school_ending_nodes[13].tree(school_ending_nodes[14])

    d = {}
    for key in ['suc_1', 'suc_2', 'suc_3', 'suc_4', 'pred', 'suc_45', 'suc_5']:
        try:
            d[key] = main_scene.data_dict[key]
        except KeyError:
            d[key] = None
    if not d['suc_2']:
        se_node = school_ending_nodes[0]
        t = 0
    else:
        if d['suc_5'] and d['suc_45']:
            se_node = school_ending_nodes[13]
            t = 3
        elif d['suc_3']:
            if d['suc_1']:
                se_node = school_ending_nodes[3]
                t = 2
            else:
                se_node = school_ending_nodes[2]
                t = 1
        else:
            se_node = school_ending_nodes[1]
            t = 1

    first = True
    for i in main_scene.data_dict['ending_table']:
        for j in i:
            if j:
                first = False

    if d['suc_4'] and d['pred'] == t:
        school_ending_nodes[9].next = school_ending_nodes[11]
        if t < 3:
            main_scene.data_dict['ending_table'][t][1] = True
    else:
        school_ending_nodes[9].next = school_ending_nodes[10]
        if t < 3:
            main_scene.data_dict['ending_table'][t][0] = True

    node_pre.next = se_node

    full = True
    for i in main_scene.data_dict['ending_table']:
        full = full and (i[0] or i[1])
    r1 = False
    r2 = False
    for i in [j[0] for j in main_scene.data_dict['ending_table']]:
        r1 = r1 or i
    for i in [j[1] for j in main_scene.data_dict['ending_table']]:
        r2 = r2 or i
    full = full and r1 and r2
    if first:
        school_try_again_node_1.tree(char_node_1_new)
        for n in ens:
            n.next = school_try_again_node_1
    elif not full:
        school_try_again_node_2.tree(char_node_1_new)
        for n in ens:
            n.next = school_try_again_node_2
    elif not already_full:
        already_full = True
        for n in ens:
            n.next = fifth_nodes.nodes[0]
        fifth_nodes.tree(char_node_1_new)
        char_node_3.tree(char_node_5.tree(char_node_4_new))
    else:
        try_again_node.nodes = [char_node_1_new, school_leave_node]
        try_again_node.side_effects = [bacon_move_aside, (lambda: None)]
        for n in ens:
            n.next = try_again_node

def change_bg(path):
    main_scene.bg_image = pygame.transform.scale(pygame.image.load(path), (screen.get_width(), screen.get_height()))


check_school_res_node = common_scene.CutsceneNode("诛余：\n* 好，现在我们来看看结果。")
check_school_res_node.side_effect = lambda: set_ending(check_school_res_node)

char_node_4.nodes[-1] = predict_node_4
char_node_1.tree(char_2_pre_node.tree(char_node_2.tree(char_3_pre_node.tree(char_node_3.tree(char_4_pre_node.tree(char_node_4.tree(check_school_res_node.tree(school_try_again_node_1.tree(char_node_1_new)))))))))
char_node_4_new.nodes[-1] = predict_node_4_new
char_node_4_new.tree(check_school_res_node)

vulgar_counter = 0
def add_vulgar_counter():
    global vulgar_counter
    vulgar_counter += 1
    if vulgar_counter == 5:
        begin_leave()
    elif vulgar_counter == 3:
        begin_pen()

vulgar_advice_node = AdviceNode(["你大胆去做，一定能找到另一半。", "你需要耐心等待对的人出现。", "你会孤独终老。"], ["\n* （围观者起哄，求卦者红着脸离开了。）", "\n* （求卦者若有所思地离开了。）", "\n* （围观者大笑，求卦者幽默地离开了。）", "\n* （求卦者困惑地离开了。）"], [add_vulgar_counter] * 4, None)
vulgar_chr_node = CharNode("求卦者：\n* 大师，我来求姻缘。", "（来者看起来嬉皮笑脸的。）", ["你……"], ["\n* （没有什么好问的。）"], vulgar_advice_node, you_func, ["你"])
vulgar_chr_node.tree(vulgar_chr_node)
pen_choice = common_scene.ChoiceNode("\n* （……）", [vulgar_chr_node, lambda: set_scene(pen_scene)], ["下一位？", "（弹笔）"])
leave_choice = common_scene.ChoiceNode("\n* （……）", [vulgar_chr_node, lambda: set_scene(pen_scene), halt], ["下一位？", "（弹笔）", "（午睡）"])

school_leave_node.tree(vulgar_chr_node)

def begin_pen():
    pen_scene.__init__()
    pen_scene.bg_shown = True
    pen_scene.esc_func = lambda: set_scene(main_scene)
    vulgar_chr_node.tree(pen_choice)

def begin_leave():
    vulgar_chr_node.tree(leave_choice)

close_down_texts = ["“大师”？",
                    "认得我吧？",
                    "有同学跟我反映说，你在这里宣扬封建迷信。\n* 还宣扬早恋。",
                    "所以，你在这里做什么呢？课后娱乐？心理疏导？",
                    "还是说，你想利用青年一代对玄学的迷信，操纵他们的人生？",
                    "马克思老先生讲，未来社会，每个人的自由发展是一切人的自由发展的条件。",
                    "人民是历史的创造者，群众是真正的英雄。劝你还是早日抛弃精英主义那一套。",
                    "从唯物主义的角度讲，现在的年轻人信玄学，确实有物质的因素在。\n* 全面深化改革开放，增速放缓，存量经济……经济基础决定上层建筑嘛。",
                    "你是八九点钟的太阳，你要想的是怎么改变这个社会，怎么普及马克思主义，而不是搞这一套。",
                    "爱钻研是好事，但别走到邪路上去了。",
                    "没事玩玩弹笔也好。"
                    ]
close_down_nodes = common_scene.LinearCutscene(*[common_scene.cutscene_str("教导主任", t) for t in close_down_texts])
leave_choice.nodes[-1] = close_down_nodes.nodes[0]
leave_choice.side_effects[-1] = lambda: set_scene(transit_scenes[3])
close_down_nodes.nodes[-1].next = halt
close_down_nodes.nodes[-1].side_effect = lambda: set_scene(pen_scene) or pen_scene.alert("完", "感谢您的游玩。", "制作：L.F.Z.小队")

start_scene = common_scene.start_scene
def unalert():
    main_scene.alerting = False

transit_scenes = []
for text in ["章一：起", "章二：承", "章三：转", "章四：合"]:
    transit_scenes.append(TransitionScene(pygame.Surface((screen.get_width(), screen.get_height())), main_scene))
    transit_scenes[-1].surface.fill("black")
    transit_scenes[-1].surface.blit(title_font.render(text, True, "white"), (screen.get_width() // 2 - title_font.size(text)[0] // 2, screen.get_height() // 2 - title_font.size(text)[1] // 2))
common_scene.true_start_scene = transit_scenes[0]
transit_scenes[1].side_effect = lambda: set_node(school_intro_nodes.nodes[0]) or main_scene.set_bg_id(0) or main_scene.animations.append(common_scene.SceneAnimation(0, 255, -1, (lambda x: tuple(i.set_alpha(x) for i in common_scene.spr_bacon.images)), common_scene.SceneAnimation.linear))
transit_scenes[2].side_effect = lambda: change_bg("images/bg_out.png") or main_scene.set_fg_spr(common_scene.spr_crowd) or main_scene.set_bg_id(3)
transit_scenes[3].side_effect = lambda: main_scene.set_fg_spr(common_scene.spr_sup) or pen_scene.set_esc_func(lambda: None) or main_scene.set_bg_id(4)
scene = start_scene
main_scene.alert("按Enter或点击鼠标左键以切换至下一文本", "按ctrl键以快进", "按esc键打开/关闭菜单")

def set_scene(new_scene):
    global scene
    scene = new_scene
common_scene.set_scene = set_scene
def read(book):
    reading_scene.set_book(book)
    set_scene(reading_scene)

reading_scene = book_scene.BookScene(lambda: set_scene(main_scene))
yi_scene.scene.esc_func = lambda: set_scene(main_scene)

# 防止卡顿的预处理，十分丑陋
for node in common_scene.choice_nodes:
    init_button(node, main_scene)
reading_scene.add_book(book_scene.zhou_yi_book)
reading_scene.add_book(book_scene.zeng_shan_book)

#main_scene.current_node = school_leave_node
# 框架主逻辑

clock = pygame.time.Clock()
running = True
dt = 0
mouse_down = False

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        scene.handle_event(event)

    scene.update(dt)
    scene.draw()

    mouse_down = False

    pygame.display.flip()

    dt = clock.tick(60) / 1000
    if dt > 0.3:
        dt = 0

pygame.quit()