Exemplo n.º 1
0
class TestShip(TestCase):

  def setUp(self):
    self.ship = Ship()

  def tearDown(self):
    if isinstance(self.ship, NodePath):
      self.ship.visualNode.removeNode()

  def testInit(self):
    self.failUnless(self.ship)
    self.failUnlessEqual(self.ship.name, Ship.NAME_DEFAULT)
    self.failUnless(self.ship.collisionSphere)

  def testGetVisualNode(self):
    node = self.ship.getVisualNode()
    self.failUnless(node)

  def testCreateVisualNode(self):
    self.ship.createVisualNode()
    node = self.ship.getVisualNode()
    self.failUnless( isinstance(node, NodePath) )

  def testIsVisible(self):
    self.ship.createVisualNode()
    self.failUnless( self.ship.isVisible() )

  def testSetCollisionHandler(self):
    f = lambda x, y: 0
    self.ship.setCollisionHandler(f)
    self.failUnlessEqual(self.ship.collisionHandler, f)
    
  def getCollisions(self):
    self.failifEqual(self.ship.collisions, None)
    
  def testSetPos(self):
    pos = (4, 7)
    self.ship.setPos(pos)
    self.failUnlessEqual( self.ship.getPos(), pos )
    
  def testGetPos(self):
    pos = self.ship.getPos()
    self.failUnless( isinstance(pos, tuple) )

  def testGetVel(self):
    vel = self.ship.getVel()
    self.failUnless( isinstance(vel, tuple) )

  def testGetAcc(self):
    acc = self.ship.getAcc()
    self.failUnless( isinstance(acc, float) )

  def testGetHeading(self):
    heading = self.ship.getHeading()
    self.failUnless( isinstance(heading, float) )

  def testShoot(self):
    bullets = self.ship.bullets
    before = len(bullets)
    # In the beginning there are no bullets
    self.failIf(before != 0)
    self.ship.shoot()
    after = len(bullets)
    self.failUnless(before < after)
    self.failUnless(after == 1)
    self.failUnless( bullets[0]['vel'] )
    self.failUnless( bullets[0]['visual'] )
    self.failUnless( bullets[0]['isAlive'] )

  def testBulletHit(self):
    healthBefore = self.ship.health
    self.ship.bulletHit()
    healthAfter = self.ship.health
    self.failUnless(healthBefore > healthAfter)

    # Test that the ship will be destroyed if it's hit enough times
    while(True):
      # Hit with bullets until health is 0
      self.ship.bulletHit()
      if self.ship.health <= 0:
        break
    self.failIf(self.ship.isAlive)

  def testDestroyBullet(self):
    self.ship.shoot()
    bullet = self.ship.bullets[0]
    visual = bullet['visual']
    physical = bullet['physical']
    self.failUnless( len(self.ship.bullets) == 1 )
    self.failUnless(visual)
    self.failUnless(physical)
    self.ship.destroyBullet(bullet)
    self.failUnless( len(self.ship.bullets) == 0 )

  def testDestroy(self):
    before = self.ship.isAlive
    self.ship.destroy()
    after = self.ship.isAlive
    self.failUnless(before == True)
    self.failUnless(after == False)

  def testThrustOn(self):
    before = self.ship.getAcc()
    self.ship.thrustOn()
    after = self.ship.getAcc()
    self.failUnless(before != after)

  def testThrustOff(self):
    self.ship.thrustOn()
    before = self.ship.getAcc()
    self.ship.thrustOff()
    after = self.ship.getAcc()
    self.failUnless(before != after)

  def testRotateLeftOn(self):
    before = self.ship.isRotatingLeft()
    self.ship.rotateLeftOn()
    after = self.ship.isRotatingLeft()
    self.failIf(before == after)
    self.failIf(before == True)
    self.failIf(after == False)

  def testRotateLeftOff(self):
    self.ship.rotateLeftOn()
    before = self.ship.isRotatingLeft()
    self.ship.rotateLeftOff()
    after = self.ship.isRotatingLeft()    
    self.failIf(before == after)
    self.failIf(before == False)
    self.failIf(after == True)

  def testIsRotatingLeft(self):
    isRotatingLeft = self.ship.isRotatingLeft()
    self.failUnless( isinstance(isRotatingLeft, bool) )

  def testRotateRightOn(self):
    before = self.ship.isRotatingRight()
    self.ship.rotateRightOn()
    after = self.ship.isRotatingRight()
    self.failIf(before == after)
    self.failIf(before == True)
    self.failIf(after == False)

  def testRotateRightOff(self):
    self.ship.rotateRightOn()
    before = self.ship.isRotatingRight()
    self.ship.rotateRightOff()
    after = self.ship.isRotatingRight()    
    self.failIf(before == after)
    self.failIf(before == False)
    self.failIf(after == True)

  def testIsRotatingRight(self):
    isRotatingRight = self.ship.isRotatingRight()
    self.failUnless( isinstance(isRotatingRight, bool) )

  def testUpdate(self):
    # Test thrustOn and visual node position changing
    velBefore = self.ship.getVel()
    posBefore = self.ship.getPos()
    visualNodePosBefore = self.ship.getVisualNode().getPos()
    self.ship.thrustOn()
    self.ship.update(1.0) # 1.0 seconds has passed.
    velAfter = self.ship.getVel()
    posAfter = self.ship.getPos()
    visualNodePosAfter = self.ship.getVisualNode().getPos()
    self.failUnless(velBefore < velAfter)
    self.failUnless(posBefore != posAfter)
    self.failUnless(visualNodePosAfter != visualNodePosBefore)

    # Test rotating left
    headingBefore = self.ship.heading
    visualNodeHeadingBefore = self.ship.getVisualNode().getH()
    self.ship.rotateLeftOn()
    self.ship.update(1.0)
    headingAfter = self.ship.heading
    visualNodeHeadingAfter = self.ship.getVisualNode().getH()
    self.failUnless(headingBefore != headingAfter)
    self.failUnless(visualNodeHeadingBefore != visualNodeHeadingAfter)

  def testLimitVelocity(self):
    vel = (1,1)
    self.ship.setVel(vel)
    self.ship.limitVelocity()
    newVel = self.ship.getVel()
    newVelScalar = tupleLength(newVel)
    self.failIf(newVelScalar > Ship.SPEED_MAX)
    self.failIf(newVelScalar < 0)

    vel = (Ship.SPEED_MAX, Ship.SPEED_MAX)
    self.ship.setVel(vel)
    self.ship.limitVelocity()
    newVel = self.ship.getVel()
    newVelScalar = tupleLength(newVel)
    self.failUnless( abs(newVelScalar - Ship.SPEED_MAX) < 0.01)

    
  def testAddCollision(self):
    self.ship.addCollision( point3ToTuple( Point3(1, 2, 0) ) )
    self.failIfEqual( self.ship.getCollisions(), [] )
    
  def testApplyForce(self):
    self.ship.applyForce( (1, 5) )
    self.failIfEqual( self.ship.forces, [] )

  # ####################################################################
  # Feature tests
  #
  # These tests don't necessarily test any single method, but rather
  # features. They are slightly more complex in that the focus of a
  # feature test is a higher level concept, such as gravity, collisions
  # or forces.
  # ####################################################################
  def testForce(self):
    oldPos = self.ship.getPos()
    self.ship.update(.01)
    newPos = self.ship.getPos()
    self.failUnlessEqual( oldPos, newPos )
    
    self.ship.applyForce( (4, 6) )
    oldPos = self.ship.getPos()
    self.ship.update(.01)
    newPos = self.ship.getPos()
    self.failIfEqual( oldPos, newPos )