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         var narrowPhase: NarrowPhase = null
  34
  35
  36
  37         @Before
  38         def setup {
  39                 narrowPhase = new SimpleNarrowPhase
  40         }
  41
  42
  43
  44         @Test
  45         def verifyUsesContinuousCircleCircleTest {
  46                 val simpleNarrowPhase = new SimpleNarrowPhase
  47                 assertTrue(simpleNarrowPhase.testCircleCircle.isInstanceOf[ContinuousCircleCircleTest])
  48         }
  49
  50
  51
  52         @Test
  53         def verifyUsesContinuousCircleLineSegmentTest {
  54                 val simpleNarrowPhase = new SimpleNarrowPhase
  55                 assertTrue(simpleNarrowPhase.testCircleLineSegment.isInstanceOf[ContinuousCircleLineSegmentTest])
  56         }
  57
  58
  59
  60         @Test
  61         def inspectTwoNoShapesExpectNoCollision {
  62                 val b1 = new Body
  63                 b1.shape = NoShape
  64                 val b2 = new Body
  65                 b2.shape = NoShape
  66
  67                 assertEquals(None, narrowPhase.inspectCollision(0.0, b1, b2))
  68         }
  69
  70
  71
  72         @Test
  73         def inspectCircleAndNoShapeExpectNoCollision {
  74                 val b1 = new Body
  75                 b1.position = Vec2D(0, 0)
  76                 b1.shape = Circle(1)
  77                 val b2 = new Body
  78                 b2.position = Vec2D(0, 0.5)
  79                 b2.shape = NoShape
  80
  81                 assertEquals(None, narrowPhase.inspectCollision(0.0, b1, b2))
  82         }
  83
  84
  85
  86         @Test
  87         def inspectLineSegmentAndNoShapeExpectNoCollision {
  88                 val b1 = new Body
  89                 val b2 = new Body
  90                 b1.shape = LineSegment(Vec2D(0, 0), Vec2D(1, 1))
  91                 b2.shape = NoShape
  92
  93                 assertEquals(None, narrowPhase.inspectCollision(0.0, b1, b2))
  94         }
  95
  96
  97
  98         @Test { val expected = classOf[IllegalArgumentException] }
  99         def inspectUnsupportedShapeAndCircleExpectException {
 100                 val b1 = new Body
 101                 val b2 = new Body
 102                 b1.shape = new Shape {}
 103                 b2.shape = Circle(1)
 104
 105                 narrowPhase.inspectCollision(0.0, b1, b2)
 106         }
 107
 108
 109
 110         @Test { val expected = classOf[IllegalArgumentException] }
 111         def inspectCircleAndUnsupportedShapeExpectException {
 112                 val b1 = new Body
 113                 val b2 = new Body
 114                 b1.shape = Circle(1)
 115                 b2.shape = new Shape {}
 116
 117                 narrowPhase.inspectCollision(0.0, b1, b2)
 118         }
 119
 120
 121
 122         @Test { val expected = classOf[IllegalArgumentException] }
 123         def inspectLineSegmentAndUnsupportedShapeExpectException {
 124                 val b1 = new Body
 125                 val b2 = new Body
 126                 b1.shape = LineSegment(Vec2D(0, 0), Vec2D(1, 0))
 127                 b2.shape = new Shape {}
 128
 129                 narrowPhase.inspectCollision(0.0, b1, b2)
 130         }
 131
 132
 133
 134         @Test
 135         def inspectTwoCirclesVerifyParametersArePassed {
 136                 val test = new CircleCircleTest {
 137                         var c1: Circle = null
 138                         var c2: Circle = null
 139                         var p1: Vec2D = null
 140                         var p2: Vec2D = null
 141                         var v1: Vec2D = null
 142                         var v2: Vec2D = null
 143                         def apply (_c1: Circle, _c2: Circle, _p1: Vec2D, _p2: Vec2D, _v1: Vec2D, _v2: Vec2D) = {
 144                                 c1 = _c1; c2 = _c2; p1 = _p1; p2 = _p2; v1 = _v1; v2 = _v2
 145                                 None
 146                         }
 147                 }
 148
 149                 val simpleNarrowPhase = new SimpleNarrowPhase
 150                 simpleNarrowPhase.testCircleCircle = test
 151
 152                 val b1 = new Body
 153                 val b2 = new Body
 154                 b1.shape = Circle(1)
 155                 b2.shape = Circle(2)
 156                 b1.position = Vec2D(1, 1)
 157                 b2.position = Vec2D(2, 2)
 158                 b1.velocity = Vec2D(3, 3)
 159                 b2.velocity = Vec2D(4, 4)
 160
 161                 val delta = 2.0
 162
 163                 simpleNarrowPhase.inspectCollision(delta, b1, b2)
 164
 165                 assertEquals(b1.shape, test.c1)
 166                 assertEquals(b2.shape, test.c2)
 167                 assertEquals(b1.position, test.p1)
 168                 assertEquals(b2.position, test.p2)
 169                 assertEquals(b1.velocity * delta, test.v1)
 170                 assertEquals(b2.velocity * delta, test.v2)
 171         }
 172
 173
 174
 175         @Test
 176         def inspectTwoCirclesExpectCollisionIsCorrect {
 177                 val simpleNarrowPhase = new SimpleNarrowPhase
 178                 simpleNarrowPhase.testCircleCircle = new CircleCircleTest {
 179                         def apply(c1: Circle, c2: Circle, p1: Vec2D, p2: Vec2D, v1: Vec2D, v2: Vec2D) = {
 180                                 Some(TestResult(0.5, Vec2D(5, 5), Vec2D(1, 0)))
 181                         }
 182                 }
 183
 184                 val b1 = new Body
 185                 val b2 = new Body
 186                 b1.shape = Circle(1)
 187                 b2.shape = Circle(1)
 188
 189                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 190
 191                 val expected = Collision(0.5, Contact(b1, Vec2D(5, 5), Vec2D(1, 0), b2),
 192                                 Contact(b2, Vec2D(5, 5), Vec2D(-1, 0), b1))
 193
 194                 assertEquals(Some(expected), collision)
 195         }
 196
 197
 198
 199         @Test
 200         def inspectTwoCirclesExpectNone {
 201                 val simpleNarrowPhase = new SimpleNarrowPhase
 202                 simpleNarrowPhase.testCircleCircle = new CircleCircleTest {
 203                         def apply(c1: Circle, c2: Circle, p1: Vec2D, p2: Vec2D, v1: Vec2D, v2: Vec2D) = {
 204                                 None
 205                         }
 206                 }
 207
 208                 val b1 = new Body
 209                 val b2 = new Body
 210                 b1.shape = Circle(1)
 211                 b2.shape = Circle(1)
 212
 213                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 214
 215                 assertEquals(None, collision)
 216         }
 217
 218
 219
 220         @Test
 221         def inspectCircleLineSegmentVerifyParametersArePassed {
 222                 val test = new CircleLineSegmentTest {
 223                         var c: Circle = null
 224                         var ls: LineSegment = null
 225                         var pc: Vec2D = null
 226                         var pls: Vec2D = null
 227                         var vc: Vec2D = null
 228                         var vls: Vec2D = null
 229                         def apply (_c: Circle, _ls: LineSegment, _pc: Vec2D, _pls: Vec2D, _vc: Vec2D, _vls: Vec2D) = {
 230                                 c = _c; ls = _ls; pc = _pc; pls = _pls; vc = _vc; vls = _vls
 231                                 None
 232                         }
 233                 }
 234
 235                 val simpleNarrowPhase = new SimpleNarrowPhase
 236                 simpleNarrowPhase.testCircleLineSegment = test
 237
 238                 val b1 = new Body
 239                 val b2 = new Body
 240                 b1.shape = Circle(1)
 241                 b2.shape = LineSegment(Vec2D(-1, -1), Vec2D(-2, -2))
 242                 b1.position = Vec2D(1, 1)
 243                 b2.position = Vec2D(2, 2)
 244                 b1.velocity = Vec2D(3, 3)
 245                 b2.velocity = Vec2D(4, 4)
 246
 247                 val delta = 2.0
 248
 249                 simpleNarrowPhase.inspectCollision(delta, b1, b2)
 250
 251                 assertEquals(b1.shape, test.c)
 252                 assertEquals(b2.shape, test.ls)
 253                 assertEquals(b1.position, test.pc)
 254                 assertEquals(b2.position, test.pls)
 255                 assertEquals(b1.velocity * delta, test.vc)
 256                 assertEquals(b2.velocity * delta, test.vls)
 257         }
 258
 259
 260
 261         @Test
 262         def inspectLineSegmentCircleVerifyParametersArePassed {
 263                 val test = new CircleLineSegmentTest {
 264                         var c: Circle = null
 265                         var ls: LineSegment = null
 266                         var pc: Vec2D = null
 267                         var pls: Vec2D = null
 268                         var vc: Vec2D = null
 269                         var vls: Vec2D = null
 270                         def apply (_c: Circle, _ls: LineSegment, _pc: Vec2D, _pls: Vec2D, _vc: Vec2D, _vls: Vec2D) = {
 271                                 c = _c; ls = _ls; pc = _pc; pls = _pls; vc = _vc; vls = _vls
 272                                 None
 273                         }
 274                 }
 275
 276                 val simpleNarrowPhase = new SimpleNarrowPhase
 277                 simpleNarrowPhase.testCircleLineSegment = test
 278
 279                 val b1 = new Body
 280                 val b2 = new Body
 281                 b1.shape = Circle(1)
 282                 b2.shape = LineSegment(Vec2D(-1, -1), Vec2D(-2, -2))
 283                 b1.position = Vec2D(1, 1)
 284                 b2.position = Vec2D(2, 2)
 285                 b1.velocity = Vec2D(3, 3)
 286                 b2.velocity = Vec2D(4, 4)
 287
 288                 val delta = 2.0
 289
 290                 simpleNarrowPhase.inspectCollision(delta, b2, b1)
 291
 292                 assertEquals(b1.shape, test.c)
 293                 assertEquals(b2.shape, test.ls)
 294                 assertEquals(b1.position, test.pc)
 295                 assertEquals(b2.position, test.pls)
 296                 assertEquals(b1.velocity * delta, test.vc)
 297                 assertEquals(b2.velocity * delta, test.vls)
 298         }
 299
 300
 301
 302         @Test
 303         def inspectCircleLineSegmentExpectCollisionIsCorrect {
 304                 val simpleNarrowPhase = new SimpleNarrowPhase
 305                 simpleNarrowPhase.testCircleLineSegment = new CircleLineSegmentTest {
 306                         def apply(c: Circle, ls: LineSegment, pc: Vec2D, pls: Vec2D, vc: Vec2D, vls: Vec2D) = {
 307                                 Some(TestResult(0.5, Vec2D(5, 5), Vec2D(1, 0)))
 308                         }
 309                 }
 310
 311                 val b1 = new Body
 312                 val b2 = new Body
 313                 b1.shape = Circle(1)
 314                 b2.shape = LineSegment(Vec2D(1, 1), Vec2D(2, 2))
 315
 316                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 317
 318                 val expected = Collision(0.5, Contact(b1, Vec2D(5, 5), Vec2D(1, 0), b2),
 319                                 Contact(b2, Vec2D(5, 5), Vec2D(-1, 0), b1))
 320
 321                 assertEquals(Some(expected), collision)
 322         }
 323
 324
 325
 326         @Test
 327         def inspectCircleLineSegmentExpectNone {
 328                 val simpleNarrowPhase = new SimpleNarrowPhase
 329                 simpleNarrowPhase.testCircleLineSegment = new CircleLineSegmentTest {
 330                         def apply(c: Circle, ls: LineSegment, pc: Vec2D, pls: Vec2D, vc: Vec2D, vls: Vec2D) = {
 331                                 None
 332                         }
 333                 }
 334
 335                 val b1 = new Body
 336                 val b2 = new Body
 337                 b1.shape = Circle(1)
 338                 b2.shape = LineSegment(Vec2D(1, 1), Vec2D(2, 2))
 339
 340                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 341
 342                 assertEquals(None, collision)
 343         }
 344
 345
 346
 347         @Test
 348         def inspectTwoLineSegmentsExpectNoCollisionEvenIfTheyCollide {
 349                 val b1 = new Body
 350                 b1.position = Vec2D(0, 1)
 351                 b1.shape = LineSegment(Vec2D(0, 0), Vec2D(2, -2))
 352                 val b2 = new Body
 353                 b2.position = Vec2D(0, -1)
 354                 b2.shape = LineSegment(Vec2D(0, 0), Vec2D(2, 2))
 355
 356                 assertEquals(None, narrowPhase.inspectCollision(2.0, b1, b2))
 357         }
 358 }