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 inspectTwoCirclesVerifyParametersArePassed {
  88                 val test = new CircleCircleTest {
  89                         var c1: Circle = null
  90                         var c2: Circle = null
  91                         var p1: Vec2D = null
  92                         var p2: Vec2D = null
  93                         var v1: Vec2D = null
  94                         var v2: Vec2D = null
  95                         def apply (_c1: Circle, _c2: Circle, _p1: Vec2D, _p2: Vec2D, _v1: Vec2D, _v2: Vec2D) = {
  96                                 c1 = _c1; c2 = _c2; p1 = _p1; p2 = _p2; v1 = _v1; v2 = _v2
  97                                 None
  98                         }
  99                 }
 100
 101                 val simpleNarrowPhase = new SimpleNarrowPhase
 102                 simpleNarrowPhase.testCircleCircle = test
 103
 104                 val b1 = new Body
 105                 val b2 = new Body
 106                 b1.shape = Circle(1)
 107                 b2.shape = Circle(2)
 108                 b1.position = Vec2D(1, 1)
 109                 b2.position = Vec2D(2, 2)
 110                 b1.velocity = Vec2D(3, 3)
 111                 b2.velocity = Vec2D(4, 4)
 112
 113                 val delta = 2.0
 114
 115                 simpleNarrowPhase.inspectCollision(delta, b1, b2)
 116
 117                 assertEquals(b1.shape, test.c1)
 118                 assertEquals(b2.shape, test.c2)
 119                 assertEquals(b1.position, test.p1)
 120                 assertEquals(b2.position, test.p2)
 121                 assertEquals(b1.velocity * delta, test.v1)
 122                 assertEquals(b2.velocity * delta, test.v2)
 123         }
 124
 125
 126
 127         @Test
 128         def inspectTwoCirclesExpectCollisionIsCorrect {
 129                 val simpleNarrowPhase = new SimpleNarrowPhase
 130                 simpleNarrowPhase.testCircleCircle = new CircleCircleTest {
 131                         def apply(c1: Circle, c2: Circle, p1: Vec2D, p2: Vec2D, v1: Vec2D, v2: Vec2D) = {
 132                                 Some(TestResult(0.5, Vec2D(5, 5), Vec2D(1, 0)))
 133                         }
 134                 }
 135
 136                 val b1 = new Body
 137                 val b2 = new Body
 138                 b1.shape = Circle(1)
 139                 b2.shape = Circle(1)
 140
 141                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 142
 143                 val expected = Collision(0.5, Contact(b1, Vec2D(5, 5), Vec2D(1, 0), b2),
 144                                 Contact(b2, Vec2D(5, 5), Vec2D(-1, 0), b1))
 145
 146                 assertEquals(Some(expected), collision)
 147         }
 148
 149
 150
 151         @Test
 152         def inspectTwoCirclesExpectNone {
 153                 val simpleNarrowPhase = new SimpleNarrowPhase
 154                 simpleNarrowPhase.testCircleCircle = new CircleCircleTest {
 155                         def apply(c1: Circle, c2: Circle, p1: Vec2D, p2: Vec2D, v1: Vec2D, v2: Vec2D) = {
 156                                 None
 157                         }
 158                 }
 159
 160                 val b1 = new Body
 161                 val b2 = new Body
 162                 b1.shape = Circle(1)
 163                 b2.shape = Circle(1)
 164
 165                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 166
 167                 assertEquals(None, collision)
 168         }
 169
 170
 171
 172         @Test
 173         def inspectCircleLineSegmentVerifyParametersArePassed {
 174                 val test = new CircleLineSegmentTest {
 175                         var c: Circle = null
 176                         var ls: LineSegment = null
 177                         var pc: Vec2D = null
 178                         var pls: Vec2D = null
 179                         var vc: Vec2D = null
 180                         var vls: Vec2D = null
 181                         def apply (_c: Circle, _ls: LineSegment, _pc: Vec2D, _pls: Vec2D, _vc: Vec2D, _vls: Vec2D) = {
 182                                 c = _c; ls = _ls; pc = _pc; pls = _pls; vc = _vc; vls = _vls
 183                                 None
 184                         }
 185                 }
 186
 187                 val simpleNarrowPhase = new SimpleNarrowPhase
 188                 simpleNarrowPhase.testCircleLineSegment = test
 189
 190                 val b1 = new Body
 191                 val b2 = new Body
 192                 b1.shape = Circle(1)
 193                 b2.shape = LineSegment(Vec2D(-1, -1), Vec2D(-2, -2))
 194                 b1.position = Vec2D(1, 1)
 195                 b2.position = Vec2D(2, 2)
 196                 b1.velocity = Vec2D(3, 3)
 197                 b2.velocity = Vec2D(4, 4)
 198
 199                 val delta = 2.0
 200
 201                 simpleNarrowPhase.inspectCollision(delta, b1, b2)
 202
 203                 assertEquals(b1.shape, test.c)
 204                 assertEquals(b2.shape, test.ls)
 205                 assertEquals(b1.position, test.pc)
 206                 assertEquals(b2.position, test.pls)
 207                 assertEquals(b1.velocity * delta, test.vc)
 208                 assertEquals(b2.velocity * delta, test.vls)
 209         }
 210
 211
 212
 213         @Test
 214         def inspectLineSegmentCircleVerifyParametersArePassed {
 215                 val test = new CircleLineSegmentTest {
 216                         var c: Circle = null
 217                         var ls: LineSegment = null
 218                         var pc: Vec2D = null
 219                         var pls: Vec2D = null
 220                         var vc: Vec2D = null
 221                         var vls: Vec2D = null
 222                         def apply (_c: Circle, _ls: LineSegment, _pc: Vec2D, _pls: Vec2D, _vc: Vec2D, _vls: Vec2D) = {
 223                                 c = _c; ls = _ls; pc = _pc; pls = _pls; vc = _vc; vls = _vls
 224                                 None
 225                         }
 226                 }
 227
 228                 val simpleNarrowPhase = new SimpleNarrowPhase
 229                 simpleNarrowPhase.testCircleLineSegment = test
 230
 231                 val b1 = new Body
 232                 val b2 = new Body
 233                 b1.shape = Circle(1)
 234                 b2.shape = LineSegment(Vec2D(-1, -1), Vec2D(-2, -2))
 235                 b1.position = Vec2D(1, 1)
 236                 b2.position = Vec2D(2, 2)
 237                 b1.velocity = Vec2D(3, 3)
 238                 b2.velocity = Vec2D(4, 4)
 239
 240                 val delta = 2.0
 241
 242                 simpleNarrowPhase.inspectCollision(delta, b2, b1)
 243
 244                 assertEquals(b1.shape, test.c)
 245                 assertEquals(b2.shape, test.ls)
 246                 assertEquals(b1.position, test.pc)
 247                 assertEquals(b2.position, test.pls)
 248                 assertEquals(b1.velocity * delta, test.vc)
 249                 assertEquals(b2.velocity * delta, test.vls)
 250         }
 251
 252
 253
 254         @Test
 255         def inspectCircleLineSegmentExpectCollisionIsCorrect {
 256                 val simpleNarrowPhase = new SimpleNarrowPhase
 257                 simpleNarrowPhase.testCircleLineSegment = new CircleLineSegmentTest {
 258                         def apply(c: Circle, ls: LineSegment, pc: Vec2D, pls: Vec2D, vc: Vec2D, vls: Vec2D) = {
 259                                 Some(TestResult(0.5, Vec2D(5, 5), Vec2D(1, 0)))
 260                         }
 261                 }
 262
 263                 val b1 = new Body
 264                 val b2 = new Body
 265                 b1.shape = Circle(1)
 266                 b2.shape = LineSegment(Vec2D(1, 1), Vec2D(2, 2))
 267
 268                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 269
 270                 val expected = Collision(0.5, Contact(b1, Vec2D(5, 5), Vec2D(1, 0), b2),
 271                                 Contact(b2, Vec2D(5, 5), Vec2D(-1, 0), b1))
 272
 273                 assertEquals(Some(expected), collision)
 274         }
 275
 276
 277
 278         @Test
 279         def inspectCircleLineSegmentExpectNone {
 280                 val simpleNarrowPhase = new SimpleNarrowPhase
 281                 simpleNarrowPhase.testCircleLineSegment = new CircleLineSegmentTest {
 282                         def apply(c: Circle, ls: LineSegment, pc: Vec2D, pls: Vec2D, vc: Vec2D, vls: Vec2D) = {
 283                                 None
 284                         }
 285                 }
 286
 287                 val b1 = new Body
 288                 val b2 = new Body
 289                 b1.shape = Circle(1)
 290                 b2.shape = LineSegment(Vec2D(1, 1), Vec2D(2, 2))
 291
 292                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 293
 294                 assertEquals(None, collision)
 295         }
 296
 297
 298
 299         @Test
 300         def inspectTwoLineSegmentsExpectNoCollisionEvenIfTheyCollide {
 301                 val b1 = new Body
 302                 b1.position = Vec2D(0, 1)
 303                 b1.shape = LineSegment(Vec2D(0, 0), Vec2D(2, -2))
 304                 val b2 = new Body
 305                 b2.position = Vec2D(0, -1)
 306                 b2.shape = LineSegment(Vec2D(0, 0), Vec2D(2, 2))
 307
 308                 assertEquals(None, narrowPhase.inspectCollision(2.0, b1, b2))
 309         }
 310 }