def myTimeToCollision(self):
        self.cp = self.myNextCollisionPoint()

        if Inf == vec.length(self.cp):
            return Inf # No collisions detected.

        # vec.copy(self.myPosition(), gui.debugPt0)
        # vec.copy(self.cp, gui.debugPt1)

        self.rp = self.cp - self.myPosition()

        # With the current set of assumptions, me could not be on a
        # collision course in the first place if the following assert
        # fails.
        assert 0 <= vec.dot(self.rp, self.myVelocity())

        # TODO: To more accurately compute the time to collision we should
        # take into account the velocity of the collider.  But if we do
        # that here, we should have done that in the computation of the
        # nearest collider.  For example, if a collider is moving out of
        # the way faster than we are approaching it, then there is no
        # danger of collision after all.  But remember this whole method
        # is a percept and percepts don't have to be perfect as they are
        # meant to model how the NPC thinks about the world.  And in that
        # vein, using a stationary snapshot of the world is OK for now.
        # Especially so as the snapshot is regularly updated when the
        # percept is recalculated every time an action is selected.
        # colliderVel = vec.dot(self.rp, self.nextCollider)
        # relVel = myVel - colliderVel;

        return vec.length(self.rp) # / self.myVelocity()
Example #2
0
    def myTimeToCollision(self):
        self.cp = self.myNextCollisionPoint()

        if Inf == vec.length(self.cp):
            return Inf  # No collisions detected.

        # vec.copy(self.myPosition(), gui.debugPt0)
        # vec.copy(self.cp, gui.debugPt1)

        self.rp = self.cp - self.myPosition()

        # With the current set of assumptions, me could not be on a
        # collision course in the first place if the following assert
        # fails.
        assert 0 <= vec.dot(self.rp, self.myVelocity())

        # TODO: To more accurately compute the time to collision we should
        # take into account the velocity of the collider.  But if we do
        # that here, we should have done that in the computation of the
        # nearest collider.  For example, if a collider is moving out of
        # the way faster than we are approaching it, then there is no
        # danger of collision after all.  But remember this whole method
        # is a percept and percepts don't have to be perfect as they are
        # meant to model how the NPC thinks about the world.  And in that
        # vein, using a stationary snapshot of the world is OK for now.
        # Especially so as the snapshot is regularly updated when the
        # percept is recalculated every time an action is selected.
        # colliderVel = vec.dot(self.rp, self.nextCollider)
        # relVel = myVel - colliderVel;

        return vec.length(self.rp)  # / self.myVelocity()
def angle(u):
    l = vec.length(u)

    if util.isAlmostZero(l):
       return 0.0

    assert util.isAlmostEq(vec.length(u), 1.0), "input must be normalized, not " + str(u)

    return math.atan2(u[1], u[0])
Example #4
0
def angle(u):
    l = vec.length(u)

    if util.isAlmostZero(l):
        return 0.0

    assert util.isAlmostEq(vec.length(u),
                           1.0), "input must be normalized, not " + str(u)

    return math.atan2(u[1], u[0])
Example #5
0
def update_snowballs(lobby):
    changed_healths = []
    destroyed_snowballs = []
    player_hit = False
    ground_hit = False
    for id, snowball in lobby.snowballs.items():
        new_vel = vec.add(snowball.velocity, (0, GRAVITY_ACCELERATION))

        new_pos = vec.add(snowball.position, new_vel)
        new_x, new_y = new_pos
        hit_object, can_move = level.can_move_to(SNOWBALL_SIZE, SNOWBALL_SIZE,
                                                 round(new_x), round(new_y),
                                                 all_players(lobby.clients))
        if can_move:
            snowball.velocity = new_vel
            snowball.position = new_pos
        else:
            destroyed_snowballs.append(id)
            if isinstance(hit_object, player.Player):
                player_hit = True
                speed = vec.length(snowball.velocity)
                hit_object.health = max(
                    0, hit_object.health - speed * SNOWBALL_DAMAGE)
                changed_healths.append(hit_object)
            else:
                ground_hit = True
    lobby.snowballs = {
        id: v
        for id, v in lobby.snowballs.items() if id not in destroyed_snowballs
    }
    return changed_healths, destroyed_snowballs, player_hit, ground_hit
Example #6
0
 def setVelocity(self, velocity):
     s = vec.length(velocity)
     if util.isAlmostZero(s):
         self.setSpeed(0)
         # Don't change the orientation if the speed is zero.
     else:
         self.setSpeed(s)
         self.shape.setOrientation(vec.normalize(velocity, self.velocity))
 def setVelocity(self, velocity):
     s = vec.length(velocity)
     if util.isAlmostZero(s):
         self.setSpeed(0)
         # Don't change the orientation if the speed is zero.
     else:
         self.setSpeed(s)
         self.shape.setOrientation(vec.normalize(velocity, self.velocity))
    def calcAction(self):
        self.action.direction[0] = self.inputDevice.getX()
        self.action.direction[1] = self.inputDevice.getY()

        if vec.isAlmostZero(self.action.direction):
            vec.zeroize(self.action.direction) # TODO: necessary?
            self.action.speed = 0.0
        else:
            self.action.speed = min(1.0, vec.length(self.action.direction))
            vec.normalize(self.action.direction, self.action.direction)
