110 lines
3.1 KiB
Python
110 lines
3.1 KiB
Python
from enum import Enum
|
|
from typing import Tuple, Dict
|
|
|
|
from data import Game, Direction
|
|
|
|
def getHotSpot(game:Game) -> (int, int):
|
|
pass
|
|
|
|
def isOrderReady(game:Game) -> bool:
|
|
pass
|
|
|
|
def getReadyOrderId(game:Game) -> int:
|
|
pass
|
|
|
|
class Action():
|
|
|
|
|
|
def __init__(self, game: Game):
|
|
self.game = Game
|
|
|
|
def rotate(self, direction: Direction) -> Game:
|
|
self.game.agentDirection = direction
|
|
pass
|
|
|
|
def move(self) -> Game:
|
|
# w zaleznosci od kierunku napierdala do przodu
|
|
pass
|
|
|
|
def special(self) -> Game:
|
|
# w zaleznosci od miejsca gdzie jest i czy ma cos na lapie odklada albo bierze przedmiot
|
|
pass
|
|
|
|
def orderOut(self, orderId: int) -> Game:
|
|
# nalicza punkty wypierdalaorder i czysci orderStock
|
|
pass
|
|
|
|
def heuristic(a: Tuple[int, int], b: Tuple[int, int]) -> float:
|
|
(x1, y1) = a
|
|
|
|
(x2, y2) = b
|
|
return abs(x1 - x2) + abs(y1 - y2)
|
|
|
|
class PossibleMoves(Enum):
|
|
move = 1
|
|
rotateLeft = 2
|
|
rotateDown = 3
|
|
rotateRight = 4
|
|
rotateTop = 5
|
|
|
|
|
|
def getRotationEvaluation(direction: Direction):
|
|
# get evaluationForMoveAfterRotation
|
|
return 1.0
|
|
|
|
def evaluateMoves(game: Game) -> Dict:
|
|
posibleMoves = Dict
|
|
currPos = game.agentPos
|
|
gameCopy = game.getCopy()
|
|
getRotationEvaluation()
|
|
posibleMoves[PossibleMoves.move] = heuristic(currPos, Action(gameCopy).move().agentPos)
|
|
posibleMoves[PossibleMoves.rotateTop] = getRotationEvaluation(Direction.Direction.top)
|
|
posibleMoves[PossibleMoves.rotateLeft] = getRotationEvaluation(Direction.Direction.left)
|
|
posibleMoves[PossibleMoves.rotateDown] = getRotationEvaluation(Direction.Direction.down)
|
|
posibleMoves[PossibleMoves.rotateRight] = getRotationEvaluation(Direction.Direction.right)
|
|
return posibleMoves
|
|
|
|
def getIndex(value: float, dict: Dict) -> PossibleMoves:
|
|
for key, val in dict:
|
|
if val == value:
|
|
return key
|
|
|
|
def getMaxFromList(list: [float]) -> float:
|
|
maxi = -10000000
|
|
for i in range(len(list)):
|
|
if list[i] > maxi:
|
|
maxi = list[i]
|
|
|
|
return maxi
|
|
|
|
def getBestPossibleMove(game: Game) -> PossibleMoves:
|
|
movesDict = evaluateMoves()
|
|
bestChoice = getMaxFromList(movesDict.values())
|
|
return getIndex(bestChoice, movesDict)
|
|
|
|
def getBestMove(game: Game) -> Game:
|
|
gameCopy = game.getCopy()
|
|
bestPossibleMove = getBestPossibleMove(gameCopy)
|
|
|
|
if bestPossibleMove == PossibleMoves.move:
|
|
return Action(gameCopy).move()
|
|
elif bestPossibleMove == PossibleMoves.rotateTop:
|
|
return Action(gameCopy).rotate(Direction.Direction.top)
|
|
elif bestPossibleMove == PossibleMoves.rotateLeft:
|
|
return Action(gameCopy).rotate(Direction.Direction.left)
|
|
elif bestPossibleMove == PossibleMoves.rotateDown:
|
|
return Action(gameCopy).rotate(Direction.Direction.down)
|
|
else:
|
|
return Action(gameCopy).rotate(Direction.Direction.right)
|
|
|
|
|
|
|
|
def nastepnik(game: Game) -> Game:
|
|
if isOrderReady(game) > -1:
|
|
return Action(game.getCopy()).orderOut(getReadyOrderId(game))
|
|
elif game.agentPos == getHotSpot(game):
|
|
return Action(game.getCopy()).special()
|
|
else:
|
|
return getBestMove(game)
|
|
|