Easier explosions with Explosion

jezhiggins · jezhiggins · commit a3391b7cd94f · 2021-01-07T23:27:19.000Z
Wraps up an Exploder in a Target, so we can just hand off to it and not
worry about anything else.
diff --git a/app/src/main/java/uk/co/jezuk/swoop/craft/Explosion.kt b/app/src/main/java/uk/co/jezuk/swoop/craft/Explosion.kt
@@ -0,0 +1,58 @@
+package uk.co.jezuk.swoop.craft
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import uk.co.jezuk.swoop.Game
+import uk.co.jezuk.swoop.geometry.Point
+import uk.co.jezuk.swoop.geometry.Rotation
+import uk.co.jezuk.swoop.geometry.Vector
+import uk.co.jezuk.swoop.wave.Wave
+
+class Explosion(
+    private val wave: Wave,
+    pos: Point,
+    private val velocity: Vector,
+    initialOrientation: Rotation,
+    private val rotation: Double,
+    shape: FloatArray,
+    brush: Paint,
+    length: Int,
+    useMid: Boolean = true,
+    expansion: Float = 5f
+) : Target {
+    private val exploder = Exploder(
+        { wave.removeTarget(this) },
+        shape,
+        brush,
+        length,
+        useMid,
+        expansion
+    )
+    override val position = pos.copy()
+    override val killDist = 0f
+    private val orientation = initialOrientation.clone()
+
+    init {
+        wave.addTarget(this)
+    }
+
+    override fun update(frameRateScale: Float) {
+        position.drift(velocity, frameRateScale)
+        exploder.update(frameRateScale)
+    } // update
+
+    override fun draw(canvas: Canvas) {
+        canvas.save()
+
+        position.translate(canvas)
+        orientation.rotate(canvas)
+
+        exploder.draw(canvas)
+
+        canvas.restore()
+    } // draw
+
+    override fun shipCollision(ship: Ship) { }
+    override fun shot(): Target.Impact = Target.Impact.NONE
+    override fun explode() {}
+}
diff --git a/app/src/main/java/uk/co/jezuk/swoop/craft/Saucer.kt b/app/src/main/java/uk/co/jezuk/swoop/craft/Saucer.kt
@@ -24,14 +24,10 @@ class Saucer(
     private val velocity = Vector(Random.nextDouble(3.0, 3.0 + aggressiveness), position.angleTo(traverse[1]))
     private val bounciness = Random.nextDouble(1.0, (aggressiveness * 2.0)) * Math.PI
     private val swinginess = Random.nextDouble(100.0, 100.0 + (50.0 * aggressiveness))
-    private var bounceOffset = 0.0
     private val traverseLength = startPosition.distance(traverse[1])
     private val skew = Rotation.random()
     private val firedStep = if (wave.ship != null) Random.nextDouble(0.4 - (0.07 * aggressiveness), 0.4) else 1000.0
     private var fired = firedStep
-    private var exploder: Exploder? = null
-
-    private val alive get() = (exploder == null)
 
     init {
         game.sound(R.raw.sauceralarm, position)
@@ -42,8 +38,7 @@ class Saucer(
 
     override fun update(frameRateScale: Float) {
         val distance = basePosition.distance(startPosition) / traverseLength
-        if (alive)
-            bounceOffset = sin(distance  * bounciness) * swinginess
+        val bounceOffset = sin(distance  * bounciness) * swinginess
 
         position.moveTo(basePosition)
         position.move(Vector(bounceOffset, skew), 1f, game.extent, killDist)
@@ -52,13 +47,9 @@ class Saucer(
             destroyed();
 
         fireIfReady(distance)
-
-        if (!alive)
-            exploder?.update(frameRateScale)
     } // update
 
     private fun fireIfReady(distance: Float) {
-        if (!alive) return
         if (fired > distance) return
 
         fired += firedStep
@@ -74,34 +65,30 @@ class Saucer(
         canvas.save()
 
         position.translate(canvas)
-        if (alive)
-            canvas.drawLines(shape, shipBrush)
-        else
-            exploder?.draw(canvas)
+
+        canvas.drawLines(shape, shipBrush)
 
         canvas.restore()
     } // draw
 
     override fun shot(): Target.Impact {
-        if (alive) {
-            game.scored(1500)
-            explode()
-            return Target.Impact.HARD
-        }
-        return Target.Impact.NONE
+        game.scored(1500)
+        explode()
+        return Target.Impact.HARD
     } // shot
 
     override fun explode() {
-        exploder = Exploder(::destroyed, shape, shipBrush, 70)
         game.sound(R.raw.saucerexplosion, position)
         BigPuff(wave, position)
+        Explosion(
+            wave, position, velocity, Rotation.none(), 0.0,
+            shape, shipBrush, 70
+        )
+        destroyed()
     } // explode
 
     override fun shipCollision(ship: Ship) = ship.hit()
-
-    private fun destroyed() {
-        wave.removeTarget(this)
-    }
+    private fun destroyed() = wave.removeTarget(this)
 
     companion object {
         val shape = floatArrayOf(
diff --git a/app/src/main/java/uk/co/jezuk/swoop/craft/Tumbler.kt b/app/src/main/java/uk/co/jezuk/swoop/craft/Tumbler.kt
@@ -20,63 +20,54 @@ class Tumbler(
     override val position = Point(traverse[0])
     private val velocity = Vector(Random.nextDouble(2.0, 5.0), position.angleTo(traverse[1]))
     private val orientation = Rotation.random()
-    private var rotation = Random.nextDouble(1.0, 2.5)
-    private var shooter = Repeat(Random.nextInt(120, 180), { fire() })
-    private var exploder: Exploder? = null
-
-    private val alive get() = (exploder == null)
+    private val rotation = initialRotation()
+    private val shooter = Repeat(Random.nextInt(120, 180), { fire() })
 
     init {
         game.sound(R.raw.sauceralarm, position)
         wave.addTarget(this)
-
-        if (Random.nextDouble() < 0.5)
-            rotation = -rotation
     } // init
 
     override val killDist get() = 50f
 
     override fun update(frameRateScale: Float) {
         position.move(velocity, frameRateScale, game.extent, killDist)
         orientation += rotation * frameRateScale
-        if (alive)
-            shooter.tick(frameRateScale)
-        else
-            exploder?.update(frameRateScale)
+        shooter.tick(frameRateScale)
     } // update
 
     override fun draw(canvas: Canvas) {
         canvas.save()
 
         position.translate(canvas)
         orientation.rotate(canvas)
-        if (alive)
-            canvas.drawLines(tumblerShape, shipBrush)
-        else
-            exploder?.draw(canvas)
+
+        canvas.drawLines(tumblerShape, shipBrush)
 
         canvas.restore()
     } // draw
 
     override fun shot(): Target.Impact {
-        if (alive) {
-            game.scored(1000)
-            explode()
-            return Target.Impact.HARD
-        }
-        return Target.Impact.NONE
+        game.scored(1000)
+        explode()
+        return Target.Impact.HARD
     } // shot
 
     override fun explode() {
-        exploder = Exploder({ wave.removeTarget(this) }, outerShape, shipBrush, 70)
         game.sound(R.raw.saucerexplosion, position)
         BigPuff(wave, position)
+        Explosion(
+            wave, position, velocity, orientation, rotation,
+            outerShape, shipBrush, 70
+        )
+        Explosion(
+            wave, position, velocity, orientation, rotation,
+            cutOuts, shipBrush, 50, expansion = 3f
+        )
+        wave.removeTarget(this)
     } // explode
 
-    override fun shipCollision(ship: Ship) {
-        if (alive)
-            ship.hit()
-    } // shipCollision
+    override fun shipCollision(ship: Ship) = ship.hit()
 
     private fun fire() {
         game.sound(R.raw.saucerfire, position)
@@ -91,6 +82,13 @@ class Tumbler(
     } // fire
 
     companion object {
+        private fun initialRotation(): Double {
+            var rotation = Random.nextDouble(1.0, 2.5)
+            if (Random.nextDouble() < 0.5)
+                rotation = -rotation
+            return rotation
+        } // initialRotation
+
         private val outerShape = floatArrayOf(
             60f, -25f, 60f, 25f,
             60f, 25f, 25f, 60f,
diff --git a/app/src/main/java/uk/co/jezuk/swoop/geometry/Point.kt b/app/src/main/java/uk/co/jezuk/swoop/geometry/Point.kt
@@ -46,6 +46,15 @@ data class Point(
         y = target.y
     } // moveTo
 
+    fun drift(
+        vec: Vector,
+        frameScaleRate: Float
+    ) {
+        val (deltaX, deltaY) = vec.offset(frameScaleRate)
+        x += deltaX.toFloat()
+        y += deltaY.toFloat()
+    }
+
     fun distance(pos: Point): Float {
         val offsetX = distanceBetween(x, pos.x)
         val offsetY = distanceBetween(y, pos.y)
diff --git a/app/src/main/java/uk/co/jezuk/swoop/geometry/Rotation.kt b/app/src/main/java/uk/co/jezuk/swoop/geometry/Rotation.kt
@@ -37,5 +37,6 @@ class Rotation(
 
     companion object {
         fun random() = Rotation(Random.nextDouble(360.0))
+        fun none() = Rotation(0.0)
     } // companion object
 } // Rotation
