Пример #1
0
    def prioritizedRunningSum(self):
        force = (0, 0)
       
        remaining_reservoir = self.force_reservoir
        
        for behaviorKeyword in self.keywords:
            action = self.actions[behaviorKeyword]
            if action is None:
                continue
            arguments = (self.agent,) + action
            behaviorFunction = self.steeringFunctions[behaviorKeyword]
            weight = self.weight[behaviorKeyword]
            forceForBehavior = calculate.multiplyVectorAndScalar(behaviorFunction(*arguments),
                                                                 weight)
            forceForBehavior = vector.truncate(forceForBehavior,
                                               remaining_reservoir)
           
            magnitudeForBehaviorForce = vector.getMagnitude(forceForBehavior)

            remaining_reservoir -= magnitudeForBehaviorForce
            force = calculate.addVectors(force,
                                         forceForBehavior)
            if remaining_reservoir <= 0:   
                break 
        
        force = vector.truncate(force,
                                self.agent.getMaxForce())
        return force
Пример #2
0
    def update(self,
               timeElapsed):
        current_time = self.world.current_time
        if self.timeOfNormalColor and current_time < self.timeOfNormalColor:
            self.color = (random.random(), random.random(), random.random())
        elif self.timeOfNormalColor:
            self.timeOfNormalColor = None
            self.color = self.normalColor

        world = self.world
        maxspeed = self.maxSpeed
        throttlespeed = self.throttleSpeed
        maxforce = self.maxForce
        minDetectionLength = self.minDetectionLength
        for stateMachine in self.stateMachines:
            stateMachine.update()
        for turret in self.turrets:
            turret.update(timeElapsed)
            
        self.launch()
        
        force = self.steeringController.calculate()
        force = vector.truncate(vectorTuple=force,
                                cap=maxforce)
        
        acceleration = calculate.multiplyVectorAndScalar(vector=force,
                                                         scalar=timeElapsed / (self.mass * 1000.0))
        
        velocity = calculate.addVectors(self.velocity,
                                        acceleration)

        velocity = vector.truncate(velocity,
                                   throttlespeed)
        self.velocity = velocity                

        speed = vector.getMagnitude(velocity)
       
        (x, y) = calculate.addPointAndVector(self.position,
                                             velocity)
        self.position = (x, y)
                
        self.obstacleDetectionDimensions[0] =\
            minDetectionLength + (speed / maxspeed) * minDetectionLength 
Пример #3
0
    def weightedTruncatedSum(self):
        force = (0, 0)
        action_list = self.action_list
        for behavior in self.keyword_list:
            if self.on(behavior):
                forceForBehavior = calculate.multiplyVectorAndScalar(action_list[behavior].getWeight(),
                                                                     action_list[behavior].executeFunction())
                force = calculate.addVectors(force,
                                             forceForBehavior)

        force = vector.truncate(force,
                                self.parent_agent.getMaxForce())
        return force
Пример #4
0
 def test_forceFiveMasOne_returnOne(self):
     startVector = (0, 5)
     newVector = vector.truncate(startVector,
                                 1)
     self.assertEquals((0, 1),
                       newVector)