AI创想家：迷宫寻宝大挑战

import api

import math

# 判断玩家是否需要离场

def ShouldLeave():

    context = api.get_context()

    # 玩家和终点信息

    me, exit = context.me, context.exit

    # 计算到终点距离

    distance = len(api.check.path(me, exit))

    # 判断是否需要离场

    ret = (me.energy <= distance + 1)

    return ret

# 缓存计算数据，每回合一次

def cache():

    context = api.get_context()

    round = context.round

    # 获取玩家的宝石收集情况

    data = context.me.item_count.items()

    # 忽略宝箱, 只统计宝石信息

    data = {k:v for k, v in data if k != 'box'}

    # 得到收集数量最少的宝石

    least = min(data.values())

    # 得到成套宝石中, 还缺少的宝石名称

    ret = [k for k, v in data.items() if v == least]

    context.set('cc', ret)

    print(f'第{round}回合, 待收集的宝石: {ret}')

    # 获取回合数

    record = context.get('record')

    if not record:

        record = dict({0: {}, 1: {}})

    enemy = context.players.get(1)

    if enemy:

        record[round % 2]['enemy'] = enemy

    me = context.me

    record[round % 2]['me'] = me

    context.set('record', record)

# 计算坐标附近的宝石数量

def GetNearCount(row, col):

    items = api.get.items()

    count = 0

    for item in items:

        if abs(item.row – row) <3:

            if abs(item.col – col) <3:

                start = (row, col)

                l = len(api.check.path(start, item, player_id=-1))

                if l < 3:

                    count +=1

    return count

# 估算物品的价值

def EstimateItemValue(item):

    context = api.get_context()

    me = context.me

    formula = 1 # 计算公式数值

    # 计算物品附近的宝石, 优先前往资源丰富的区域

    nearCnt = GetNearCount(item.row, item.col)

    if nearCnt > 1:

        print(f'X {nearCnt}  {item}')

        formula *= nearCnt

    # 计算玩家到物品距离

    self_distance = len(api.check.path(me, item))

    # 获取待收集的宝石

    allOne = context.get('cc')

    allOneCnt = len(allOne)

    # 如果是待收集的宝石

    isBelongToAllOne = item.name in allOne

    if isBelongToAllOne:

        formula *= (5 / allOneCnt)

    # 如果有敌人

    enemy = context.players.get(1)

    if enemy:

        enemy_score = enemy.score

        enemy_distance = len(api.check.path(enemy, item,player_id=enemy.id))

        # 获取敌人的上一回合信息

        record = context.get('record')

        prev_enemy = record[(context.round + 1) %2].get('enemy')

        # 如果敌人离宝石更近

        if enemy_distance < self_distance:

            formula *= 0.5

            if prev_enemy:

                prev_enemy_distance = len(api.check.path(prev_enemy, item,player_id=enemy.id))

                # 如果敌人正在远离宝石

                if prev_enemy_distance < enemy_distance:

                    formula *= 2

                # 否则敌人正在靠近宝石

                else:

                    formula *= 1

        elif enemy_distance == self_distance:

            formula *= 2 if me.order < enemy.order else 0.5

        else: # 如果敌人离宝石更远

            if prev_enemy:

                prev_enemy_distance = len(api.check.path(prev_enemy, item))

                # 如果敌人正在远离宝石

                if prev_enemy_distance < enemy_distance:

                    formula *= 1

                # 否则敌人正在靠近宝石

                else:

                    formula *= 2

    # 如果物品是宝箱

    isBelongToBox = item.name == 'box'

    if isBelongToBox:

        formula *= 3

    # 距离短就优先考虑, 距离过长就主动放弃

    formula *= 16 / (math.pow(self_distance, 2))

    return formula

 

# 寻找最有价值的物品

def findBestValueItem():

    items = api.get.items()

    estimate = lambda item: (EstimateItemValue(item), item)

    bestInfo = max([estimate(item) for item in items],key=lambda t: t[0])

    bestValue, bestItem = bestInfo

    print(f'最有价值物品: [Value = {bestValue:.2f}][Item = {bestItem}]')

    return bestItem

def update(context):

    cache()

    if ShouldLeave():

        exit = context.exit

        print(f'前往出口 {exit}')

        direction = api.check.next(exit)

    else:

        item = findBestValueItem()

        print(f'前往物品 {item}')

        direction = api.check.next(item)

    return direction

作者：lqk30875