test/net/habraun/sd/SimpleNarrowPhaseTest.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.sd
  20
  21
  22
  23 import collision._
  24 import math._
  25
  26 import org.junit._
  27 import org.junit.Assert._
  28
  29
  30
  31 class SimpleNarrowPhaseTest {
  32
  33         @Test
  34         def verifyIsNarrowPhase {
  35                 val narrowPhase = new SimpleNarrowPhase
  36                 assertTrue(narrowPhase.isInstanceOf[NarrowPhase])
  37         }
  38
  39
  40
  41         @Test
  42         def verifyUsesContinuousCircleCircleTest {
  43                 val narrowPhase = new SimpleNarrowPhase
  44                 assertTrue(narrowPhase.testCircleCircle.isInstanceOf[ContinuousCircleCircleTest])
  45         }
  46
  47
  48
  49         @Test
  50         def inspectTwoNoShapesExpectNoCollision {
  51                 val narrowPhase = new SimpleNarrowPhase
  52
  53                 val b1 = new Body
  54                 b1.shape = NoShape
  55                 val b2 = new Body
  56                 b2.shape = NoShape
  57
  58                 assertEquals(None, narrowPhase.inspectCollision(0.0, b1, b2))
  59         }
  60
  61
  62
  63         @Test
  64         def inspectCircleAndNoShapeExpectNoCollision {
  65                 val narrowPhase = new SimpleNarrowPhase
  66
  67                 val b1 = new Body
  68                 b1.position = Vec2D(0, 0)
  69                 b1.shape = Circle(1)
  70                 val b2 = new Body
  71                 b2.position = Vec2D(0, 0.5)
  72                 b2.shape = NoShape
  73
  74                 assertEquals(None, narrowPhase.inspectCollision(0.0, b1, b2))
  75         }
  76
  77
  78
  79         @Test
  80         def inspectTwoCirclesVerifyParametersArePassed {
  81                 val test = new CircleCircleTest {
  82                         var c1: Circle = null
  83                         var c2: Circle = null
  84                         var p1: Vec2D = null
  85                         var p2: Vec2D = null
  86                         var v1: Vec2D = null
  87                         var v2: Vec2D = null
  88                         override def apply (_c1: Circle, _c2: Circle, _p1: Vec2D, _p2: Vec2D, _v1: Vec2D, _v2: Vec2D) = {
  89                                 c1 = _c1; c2 = _c2; p1 = _p1; p2 = _p2; v1 = _v1; v2 = _v2
  90                                 None
  91                         }
  92                 }
  93
  94                 val narrowPhase = new SimpleNarrowPhase
  95                 narrowPhase.testCircleCircle = test
  96
  97                 val b1 = new Body
  98                 val b2 = new Body
  99                 b1.shape = Circle(1)
 100                 b2.shape = Circle(2)
 101                 b1.position = Vec2D(1, 1)
 102                 b2.position = Vec2D(2, 2)
 103                 b1.velocity = Vec2D(3, 3)
 104                 b2.velocity = Vec2D(4, 4)
 105
 106                 val delta = 2.0
 107
 108                 narrowPhase.inspectCollision(delta, b1, b2)
 109
 110                 assertEquals(b1.shape, test.c1)
 111                 assertEquals(b2.shape, test.c2)
 112                 assertEquals(b1.position, test.p1)
 113                 assertEquals(b2.position, test.p2)
 114                 assertEquals(b1.velocity * delta, test.v1)
 115                 assertEquals(b2.velocity * delta, test.v2)
 116         }
 117
 118
 119
 120         @Test
 121         def inspectTwoCirclesExpectCollisionIsCorrect {
 122                 val narrowPhase = new SimpleNarrowPhase
 123                 narrowPhase.testCircleCircle = new CircleCircleTest {
 124                         def apply(c1: Circle, c2: Circle, p1: Vec2D, p2: Vec2D, v1: Vec2D, v2: Vec2D) = {
 125                                 Some(TestResult(0.5, Vec2D(5, 5), Vec2D(1, 0)))
 126                         }
 127                 }
 128
 129                 val b1 = new Body
 130                 val b2 = new Body
 131                 b1.shape = Circle(1)
 132                 b2.shape = Circle(1)
 133
 134                 val collision = narrowPhase.inspectCollision(2.0, b1, b2)
 135
 136                 val expected = Collision(0.5, Contact(b1, b2, Vec2D(1, 0), Vec2D(-1, 0), Vec2D(5, 5)))
 137
 138                 assertEquals(Some(expected), collision)
 139         }
 140
 141
 142
 143         @Test
 144         def inspectTwoCirclesExpectNone {
 145                 val narrowPhase = new SimpleNarrowPhase
 146                 narrowPhase.testCircleCircle = new CircleCircleTest {
 147                         def apply(c1: Circle, c2: Circle, p1: Vec2D, p2: Vec2D, v1: Vec2D, v2: Vec2D) = {
 148                                 None
 149                         }
 150                 }
 151
 152                 val b1 = new Body
 153                 val b2 = new Body
 154                 b1.shape = Circle(1)
 155                 b2.shape = Circle(1)
 156
 157                 val collision = narrowPhase.inspectCollision(2.0, b1, b2)
 158
 159                 assertEquals(None, collision)
 160         }
 161
 162
 163
 164         @Test
 165         def inspectStationaryCircleAndLineSegmentExpectNoCollision {
 166                 val narrowPhase = new SimpleNarrowPhase
 167
 168                 val b1 = new Body
 169                 b1.position = Vec2D(0, 0)
 170                 b1.shape = Circle(1)
 171                 val b2 = new Body
 172                 b2.position = Vec2D(0, 2)
 173                 b2.shape = LineSegment(Vec2D(-1, 0), Vec2D(2, 0))
 174
 175                 assertEquals(None, narrowPhase.inspectCollision(2.0, b1, b2))
 176         }
 177
 178
 179
 180         @Test
 181         def inspectStationaryLineSegmentAndCircleExpectNoCollision {
 182                 val narrowPhase = new SimpleNarrowPhase
 183
 184                 val b1 = new Body
 185                 b1.position = Vec2D(0, 0)
 186                 b1.shape = Circle(1)
 187                 val b2 = new Body
 188                 b2.position = Vec2D(0, 2)
 189                 b2.shape = LineSegment(Vec2D(-1, 0), Vec2D(2, 0))
 190
 191                 assertEquals(None, narrowPhase.inspectCollision(2.0, b2, b1))
 192         }
 193
 194
 195
 196         @Test
 197         def inspectStationaryCircleAndLineSegmentExpectCollision {
 198                 val narrowPhase = new SimpleNarrowPhase
 199
 200                 val b1 = new Body
 201                 b1.position = Vec2D(0, 0)
 202                 b1.shape = Circle(1)
 203                 val b2 = new Body
 204                 b2.position = Vec2D(0, 0.5)
 205                 b2.shape = LineSegment(Vec2D(-1, 0), Vec2D(2, 0))
 206
 207                 val expectedCollision = Collision(0.0, Contact(b1, b2, Vec2D(0, 1), Vec2D(0, -1), Vec2D(0, 0)))
 208
 209                 assertEquals(Some(expectedCollision), narrowPhase.inspectCollision(2.0, b1, b2))
 210         }
 211
 212
 213
 214         @Test
 215         def inspectStationaryCircleAndLineSegmentWithCircleOnLineExpectNoCollision {
 216                 val narrowPhase = new SimpleNarrowPhase
 217
 218                 val b1 = new Body
 219                 b1.position = Vec2D(0, 0)
 220                 b1.shape = Circle(1)
 221                 val b2 = new Body
 222                 b2.position = Vec2D(2, 0)
 223                 b2.shape = LineSegment(Vec2D(0, 0), Vec2D(2, 0))
 224
 225                 assertEquals(None, narrowPhase.inspectCollision(2.0, b1, b2))
 226         }
 227
 228
 229
 230         @Test
 231         def inspectStationaryLineSegmentAndCirlceExpectCollision {
 232                 val narrowPhase = new SimpleNarrowPhase
 233
 234                 val b1 = new Body
 235                 b1.position = Vec2D(0, 0)
 236                 b1.shape = Circle(1)
 237                 val b2 = new Body
 238                 b2.position = Vec2D(0, 0.5)
 239                 b2.shape = LineSegment(Vec2D(-1, 0), Vec2D(2, 0))
 240
 241                 val expectedCollision = Collision(0.0, Contact(b1, b2, Vec2D(0, 1), Vec2D(0, -1), Vec2D(0, 0)))
 242
 243                 assertEquals(Some(expectedCollision), narrowPhase.inspectCollision(2.0, b2, b1))
 244         }
 245
 246
 247
 248         @Test
 249         def inspectMovingCircleAndStationaryLineSegmentExpectNoCollision1 {
 250                 // Circle moving parallel to the line segment.
 251                 val narrowPhase = new SimpleNarrowPhase
 252
 253                 val circle = new Body
 254                 circle.shape = Circle(1)
 255                 circle.position = Vec2D(0, 0)
 256                 circle.velocity = Vec2D(1, 0)
 257                 val segment = new Body
 258                 segment.shape = LineSegment(Vec2D(0, 0), Vec2D(5, 0))
 259                 segment.position = Vec2D(0, 2)
 260
 261                 assertEquals(None, narrowPhase.inspectCollision(2.0, circle, segment))
 262         }
 263
 264
 265
 266         @Test
 267         def inspectMovingCircleAndStationaryLineSegmentExpectNoCollision2 {
 268                 // Circle moving away from the line segment.
 269                 val narrowPhase = new SimpleNarrowPhase
 270
 271                 val circle = new Body
 272                 circle.shape = Circle(1)
 273                 circle.position = Vec2D(0, 0)
 274                 circle.velocity = Vec2D(0, -1)
 275                 val segment = new Body
 276                 segment.shape = LineSegment(Vec2D(0, 0), Vec2D(5, 0))
 277                 segment.position = Vec2D(0, 2)
 278
 279                 assertEquals(None, narrowPhase.inspectCollision(2.0, circle, segment))
 280         }
 281
 282
 283
 284         @Test
 285         def inspectMovingCircleAndStationaryLineSegmentExpectNoCollision3 {
 286                 // Circle stopping before reaching the line segment.
 287                 val narrowPhase = new SimpleNarrowPhase
 288
 289                 val circle = new Body
 290                 circle.shape = Circle(1)
 291                 circle.position = Vec2D(0, -5)
 292                 circle.velocity = Vec2D(0, 1)
 293                 val segment = new Body
 294                 segment.shape = LineSegment(Vec2D(0, 0), Vec2D(5, 0))
 295                 segment.position = Vec2D(0, 2)
 296
 297                 assertEquals(None, narrowPhase.inspectCollision(2.0, circle, segment))
 298         }
 299
 300
 301
 302         @Test
 303         def inspectMovingCircleAndStationaryLineSegmentExpectNoCollision4 {
 304                 // Circle missing the line segment.
 305                 val narrowPhase = new SimpleNarrowPhase
 306
 307                 val circle = new Body
 308                 circle.shape = Circle(1)
 309                 circle.position = Vec2D(-2, 0)
 310                 circle.velocity = Vec2D(0, 1)
 311                 val segment = new Body
 312                 segment.shape = LineSegment(Vec2D(0, 0), Vec2D(5, 0))
 313                 segment.position = Vec2D(0, 2)
 314
 315                 assertEquals(None, narrowPhase.inspectCollision(2.0, circle, segment))
 316         }
 317
 318
 319
 320         @Test
 321         def inspectMovingCircleAndStationaryLineSegmentExpectCollision {
 322                 val narrowPhase = new SimpleNarrowPhase
 323
 324                 val circle = new Body
 325                 circle.shape = Circle(1)
 326                 circle.position = Vec2D(2, 0)
 327                 circle.velocity = Vec2D(0, 1)
 328                 val segment = new Body
 329                 segment.shape = LineSegment(Vec2D(0, 0), Vec2D(5, 0))
 330                 segment.position = Vec2D(0, 2)
 331
 332                 val expectedCollision = Collision(0.5, Contact(circle, segment, Vec2D(0, 1), Vec2D(0, -1),
 333                                 Vec2D(2, 2)))
 334
 335                 assertEquals(Some(expectedCollision), narrowPhase.inspectCollision(2.0, circle, segment))
 336         }
 337
 338
 339
 340         @Test
 341         def inspectStationaryCircleAndMovingLineSegmentExpectNoCollision {
 342                 val narrowPhase = new SimpleNarrowPhase
 343
 344                 val circle = new Body
 345                 circle.shape = Circle(1)
 346                 circle.position = Vec2D(0, 0)
 347                 val segment = new Body
 348                 segment.shape = LineSegment(Vec2D(0, 0), Vec2D(5, 0))
 349                 segment.position = Vec2D(0, 2)
 350                 segment.velocity = Vec2D(0, 1)
 351
 352                 assertEquals(None, narrowPhase.inspectCollision(2.0, circle, segment))
 353         }
 354
 355
 356
 357         @Test
 358         def inspectStationaryCircleAndMovingLineSegmentExpectCollision {
 359                 val narrowPhase = new SimpleNarrowPhase
 360
 361                 val circle = new Body
 362                 circle.shape = Circle(1)
 363                 circle.position = Vec2D(2, 0)
 364                 val segment = new Body
 365                 segment.shape = LineSegment(Vec2D(0, 0), Vec2D(5, 0))
 366                 segment.position = Vec2D(0, 2)
 367                 segment.velocity = Vec2D(0, -1)
 368
 369                 val expectedCollision = Collision(0.5, Contact(circle, segment, Vec2D(0, 1), Vec2D(0, -1),
 370                                 Vec2D(2, 1)))
 371
 372                 assertEquals(Some(expectedCollision), narrowPhase.inspectCollision(2.0, circle, segment))
 373         }
 374
 375
 376
 377         @Test
 378         def inspectMovingCircleAndLineSegmentExpectNoCollision {
 379                 val narrowPhase = new SimpleNarrowPhase
 380
 381                 val circle = new Body
 382                 circle.shape = Circle(1)
 383                 circle.position = Vec2D(0, 0)
 384                 circle.velocity = Vec2D(1, 0)
 385                 val segment = new Body
 386                 segment.shape = LineSegment(Vec2D(0, 0), Vec2D(5, 0))
 387                 segment.position = Vec2D(0, 2)
 388                 segment.velocity = Vec2D(-1, 0)
 389
 390                 assertEquals(None, narrowPhase.inspectCollision(2.0, circle, segment))
 391         }
 392
 393
 394
 395         @Test
 396         def inspectMovingCircleAndLineSegmentExpectCollision {
 397                 val narrowPhase = new SimpleNarrowPhase
 398
 399                 val circle = new Body
 400                 circle.shape = Circle(1)
 401                 circle.position = Vec2D(2, -1)
 402                 circle.velocity = Vec2D(0, 1)
 403                 val segment = new Body
 404                 segment.shape = LineSegment(Vec2D(0, 0), Vec2D(5, 0))
 405                 segment.position = Vec2D(0, 2)
 406                 segment.velocity = Vec2D(0, -1)
 407
 408                 val expectedCollision = Collision(0.5, Contact(circle, segment, Vec2D(0, 1), Vec2D(0, -1),
 409                                 Vec2D(2, 1)))
 410
 411                 assertEquals(Some(expectedCollision), narrowPhase.inspectCollision(2.0, circle, segment))
 412         }
 413
 414
 415
 416         @Test
 417         def inspectTwoLineSegmentsExpectNoCollisionEvenIfTheyCollide {
 418                 val narrowPhase = new SimpleNarrowPhase
 419
 420                 val b1 = new Body
 421                 b1.position = Vec2D(0, 1)
 422                 b1.shape = LineSegment(Vec2D(0, 0), Vec2D(2, -2))
 423                 val b2 = new Body
 424                 b2.position = Vec2D(0, -1)
 425                 b2.shape = LineSegment(Vec2D(0, 0), Vec2D(2, 2))
 426
 427                 assertEquals(None, narrowPhase.inspectCollision(2.0, b1, b2))
 428         }
 429 }