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, b2, Vec2D(1, 0), Vec2D(-1, 0), Vec2D(5, 5)))
 144
 145                 assertEquals(Some(expected), collision)
 146         }
 147
 148
 149
 150         @Test
 151         def inspectTwoCirclesExpectNone {
 152                 val simpleNarrowPhase = new SimpleNarrowPhase
 153                 simpleNarrowPhase.testCircleCircle = new CircleCircleTest {
 154                         def apply(c1: Circle, c2: Circle, p1: Vec2D, p2: Vec2D, v1: Vec2D, v2: Vec2D) = {
 155                                 None
 156                         }
 157                 }
 158
 159                 val b1 = new Body
 160                 val b2 = new Body
 161                 b1.shape = Circle(1)
 162                 b2.shape = Circle(1)
 163
 164                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 165
 166                 assertEquals(None, collision)
 167         }
 168
 169
 170
 171         @Test
 172         def inspectCircleLineSegmentVerifyParametersArePassed {
 173                 val test = new CircleLineSegmentTest {
 174                         var c: Circle = null
 175                         var ls: LineSegment = null
 176                         var pc: Vec2D = null
 177                         var pls: Vec2D = null
 178                         var vc: Vec2D = null
 179                         var vls: Vec2D = null
 180                         def apply (_c: Circle, _ls: LineSegment, _pc: Vec2D, _pls: Vec2D, _vc: Vec2D, _vls: Vec2D) = {
 181                                 c = _c; ls = _ls; pc = _pc; pls = _pls; vc = _vc; vls = _vls
 182                                 None
 183                         }
 184                 }
 185
 186                 val simpleNarrowPhase = new SimpleNarrowPhase
 187                 simpleNarrowPhase.testCircleLineSegment = test
 188
 189                 val b1 = new Body
 190                 val b2 = new Body
 191                 b1.shape = Circle(1)
 192                 b2.shape = LineSegment(Vec2D(-1, -1), Vec2D(-2, -2))
 193                 b1.position = Vec2D(1, 1)
 194                 b2.position = Vec2D(2, 2)
 195                 b1.velocity = Vec2D(3, 3)
 196                 b2.velocity = Vec2D(4, 4)
 197
 198                 val delta = 2.0
 199
 200                 simpleNarrowPhase.inspectCollision(delta, b1, b2)
 201
 202                 assertEquals(b1.shape, test.c)
 203                 assertEquals(b2.shape, test.ls)
 204                 assertEquals(b1.position, test.pc)
 205                 assertEquals(b2.position, test.pls)
 206                 assertEquals(b1.velocity * delta, test.vc)
 207                 assertEquals(b2.velocity * delta, test.vls)
 208         }
 209
 210
 211
 212         @Test
 213         def inspectLineSegmentCircleVerifyParametersArePassed {
 214                 val test = new CircleLineSegmentTest {
 215                         var c: Circle = null
 216                         var ls: LineSegment = null
 217                         var pc: Vec2D = null
 218                         var pls: Vec2D = null
 219                         var vc: Vec2D = null
 220                         var vls: Vec2D = null
 221                         def apply (_c: Circle, _ls: LineSegment, _pc: Vec2D, _pls: Vec2D, _vc: Vec2D, _vls: Vec2D) = {
 222                                 c = _c; ls = _ls; pc = _pc; pls = _pls; vc = _vc; vls = _vls
 223                                 None
 224                         }
 225                 }
 226
 227                 val simpleNarrowPhase = new SimpleNarrowPhase
 228                 simpleNarrowPhase.testCircleLineSegment = test
 229
 230                 val b1 = new Body
 231                 val b2 = new Body
 232                 b1.shape = Circle(1)
 233                 b2.shape = LineSegment(Vec2D(-1, -1), Vec2D(-2, -2))
 234                 b1.position = Vec2D(1, 1)
 235                 b2.position = Vec2D(2, 2)
 236                 b1.velocity = Vec2D(3, 3)
 237                 b2.velocity = Vec2D(4, 4)
 238
 239                 val delta = 2.0
 240
 241                 simpleNarrowPhase.inspectCollision(delta, b2, b1)
 242
 243                 assertEquals(b1.shape, test.c)
 244                 assertEquals(b2.shape, test.ls)
 245                 assertEquals(b1.position, test.pc)
 246                 assertEquals(b2.position, test.pls)
 247                 assertEquals(b1.velocity * delta, test.vc)
 248                 assertEquals(b2.velocity * delta, test.vls)
 249         }
 250
 251
 252
 253         @Test
 254         def inspectCircleLineSegmentExpectCollisionIsCorrect {
 255                 val simpleNarrowPhase = new SimpleNarrowPhase
 256                 simpleNarrowPhase.testCircleLineSegment = new CircleLineSegmentTest {
 257                         def apply(c: Circle, ls: LineSegment, pc: Vec2D, pls: Vec2D, vc: Vec2D, vls: Vec2D) = {
 258                                 Some(TestResult(0.5, Vec2D(5, 5), Vec2D(1, 0)))
 259                         }
 260                 }
 261
 262                 val b1 = new Body
 263                 val b2 = new Body
 264                 b1.shape = Circle(1)
 265                 b2.shape = LineSegment(Vec2D(1, 1), Vec2D(2, 2))
 266
 267                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 268
 269                 val expected = Collision(0.5, Contact(b1, b2, Vec2D(1, 0), Vec2D(-1, 0), Vec2D(5, 5)))
 270
 271                 assertEquals(Some(expected), collision)
 272         }
 273
 274
 275
 276         @Test
 277         def inspectCircleLineSegmentExpectNone {
 278                 val simpleNarrowPhase = new SimpleNarrowPhase
 279                 simpleNarrowPhase.testCircleLineSegment = new CircleLineSegmentTest {
 280                         def apply(c: Circle, ls: LineSegment, pc: Vec2D, pls: Vec2D, vc: Vec2D, vls: Vec2D) = {
 281                                 None
 282                         }
 283                 }
 284
 285                 val b1 = new Body
 286                 val b2 = new Body
 287                 b1.shape = Circle(1)
 288                 b2.shape = LineSegment(Vec2D(1, 1), Vec2D(2, 2))
 289
 290                 val collision = simpleNarrowPhase.inspectCollision(2.0, b1, b2)
 291
 292                 assertEquals(None, collision)
 293         }
 294
 295
 296
 297         @Test
 298         def inspectTwoLineSegmentsExpectNoCollisionEvenIfTheyCollide {
 299                 val b1 = new Body
 300                 b1.position = Vec2D(0, 1)
 301                 b1.shape = LineSegment(Vec2D(0, 0), Vec2D(2, -2))
 302                 val b2 = new Body
 303                 b2.position = Vec2D(0, -1)
 304                 b2.shape = LineSegment(Vec2D(0, 0), Vec2D(2, 2))
 305
 306                 assertEquals(None, narrowPhase.inspectCollision(2.0, b1, b2))
 307         }
 308 }