Example #9
0
    def calcAction(self):
        self.action.direction[0] = self.inputDevice.getX()
        self.action.direction[1] = self.inputDevice.getY()

        if vec.isAlmostZero(self.action.direction):
            vec.zeroize(self.action.direction) # TODO: necessary?
            self.action.speed = 0.0
        else:
            self.action.speed = min(1.0, vec.length(self.action.direction))
            vec.normalize(self.action.direction, self.action.direction)
    def myNextCollider(self):
        # If the previous calculation of the next collider is still valid,
        # return the cached value.

        if self.nextCollider:
            return self.nextCollider

        which = None
        dMin = Inf

        for o in self.gs.obstacles:
            if self.me == o:
                continue # Don't include me!

            self.ip = o.nearestIntersection(self.me, self.ip)

            # Infinity is used to indicate no intersection.
            if vec.length(self.ip) < Inf:
                p = self.ip - self.myPosition()

                d = vec.length(p) - self.myMaxExtent()
                if d < dMin:
                    dMin = d
                    which = o
                    vec.copy(self.ip, self.cp)

        # We must at least be on a collision course with one of the sides.
        # TODO: turn side collisions back on
        # if false and not which:
        #    print self.myPosition(), "; ", self.myOrientation()
        #    pause
        #    assert which

        # Computing the nearest collider is expensive so cache the result
        # in case it's needed again.

        # TODO: Could also be worth caching dMin as the distance to the
        # nearest collider.

        self.nextCollider = which
        return which
Example #11
0
    def myNextCollider(self):
        # If the previous calculation of the next collider is still valid,
        # return the cached value.

        if self.nextCollider:
            return self.nextCollider

        which = None
        dMin = Inf

        for o in self.gs.obstacles:
            if self.me == o:
                continue  # Don't include me!

            self.ip = o.nearestIntersection(self.me, self.ip)

            # Infinity is used to indicate no intersection.
            if vec.length(self.ip) < Inf:
                p = self.ip - self.myPosition()

                d = vec.length(p) - self.myMaxExtent()
                if d < dMin:
                    dMin = d
                    which = o
                    vec.copy(self.ip, self.cp)

        # We must at least be on a collision course with one of the sides.
        # TODO: turn side collisions back on
        # if false and not which:
        #    print self.myPosition(), "; ", self.myOrientation()
        #    pause
        #    assert which

        # Computing the nearest collider is expensive so cache the result
        # in case it's needed again.

        # TODO: Could also be worth caching dMin as the distance to the
        # nearest collider.

        self.nextCollider = which
        return which
Example #12
0
def drawArrow(begin, lvec, lineSize):
    assert util.isAlmostEq(1.0, vec.length(lvec)), "unnormalized input"

    headSize = 0.5 * lineSize
    lAngle = 2.5
    rAngle = -2.5

    # TODO: get rid of all these constructor calls
    hvec1 = zeros((util.numDim, ), float)
    hvec2 = zeros((util.numDim, ), float)
    tmp = zeros((util.numDim, ), float)

    hvec1 = vec.scale(
        array([
            lvec[0] * math.cos(lAngle) - lvec[1] * math.sin(lAngle),
            lvec[0] * math.sin(lAngle) + lvec[1] * math.cos(lAngle)
        ]), headSize, hvec1)
    hvec2 = vec.scale(
        array([
            lvec[0] * math.cos(rAngle) - lvec[1] * math.sin(rAngle),
            lvec[0] * math.sin(rAngle) + lvec[1] * math.cos(rAngle)
        ]), headSize, hvec2)

    tmp = vec.scale(lvec, lineSize, tmp)

    rightWay = True
    glPushMatrix()
    if rightWay:
        glTranslate(begin[0], begin[1], 0.0)
    else:
        glTranslate(begin[0] - tmp[0], begin[1] - tmp[1], 0.0)

    glBegin(GL_LINE_STRIP)
    glVertex(0.0, 0.0)
    glVertex(tmp[0], tmp[1])
    glVertex(tmp[0] + hvec1[0], tmp[1] + hvec1[1])
    glEnd()
    glPopMatrix()

    glPushMatrix()
    if rightWay:
        glTranslate(begin[0] + tmp[0], begin[1] + tmp[1], 0.0)
    else:
        glTranslate(begin[0], begin[1], 0.0)

    glBegin(GL_LINES)
    glVertex(0.0, 0.0)
    glVertex(hvec2[0], hvec2[1])
    glEnd()
    glPopMatrix()
    def setOrientation(self, orientation):
        assert util.isAlmostEq(1.0, vec.length(orientation)), 'invalid orientation ' + str(orientation)

        vec.copy(orientation, self.orientation)
    def getOrientation(self):
        assert util.isAlmostEq(1.0, vec.length(self.shape.orientation)), 'invalid orientation ' + str(self.shape.orientation)

        return self.shape.orientation
Example #15
0
def distanceTo(c0, c1):
   return vec.length(c0.position - c1.position) - c0.radius - c1.radius
Example #16
0
    def setOrientation(self, orientation):
        assert util.isAlmostEq(1.0, vec.length(orientation)), 'invalid orientation ' + str(orientation)

        vec.copy(orientation, self.orientation)
 def setActualVelocity(self, velocity):
     self.actualVelocity = velocity
     self.actualSpeed = vec.length(velocity)
Example #18
0
    def getOrientation(self):
        assert util.isAlmostEq(1.0, vec.length(self.shape.orientation)), 'invalid orientation ' + str(self.shape.orientation)

        return self.shape.orientation
def distanceTo(c0, c1):
   return vec.length(c0.position - c1.position) - c0.radius - c1.radius