def wander(agent):
steeringController = agent.getSteeringController()
centerToTargetVector = steeringController.centerToWanderTarget
wanderDistance = steeringController.wanderDistance
wanderJitter = steeringController.wanderJitter
wanderRadius = steeringController.wanderRadius
agentPosition = agent.getPosition()
projectionVector = (wanderDistance, 0)
targetAdjustment =\
((random.random() * 2 - 1) * wanderJitter,
(random.random() * 2 - 1) * wanderJitter)
centerToTargetVector = calculate.addVectors(centerToTargetVector,
targetAdjustment)
centerToTargetVector = vector.setMagnitude(centerToTargetVector,
wanderRadius)
localTargetVector = calculate.addVectors(centerToTargetVector,
projectionVector)
worldTargetVector = convert.vectorToWorldSpace(localTargetVector,
agentPosition,
agent.getDirectionRadians())
return worldTargetVector
def pursueoffset(agent,
targetAgent,
targetToOffset):
agentPosition = agent.getPosition()
agentMaxSpeed = agent.getMaxSpeed()
targetPosition = targetAgent.getPosition()
targetDirection = targetAgent.getDirection()
targetSpeed = targetAgent.getSpeed()
targetVelocity = targetAgent.getVelocity()
worldTargetToOffset = convert.vectorToWorldSpace(targetToOffset,
targetPosition,
targetDirection)
offsetPosition = calculate.addPointAndVector(targetPosition,
worldTargetToOffset)
agentToOffset = calculate.subtractPoints(offsetPosition,
agentPosition)
distanceToOffset = vector.getMagnitude(agentToOffset)
if targetSpeed == 0:
lookAheadTime = 0
else:
lookAheadTime = distanceToOffset / (agentMaxSpeed + targetSpeed)
targetToPredictedPosition = calculate.multiplyVectorAndScalar(targetVelocity,
lookAheadTime)
predictedOffsetPosition = calculate.addPointAndVector(offsetPosition,
targetToPredictedPosition)
return arrive.arrive(agent,
predictedOffsetPosition,
.9)
def avoidobstacles(agent,
obstacles):
agentPosition = agent.getPosition()
agentDirectionRadians = agent.getDirectionRadians()
(obstacleDetectionLength,
obstacleDetectionWidth) = agent.getObstacleDetectionDimensions()
obstaclesInRange = _getObstaclesInRange(agent=agent,
obstacles=obstacles)
(closestObstacle,
obstacleLocalPosition) = _getClosestObstacle(agent=agent,
obstaclesInRange=obstaclesInRange)
if closestObstacle is None:
return (0, 0)
obstacleX, obstacleY = obstacleLocalPosition
_colorObstacle(closestObstacle)
multiplier = 1.0 + (obstacleDetectionLength - obstacleX) / obstacleDetectionLength
brake_weight = .2
forceInLocalSpace =\
((closestObstacle.getRadius() - obstacleX) * brake_weight,
(closestObstacle.getRadius() - obstacleY) * multiplier)
forceInWorldSpace =\
convert.vectorToWorldSpace(forceInLocalSpace,
agentPosition,
agentDirectionRadians)
return forceInWorldSpace
def launch(self):
current_time = self.world.current_time
if not self.flightGroups:
return
if current_time < self.timeOfNextLaunch:
return
else:
self.timeOfNextLaunch = current_time + self.msBetweenLaunches
desiredNumberOfFriendlyBombers = 1
desiredNumberOfFriendlyFighters = 1
fleet = self.fleet
enemyFleet = fleet.getEnemyFleet()
friendlyFlightGroups = fleet.flightGroups
enemyFlightGroups = enemyFleet.flightGroups
onboardFlightGroups = self.flightGroups
onboardInterceptorGroups = onboardFlightGroups['interceptor']
onboardBomberGroups = onboardFlightGroups['bomber']
onboardFighterGroups = onboardFlightGroups['fighter']
friendlyInterceptorGroups = friendlyFlightGroups['interceptor']
friendlyBomberGroups = friendlyFlightGroups['bomber']
friendlyFighterGroups = friendlyFlightGroups['fighter']
enemyBomberGroups = enemyFlightGroups['bomber']
if (len(enemyBomberGroups) > len(friendlyInterceptorGroups) and
len(onboardInterceptorGroups) > 0):
groupToLaunch = onboardInterceptorGroups[0]
elif (len(friendlyBomberGroups) < desiredNumberOfFriendlyBombers and
len(onboardBomberGroups) > 0):
groupToLaunch = onboardBomberGroups[0]
elif (len(friendlyFighterGroups) < desiredNumberOfFriendlyFighters and
len(onboardFighterGroups) > 0):
groupToLaunch = onboardFighterGroups[0]
else:
return
carrierPosition = self.getPosition()
worldLaunchOffset = convert.vectorToWorldSpace(self.launchOffset,
carrierPosition,
self.getDirection())
newPosition = calculate.addPointAndVector(carrierPosition,
worldLaunchOffset)
groupToLaunch.setPosition(newPosition)
groupToLaunch.setVelocity((1, 0))
self.removeFlightGroup(groupToLaunch)
fleet.addFlightGroups([groupToLaunch])
groupToLaunch.startStateMachine()
def test_localSpaceIsTranslatedAndRotated_vectorIsRotated(self):
newVector = convert.vectorToWorldSpace(vector=(2, 0),
localOrigin=(0, 1),
localDirection=math.pi / 2)
self.assertEquals((0, 2),
newVector)
def test_localSpaceIsRotated90Degrees_vectorIsRotated90Degrees(self):
newVector = convert.vectorToWorldSpace(vector=(1, 0),
localOrigin=(0, 0),
localDirection=math.pi / 2)
self.assertEquals((0, 1),
newVector)
def test_localSpaceIsOnlyTranslated_vectorIsTheSame(self):
newVector = convert.vectorToWorldSpace(vector=(1, 1),
localOrigin=(2, 2),
localDirection=0)
self.assertEquals((1, 1),
newVector)
def test_localSpaceIsWorldSpace_vectorIsTheSame(self):
newVector = convert.vectorToWorldSpace(vector=(1, 1),
localOrigin=(0, 0),
localDirection=0)
self.assertEquals((1, 1),
newVector)
