Skip to content

Instantly share code, notes, and snippets.

@minaminao

minaminao/halite.py

Created Sep 23, 2020
Embed
What would you like to do?
# https://github.com/Kaggle/kaggle-environments/blob/master/kaggle_environments/envs/halite/helpers.py
import datetime
import math
from operator import pos
import random
import sys
import time
from collections import deque
from heapq import heappop, heappush
import numpy as np
from kaggle_environments.envs.halite.helpers import *
from tqdm import tqdm_notebook as tqdm
"""
Global constants
NOTE: 関数内で変更しても変わらない
"""
LOG = False
LOG_FLOW_ADD_EDGE = True
MAX_STEPS = 400
# Attack mode
ATTACK_START_STEP = 100
ATTACK_END_STEP = 300
MAX_BFS_DISTANCE = 10
# No need to change
INF = 10000000000
EPS = 1e-5
# 船が移動する4方向
DIRECTIONS = [ShipAction.NORTH, ShipAction.EAST,
ShipAction.SOUTH, ShipAction.WEST]
# ユーザーの行動
ACTIONS = [ShipAction.NORTH, ShipAction.EAST, ShipAction.SOUTH,
ShipAction.WEST, None] # TODO: ShipAction.CONVERT
# 所持していい船の最大数
MAX_SHIP_NUM = 50
# spawn と止めるターン数
STOP_SPAWN = 300
"""
Global variables
"""
# Logging
# 動作環境だと一意なシード値になってしまうため
rnd = random.Random(time.time())
# TODO: botnameをつける __file__は使えない
if LOG:
log_filename_time_prefix = datetime.datetime.now().strftime('%m%d_%H%M%S')
log_filename = f"{log_filename_time_prefix}_{rnd.randint(0, 10000)}.log"
progress_bar = None
"""
Structures and Functions
"""
class MinCostFlow:
"""
最小費用流
"""
INF = 10**18
EPS = 1e-6
ABORT = "ABORT"
def __init__(self, N):
self.N = N
self.G = [[] for _ in range(N)]
self.edge_num = 0
def add_edge(self, fr, to, cap, cost):
forward = [to, cap, cost, None]
backward = forward[3] = [fr, 0, -cost, forward]
self.G[fr].append(forward)
self.G[to].append(backward)
self.edge_num += 2
def flow(self, s, t, f, start_time=None, exit_time=None):
N = self.N
G = self.G
INF = MinCostFlow.INF
EPS = MinCostFlow.EPS
res = 0
H = [0]*N
prv_v = [0]*N
prv_e = [None]*N
d0 = [INF]*N
dist = [INF]*N
while f > EPS:
dist[:] = d0
dist[s] = 0
que = [(0, s)]
if start_time and time.time() - start_time > exit_time:
return self.ABORT
while que:
c, v = heappop(que)
if dist[v] + EPS < c:
continue
r0 = dist[v] + H[v]
for e in G[v]:
w, cap, cost, _ = e
if cap > EPS and r0 + cost - H[w] + EPS < dist[w]:
dist[w] = r = r0 + cost - H[w]
prv_v[w] = v
prv_e[w] = e
heappush(que, (r, w))
if dist[t] == INF:
return None
for i in range(N):
H[i] += dist[i]
d = f
v = t
while v != s:
d = min(d, prv_e[v][1])
v = prv_v[v]
f -= d
res += d * H[t]
v = t
while v != s:
e = prv_e[v]
e[1] -= d
e[3][1] += d
v = prv_v[v]
return res
TURNS_OPTIMAL = np.array(
[[0, 2, 3, 4, 4, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8],
[0, 1, 2, 3, 3, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7],
[0, 0, 2, 2, 3, 3, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7],
[0, 0, 1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6],
[0, 0, 0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6],
[0, 0, 0, 0, 0, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5],
[0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
def limit(x, a, b):
if x < a:
return a
if x > b:
return b
return x
def num_turns_to_mine(carrying, halite, rt_travel):
# How many turns should we plan on mining?
# C=carried halite, H=halite in square, rt_travel=steps to square and back
# to shipyard
if carrying < 0.01:
ch = 0
elif halite < 30:
ch = TURNS_OPTIMAL.shape[0] - 1
else:
ch = int(math.log(carrying / halite) * 2.5 + 5.5)
ch = limit(ch, 0, TURNS_OPTIMAL.shape[0] - 1)
rt_travel = int(limit(rt_travel, 0, TURNS_OPTIMAL.shape[1] - 1))
return TURNS_OPTIMAL[ch, rt_travel]
def halite_per_turn(carrying, halite, travel, min_mine=1):
# compute return from going to a cell containing halite, using optimal number of mining steps
# returns halite mined per turn, optimal number of mining steps
# Turns could be zero, meaning it should just return to a shipyard
# (subject to min_mine)
turns = num_turns_to_mine(carrying, halite, travel)
if turns < min_mine:
turns = min_mine
mined = carrying + (1 - .75**turns) * halite
return mined / (travel + turns)
def log(message):
"""
messageをlog_fileに書き込む
"""
if not LOG:
return
with open(f"logs/{log_filename}", 'a') as log_file:
log_file.write(message + "\n")
def spawn_step(ship: Ship):
"""
shipが生成されたターンを返す
"""
return int(ship.id.split('-')[0])
# 状態初期化したかどうか
# 途中からゲームを始めるとき用
initialized = False
def agent(obs, config):
"""
obs
- obs.step: 0 ~ MAX_STEPS - 2
config
- dict
- configじゃなくてboard.configurationを使うべし
"""
global initialized
global progress_bar
# boardに全情報が詰まっている
board = Board(obs, config)
"""
時間計測系
"""
start_time = time.time()
if not initialized:
EXIT_TIME = board.configuration.agent_timeout * 0.8
else:
EXIT_TIME = board.configuration.act_timeout * 0.8
def log_time(message, logging=True):
elapsed_time = time.time() - start_time
if logging:
log(f"time: {elapsed_time: .5f} {message}")
if elapsed_time >= EXIT_TIME:
print(
f"Step {obs.step} time over: {elapsed_time}, {message}", file=sys.stderr)
return True
return False
"""
情報加工系
obsとconfigからboardを構築する
"""
me = board.current_player
# Constants
BOARD_SIZE = board.configuration.size # 21
# プログレスバーの初期化
if me.id == 0:
if not progress_bar:
progress_bar = tqdm(total=board.configuration.episode_steps)
progress_bar.update(obs.step + 1)
progress_bar.update(1)
if not initialized:
initialized = True
if LOG:
print(f"player {me.id}'s log filename: {log_filename}")
log(f"player_id: {me.id}")
log(f"step {obs.step + 1}")
# index to cell 高速化用
index_to_cell = {point.to_index(BOARD_SIZE): cell for point,
cell in board.cells.items()}
# 障害物 index => (max_cargo, count)
# 例えば、100 だったら、最小 100 haliteを持つ敵がいる。
# haliteを120持つshipはNG haliteを80持つshipはOK と判定するための辞書
# TODO: remove
index_to_ship_max_cargo: Dict[int, (int, int)] = {}
# 小さいほうが強い
rank_of_ship_num = 0
for opponent in board.opponents:
if len(me.ships) < len(opponent.ships):
rank_of_ship_num += 1
"""
Methods
"""
def calc_distance_between_points(p1x, p1y, p2x, p2y):
"""
2点間の距離を計算
"""
dx = min((p1x - p2x) % BOARD_SIZE, (p2x - p1x) % BOARD_SIZE)
dy = min((p1y - p2y) % BOARD_SIZE, (p2y - p1y) % BOARD_SIZE)
return dx + dy
def calc_chebyshev_distance_between_points(p1x, p1y, p2x, p2y):
"""
2点間のChebyshev距離を計算
"""
dx = min((p1x - p2x) % BOARD_SIZE, (p2x - p1x) % BOARD_SIZE)
dy = min((p1y - p2y) % BOARD_SIZE, (p2y - p1y) % BOARD_SIZE)
return max(dx, dy)
def calc_min_xy_distance_between_points(p1x, p1y, p2x, p2y):
"""
2点間のChebyshev距離を計算
"""
dx = min((p1x - p2x) % BOARD_SIZE, (p2x - p1x) % BOARD_SIZE)
dy = min((p1y - p2y) % BOARD_SIZE, (p2y - p1y) % BOARD_SIZE)
return min(dx, dy)
def translate(ax, ay, dx, dy):
"""
(ax, ay) + (dx, dy) -> (bx, by)
"""
return (ax + dx + BOARD_SIZE) % BOARD_SIZE, (ay + dy + BOARD_SIZE) % BOARD_SIZE
def index_to_xy(index):
"""
index -> (x, y)
"""
y, x = divmod(index, BOARD_SIZE)
return x, (BOARD_SIZE - y - 1)
def xy_to_index(x, y):
"""
(x, y) -> index
"""
return (BOARD_SIZE - y - 1) * BOARD_SIZE + x
def is_opposite_ship_or_shipyard(point_index) -> bool:
"""
pointにshipかshipyardがいるかどうか
"""
cell = index_to_cell[point_index]
return (cell.ship and cell.ship.player_id != me.id) or (cell.shipyard and cell.shipyard.player_id != me.id)
def update_index_to_ship_max_cargo(index, cargo: int):
"""
"""
if index in index_to_ship_max_cargo:
max_cargo, count = index_to_ship_max_cargo[index]
if cargo < max_cargo:
index_to_ship_max_cargo[index] = (cargo, 1)
elif cargo == max_cargo:
index_to_ship_max_cargo[index] = (cargo, count + 1)
else:
index_to_ship_max_cargo[index] = (cargo, 1)
(SHIP_LOSE, SHIP_DRAW, SHIP_WIN) = range(3)
def check_max_cargo_condition(ship_halite, index):
"""
あるshipがpへ行っても船が壊されないかどうか
TODO: Rename
"""
if not index in index_to_ship_max_cargo:
return SHIP_WIN
if ship_halite < index_to_ship_max_cargo[index][0]:
return SHIP_WIN
elif ship_halite > index_to_ship_max_cargo[index][0]:
return SHIP_LOSE
return SHIP_DRAW
if log_time(""):
return me.next_actions
# 各マスの制限を更新
# 相手のshipに対して
# TODO: 周辺4マスは制限強いので緩くする
for ship_id, ship in board.ships.items():
if ship.player_id != me.id:
update_index_to_ship_max_cargo(
ship.position.to_index(BOARD_SIZE), ship.halite)
for direction in DIRECTIONS:
next_point = ship.position.translate(
direction.to_point(), BOARD_SIZE)
update_index_to_ship_max_cargo(
next_point.to_index(BOARD_SIZE), ship.halite)
# 各地点について、その地点から最短の拠点までの距離
# 拠点が一つも存在しなければINFになる
distance_to_my_nearest_shipyard = [
[0 for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
distance_to_opponent_nearest_shipyard = [
[0 for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
chebyshev_distance_to_my_nearest_shipyard = [
[0 for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
min_xy_distance_to_my_nearest_shipyard = [
[0 for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
distance_to_opponent_nearest_ship = [
[0 for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
distance_to_my_nearest_ship = [
[0 for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
distances_to_my_nearest_shipyard = [
[[] for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
for x in range(BOARD_SIZE):
for y in range(BOARD_SIZE):
min_num = INF
for shipyard in me.shipyards:
min_num = min(min_num, calc_distance_between_points(
shipyard.position.x, shipyard.position.y, x, y))
distance_to_my_nearest_shipyard[x][y] = min_num
min_num = INF
for shipyard in me.shipyards:
min_num = min(min_num, calc_chebyshev_distance_between_points(
shipyard.position.x, shipyard.position.y, x, y))
chebyshev_distance_to_my_nearest_shipyard[x][y] = min_num
min_num = INF
for shipyard in me.shipyards:
min_num = min(min_num, calc_min_xy_distance_between_points(
shipyard.position.x, shipyard.position.y, x, y))
min_xy_distance_to_my_nearest_shipyard[x][y] = min_num
min_num = INF
for opponent in board.opponents:
for ship in opponent.ships:
min_num = min(min_num, calc_distance_between_points(
ship.position.x, ship.position.y, x, y))
distance_to_opponent_nearest_ship[x][y] = min_num
min_num = INF
for opponent in board.opponents:
for shipyard in opponent.shipyards:
min_num = min(min_num, calc_distance_between_points(
shipyard.position.x, shipyard.position.y, x, y))
distance_to_opponent_nearest_shipyard[x][y] = min_num
min_num = INF
for ship in me.ships:
distance = calc_distance_between_points(
ship.position.x, ship.position.y, x, y)
if distance == 0:
continue
min_num = min(min_num, distance)
distance_to_my_nearest_ship[x][y] = min_num
for shipyard in me.shipyards:
distances_to_my_nearest_shipyard[x][y].append(calc_distance_between_points(
shipyard.position.x, shipyard.position.y, x, y))
distances_to_my_nearest_shipyard[x][y].sort()
# 相手のshipyardに対して
for _shipyard_id, shipyard in board.shipyards.items():
if shipyard.player_id != me.id:
shipyard_index = shipyard.position.to_index(BOARD_SIZE)
shipyard_destroyer_max_cargo = 0 # 0 だと障害物
if (rank_of_ship_num <= 1 and distance_to_my_nearest_shipyard[shipyard.position.x][shipyard.position.y] <= 3) or obs.step >= 375:
shipyard_destroyer_max_cargo = 1
if shipyard_index in index_to_ship_max_cargo:
index_to_ship_max_cargo.pop(shipyard_index)
update_index_to_ship_max_cargo(
shipyard_index, shipyard_destroyer_max_cargo)
for next_direction in DIRECTIONS:
neighbor_point_index = shipyard.position.translate(
next_direction.to_point(), BOARD_SIZE).to_index(BOARD_SIZE)
if neighbor_point_index in index_to_ship_max_cargo:
index_to_ship_max_cargo.pop(neighbor_point_index)
update_index_to_ship_max_cargo(
neighbor_point_index, shipyard_destroyer_max_cargo)
RANGE_CAMP = math.ceil(math.sqrt(
5 * len(me.ships) / max(1, len(me.shipyards)) / 2))
log(f"{len(me.ships)},{len(me.shipyards)} => RANGE_CAMP: {RANGE_CAMP}")
CAMP_HALITE = 100
log("index_to_ship_max_cargo")
for k, v in index_to_ship_max_cargo.items():
log(f" {index_to_xy(k)} {v}")
def is_minable_halite_area_in_attack_mode(x, y):
"""
Attack mode中にhaliteをマイニングしていいエリア
TODO: なめらかにしたい
"""
if distance_to_my_nearest_shipyard[x][y] <= 2:
return distance_to_opponent_nearest_ship[x][y] >= 1
if distance_to_my_nearest_shipyard[x][y] <= 4:
return distance_to_opponent_nearest_ship[x][y] >= 2
if distance_to_my_nearest_shipyard[x][y] <= 8:
return distance_to_opponent_nearest_ship[x][y] >= 3
return False
def bfs(ship: Ship, point_from: Point, max_distance=1000):
"""
shipから全点への最短経路を求める
point_fromの条件チェックはしない(TODO: 本当に良い?)
"""
point_directions = [direction.to_point() for direction in DIRECTIONS]
q = deque()
# (position, distance, parent, prev direction)
q.append((point_from.to_index(BOARD_SIZE), 0, -1, -1))
index_to_info = {}
while len(q):
point_u_index, distance, parent_index, direction = q.popleft()
point_u_x, point_u_y = index_to_xy(point_u_index)
if point_u_index in index_to_info:
continue
index_to_info[point_u_index] = (
distance, parent_index, direction)
if distance == max_distance:
continue
for (direction, point_direction) in zip(DIRECTIONS, point_directions):
point_v_x, point_v_y = translate(
point_u_x, point_u_y, point_direction.x, point_direction.y)
point_v_index = xy_to_index(point_v_x, point_v_y)
# 自分の拠点はcontinueしない。2つ目のbfsではmax_cargoを考慮
if not (index_to_cell[point_v_index].shipyard and index_to_cell[point_v_index].shipyard.player_id != me.id):
# 強い船が周囲1マス以内にいるならcontinue
if check_max_cargo_condition(ship.halite, point_v_index) == SHIP_LOSE:
continue
# 互角の船が周囲1マス以内にいるならcontinue
if check_max_cargo_condition(ship.halite, point_v_index) == SHIP_DRAW:
# and is_opposite_ship_or_shipyard(point_v_index):
continue
if point_v_index in index_to_info:
continue
q.append((point_v_index, distance+1,
point_u_index, direction))
return index_to_info
def bfs_one_target(ship: Ship, point_from: Point, point_to: Point, check_max_cargo=True):
"""
ある点 から ある点 への最短経路を求める
point_fromの条件チェックはしない
"""
point_directions = [direction.to_point() for direction in DIRECTIONS]
q = deque()
point_from_index = point_from.to_index(BOARD_SIZE)
point_to_index = point_to.to_index(BOARD_SIZE)
# (position, distance, parent, prev direction)
q.append((point_from_index, 0, -1, -1))
index_to_info = {}
while len(q):
point_u_index, distance, parent_index, direction = q.popleft()
point_u_x, point_u_y = index_to_xy(point_u_index)
if point_u_index in index_to_info:
continue
index_to_info[point_u_index] = (
distance, parent_index, direction)
if point_to_index in index_to_info:
break
for (direction, point_direction) in zip(DIRECTIONS, point_directions):
point_v_x, point_v_y = translate(
point_u_x, point_u_y, point_direction.x, point_direction.y)
point_v_index = xy_to_index(point_v_x, point_v_y)
# TODO: refine
if check_max_cargo and check_max_cargo_condition(ship.halite, point_v_index) != SHIP_WIN:
continue
if point_v_index in index_to_info:
continue
q.append((point_v_index, distance+1, point_u_index, direction))
if point_to_index in index_to_info:
res = []
point_v_index = point_to_index
while point_v_index != point_from_index:
distance, point_u_index, direction = index_to_info[point_v_index]
res.append((point_u_index, direction))
point_v_index = point_u_index
res = res[::-1]
return True, res
else:
return False, []
tmp_halite = me.halite
log(f"len(me.ships): {len(me.ships)}")
# shipをconvertすべきタイミングかどうか
def should_ship_convert():
if len(me.ships) < 12:
n = 1
elif len(me.ships) < 14:
n = 2
elif len(me.ships) < 23:
n = 3
elif len(me.ships) < 33:
n = 4
else:
n = 5
if obs.step < 200:
n = min(n, 5)
elif obs.step < 250:
n = min(n, 4)
elif obs.step < 300:
n = min(n, 3)
elif obs.step < 350:
n = min(n, 2)
else:
n = min(n, 1)
return len(me.shipyards) < n
ship_convert = should_ship_convert()
log(f"ship_convert {ship_convert}")
"""
Cell scoring
"""
if log_time("cell scoring start"):
return me.next_actions
# セルの評価 (近くにhaliteがあれば高くなる。自セルは含まない。)
cell_score = [[0 for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
cell_score_and_index = []
RANGE_DISTANCE = 3
for ax in range(BOARD_SIZE):
for ay in range(BOARD_SIZE):
log(f"({ax}, {ay}) cell halite: {index_to_cell[xy_to_index(ax,ay)].halite}, ship halite: {index_to_cell[xy_to_index(ax,ay)].ship.halite if index_to_cell[xy_to_index(ax,ay)].ship else None}")
if is_opposite_ship_or_shipyard(xy_to_index(ax, ay)):
continue
for dx in range(-RANGE_DISTANCE, RANGE_DISTANCE + 1):
for dy in range(-RANGE_DISTANCE, RANGE_DISTANCE + 1):
if abs(dx) + abs(dy) > RANGE_DISTANCE:
continue
bx, by = translate(ax, ay, dx, dy)
distance = calc_distance_between_points(
ax, ay, bx, by)
if distance == 0:
continue
cell_score[ax][ay] += index_to_cell[xy_to_index(bx, by)
].halite / distance
cell_score_and_index.append((cell_score[ax][ay], (ax, ay)))
cell_score_and_index.sort()
cell_score_and_index.reverse()
log(f"cell_score_and_index: {cell_score_and_index[:5]}")
if log_time("cell scoring end"):
return me.next_actions
"""
shipyardの行動
"""
if log_time("shipyard start"):
return me.next_actions
# board_total_halite = sum(obs.halite)
score_and_shipyard_ids = []
for shipyard in me.shipyards:
score_and_shipyard_ids.append(
(cell_score[shipyard.position.x][shipyard.position.y], shipyard.id))
score_and_shipyard_ids.sort()
score_and_shipyard_ids.reverse()
# 作るなら早めに作ったほうが良い
# 躊躇する必要はない
spawn_ship_num = 0
# expected_ship_halite = 754.2045976147749 + obs.step*- \
# 2.28367203 + board_total_halite * 0.00364342
# log(f"expected ship halite: {expected_ship_halite}")
for _, shipyard_id in score_and_shipyard_ids:
shipyard = board.shipyards[shipyard_id]
shipyard_index = shipyard.position.to_index(BOARD_SIZE)
# ship convert するならその余地を残しておく
if ship_convert and tmp_halite < 1000:
break
spawn = False
# >= 1000 は拠点攻撃マン対策
if tmp_halite >= 1000 or (obs.step < ATTACK_START_STEP and tmp_halite >= 500):
spawn |= obs.step < STOP_SPAWN and len(
me.ships) + spawn_ship_num < MAX_SHIP_NUM # and expected_ship_halite > 500
spawn |= len(me.ships) + spawn_ship_num < 2
if spawn:
shipyard.next_action = ShipyardAction.SPAWN
spawn_ship_num += 1
tmp_halite -= 500
update_index_to_ship_max_cargo(
shipyard_index, -1) # -1にしないと拠点守るくんと競合してしまう
else:
shipyard.next_action = None
if log_time("shipyard end"):
return me.next_actions
"""
ターゲットの割当
"""
# 最小費用流インデックス構築
ship_id_to_mcf_node_id = {}
mcf_id_to_ship_id = {}
for ship_index, ship_id in enumerate(me.ship_ids):
ship_id_to_mcf_node_id[ship_id] = ship_index
mcf_id_to_ship_id[ship_index] = ship_id
BASE_COST = 10000
def calc_cost(x):
return x + BASE_COST + 1
"""
フローの計算量
N = 30 + 400 + 2 = 432
M = 30
M * (N*M) * log N = 30 * 432 * 30 * 9 = 3,499,200
"""
mcf_node_num = len(me.ships) + BOARD_SIZE * BOARD_SIZE + 2
ship_num = len(me.ships)
start_mcf_node_id = mcf_node_num - 1
goal_mcf_node_id = mcf_node_num - 2
def build_mcf(first=False):
"""
最小費用流のグラフの初期化
"""
mcf = MinCostFlow(mcf_node_num)
for i in range(len(me.ships)):
mcf.add_edge(start_mcf_node_id, i, 1,
calc_cost(0)) # fr, to, cap, cost
for i in range(BOARD_SIZE * BOARD_SIZE):
point = Point.from_index(i, BOARD_SIZE)
if first:
# 拠点
if distance_to_my_nearest_shipyard[point.x][point.y] == 0:
if obs.step < ATTACK_END_STEP:
mcf.add_edge(ship_num + i, goal_mcf_node_id,
5, calc_cost(0))
else:
mcf.add_edge(ship_num + i, goal_mcf_node_id,
100, calc_cost(0))
if (100 <= obs.step or len(me.ships) >= 2) and distance_to_my_nearest_shipyard[point.x][point.y] == 0:
mcf.add_edge(ship_num + i, goal_mcf_node_id,
1, calc_cost(-1000))
elif is_opposite_ship_or_shipyard(point.to_index(BOARD_SIZE)) and ATTACK_START_STEP <= obs.step < ATTACK_END_STEP:
if distance_to_opponent_nearest_shipyard[point.x][point.y] == 0:
mcf.add_edge(ship_num + i, goal_mcf_node_id,
2, calc_cost(0))
elif is_minable_halite_area_in_attack_mode(point.x, point.y):
mcf.add_edge(ship_num + i, goal_mcf_node_id,
2, calc_cost(0))
else:
mcf.add_edge(ship_num + i, goal_mcf_node_id,
4, calc_cost(0))
else:
mcf.add_edge(ship_num + i, goal_mcf_node_id,
1, calc_cost(0))
else:
if obs.step < 390:
if (100 <= obs.step or len(me.ships) >= 2) and distance_to_my_nearest_shipyard[point.x][point.y] == 0:
mcf.add_edge(ship_num + i, goal_mcf_node_id,
1, calc_cost(-1000))
else:
mcf.add_edge(ship_num + i, goal_mcf_node_id,
1, calc_cost(0))
else:
mcf.add_edge(ship_num + i, goal_mcf_node_id,
10, calc_cost(0))
return mcf
mcf = build_mcf(True)
if log_time("flow1 adding edge start"):
return me.next_actions
def fast_hash(x):
return x * 107 % 31
# bfsして各船に対して各セルの評価値を定める
# haliteが多いほど高く、距離が遠いほど低く
for ship in me.ships:
if log_time("flow1 ship loop", False):
return me.next_actions
ship_index = ship_id_to_mcf_node_id[ship.id]
if obs.step <= 15:
index_to_info = bfs(ship, ship.position, MAX_BFS_DISTANCE * 2)
else:
index_to_info = bfs(ship, ship.position, MAX_BFS_DISTANCE)
for target_point_index, (distance, _parent_index, _direction) in index_to_info.items():
target_point = Point.from_index(target_point_index, BOARD_SIZE)
# TODO: refine
# if (not check_max_cargo_condition(ship.halite, target_point_index)) and is_opposite_ship_or_shipyard(target_point_index):
# BFSは相打ち以外
if check_max_cargo_condition(ship.halite, target_point_index) != SHIP_WIN:
# spawnされてると自分の拠点上にはいけないため、SHIP_LOSE でここに入る
continue
if len(me.shipyards) == 0 and MAX_STEPS - (obs.step + 1) < distance:
continue
if len(me.shipyards) > 0 and MAX_STEPS - (obs.step + 1) < distance + distance_to_my_nearest_shipyard[target_point.x][target_point.y]:
continue
# distance == 0 だと stay するから、その分を引かなくちゃいけない
if len(me.shipyards) > 0 and MAX_STEPS - (obs.step + 2) < distance + distance_to_my_nearest_shipyard[target_point.x][target_point.y] and distance == 0:
continue
# 自分の拠点だった場合
if distance_to_my_nearest_shipyard[target_point.x][target_point.y] == 0:
# shipが居ると distance=0 でゼロ除算になるため場合分け
if distance > 0:
expected_halite = ship.halite / distance
else:
expected_halite = 0
else:
target_position_halite = 0
target_cell = index_to_cell[target_point_index]
if obs.step <= 20 and len(me.shipyards) <= 1 and distance_to_my_nearest_shipyard[target_point.x][target_point.y] < 10 - spawn_step(ship):
continue
if obs.step < ATTACK_START_STEP and target_cell.halite < 100:
continue
if ATTACK_START_STEP <= obs.step < ATTACK_END_STEP:
# TODO: 相手の船のhaliteをhalite_per_turnに入れない (絶対値的には良くない)
# if ship.halite == 0 and distance_to_my_nearest_shipyard[target_point.x][target_point.y] <= RANGE_CAMP and target_cell.halite == 0 and (target_point_index + obs.step) % 3 == 0:
# target_position_halite += 300 / \
# distance_to_my_nearest_shipyard[target_point.x][target_point.y]
# if is_minable_halite_area_in_attack_mode(target_point.x, target_point.y):
# # 割る数が以外と重要
# target_position_halite += obs.halite[target_point.to_index(
# BOARD_SIZE)] / 3
# elif ship.halite == 0 and distance_to_my_nearest_shipyard[target_point.x][target_point.y] <= RANGE_CAMP and target_cell.ship and target_cell.ship.player_id != me.id:
# target_position_halite += 200
# else:
# # 500未満じゃないと拠点作られて船を失ってしまう
# if spawn_step(ship) % 2 == 1 and ship.halite == 0 \
# and target_cell.ship and target_cell.ship.player_id != me.id and 0 < target_cell.ship.halite < 500:
# target_position_halite += target_cell.ship.halite
if is_minable_halite_area_in_attack_mode(target_point.x, target_point.y):
if obs.halite[target_point_index] > 400 / pow(distance_to_my_nearest_shipyard[target_point.x][target_point.y], 0.5):
target_position_halite += obs.halite[target_point_index]
if ship.halite == 0:
# 500未満じゃないと拠点作られて船を失ってしまう
if target_cell.ship and target_cell.ship.player_id != me.id and 0 <= target_cell.ship.halite < 500:
halite = target_cell.ship.halite
if distance_to_my_nearest_shipyard[target_point.x][target_point.y] <= RANGE_CAMP:
halite = max(100, halite)
target_position_halite += halite
# 陣地ロジック
# if ship.halite == 0:
# if distance_to_nearest_shipyard[target_point.x][target_point.y] <= RANGE_CAMP and obs.halite[target_point_index] >= CAMP_HALITE:
# target_position_halite += obs.halite[target_point_index]
# elif distance_to_nearest_shipyard[target_point.x][target_point.y] <= RANGE_CAMP:
# if target_cell.ship and target_cell.ship.player_id != me.id and target_cell.ship.halite > ship.halite:
# target_position_halite += 100 * \
# distance_to_nearest_shipyard[target_point.x][target_point.y]
# if len(me.shipyards) > 0:
# target_position_halite += obs.halite[target_point_index] / 10
else:
target_position_halite += obs.halite[target_point_index]
if 375 <= obs.step and target_cell.shipyard and target_cell.shipyard.player_id != me.id:
target_position_halite += 500
# 近くにいるshipyardは破壊
elif rank_of_ship_num <= 1 and distance_to_my_nearest_shipyard[target_point.x][target_point.y] <= 3 and target_cell.shipyard and target_cell.shipyard.player_id != me.id:
target_position_halite += 500
# TODO: 距離2以内にいるshipは破壊
# 0だったら目的地として相応しくない
# 2回目のフローでは0のマスも候補になるからcontinueしても良い
if target_position_halite == 0:
continue
if len(me.shipyards) == 0:
# 拠点に帰らないので、cargo は 0 にしないと動かなくなってしまう
expected_halite = halite_per_turn(
0, target_position_halite, distance)
else:
expected_halite = halite_per_turn(
ship.halite, target_position_halite, distance_to_my_nearest_shipyard[target_point.x][target_point.y] + distance)
if expected_halite > 0:
mcf.add_edge(ship_index, ship_num + target_point_index,
1, calc_cost(-expected_halite))
if LOG_FLOW_ADD_EDGE:
log(
f"flow1 add edge: {ship.position} => {target_point}, expected_halite {expected_halite}")
if log_time("flow1 adding edge end"):
return me.next_actions
log(f"flow1 edge num: {mcf.edge_num}")
if mcf.flow(start_mcf_node_id, goal_mcf_node_id, ship_num, start_time, EXIT_TIME) == MinCostFlow.ABORT:
log_time("abort flow1")
return me.next_actions
if log_time("flow1 end"):
return me.next_actions
mcf_node_id_to_target_index_and_score = {}
for ship_index in range(len(mcf.G)):
edges = mcf.G[ship_index]
for to, cap, cost, _ in edges:
if ship_index < ship_num and ship_num <= to < mcf_node_num - 2 and cap < MinCostFlow.EPS:
next_index = to - ship_num
ship_id = mcf_id_to_ship_id[ship_index]
ship = board.ships[ship_id]
mcf_node_id_to_target_index_and_score[ship_index] = (
next_index, cost)
next_point = Point.from_index(next_index, BOARD_SIZE)
log(
f"flow1: id {ship_id}, halite {ship.halite}, {ship.position} => target {next_point}, cost {cost}")
# グラフの初期化
mcf = build_mcf()
if log_time("flow2 adding edge start"):
return me.next_actions
for ship in me.ships:
if log_time("flow2 ship loop", False):
return me.next_actions
ship_id = ship.id
ship_node_id = ship_id_to_mcf_node_id[ship_id]
ship_index = ship.position.to_index(BOARD_SIZE)
# 移動候補の評価値の初期化
for next_direction in DIRECTIONS:
target_point = ship.position.translate(
next_direction.to_point(), BOARD_SIZE)
target_point_index = target_point.to_index(BOARD_SIZE)
target_cell = index_to_cell[target_point_index]
if check_max_cargo_condition(ship.halite, target_point_index) == SHIP_WIN:
cost = distance_to_my_nearest_shipyard[target_point.x][
target_point.y] if distance_to_my_nearest_shipyard[target_point.x][target_point.y] != INF else 0
mcf.add_edge(
ship_node_id, ship_num + target_point_index, 1, calc_cost(cost))
if LOG_FLOW_ADD_EDGE:
log(
f"flow2 add edge: {ship.position} => {target_point}, cost {cost}, distance 1")
# 行けるっちゃいける
elif check_max_cargo_condition(ship.halite, target_point_index) == SHIP_DRAW:
mcf.add_edge(
ship_node_id, ship_num + target_point_index, 1, calc_cost(BASE_COST/2-1))
if LOG_FLOW_ADD_EDGE:
log(
f"flow2 add edge: {ship.position} => {target_point}, cost {BASE_COST/2-1}, distance 1")
# shipyardの条件がないと spawn した船と衝突してしまう
elif not is_opposite_ship_or_shipyard(target_point_index) and not (target_cell.shipyard and target_cell.shipyard.player_id == me.id):
mcf.add_edge(
ship_node_id, ship_num + target_point_index, 1, calc_cost(BASE_COST/2))
if LOG_FLOW_ADD_EDGE:
log(
f"flow2 add edge: {ship.position} => {target_point}, cost {BASE_COST/2}, distance 1")
elif target_point_index in index_to_ship_max_cargo and index_to_ship_max_cargo[target_point_index][1] == 1 and not (target_cell.shipyard and target_cell.shipyard.player_id == me.id):
mcf.add_edge(
ship_node_id, ship_num + target_point_index, 1, calc_cost(BASE_COST/2+1))
if LOG_FLOW_ADD_EDGE:
log(
f"flow2 add edge: {ship.position} => {target_point}, cost {BASE_COST/2+1}, distance 1")
else:
mcf.add_edge(
ship_node_id, ship_num + target_point_index, 1, calc_cost(BASE_COST))
if LOG_FLOW_ADD_EDGE:
log(
f"flow2 add edge: {ship.position} => {target_point}, cost {BASE_COST}, distance 1")
# 居座るかどうか
if check_max_cargo_condition(ship.halite, ship_index) == SHIP_WIN:
if ATTACK_START_STEP <= obs.step < ATTACK_END_STEP:
if is_minable_halite_area_in_attack_mode(ship.position.x, ship.position.y) \
or index_to_cell[ship_index].shipyard:
cost = distance_to_my_nearest_shipyard[ship.position.x][
ship.position.y] if distance_to_my_nearest_shipyard[ship.position.x][ship.position.y] != INF else 0
mcf.add_edge(
ship_node_id, ship_num + ship_index, 1, calc_cost(cost))
if LOG_FLOW_ADD_EDGE:
log(
f"flow2 add edge: {ship.position} => {ship.position}, cost {cost}, distance 0")
else:
mcf.add_edge(
ship_node_id, ship_num + ship_index, 1, calc_cost(BASE_COST/3))
if LOG_FLOW_ADD_EDGE:
log(
f"flow2 add edge: {ship.position} => {ship.position}, cost {BASE_COST/3}, distance 0")
else:
cost = distance_to_my_nearest_shipyard[ship.position.x][
ship.position.y] if distance_to_my_nearest_shipyard[ship.position.x][ship.position.y] != INF else 0
mcf.add_edge(
ship_node_id, ship_num + ship_index, 1, calc_cost(cost))
if LOG_FLOW_ADD_EDGE:
log(
f"flow2 add edge: {ship.position} => {ship.position}, cost {cost}, distance 0")
# 拠点守る
# 相手が隣にいるけど、shipyardに居る
elif check_max_cargo_condition(ship.halite, ship_index) == SHIP_DRAW and index_to_cell[ship_index].shipyard:
mcf.add_edge(
ship_node_id, ship_num + ship_index, 1, calc_cost(0))
if LOG_FLOW_ADD_EDGE:
log(f"flow2 add edge: {ship.position} => {ship.position}, cost 0, distance 0")
# 相手が隣にいたら評価を悪く
else:
mcf.add_edge(
ship_node_id, ship_num + ship_index, 1, calc_cost(BASE_COST))
if LOG_FLOW_ADD_EDGE:
log(f"flow2 add edge: {ship.position} => {ship.position}, cost {BASE_COST}, distance 0")
# 船にターゲットが指定されていれば
if ship_node_id in mcf_node_id_to_target_index_and_score:
target_index, score = mcf_node_id_to_target_index_and_score[ship_node_id]
score -= BASE_COST + 1 # expected_halite
target_point = Point.from_index(target_index, BOARD_SIZE)
# target から逆算
index_to_info = bfs(ship, target_point)
for next_action in ACTIONS:
if next_action:
next_point = ship.position.translate(
next_action.to_point(), BOARD_SIZE)
else:
next_point = ship.position
if ATTACK_START_STEP <= obs.step < ATTACK_END_STEP \
and not is_minable_halite_area_in_attack_mode(next_point.x, next_point.y):
continue
next_point_index = next_point.to_index(BOARD_SIZE)
if next_point_index in index_to_info:
distance, _, _ = index_to_info[next_point_index]
log(f"{ship.position} {next_point} {distance}")
if check_max_cargo_condition(ship.halite, next_point_index) == SHIP_WIN:
# TODO: refine
# halite_per_turn などを考慮して厳密に
mcf.add_edge(ship_node_id, ship_num + next_point_index,
1, calc_cost(score / (distance+1)))
if LOG_FLOW_ADD_EDGE:
log(
f"flow2 add edge: {ship.position} => {next_point}, cost {score / (distance+1)}, distance {distance}")
if log_time("flow2 adding edge end"):
return me.next_actions
log(f"flow2 edge num: {mcf.edge_num}")
if mcf.flow(start_mcf_node_id, goal_mcf_node_id, ship_num, start_time, EXIT_TIME) == MinCostFlow.ABORT:
log_time("abort flow2")
return me.next_actions
if log_time("flow2 end"):
return me.next_actions
mcf_node_id_to_target_index_and_score = {}
for ship_index in range(len(mcf.G)):
edges = mcf.G[ship_index]
for to, cap, cost, _ in edges:
if ship_index < ship_num and ship_num <= to < mcf_node_num - 2 and cap < MinCostFlow.EPS:
next_index = to - ship_num
ship_id = mcf_id_to_ship_id[ship_index]
ship = board.ships[ship_id]
mcf_node_id_to_target_index_and_score[ship_index] = (
next_index, cost)
next_point = Point.from_index(next_index, BOARD_SIZE)
log(
f"flow2: id {ship_id}, halite {ship.halite}, {ship.position} => next {next_point}, cost {cost}")
for ship_index, (next_position_id, score) in mcf_node_id_to_target_index_and_score.items():
ship_id = mcf_id_to_ship_id[ship_index]
ship = board.ships[ship_id]
next_position = Point.from_index(next_position_id, BOARD_SIZE)
# TODO: refine
if score > BASE_COST + 1:
_success, path = bfs_one_target(
ship, ship.position, next_position, False)
else:
_success, path = bfs_one_target(ship, ship.position, next_position)
if len(path) == 0:
next_action = None
else:
next_action = path[0][1]
ship.next_action = next_action
for ship in me.ships:
if ship.next_action:
next_position = ship.position.translate(
ship.next_action.to_point(), BOARD_SIZE)
else:
next_position = ship.position
update_index_to_ship_max_cargo(
next_position.to_index(BOARD_SIZE), ship.halite)
"""
Convert ship to shipyard
"""
if ship_convert:
v = []
log(f"convert: ")
for ship in me.ships:
# 拠点があればスキップ
if index_to_cell[ship.position.to_index(BOARD_SIZE)].shipyard:
continue
if 20 <= obs.step and distance_to_my_nearest_ship[ship.position.x][ship.position.y] != INF and distance_to_opponent_nearest_ship[ship.position.x][ship.position.y] <= distance_to_my_nearest_ship[ship.position.x][ship.position.y]:
continue
log(f" candidate: {ship.id} {ship.position} halite {ship.halite}")
if ship.halite + tmp_halite >= 500:
if len(distances_to_my_nearest_shipyard[ship.position.x][ship.position.y]) == 0:
v.append((cell_score[ship.position.x]
[ship.position.y], ship.id))
elif len(distances_to_my_nearest_shipyard[ship.position.x][ship.position.y]) == 1:
if 6 <= distances_to_my_nearest_shipyard[ship.position.x][ship.position.y][0] <= 7:
v.append((cell_score[ship.position.x]
[ship.position.y], ship.id))
else:
if 6 <= distances_to_my_nearest_shipyard[ship.position.x][ship.position.y][0] <= 7 \
and 6 <= distances_to_my_nearest_shipyard[ship.position.x][ship.position.y][1] <= 7:
v.append((cell_score[ship.position.x]
[ship.position.y], ship.id))
v.sort()
v.reverse()
log(f"v {v}")
if len(v):
distance, ship_id = v[0]
if 4 <= distance:
ship = board.ships[ship_id]
tmp_halite -= 500 - ship.halite
ship.next_action = ShipAction.CONVERT
log(str(me.next_actions))
log(f"time: {time.time() - start_time}")
log("")
return me.next_actions
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.