问山海——天涯海角——桃花渊攻击顺序

桃花渊

规划击杀各个boss顺序。

副本持续时间为30分钟，每个地方的boss被打死后，需要一定时间才能重新刷新。

只考虑其中两种boss，龟将和龟龙。各有四个。

其中我从一个boss地点到达另一个boss地点移动时间为20秒。（作为变量可设）

我击杀龟龙需要时间40秒，击杀龟将时间需要20秒。（作为变量可设）

四个龟将被击杀后，下一次刷新所需时间分别为：9:55 12:55 14:55 17:55
四个龟龙被击杀后，下一次刷新所需时间分别为：22:55 25:55 27:55 31:55

规划攻打顺序，击杀最大数量boss。

代码

from itertools import permutations


def format_time(seconds):
    """将时间从秒转换为分:秒的格式"""
    return f"{seconds // 60}分{seconds % 60}秒"


def calculate_kills_verbose(order, move_time=20, kill_time_turtle=20, kill_time_dragon=40):
    # 刷新时间
    refresh_times = {
        'J1': 9*60 + 55,
        'J2': 12*60 + 55,
        'J3': 14*60 + 55,
        'J4': 17*60 + 55,
        'L1': 22*60 + 55,
        'L2': 25*60 + 55,
        'L3': 27*60 + 55,
        'L4': 31*60 + 55,
    }

    # Boss备注信息
    boss_notes = {
        'J1': '右下角龟将',
        'J2': '右上角龟将',
        'J3': '左上角龟将',
        'J4': '左下角龟将',
        'L1': '右下角龟龙',
        'L2': '左下角龟龙',
        'L3': '右上角龟龙',
        'L4': '左上角龟龙'
    }

    # 初始化变量
    current_time = 0
    kills = {'J': 0, 'L': 0}
    last_kill_time = {key: -refresh_times[key]
                      for key in refresh_times}  # 记录每个boss上次被击杀的时间
    kill_sequence = []  # 新增：用于记录击杀顺序
    for boss in order:
        if current_time >= 30*60:  # 副本时间结束
            print("副本时间已结束")
            break

        # 打印攻击前Boss的剩余刷新时间
        print_boss_refresh_times(
            current_time, last_kill_time, refresh_times, boss_notes)

        current_time += move_time  # 移动到下一个boss

        # 计算击杀时间
        kill_time = kill_time_turtle if boss.startswith(
            'J') else kill_time_dragon

        # 获取Boss备注
        note = boss_notes.get(boss, '')  # 如果Boss没有备注，则默认为空字符串

        # 检查boss是否刷新
        if current_time - last_kill_time[boss] >= refresh_times[boss]:
            # 如果已经刷新，则击杀boss
            print(
                f"\n攻击{boss} ({note}), 剩余时间: {format_time(30*60 - current_time)}\n")
            kill_sequence.append(note)  # 新增：记录击杀顺序
            current_time += kill_time
            kills[boss[0]] += 1
            last_kill_time[boss] = current_time

        else:
            # 如果还未刷新，则计算等待时间
            wait_time = refresh_times[boss] - \
                (current_time - last_kill_time[boss])

            if current_time + wait_time + kill_time > 30*60:
                print(f"{boss} ({note}) 刷新所需时间超过剩余副本时间，无法继续击杀")
                break  # 剩余时间不够等待此boss刷新

            print(
                f"\n等待{boss} ({note}) 刷新, 需要等待{format_time(wait_time)}, 剩余时间: {format_time(30*60 - (current_time + wait_time))}\n")
            kill_sequence.append(note)  # 新增：记录击杀顺序
            current_time += wait_time + kill_time
            kills[boss[0]] += 1
            last_kill_time[boss] = current_time

        # 打印攻击后Boss的剩余刷新时间
        print_boss_refresh_times(
            current_time, last_kill_time, refresh_times, boss_notes)

        print('\n----------------------------------------------------------------------------------------------------------------------------------------------------\n')
    # 函数结束前，打印击杀顺序
    print("\n击杀顺序汇总：")
    for i, kill in enumerate(kill_sequence, start=1):
        print(f"{i}. {kill}")

    return kills


def print_boss_refresh_times(current_time, last_kill_time, refresh_times, boss_notes):
    for boss, refresh_time in refresh_times.items():
        time_since_last_kill = current_time - last_kill_time[boss]
        if time_since_last_kill < refresh_time:
            remaining_time = refresh_time - time_since_last_kill
            print(
                f"{boss} ({boss_notes[boss]}) 剩余刷新时间: {format_time(remaining_time)}")
        else:
            print(f"{boss} ({boss_notes[boss]}) 已刷新")


# 输入攻击顺序
order = ["J2", "J1", "L1", "L2", "J4", "J3",
         "L4", "L3", "J2", "J1", "J3", "J1", "J4", "J2", "L1", "L2"]

result = calculate_kills_verbose(order)
print(f"\n击杀总结：击杀龟将数量：{result['J']}, 击杀龟龙数量：{result['L']}")

代码解读

这个代码主要实现了一个计算和模拟游戏中的“副本”击杀策略的功能。在这个游戏中，有两种类型的boss（龟将和龟龙），每种boss有不同的刷新时间，并分布在地图的不同位置。玩家需要在一定的时间内尽可能多地击杀boss以获得奖励。

下面是对这个代码的详细解读：

1. 首先，定义了一个format_time函数，该函数接受一个表示秒数的参数，并将其转换为"分钟:秒"的格式。

2. 然后，定义了主要的函数calculate_kills_verbose，该函数接收四个参数：攻击顺序、移动时间、击杀龟将所需时间和击杀龟龙所需时间。其中，攻击顺序是一个列表，包含按顺序要击杀的boss的标识符。

3. 在calculate_kills_verbose函数中，首先定义了两个字典：refresh_times和boss_notes。refresh_times字典存储每个boss的刷新时间，boss_notes字典存储每个boss的备注信息。

4. 接着，初始化了一些变量，包括当前时间、各类boss的击杀数量，最后一次击杀每个boss的时间，以及用于记录击杀顺序的列表kill_sequence。

5. 然后，函数进入一个主循环，按照给定的顺序遍历并处理每个boss。在每次循环中，首先打印出当前时间和各个boss的剩余刷新时间，然后计算移动到下一个boss所需的时间，并增加当前时间。

6. 对于每个boss，首先检查它是否已经刷新。如果已经刷新，那么就直接击杀它，并更新相关信息。如果还未刷新，那么需要等待其刷新，然后再击杀它。在等待过程中，会不断检查剩余的副本时间是否足够。

7. 击杀完boss后，会打印出击杀后的当前时间和各个boss的剩余刷新时间。

8. 在处理完所有boss或者副本时间结束后，函数会退出主循环，然后打印出整个副本过程中的击杀顺序，最后返回一个包含各类boss击杀数量的字典。

9. print_boss_refresh_times函数是用来打印各个boss的剩余刷新时间的辅助函数。

10. 在最后的部分，定义了一个攻击顺序，然后调用calculate_kills_verbose函数模拟副本过程，并打印出击杀结果。