def haveClearShotOfTarget(self, target): owner = self.owner fleet = owner.fleet turretPosition = self.getPosition() targetPosition = target.getPosition() turretToTarget = calculate.subtractPoints(targetPosition, turretPosition) distanceSquaredToTarget = vector.getMagnitudeSquared(turretToTarget) headingToTarget = vector.normalize(turretToTarget) for friendlyShip in fleet.getAllShips(): friendPosition = friendlyShip.getPosition() turretToFriend = calculate.subtractPoints(friendPosition, turretPosition) distanceSquaredToFriend = vector.getMagnitudeSquared(turretToFriend) if distanceSquaredToFriend > distanceSquaredToTarget: continue headingToFriend = vector.normalize(turretToFriend) dotProductOfFriendAndTarget = calculate.dotProduct(headingToTarget, headingToFriend) if calculate.withinTolerance(dotProductOfFriendAndTarget, 1, self.clearShotTolerance): return False return True
def update(self, timeElapsed): world = self.world currentPosition = self.position shipHit = self.hit() if shipHit: shipHit.hitBy(self) world.removeShot(self) self.active = False return originToCurrent = calculate.subtractPoints(currentPosition, self.startingPosition) distanceSquaredFromOrigin = vector.getMagnitudeSquared(originToCurrent) if distanceSquaredFromOrigin > self.maxDistanceSquared: world.removeShot(self) return (x, y) = calculate.addPointAndVector(currentPosition, self.velocity) self.position = (x, y)
def acquireTemporaryTarget(self): '''Collect any targets that are in range. Then, collect from those the targets to which we have a clear shot. Find the one that is closest. That is the temporary target.''' turretPosition = self.getPosition() owner = self.owner fleet = owner.fleet enemiesInRange = [] for enemyShip in fleet.getAllEnemyShips(): if not self.targetIsInRange(enemyShip): continue if not self.haveClearShotOfTarget(enemyShip): continue enemiesInRange.append(enemyShip) closestShip = None closestDistanceSquared = None for enemyShip in enemiesInRange: enemyPosition = enemyShip.getPosition() turretToEnemy = calculate.subtractPoints(enemyPosition, turretPosition) distanceSquaredToEnemy = vector.getMagnitudeSquared(turretToEnemy) if closestShip is None or distanceSquaredToEnemy < closestDistanceSquared: closestShip = enemyShip closestDistanceSquared = distanceSquaredToEnemy if closestShip: self.setTarget(closestShip) return closestShip else: return None
def plotLocalRouteAroundTarget(owner, target): steeringController = owner.steeringController ownerPosition = owner.getPosition() targetPosition = target.getPosition() ownerToTarget = calculate.subtractPoints(targetPosition, ownerPosition) distanceToTarget = vector.getMagnitude(ownerToTarget) optimalPathDistance = min(distanceToTarget, owner.getMaximumFiringRange()) #These are the eight "compass" directions, projected #in the target's local space vectors = ((0, 1), (1, 1), (1, 0), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)) #Now scale the directions so that they have my magnitude. #We can treat these vectors as points in an octagonal #path around the target - a path scaled to an optimal distance. pathPoints = [calculate.multiplyVectorAndScalar(normalizedVector, optimalPathDistance) for normalizedVector in vectors] #Find the point in the path that is closest to my position. ownerLocalPosition = convert.pointToLocalSpace(ownerPosition, targetPosition, target.getDirection()) closestDistanceSquared = None closestIndex = None for index in range(len(pathPoints)): pathPoint = pathPoints[index] ownerToPathPoint = calculate.subtractPoints(pathPoint, ownerLocalPosition) distanceSquaredToPathPoint =\ vector.getMagnitudeSquared(ownerToPathPoint) if (closestDistanceSquared is None or distanceSquaredToPathPoint < closestDistanceSquared): closestIndex = index closestDistanceSquared = distanceSquaredToPathPoint #Now "shift" the path so that my closest point is the first in the list. path = pathPoints[closestIndex:] + pathPoints[:closestIndex] #Plot a course to visit the path. If at any point I find a clear shot to the target, #I will dive at it. steeringController.plotPath(path, closed=True)
def circleWithCircle(circle1, circle2): position_1, radius_1 = circle1 position_2, radius_2 = circle2 circle1_to_circle2 = calculate.subtractPoints(position_2, position_1) bounding_distance_squared = (radius_1 ** 2) + (radius_2 ** 2) actual_distance_squared = vector.getMagnitudeSquared( circle1_to_circle2) return actual_distance_squared < bounding_distance_squared
def execute(cls, owner): motherShip = owner.fleet.motherShip ownerPosition = owner.getPosition() targetPosition = motherShip.getPosition() ownerToTarget = calculate.subtractPoints(targetPosition, ownerPosition) distanceSquaredToTarget = vector.getMagnitudeSquared(ownerToTarget) if distanceSquaredToTarget <= motherShip.hangarEntryThresholdSquared: motherShip.pickup(owner)
def withinFiringRange(owner, target): ownerPosition = owner.getPosition() targetPosition = target.getPosition() ownerToTarget = calculate.subtractPoints(targetPosition, ownerPosition) distanceSquaredToTarget = vector.getMagnitudeSquared(ownerToTarget) if distanceSquaredToTarget < owner.getMaximumFiringRangeSquared(): return True else: return False
def pastBreakThreshold(owner, target): targetPosition = target.getPosition() ownerPosition = owner.getPosition() ownerToTarget = calculate.subtractPoints(targetPosition, ownerPosition) distanceSquaredToTarget = vector.getMagnitudeSquared(ownerToTarget) if distanceSquaredToTarget > breakThresholdSquared: return True else: return False
def findClosestEntity(owner, listOfEntities): ownerPosition = owner.getPosition() closestEntity = None closestDistanceSquared = None for entity in listOfEntities: entityPosition = entity.getPosition() entityToOwner = calculate.subtractPoints(entityPosition, ownerPosition) distanceSquaredToOwner = vector.getMagnitudeSquared(entityToOwner) if closestEntity is None or distanceSquaredToOwner < closestDistanceSquared: closestEntity = entity closestDistanceSquared = distanceSquaredToOwner return closestEntity
def targetIsInRange(self, target): gunPosition = self.getPosition() targetPosition = target.getPosition() gunToTarget = calculate.subtractPoints(targetPosition, gunPosition) distanceSquaredToTarget = vector.getMagnitudeSquared(gunToTarget) headingToTarget = vector.normalize(gunToTarget) headingDotProduct = calculate.dotProduct(self.heading, headingToTarget) if (distanceSquaredToTarget < self.firingRangeSquared and headingDotProduct > 0): return True return False
def avoidwalls(agent, walls): if not walls: return (0, 0) agentPosition = agent.getPosition() feelers = createFeelers(agent) closestWall = None closestIntersection = None distanceSquaredToClosestIntersection = None closestFeeler = None for feeler in feelers: for wall in walls: intersectPoint = intersect.lineWithLine(feeler, wall) if intersectPoint is None: continue agentToIntersection = calculate.subtractPoints(intersectPoint, agentPosition) distanceSquaredToIntersection = vector.getMagnitudeSquared(agentToIntersection) if closestIntersection is None or distanceSquaredToIntersection < distanceSquaredToClosestIntersection: distanceSquaredToClosestIntersection = distanceSquaredToIntersection closestWall = wall closestIntersection = intersectPoint closestFeeler = feeler if closestWall is None: return (0, 0) (closestFeelerOrigin, closestFeelerEndpoint) = closestFeeler (wallOrigin, wallEndpoint) = closestWall wallVector = calculate.subtractPoints(wallEndpoint, wallOrigin) intersectionToFeelerEndpoint = calculate.subtractPoints(closestFeelerEndpoint, closestIntersection) overshootLength = vector.getMagnitude(intersectionToFeelerEndpoint) normalizedWallVector = vector.normalize(wallVector) wallNormal = vector.getRightPerpendicular(normalizedWallVector) steeringForce = calculate.multiplyVectorAndScalar(wallNormal, overshootLength) return steeringForce
def acquireTarget(cls, owner): fleet = owner.fleet ownerPosition = owner.getPosition() enemyFleet = fleet.getEnemyFleet() closestShip = None closestDistanceSquared = None for enemy in enemyFleet.getAllFighters(): enemyPosition = enemy.getPosition() ownerToEnemy = calculate.subtractPoints(enemyPosition, ownerPosition) distanceSquaredToEnemy = vector.getMagnitudeSquared(ownerToEnemy) if closestShip is None or distanceSquaredToEnemy < closestDistanceSquared: closestShip = enemy closestDistanceSquared = distanceSquaredToEnemy return closestShip
def acquireTarget(cls, owner): fleet = owner.fleet motherShip = fleet.getMotherShip() motherShipPosition = motherShip.getPosition() enemyFleet = fleet.getEnemyFleet() closestShip = None closestDistanceSquared = None enemyBombers = enemyFleet.getAllFighters(shipType='bomber') for enemy in enemyBombers: enemyPosition = enemy.getPosition() motherShipToEnemy = calculate.subtractPoints(enemyPosition, motherShipPosition) distanceSquaredToEnemy = vector.getMagnitudeSquared(motherShipToEnemy) if closestShip is None or distanceSquaredToEnemy < closestDistanceSquared: closestShip = enemy closestDistanceSquared = distanceSquaredToEnemy return closestShip
def flee(agent, targetPosition, evadeDistanceSquared=None): steeringController = agent.getSteeringController() agentPosition = agent.getPosition() agentMaxSpeed = agent.getMaxSpeed() agentVelocity = agent.getVelocity() agentToTarget = calculate.subtractPoints(agentPosition, targetPosition) distanceSquaredToTarget = vector.getMagnitudeSquared(agentToTarget) if (evadeDistanceSquared is not None and distanceSquaredToTarget > evadeDistanceSquared): return (0, 0) desiredVelocity = vector.setMagnitude(agentToTarget, agentMaxSpeed) return calculate.subtractVectors(desiredVelocity, agentVelocity)
def intersectsPoint(self, point): shipPosition = self.getPosition() shipToPoint = calculate.subtractPoints(point, shipPosition) distanceSquaredToPoint = vector.getMagnitudeSquared(shipToPoint) if (distanceSquaredToPoint > self.lengthSquared or distanceSquaredToPoint > self.widthSquared): return None directionRadians = self.getDirection() localPoint = convert.pointToLocalSpace(point, shipPosition, directionRadians) (topy, rightx, bottomy, leftx) = self.boundingBox x, y = localPoint if (x > leftx and x < rightx and y < topy and y > bottomy): return True
def lineSegmentWithCircle(line_segment, circle): if not lineWithCircle(line_segment, circle): return False circle_point, circle_radius = circle line_seg_point1, line_seg_point2 = line_segment # Line to circle vector (pick an endpoint) a = calculate.subtractPoints(circle_point, line_seg_point1) # Line segment vector b = calculate.subtractPoints(line_seg_point2, line_seg_point1) # a is the vector from line_point1 and the circle's center-point # b is the vector from line_point1 to line_point2 # If a and b are pointing in opposing directions, then there is # no intersection if calculate.dotProduct(a, b) <= 0: return False # Project a onto b. If this projection is longer than the # length of the line segment, then there is no intersection a_onto_b = calculate.dotProduct(a, vector.normalize(b)) return math.pow(a_onto_b, 2) <= vector.getMagnitudeSquared(b)
def pointInCircle(point, circle): circle_point, circle_radius = circle point_to_circle = calculate.subtractPoints(circle_point, point) return vector.getMagnitudeSquared(point_to_circle) <= math.pow(circle_radius, 2)