test/net/habraun/kong/physics/WorldTest.scala

   1 /*
   2         Copyright (c) 2009 Hanno Braun <hanno@habraun.net>
   3
   4         Licensed under the Apache License, Version 2.0 (the "License");
   5         you may not use this file except in compliance with the License.
   6         You may obtain a copy of the License at
   7
   8                 http://www.apache.org/licenses/LICENSE-2.0
   9
  10         Unless required by applicable law or agreed to in writing, software
  11         distributed under the License is distributed on an "AS IS" BASIS,
  12         WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13         See the License for the specific language governing permissions and
  14         limitations under the License.
  15 */
  16
  17
  18
  19 package net.habraun.kong.physics
  20
  21
  22
  23 import org.junit._
  24 import org.junit.Assert._
  25
  26
  27
  28 class WorldTest {
  29
  30         @Test
  31         def addBodyStepExpectBodyMoved {
  32                 val world = new World
  33                 val body = new Body
  34                 body.velocity = Vec2D(1, 0)
  35                 world.add(body)
  36                 world.step(2.0)
  37                 assertEquals(Vec2D(2, 0), body.position)
  38         }
  39
  40
  41
  42         @Test
  43         def addAndRemoveBodyExpectBodyNotMoved {
  44                 val world = new World
  45                 val body = new Body
  46                 body.velocity = Vec2D(1, 0)
  47                 world.add(body)
  48                 world.remove(body)
  49                 world.step(2.0)
  50                 assertEquals(Vec2D(0, 0), body.position)
  51         }
  52
  53
  54
  55         @Test
  56         def addBodyApplyForceCheckVelocity {
  57                 val world = new World
  58                 val body = new Body
  59                 body.mass = 5
  60                 body.applyForce(Vec2D(5, 0))
  61                 world.add(body)
  62                 world.step(2.0)
  63                 assertEquals(Vec2D(2, 0), body.velocity)
  64         }
  65
  66
  67
  68         @Test
  69         def addBodyApplyForceStepTwiceCheckVelocity {
  70                 val world = new World
  71                 val body = new Body
  72                 body.mass = 5
  73                 body.applyForce(Vec2D(5, 0))
  74                 world.add(body)
  75                 world.step(2.0)
  76                 world.step(2.0)
  77                 assertEquals(Vec2D(2, 0), body.velocity)
  78         }
  79
  80
  81
  82         @Test
  83         def addBodyApplyForceStepCheckPosition {
  84                 val world = new World
  85                 val body = new Body
  86                 body.mass = 5
  87                 body.applyForce(Vec2D(5, 0))
  88                 world.add(body)
  89                 world.step(2.0)
  90                 assertEquals(Vec2D(4, 0), body.position)
  91         }
  92
  93
  94
  95         @Test
  96         def addBodyApplyImpulseCheckVelocity {
  97                 val world = new World
  98                 val body = new Body
  99                 body.mass = 5
 100                 body.velocity = Vec2D(3, 0)
 101                 body.applyImpulse(Vec2D(5, 0))
 102                 world.add(body)
 103                 world.step(2.0)
 104                 assertEquals(Vec2D(4, 0), body.velocity)
 105         }
 106
 107
 108
 109         @Test
 110         def addBodyApplyImpulseCheckVelocity2 {
 111                 val world = new World
 112                 val body = new Body
 113                 body.mass = 5
 114                 body.velocity = Vec2D(3, 0)
 115                 body.applyImpulse(Vec2D(5, 0))
 116                 world.add(body)
 117                 world.step(5.0)
 118                 assertEquals(Vec2D(4, 0), body.velocity)
 119         }
 120
 121
 122
 123         @Test
 124         def addBodyApplyImpulseCheckImpulse {
 125                 val world = new World
 126                 val body = new Body
 127                 body.applyImpulse(Vec2D(10, 10))
 128                 world.add(body)
 129                 world.step(2.0)
 130                 assertEquals(Vec2D(0, 0), body.appliedImpulse)
 131         }
 132
 133
 134
 135         @Test
 136         def addBodyDisallowXMovementStepCheckPosition {
 137                 val world = new World
 138                 val body = new Body
 139                 body.allowXMovement(false)
 140                 body.applyForce(Vec2D(1, 1))
 141                 world.add(body)
 142                 world.step(2.0)
 143                 assertEquals(Vec2D(0, 4), body.position)
 144         }
 145
 146
 147
 148         @Test
 149         def addBodyDisallowYMovementStepCheckPosition {
 150                 val world = new World
 151                 val body = new Body
 152                 body.allowYMovement(false)
 153                 body.applyForce(Vec2D(1, 1))
 154                 world.add(body)
 155                 world.step(2.0)
 156                 assertEquals(Vec2D(4, 0), body.position)
 157         }
 158
 159
 160
 161         @Test
 162         def verifyInitialBroadPhase {
 163                 val world = new World
 164                 assertTrue(world.broadPhase.isInstanceOf[SimpleBroadPhase])
 165         }
 166
 167
 168
 169         @Test
 170         def verifyInitialNarrowPhase {
 171                 val world = new World
 172                 assertTrue(world.narrowPhase.isInstanceOf[SimpleNarrowPhase])
 173         }
 174
 175
 176
 177         @Test { val expected = classOf[NullPointerException] }
 178         def setBroadPhaseNullExpectException {
 179                 val world = new World
 180                 world.broadPhase = null
 181         }
 182
 183
 184
 185         @Test { val expected = classOf[NullPointerException] }
 186         def setNarrowPhaseNullExpectException {
 187                 val world = new World
 188                 world.narrowPhase = null
 189         }
 190
 191
 192
 193         @Test
 194         def addBodyVerifyItIsPassedToBroadPhase {
 195                 val world = new World
 196
 197                 val broadPhase = new BroadPhase {
 198                         var passedBodies: List[Body] = null
 199                         def detectPossibleCollisions(bodies: List[Body]) = { passedBodies = bodies; Nil }
 200                 }
 201                 world.broadPhase = broadPhase
 202
 203                 val body = new Body
 204                 world.add(body)
 205                 world.step(2.0)
 206
 207                 assertEquals(body::Nil, broadPhase.passedBodies)
 208         }
 209
 210
 211
 212         @Test
 213         def addBroadPhaseReturningBodyPairsVerifyTheyArePassedToNarrowPhase {
 214                 val world = new World
 215
 216                 val b1 = new Body
 217                 val b2 = new Body
 218                 val b3 = new Body
 219                 val b4 = new Body
 220
 221                 world.broadPhase = new BroadPhase {
 222                         def detectPossibleCollisions(bodies: List[Body]) = (b1, b2)::(b3, b4)::Nil
 223                 }
 224
 225                 val narrowPhase = new NarrowPhase {
 226                         var passedPairs: List[(Body, Body)] = Nil
 227                         def inspectCollision(b1: Body, b2: Body) = { passedPairs = passedPairs:::List((b1, b2)); None }
 228                 }
 229                 world.narrowPhase = narrowPhase
 230
 231                 world.step(2.0)
 232
 233                 assertEquals((b1, b2)::(b3, b4)::Nil, narrowPhase.passedPairs)
 234         }
 235
 236
 237
 238         @Test
 239         def verifyCollisionEffects {
 240                 val world = new World
 241
 242                 val b1 = new Body
 243                 b1.position = Vec2D(0, 1)
 244                 b1.mass = 4
 245                 b1.velocity = Vec2D(-10, -10)
 246                 val b2 = new Body
 247                 b2.position = Vec2D(0, -1)
 248                 b2.mass = 8
 249                 b2.velocity = Vec2D(5, 5)
 250
 251                 world.narrowPhase = new NarrowPhase {
 252                         def inspectCollision(b1: Body, b2: Body) = {
 253                                 Some(Collision(1.0, Contact(b1, b2, Vec2D(0, -1), Vec2D(0, 1), Vec2D(0, 0))))
 254                         }
 255                 }
 256
 257                 world.add(b1)
 258                 world.add(b2)
 259                 world.step(2.0)
 260
 261                 assertEquals(Vec2D(0, 80), b1.appliedImpulse)
 262                 assertEquals(Vec2D(0, -80), b2.appliedImpulse)
 263         }
 264
 265
 266
 267         @Test
 268         def verifyCollisionEffectsWithBody1Static {
 269                 val world = new World
 270
 271                 val b1 = new Body
 272                 b1.mass = Double.PositiveInfinity
 273                 val b2 = new Body
 274                 b2.mass = 5
 275                 b2.velocity = Vec2D(1, 1)
 276
 277                 world.narrowPhase = new NarrowPhase {
 278                         def inspectCollision(b1: Body, b2: Body) = {
 279                                 Some(Collision(1.0, Contact(b1, b2, Vec2D(0, -1), Vec2D(0, 1), Vec2D(0, 0))))
 280                         }
 281                 }
 282
 283                 world.add(b1)
 284                 world.add(b2)
 285                 world.step(2.0)
 286
 287                 assertEquals(Vec2D(0, 0), b1.appliedImpulse)
 288                 assertEquals(Vec2D(0, -10), b2.appliedImpulse)
 289         }
 290
 291
 292
 293         @Test
 294         def verifyCollisionEffectsWithBody2Static {
 295                 val world = new World
 296
 297                 val b1 = new Body
 298                 b1.mass= 5
 299                 b1.velocity = Vec2D(1, 1)
 300                 val b2 = new Body
 301                 b2.mass = Double.PositiveInfinity
 302
 303                 world.narrowPhase = new NarrowPhase {
 304                         def inspectCollision(b1: Body, b2: Body) = {
 305                                 Some(Collision(1.0, Contact(b1, b2, Vec2D(0, 1), Vec2D(0, -1), Vec2D(0, 0))))
 306                         }
 307                 }
 308
 309                 world.add(b1)
 310                 world.add(b2)
 311                 world.step(2.0)
 312
 313                 assertEquals(Vec2D(0, -10), b1.appliedImpulse)
 314                 assertEquals(Vec2D(0, 0), b2.appliedImpulse)
 315         }
 316
 317
 318
 319         @Test
 320         def verifyForceIsAppliedBeforeCollisionDetection {
 321                 val world = new World
 322
 323                 val broadPhase = new BroadPhase {
 324                         var v: Vec2D = null
 325                         def detectPossibleCollisions(bodies: List[Body]) = {
 326                                 v = bodies(0).velocity
 327                                 Nil
 328                         }
 329                 }
 330                 world.broadPhase = broadPhase
 331
 332                 val body = new Body
 333                 body.mass = 5
 334                 body.applyForce(Vec2D(10, 0))
 335                 world.add(body)
 336
 337                 world.step(2.0)
 338
 339                 assertEquals(Vec2D(4, 0), broadPhase.v)
 340         }
 341
 342
 343
 344         @Test
 345         def verifyImpulseIsAppliedBeforeCollisionDetection {
 346                 val world = new World
 347
 348                 val broadPhase = new BroadPhase {
 349                         var v: Vec2D = null
 350                         def detectPossibleCollisions(bodies: List[Body]) = {
 351                                 v = bodies(0).velocity
 352                                 Nil
 353                         }
 354                 }
 355                 world.broadPhase = broadPhase
 356
 357                 val body = new Body
 358                 body.mass = 5
 359                 body.applyImpulse(Vec2D(10, 0))
 360                 world.add(body)
 361
 362                 world.step(2.0)
 363
 364                 assertEquals(Vec2D(2, 0), broadPhase.v)
 365         }
 366 }