def getPositionIndex(self, unit, pos):
# TODO: maybe calculate from the middle, not the corner
pt1x = self.pt1[0] - self._unitCornerOffset[0] * unit.HALF_WIDTH
pt1y = self.pt1[1] - self._unitCornerOffset[1] * unit.HALF_HEIGHT
dist = math.distance((pt1x, pt1y), pos)
fullDist = math.distance((0, 0), self.deltaPt)
midPoint = 0.5 * fullDist
return int(floor((dist - midPoint) / D_UNIT + 0.5))
def isRouteGoodEnough(self, route):
if route.finishPoint is None:
# Route isn't yet sure where it will end
return True
# Don't recalculate the route if we're still far from the target
target = self.getTargetPos()
error = distance(route.finishPoint, target)
total = distance(self.bot.player.pos, target)
if error / total >= 0.2:
return False
return True
def advance(self):
try:
onlyGrav, xAcc, yAcc = self.getAcceleration()
if self.stopped and onlyGrav:
return
self.stopped = False
deltaT = self.world.tickPeriod
self.xVel += xAcc * deltaT
self.yVel += yAcc * deltaT
deltaX = self.xVel * deltaT
deltaY = self.yVel * deltaT
oldX, oldY = self.pos
obstacle = self.world.physics.moveUnit(self, deltaX, deltaY)
if distance(self.pos, (oldX, oldY)) < self.stopToleranceDistance:
self.stationaryTicks += 1
if self.stationaryTicks > self.stopToleranceTicks:
self.xVel = self.yVel = 0
self.stopped = True
return
else:
self.stationaryTicks = 0
if obstacle is not None:
self.performRebound(obstacle)
except Exception:
log.exception('Error advancing {}'.format(self.__class__.__name__))
def advance(self):
if self.stopped:
return
deltaT = self.world.tickPeriod
try:
delta = (self.xVel * deltaT, self.yVel * deltaT)
oldPos = self.pos
self.pos, collision = self.world.physics.getMotion(
self, delta, ignoreLedges=self.ignoreLedges)
if distance(self.pos, oldPos) < self.stopToleranceDistance:
self.stationaryTicks += 1
if self.stationaryTicks > self.stopToleranceTicks:
self.stopped = True
self.xVel = self.yVel = 0
return
else:
self.stationaryTicks = 0
if collision:
self.performRebound(collision)
vFinal = self.yVel + self.getGravity() * deltaT
if vFinal > self.getMaxFallVel():
self.yVel = self.getMaxFallVel()
else:
self.yVel = vFinal
except Exception:
log.exception('Error advancing bouncy unit')
def advance(self):
try:
onlyGrav, xAcc, yAcc = self.getAcceleration()
if self.stopped and onlyGrav:
return
self.stopped = False
deltaT = self.world.tickPeriod
self.xVel += xAcc * deltaT
self.yVel += yAcc * deltaT
delta = (self.xVel * deltaT, self.yVel * deltaT)
oldX, oldY = self.pos
self.pos, collision = self.world.physics.getMotion(self, delta)
if distance(self.pos, (oldX, oldY)) < self.stopToleranceDistance:
self.stationaryTicks += 1
if self.stationaryTicks > self.stopToleranceTicks:
self.xVel = self.yVel = 0
self.stopped = True
return
else:
self.stationaryTicks = 0
if collision:
self.performRebound(collision)
except Exception:
log.exception('Error advancing {}'.format(self.__class__.__name__))
def reevaluate(self):
if self.bot.player.dead:
self.returnToParent()
return
zone = self.bot.player.getZone()
if zone != self.zone:
self.returnToParent()
return
playersInZone = set(p for p in zone.players if not p.dead)
if playersInZone != self.playersInZone:
self.returnToParent()
return
enemiesInZone = [
p for p in playersInZone if not p.isFriendsWith(self.bot.player)
]
if not enemiesInZone:
self.returnToParent()
return
target = min(enemiesInZone,
key=lambda p: distance(p.pos, self.bot.player.pos))
self.bot.attackPlayer(target)
def unitsHaveAdvanced(self):
for team in self.world.teams:
distance = math.distance(
self.world.trosballManager.getPosition(),
self.world.trosballManager.getTargetZoneDefn(team).pos)
if distance < ZONE_CAP_DISTANCE:
self.onTrosballScore(
team, self.world.trosballManager.lastTrosballPlayer)
def checkOrderCompletion(self, player):
playerZone = player.getZone()
if self.stopOnEntry:
if playerZone == self.zone and player.attachedObstacle:
return True
elif distance(player.pos, self.zone.defn.pos) < ZONE_CAP_DISTANCE:
return True
return False
def reevaluate(self):
if self.bot.player.dead:
self.returnToParent()
return
playerPos = self.bot.player.pos
targetZone = max(self.bot.world.zones,
key=lambda z: distance(z.defn.pos, playerPos))
self.bot.moveToOrb(targetZone)
def moveToFriendlyZone(self):
zones = [
z for z in self.world.zones if self.player.isZoneRespawnable(z)
]
if not zones:
self.world.callLater(3, self.orderFinished)
return
playerPos = self.player.pos
bestZone = min(zones, key=lambda z: distance(z.defn.pos, playerPos))
self.moveToZone(bestZone)
def getPositionFromIndex(self, unit, posIndex):
pt1x = self.pt1[0] - self._unitCornerOffset[0] * unit.HALF_WIDTH
pt1y = self.pt1[1] - self._unitCornerOffset[1] * unit.HALF_HEIGHT
fullDist = math.distance((0, 0), self.deltaPt)
midPoint = 0.5 * fullDist
u = midPoint + posIndex * D_UNIT
f = min(0.999, max(0.001, u / fullDist))
x = pt1x + f * self.deltaPt[0]
y = pt1y + f * self.deltaPt[1]
return (x, y)
def _reAim(self):
now = self.bot.world.getMonotonicTime()
dist = distance(self.bot.player.pos, self.zone.defn.pos)
if dist < 100:
if self.bot.player.ghostThrust:
self.bot.sendRequest(
AimPlayerAtMsg(0, 0, self.bot.world.lastTickId))
elif dist < 300 or self.nextCheckTime < now:
playerPos = self.bot.player.pos
zonePos = self.zone.defn.pos
dx = zonePos[0] - playerPos[0]
dy = zonePos[1] - playerPos[1]
theta = atan2(dx, -dy)
thrust = min(1, distance(playerPos, zonePos) / 300.)
self.bot.sendRequest(
AimPlayerAtMsg(theta, thrust, self.bot.world.lastTickId))
now = self.bot.world.getMonotonicTime()
self.nextCheckTime = now + 0.5
def tick(self):
if self.bot.player.ghostThrust == 0:
self._doAim()
if self.stopOnZoneEntry:
if self.bot.player.getZone() == self.stopOnZoneEntry:
self.bot.orderFinished()
return
else:
if distance(self.bot.player.pos, self.pos) < ZONE_CAP_DISTANCE:
self.bot.orderFinished()
return
def startMoving(self):
enemies = [
p for p in self.world.players
if not (p.dead or self.player.isFriendsWith(p))
]
playerPos = self.player.pos
if enemies:
nearestEnemy = min(enemies,
key=lambda p: distance(p.pos, playerPos))
self.attackPlayer(nearestEnemy)
else:
zones = [
z for z in self.world.zones if z.owner != self.player.team
and z.adjacentToAnotherZoneOwnedBy(self.player.team)
]
if zones:
nearestZone = min(
zones, key=lambda z: distance(z.defn.pos, playerPos))
self.moveToOrb(nearestZone)
else:
self.world.callLater(3, self.orderFinished)
def select_target(self, potentials):
my_pos = self.bot.player.pos
scoreboard = self.bot.world.scoreboard
best_score = -1
best_target = None
for player in potentials:
d = distance(my_pos, player.pos)
if d == 0:
return player
# Select player based on (score ** 2) / distance
score = scoreboard.playerScores.get(player, 0)**2 / d
if score > best_score:
best_score = score
best_target = player
return best_target
def updatePlayerViewAngle(self):
'''Updates the viewing angle of the player based on the mouse pointer
being at the position pos. This gets its own method because it needs
to happen as the result of a mouse motion and of the viewManager
scrolling the screen.'''
if self.world.uiOptions.showPauseMessage:
return
if self.player and self.player.dead and \
self.gameInterface.detailsInterface.trajectoryOverlay.enabled:
# Move ghost towards the orb
pos0 = self.player.pos
zone = self.player.getZone()
if zone is None:
theta = 0
dist = 0
else:
pos1 = zone.defn.pos
theta = atan2(pos1[0] - pos0[0], -(pos1[1] - pos0[1]))
dist = distance(pos0, pos1) * MAP_TO_SCREEN_SCALE
else:
dx, dy = self.mousePos
pos = (self.playerSprite.rect.center[0] + dx,
self.playerSprite.rect.center[1] + dy)
if self.playerSprite.rect.collidepoint(pos):
return
# Angle is measured clockwise from vertical.
theta = atan2(dx, -dy)
dist = (dx**2 + dy**2)**0.5
# Calculate a thrust value based on distance.
if dist < self.NO_GHOST_THRUST_MOUSE_RADIUS:
thrust = 0.0
elif dist > self.FULL_GHOST_THRUST_MOUSE_RADIUS:
thrust = 1.0
else:
span = (self.FULL_GHOST_THRUST_MOUSE_RADIUS -
self.NO_GHOST_THRUST_MOUSE_RADIUS)
thrust = (dist - self.NO_GHOST_THRUST_MOUSE_RADIUS) / span
thrust **= 2
self.gameInterface.sendRequest(
AimPlayerAtMsg(theta, thrust, tickId=self.getTickId()))
def getAcceleration(self):
minDist = None
closest = None
livePlayers = [p for p in self.world.players if not p.dead]
if livePlayers:
minDist, discard, player = min(
(distance(p.pos, self.pos), p.id, p) for p in livePlayers)
if 0 < minDist < self.attractiveRadius:
xr = (player.pos[0] - self.pos[0]) / minDist
yr = (player.pos[1] - self.pos[1]) / minDist
x = self.playerAttraction * xr
if yr > 0:
y = self.gravity * yr
else:
y = self.playerAttraction * yr
return False, x, y
return True, 0, self.gravity
def canHitPlayer(self, target):
physics = self.world.physics
gunRange = physics.shotLifetime * physics.shotSpeed
if target.dead or target.invisible or target.turret:
return False
if distance(self.player.pos, target.pos) < gunRange:
# Check if we can shoot without hitting obstacles
shot = self.player.createShot()
deltaX = target.pos[0] - self.player.pos[0]
deltaY = target.pos[1] - self.player.pos[1]
obstacle, dX, dY = physics.trimPathToObstacle(
shot, deltaX, deltaY, ())
if obstacle is None:
return True
return False
def canHitPlayer(self, target):
physics = self.world.physics
gunRange = physics.shotLifetime * physics.shotSpeed
if target.dead or target.invisible:
return False
if distance(self.player.pos, target.pos) < gunRange:
# Check if we can shoot without hitting obstacles
shot = self.player.createShot()
deltaX = target.pos[0] - self.player.pos[0]
deltaY = target.pos[1] - self.player.pos[1]
collision = physics.getCollision(shot, (deltaX, deltaY),
ignoreLedges=True)
if collision is None:
return True
return False
def selectZone(self):
if self.targetZone:
self.world.sendServerCommand(
ZoneStateMsg(self.targetZone.id, NEUTRAL_TEAM_ID, True))
allZones = [z for z in self.world.zones if z.owner is None]
options = [z for z in allZones if not z.players]
if options:
zone = random.choice(options)
else:
zone = min(
allZones,
key=lambda z: min(
distance(z.defn.pos, p.pos) for p in z.players))
self.world.sendServerCommand(
ZoneStateMsg(zone.id, self.targetTeamId, True))
self.targetZone = zone
return zone
def popPosition(self, expectedPosition):
if not self.positions:
log.warning('No positions left to pop!')
return
self.popCount += 1
pos = self.positions.pop(0)
if distance(pos, expectedPosition) >= 0.5:
log.warning('Bot simulation did not match actual position!')
log.warning(
'actual: %s simulated: %s (%s)', expectedPosition, pos,
', '.join(actionKind.__name__
for actionKind in self.actionKinds))
raise InconsistencyDetected()
if not self.positions:
# Ensure we always have at least one position recorded
self.getNextPosition()
def playerIsWithinTaggingDistance(self, player):
distance = math.distance(self.defn.pos, player.pos)
return distance < ZONE_CAP_DISTANCE
def distance(self, pos):
return distance(self.gameViewer.viewManager.getTargetPoint(), pos)
def playerIsWithinTaggingDistance(self, player):
if player.team and not player.team.abilities.zoneCaps:
return False
distance = math.distance(self.defn.pos, player.pos)
return distance < ZONE_CAP_DISTANCE
def distanceFromCentre(self):
zone = self.getZone()
if not zone:
return 2000
return distance(zone.defn.pos, self.pos)
