def get_flanking_coordinates(self, reference_position, flanked_position,
firing_distance, action):
""" Caluclate bot, left and rught flanking coordiantes. """
distance = (reference_position - flanked_position)
right_normalized = Vector2(-distance.y, distance.x).normalized()
left_normalized = Vector2(distance.y, -distance.x).normalized()
front_normalized = Vector2(distance.x, distance.y).normalized()
# calcualte flanked distance
front = front_normalized * (distance.length() -
(firing_distance *
(action.kwargs["flanking_distance"])))
# always a little bit on the left/right than in front so + 0.1
right = right_normalized * (firing_distance *
(0.2 + action.kwargs["flanking_distance"]))
left = left_normalized * (firing_distance *
(0.2 + action.kwargs["flanking_distance"]))
if action.action_type == Action.ActionType.PREPARE_FLANKING_RIGHT:
return [
reference_position - front * 0.75 - right,
reference_position - front - right
]
elif action.action_type == Action.ActionType.PREPARE_FLANKING_LEFT:
return [
reference_position - front * 0.75 - left,
reference_position - front - left
]
return None
def createShortFlankingPath(self,botPos,target):
# if they have same x then they differ in the y coordinate thus the one is up and the other is down :P
if(abs(botPos.x - target.x)<=abs(botPos.y - target.y)):
# relative positions between bot and target
# its either up and down or right and left, depending on that the capper
# approaches in a different way
upDown = True
# 1 or -1 depending on the scoring pos and enemy flag spawn pos
# want to know if we are going up or down the x or y coords when going to flag or back
# in order to build the path
middlesign = self.getSign(botPos.y,target.y)
else:
upDown = False
middlesign = self.getSign(botPos.x,target.x)
middle = botPos.midPoint(target)
if (not upDown):
# find closest side
if self.level.height - botPos.y > self.level.height/2:
path = [
self.commander.level.findNearestFreePosition(Vector2(middle.x - (middlesign*middle.x)/2,5)),
self.commander.level.findNearestFreePosition(Vector2(middle.x,5)),
self.commander.level.findNearestFreePosition(Vector2(middle.x + (middlesign*middle.x)/2,5)),
target,
self.commander.level.findRandomFreePositionInBox([target-2.5,target+2.5])
]
else:
path = [ self.commander.level.findNearestFreePosition(Vector2(middle.x - (middlesign*middle.x)/2,self.level.height-5)),
self.commander.level.findNearestFreePosition(Vector2(middle.x,self.level.height-5)),
self.commander.level.findNearestFreePosition(Vector2(middle.x + (middlesign*middle.x)/2,self.level.height-5)),
target,
self.commander.level.findRandomFreePositionInBox([target-2.5,target+2.5])
]
else:
# find closest side
if self.level.width - botPos.x > self.level.width/2:
path = [ self.commander.level.findNearestFreePosition(Vector2(5,middle.y - (middlesign*middle.y)/2)),
self.commander.level.findNearestFreePosition(Vector2(5,middle.y)),
self.commander.level.findNearestFreePosition(Vector2(5,middle.y + (middlesign*middle.y)/2)),
target,
self.commander.level.findRandomFreePositionInBox([target-2.5,target+2.5])
]
else:
path = [self.commander.level.findNearestFreePosition(Vector2(self.level.width-5,middle.y - (middlesign*middle.y)/2)),
self.commander.level.findNearestFreePosition(Vector2(self.level.width-5,middle.y)),
self.commander.level.findNearestFreePosition(Vector2(self.level.width-5,middle.y + (middlesign*middle.y)/2)),
target,
self.commander.level.findRandomFreePositionInBox([target-2.5,target+2.5])
]
# in case the capper has picked the flag from a fallen capper and the flag is near
# the scoring base then it is better to approach straight away
while True:
if botPos.squaredDistance(path[0]) > botPos.squaredDistance(path[-1]):
path = [path[-1]]
break
elif len(path) > 2 and Vector2.distance(botPos,path[-1]) < Vector2.distance(path[0],path[-1]):
path.pop(0)
else:
break
return path
def moveOrFace(self, bot):
enemyFlagLocation = self.game.enemyTeam.flag.position
# defend the flag!
targetPosition = self.game.team.flagScoreLocation
targetMin = targetPosition - Vector2(8.0, 8.0)
targetMax = targetPosition + Vector2(8.0, 8.0)
if bot.flag:
#bring it hooome
targetLocation = self.game.team.flagScoreLocation
self.issue(commands.Charge,
bot,
targetLocation,
description='returning enemy flag!')
else:
if (targetPosition - bot.position).length() > 9.0 and (
targetPosition - bot.position).length() > 3.0:
while True:
position = self.level.findRandomFreePositionInBox(
(targetMin, targetMax))
if position and (targetPosition - position).length() > 3.0:
#self.issue(commands.Move, bot, position, description = 'defending around flag')
self.issue(commands.Attack,
bot,
position,
description='defending around flag',
lookAt=enemyFlagLocation)
break
else:
self.issue(commands.Defend,
bot, (enemyFlagLocation - bot.position),
description='defending facing flag')
def getPathWithPathDistanceMap(start, end, mapData, finishWhenFoundPath = True):
sq2 = math.sqrt(2)
w = len(mapData)
h = len(mapData[0])
distance =[ [(0) for y in range(h)] for x in range(w)]
parent =[ [None for y in range(h)] for x in range(w)]
queue = PriorityQueue()
xstart = int(start.x)
ystart = int(start.y)
xend = int(end.x)
yend = int(end.y)
def heuristic(x0,y0, x1,y1):
return math.sqrt((x0-x1)*(x0-x1)+(y0-y1)*(y0-y1))
def checkPos(d, x, y, dx ,dy, delta):
x1 =x+dx
y1 = y+dy
result = False
if (x1<0 or x1>=w or y1<0 or y1>=h):
return False
fullDistance = d+delta*(mapData[x][y])
if (mapData[x1][y1]!=-1) and (parent[x1][y1]==None or distance[x1][y1]>fullDistance):
parent[x1][y1] = (x,y)
distance[x1][y1] = fullDistance
heursticD = fullDistance+heuristic(x,y,x1,y1)
queue._put((heursticD, (x1,y1)))
if ((x1==xend) and (y1==yend)):
result = True
return result
pathFounded = False
if checkPos(0, xstart,ystart, 0,0, 0) and finishWhenFoundPath:
return [Vector2(x+0.5,y+0.5)], distance, parent
while queue._qsize()>0:
prior,pos = queue._get()
x,y=pos
d = distance[x][y]
if (checkPos(d, x,y, 1,0, 1) or checkPos(d, x,y, -1,0, 1) or checkPos(d, x,y, 0,1, 1) or checkPos(d, x,y, 0,-1, 1) or
checkPos(d, x,y, 1,1, sq2) or checkPos(d, x,y, -1,1, sq2) or checkPos(d, x,y, 1,-1, sq2) or checkPos(d, x,y, -1,-1, sq2)):
pathFounded = True
if (finishWhenFoundPath):
break
result = []
if pathFounded:
x = xend
y = yend
while (parent[x][y]!=(x,y)):
result.append(Vector2(x+0.5,y+0.5))
x,y = parent[x][y]
result.reverse()
savePath('path',result, mapData)
return result, distance, parent
def getFlankingPositionBot(self, bot, target):
# Now figure out the flanking directions, assumed perpendicular.
d = (bot.position - target)
left = Vector2(-d.y, d.x).normalized()
right = Vector2(d.y, -d.x).normalized()
front = Vector2(d.x, d.y).normalized()
flanks = [target + f * 26.0 for f in [left, right]]
options = map(lambda f: self.level.findNearestFreePosition(f), flanks)
return sorted(options, key=lambda p: (bot.position - p).length())[0]
def findNearestFreePosition(self, target):
"""
Find a free position near 'target' for a character to move to.
None is returned if no position could be found.
"""
for r in range(1, 100):
areaMin = Vector2(target.x - r, target.y - r)
areaMax = Vector2(target.x + r, target.y + r)
position = self.findRandomFreePositionInBox((areaMin, areaMax))
if position:
return position
return None
def tick(self):
if self.attacker and self.attacker.health <= 0:
self.attacker = None
for bot in self.game.bots_available:
if (not self.attacker or self.attacker == bot
or bot.flag) and len(self.game.bots_alive) > 1:
self.attacker = bot
if bot.flag:
# Return the flag home relatively quickly!
targetLocation = self.game.team.flagScoreLocation
self.issue(commands.Move,
bot,
targetLocation,
description='returning enemy flag!')
else:
# Find the enemy team's flag position and run to that.
enemyFlagLocation = self.game.enemyTeam.flag.position
self.issue(commands.Charge,
bot,
enemyFlagLocation,
description='getting enemy flag!')
else:
if self.attacker == bot:
self.attacker = None
# defend the flag!
targetPosition = self.game.team.flag.position
targetMin = targetPosition - Vector2(8.0, 8.0)
targetMax = targetPosition + Vector2(8.0, 8.0)
if (targetPosition - bot.position).length() > 9.0 and (
targetPosition - bot.position).length() > 3.0:
while True:
position = self.level.findRandomFreePositionInBox(
(targetMin, targetMax))
if position and (targetPosition -
position).length() > 3.0:
self.issue(commands.Charge,
bot,
position,
description='defending around flag')
break
else:
self.issue(commands.Defend,
bot, (targetPosition - bot.position),
description='defending facing flag')
def initialize(self):
self.attacker = None
self.defender = None
self.verbose = False
# Calculate flag positions and store the middle.
ours = self.game.team.flag.position
theirs = self.game.enemyTeam.flag.position
self.middle = (theirs + ours) / 2.0
# Now figure out the flaking directions, assumed perpendicular.
d = (ours - theirs)
self.left = Vector2(-d.y, d.x).normalized()
self.right = Vector2(d.y, -d.x).normalized()
self.front = Vector2(d.x, d.y).normalized()
def area(self):
"""
Return the full area of the world.
This can be used with findRandomFreePositionInBox to find a random position in the world.
eg levelInfo.findRandomFreePositionInBox(levelInfo.area)
"""
return (Vector2.ZERO, Vector2(self.width, self.height))
def Command_AttackPathSmartStart(commander, bot, path):
#pos = commander.freePos(commander.game.enemyTeam.flag.position)
if len(path) <= 1:
return False
lookAt = None
if len(path) > commander.level.firingDistance + 2:
d = int(commander.level.firingDistance)
path = path[:d]
points = commander.levelAnalysis.getAllVisiblePoints(
path[d - 1], commander.level.firingDistance * 2, -1, 0, False)
_, lookP = min([(commander.enemyDistMap[x][y] if
commander.enemyDistMap[x][y] > 0 else 10000, (x, y))
for (x, y) in points],
key=lambda pair: pair[0])
lookAt = Vector2(lookP[0] + 0.5, lookP[1] + 0.5)
else:
lookAt = None
command = commands.Attack
commander.issue(command,
bot,
path,
lookAt,
description='Go smart at start')
return True
def Command_AttackDangerEvent(commander, bot):
e = bot.investigateEvent
pos = e.instigator.position if e.instigator != None else e.subject.position
if (bot.position - pos).length() > commander.level.firingDistance * 1.5:
return False
visiblePoints = commander.levelAnalysis.getAllVisiblePoints(
bot.position, commander.level.firingDistance)
minPos = min(visiblePoints,
key=lambda p: (pos - Vector2(p[0], p[1])).length())
lookPos = Vector2(minPos[0], minPos[1])
#dir = lookPos - bot.position
commander.issue(commands.Attack,
bot,
lookPos,
lookPos,
description='Attack danger event')
def issue_moves(self, move):
move_index = 0
for bot in self.game.bots_available:
pos = self.corridor_graph.node[move[move_index]]["position"]
pos = Vector2(pos[0], pos[1])
self.issue(orders.Charge, bot, pos)
move_index += 1
def lastTickEventsAnalyze(self):
self.dangerEvents = [e for e in self.dangerEvents if (self.game.match.timePassed-e.time)<self.eventInvalidationTime]
for event in self.lastTickEvents:
if event.type==MatchCombatEvent.TYPE_RESPAWN:
bot = event.subject
if bot in self.game.enemyTeam.members:
bot.position = self.level.findRandomFreePositionInBox(self.game.enemyTeam.botSpawnArea)
bot.seenLast = 0
bot.health = 100
bot.facingDirection = Vector2((random()-0.5),random()-0.5)
if self.enemyBotsAlive!=self.countBot:
self.updateDangerAtRespawn()
self.enemyBotsAlive=self.countBot
#print "Alive enemies: %d"%self.enemyBotsAlive
elif event.type==MatchCombatEvent.TYPE_KILLED:
if event.subject.team.name!=self.game.team.name:
self.enemyBotsAlive-=1
#print "Alive enemies: %d"%self.enemyBotsAlive
else:
self.dangerEvents.append(event)
#pos = e.instigator.position if e.instigator!=None else e.subject.position
pos = event.subject.position
self.levelAnalysis.updateDangerStatic(pos, 4, 196)
self.botInit(event.subject)
elif event.type == MatchCombatEvent.TYPE_FLAG_PICKEDUP and event.subject.team.name==self.game.team.name:
self.dangerEvents.append(event)
def getCornerPointInVisibility(self, pos, r):
points = self.getAllVisiblePoints(pos,r)
for p in points:
x,y = p[0], p[1]
if self.isCorner(x,y):
return Vector2(x+0.5, y+0.5)
return None
def __init__(self, map):
self.map = map
self.w = len(self.map)
self.h = len(self.map[0])
self.visibleSectors = self.buildLOS()
self.averageMin = [ [(self.visibleSectors[0][x][y][0]
+self.visibleSectors[1][x][y][0]
+self.visibleSectors[2][x][y][0]
+self.visibleSectors[3][x][y][0]
+self.visibleSectors[4][x][y][0]
+self.visibleSectors[5][x][y][0]
+self.visibleSectors[6][x][y][0]
+self.visibleSectors[7][x][y][0]
+7)/8.0 for y in range(self.h)] for x in range(self.w)]
self.distanceField = [ [min([self.visibleSectors[0][x][y][0],
self.visibleSectors[1][x][y][0],
self.visibleSectors[2][x][y][0],
self.visibleSectors[3][x][y][0],
self.visibleSectors[4][x][y][0],
self.visibleSectors[5][x][y][0],
self.visibleSectors[6][x][y][0],
self.visibleSectors[7][x][y][0]])
for y in range(self.h)] for x in range(self.w)]
self.maxField = [ [max([self.visibleSectors[0][x][y][0],
self.visibleSectors[1][x][y][0],
self.visibleSectors[2][x][y][0],
self.visibleSectors[3][x][y][0],
self.visibleSectors[4][x][y][0],
self.visibleSectors[5][x][y][0],
self.visibleSectors[6][x][y][0],
self.visibleSectors[7][x][y][0]])
for y in range(self.h)] for x in range(self.w)]
self.directions =[Vector2(1,0), Vector2(1,-1).normalized(), Vector2(0,-1), Vector2(-1,-1).normalized(),
Vector2(-1,0), Vector2(-1,1).normalized(), Vector2(0,1), Vector2(1,1).normalized()]
angle = math.pi/8
self.directions=[rotateVector2(x,angle) for x in self.directions]
self.dangerMap =[ [(0) for y in range(self.h)] for x in range(self.w)]
self.pathMap = self.createMapForPathFinding()
self.dangerMapStatic =[ [ -1 if self.map[x][y]>0 else 1 for y in range(self.h)] for x in range(self.w)]
self.visibleSafeToCharge = self.generateVisibleSafeMap()
self.mergeDangerStaticWith(self.visibleSafeToCharge)
self.cornerPoints = []
for y in range(self.h):
for x in range(self.w):
if self.isCorner(x,y):
self.cornerPoints.append(Vector2(x+0.5,y+0.5))
def postWorldHook(self, visualizer):
"""
Will draw a graphical representation of the corridor map on to the
visualisation window.
"""
for s, f in self.corridor_graph.edges():
visualizer.drawLine(self.corridor_graph.node[s]["position"],
self.corridor_graph.node[f]["position"],
QtGui.qRgb(255, 255, 255))
for n in self.corridor_graph.nodes():
#visualizer.drawCircle(self.corridor_graph.node[n]["position"],
# QtGui.qRgb(255, 255, 255))
pos = self.corridor_graph.node[n]["position"]
pos = Vector2(pos[0], pos[1])
visualizer.drawText(pos, QtGui.qRgb(255, 255, 255), unicode(n))
#if self.explored[n]:
#visualizer.drawCircle(self.corridor_graph.node[n]["position"],
# QtGui.qRgb(0, 0, 0), scale=0.8)
height_separator = self.level.height / 2
width_separator = self.level.width / 2
graph_one = []
graph_two = []
graph_three = []
graph_four = []
for n in self.corridor_graph.nodes():
position = self.corridor_graph.node[n]["position"]
position = Vector2(position[0], position[1])
if position.y > height_separator:
if position.x > width_separator:
graph_one.append(n)
else:
graph_two.append(n)
else:
if position.x > width_separator:
graph_three.append(n)
else:
graph_four.append(n)
graph_one = self.corridor_graph.subgraph(graph_one)
for n in graph_one.nodes():
visualizer.drawCircle(self.corridor_graph.node[n]["position"],
QtGui.qRgb(255, 0, 0),
scale=0.8)
def issue_moves(self, move):
move_index = 0
for bot in self.game.bots_alive:
if bot.state == bot.STATE_IDLE:
pos = self.corridor_graph.node[move[move_index]]["position"]
pos = Vector2(pos[0], pos[1])
self.issue(orders.Charge, bot, pos)
move_index += 1
def test_get_flaking_coordinates(self):
reference_position = Vector2(0, 0)
flanked_position = Vector2(0, 10)
firing_distance = 5
action_left = Action(Action.ActionType.PREPARE_FLANKING_LEFT,
flanking_distance=1.0)
action_rigth = Action(Action.ActionType.PREPARE_FLANKING_RIGHT,
flanking_distance=1.0)
flanking_left = self.coordinates_calculator.get_flanking_coordinates(
reference_position, flanked_position, firing_distance, action_left)
flanking_rigth = self.coordinates_calculator.get_flanking_coordinates(
reference_position, flanked_position, firing_distance,
action_rigth)
self.assertEqual(flanking_rigth[0].x, -flanking_left[0].x)
self.assertEqual(flanking_rigth[1].x, -flanking_left[1].x)
self.assertEqual(flanking_rigth[0].y, flanking_left[0].y)
self.assertEqual(flanking_rigth[1].y, flanking_left[1].y)
def initialize(self):
#self.attacker = None
self.verbose = False
self.enemyFlagLocation = self.game.enemyTeam.flag.position
#types - def,att,scr,spa
#spa experiment depends on '4,4' offset and kilroy start in top-right
#2 def, 2 att, rest scramble the middle
#FIX - the below is very hard-coded(and duplicative) and could be fixed to a more dynamic assignment function depending on the team assigned and roles needed - perhaps also as class properties rather than a dictionary also
self.info = {'Red0': {'timeLastCommand': 0, 'role': 'att1', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': ''},\
'Red1': {'timeLastCommand': 0, 'role': 'att2', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': ''},\
'Red2': {'timeLastCommand': 0, 'role': 'attX', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':0, 'flagY':0},\
'Red3': {'timeLastCommand': 0, 'role': 'def1', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':2, 'flagY':2},\
'Red4': {'timeLastCommand': 0, 'role': 'def2', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':-2, 'flagY':-2},\
'Red5': {'timeLastCommand': 0, 'role': 'def3', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':2, 'flagY':-2},\
'Red6': {'timeLastCommand': 0, 'role': 'def4', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':0, 'flagY':0},\
'Red7': {'timeLastCommand': 0, 'role': 'scr4', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':0, 'flagY':0},\
'Red8': {'timeLastCommand': 0, 'role': 'scr5', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':0, 'flagY':0},\
'Red9': {'timeLastCommand': 0, 'role': 'scr6', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':0, 'flagY':0},\
'Blue0': {'timeLastCommand': 0, 'role': 'att1', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': ''},\
'Blue1': {'timeLastCommand': 0, 'role': 'att2', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': ''},\
'Blue2': {'timeLastCommand': 0, 'role': 'attX', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':0, 'flagY':0},\
'Blue3': {'timeLastCommand': 0, 'role': 'def1', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':2, 'flagY':2},\
'Blue4': {'timeLastCommand': 0, 'role': 'def2', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':-2, 'flagY':-2},\
'Blue5': {'timeLastCommand': 0, 'role': 'def3', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':2, 'flagY':-2},\
'Blue6': {'timeLastCommand': 0, 'role': 'def4', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':0, 'flagY':0},\
'Blue7': {'timeLastCommand': 0, 'role': 'scr4', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':0, 'flagY':0},\
'Blue8': {'timeLastCommand': 0, 'role': 'scr5', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':0, 'flagY':0},\
'Blue9': {'timeLastCommand': 0, 'role': 'scr6', 'threshEvade': 30, 'distEvade': 4, 'botTrack': '', 'state': '', 'flagX':0, 'flagY':0}}
#self.info['Red4']['timeLastCommand'] = 40
# flanking setup from BalancedCommander
# Calculate flag positions and store the middle.
ours = self.game.team.flag.position
theirs = self.game.enemyTeam.flag.position
self.middle = (theirs + ours) / 2.0
# Now figure out the flanking directions, assumed perpendicular.
d = (ours - theirs)
self.left = Vector2(-d.y, d.x).normalized()
self.right = Vector2(d.y, -d.x).normalized()
self.front = Vector2(d.x, d.y).normalized()
self.flagRunner = ''
def initialize(self):
self.attacker = None
self.defenderSquad = [None, None] #defender pair
self.verbose = True
# Calculate flag positions and store the middle.
ours = self.game.team.flag.position
theirs = self.game.enemyTeam.flag.position
self.middle = (theirs + ours) / 2.0
self.centre = Vector2(self.level.width, self.level.height) / 2.0
# Now figure out the flaking directions, assumed perpendicular.
d = (ours - theirs)
self.left = Vector2(-d.y, d.x).normalized()
self.right = Vector2(d.y, -d.x).normalized()
self.front = Vector2(d.x, d.y).normalized()
self.respawnTime = self.game.match.timeToNextRespawn
def generateFlagPoints(self):
path, distMap, parentMap = getPathWithPathDistanceMap( self.game.enemyTeam.flag.position, self.ourSpawn, self.levelAnalysis.pathMap, False)
d = self.level.firingDistance*2+2
result=[]
for y in range(self.level.height):
for x in range(self.level.width):
if abs(distMap[x][y]-d)<0.5:
result.append(Vector2(x+0.5,y+0.5))
return result
def setVisible(x, y):
d = (Vector2(x, y) - position).normalized()
dp = d.dotProduct(facing_direction)
if dp > coshalffov:
self.game_state.visibility[x][y] = True
node_index = self.game_state.lookup[x][y]
if not self.game_state.seen[x][y]:
self.game_state.seen[x][y] = True
def IssueMoves(self, move):
i = 0
# print 'Issuing orders'
for bot in self.game.bots_available:
# print ' Issuing order to bot ' ,bot.name
# print ' Move from ', self.game_state.lookup[int(bot.position.x)][int(bot.position.y)], 'to ', move[i]
pos = self.game_state.corridor_graph.node[move[i]]["position"]
pos = Vector2(pos[0], pos[1])
self.issue(orders.Charge, bot, pos)
i = i + 1
def defenderLogic(self, bot):
# Stand on a random position in a box of 4m around the flag.
targetPosition = self.game.team.flagSpawnLocation
targetMin = targetPosition - Vector2(2.0, 2.0)
targetMax = targetPosition + Vector2(2.0, 2.0)
goal = self.level.findRandomFreePositionInBox([targetMin, targetMax])
if (goal - bot.position).length() > 8.0:
self.issue(commands.Charge,
bot,
goal,
description='running to defend')
else:
if bot == self.defenderSquad[0]:
self.issue(commands.Defend,
bot, (self.middle - bot.position),
description='turning to defend')
else:
self.issue(commands.Defend,
bot, (self.centre - bot.position),
description='turning to defend')
def buildDirecionMap(self, dangerPos):
self.bestDirectionsMap =[ [(0,0) for y in range(self.h)] for x in range(self.w)]
for x in range(0,self.w):
for y in range(0,self.h):
dirs =[(i, self.visibleSectors[i][x][y], self.visibleSectors[(i+7)%8][x][y]) for i in range(8)]
delta = dangerPos-Vector2(x,y)
dangerSector = self.getSectorIndex(delta)
dangerSector2 = (dangerSector+1)%8
bestI = max(dirs, key=lambda d: (d[1][0]+d[2][0]+ (d[1][1]+d[2][1])/16) * (2 if (d[0]==dangerSector or d[0]==dangerSector2) else 1) )
bestDirection = bestI[0]
self.bestDirectionsMap[x][y]=bestDirection
def Command_RunToMiddlePerpen(commander, bot, pos):
#pos = commander.game.enemyTeam.flag.position
middle = (pos + bot.position) / 2
d = pos - bot.position
left = Vector2(-d.y, d.x).normalized()
rnd = (random.random() - 0.5) * 2
goalPos = middle + left * rnd * d.length() / 4
path = [commander.freePos(goalPos), pos]
commander.issue(commands.Charge,
bot,
path,
description='Charge to perpen (ATTACKER)')
return True
def getSituation(self):
result = None
score = 0.0
for i in range(10):
p = self.level.findRandomFreePositionInBox(self.level.area)
o = Vector2(random.uniform(-0.5, 0.5),
random.uniform(-0.5, 0.5)).normalized()
s = self.evaluate(p, o, lambda x, y: 15.0 - self.getDistance(x, y))
# - self.getDistance(int(p.x), int(p.y)) * 100
if s > score or result == None:
result = (p, o)
score = s
print score
return result
def nearest_unexplored_root_node(self, bot_position):
closest_node = None
closest_distance = 1000000
for node in self.terminal_nodes:
if self.explored[node] == False:
node_pos = self.corridor_graph.node[node]["position"]
node_pos = Vector2(node_pos[0], node_pos[1])
distance = bot_position.distance(node_pos)
if distance < closest_distance:
closest_distance = distance
closest_node = node
if closest_node == None:
return 1
return closest_node
def getMin(self, pos,r,data, key):
minX, minY = self.clamp(int(pos.x-r), 0, self.w), self.clamp(int(pos.y-r), 0, self.h)
maxX, maxY = self.clamp(int(pos.x+r), 0, self.w), self.clamp(int(pos.y+r), 0, self.h)
rangeX, rangeY = maxX - minX, maxY - minY
if (rangeX == 0.0) or (rangeY == 0.0):
return None
bestPos = None
bestResult = 0
for x in range(minX, maxX):
for y in range(minY, maxY):
if (bestPos == None or data[x][y]<bestResult):
bestPos = Vector2(x+0.5,y+0.5)
bestResult = data[x][y]
return bestPos
def getBestBreakingPoints(self, startPoints, end, rPrefered, rControl, n):
pathMaxLength = 50
tmpMap = self.createMapForPathFinding()
result = []
allpaths = []
allPathData = [ [0 for y in range(self.h)] for x in range(self.w)]
for i in range(n):
start = startPoints[i%len(startPoints)]
path = getPath(start, end, tmpMap)
savePath("path_iteration"+str(i), path, tmpMap)
if len(path)<1:
break
allpaths.append(path[-pathMaxLength:])
self.MergeDataOnPath(path, rPrefered, allPathData, 1)
breakingMap = self.getBreakingMap([path], rPrefered, allPathData)
x,y = self.getTheBestPos(breakingMap)
bestPoint = Vector2(x+0.5,y+0.5)
pathMap = [ [tmpMap[x][y] for y in range(self.h)] for x in range(self.w)]
bestPair = None
for p in path:
if self.checkVisibility(bestPoint, p):
bestPair = (bestPoint,[p], path, pathMap, i)
break
if bestPair==None:
break
result.append(bestPair)
sector = self.getSectorIndexFloat(bestPair[1][0]-bestPair[0])
visiblePoints = self.getAllVisiblePoints(bestPoint, rControl, sector, 1)
#for p in path:
# x,y=int(p.x), int(p.y)
# if tmpMap[x][y] > 0:
# tmpMap[x][y] += 128
# if tmpMap[x][y]>255:
# tmpMap[x][y] = 255
for x,y in visiblePoints:
if tmpMap[x][y] > 0:
tmpMap[x][y] += 128
if tmpMap[x][y]>255:
tmpMap[x][y] = 255
savePath("allBreakingPoints", result, self.createMapForPathFinding())
saveImage('corners', [ [ 0 if self.distanceField[x][y]<0 else 124 if self.isCorner(x,y) else 255 for x in range(self.w)] for y in range(self.h)] )
saveImage('allPathData', allPathData)
return result
def getBestPosition(self, pos, r):
minX, minY = self.clamp(int(pos.x-r), 0, self.w), self.clamp(int(pos.y-r), 0, self.h)
maxX, maxY = self.clamp(int(pos.x+r), 0, self.w), self.clamp(int(pos.y+r), 0, self.h)
rangeX, rangeY = maxX - minX, maxY - minY
if (rangeX == 0.0) or (rangeY == 0.0):
return None
bestPos = None
bestResult = 255
for x in range(minX, maxX):
for y in range(minY, maxY):
if (self.averageMin[x][y]<bestResult):
bestPos = Vector2(x,y)
bestResult = self.averageMin[x][y]
return bestPos