Let’s give a splat to the Saucer and maybe to splits.

Pleased with the Splat when the Ship is destroyed, I want the positive feeling that I’ll get when I manage to shoot down the Saucer. And, if time and brain permit, I’d like to have little Splats when I hit an Asteroid. Is that so much to ask?

Let’s begin with a review of the existing Splat logic. I suspect it needs a bit of improvement.

When the ship is deactivated, we do this:

``````fun deactivate(entity: SpaceObject) {
if (splittable(entity)) {
activateAsteroid(entity, entity.scale / 2, entity.position, randomVelocity())
spawnNewAsteroid(entity)
} else {
entity.active = false
resetComponents(entity)
}
if (entity.type == SpaceObjectType.SHIP) {
Splat.active = true
elapsedSplatTime = 0.0
Splat.position = entity.position
Splat.angle = randomAngle()
}
}
``````

That works because the only way the ship is ever deactivated is when it is shot down. For the Saucer, we may find the situation to be different. We might want to extract a function to do the Splat activation. It will express what’s going on and it might come in handy if we pass the Splat as a parameter.

``````fun deactivate(entity: SpaceObject) {
if (splittable(entity)) {
activateAsteroid(entity, entity.scale / 2, entity.position, randomVelocity())
spawnNewAsteroid(entity)
} else {
entity.active = false
resetComponents(entity)
}
if (entity.type == SpaceObjectType.SHIP) {
activateSplat(entity,Splat)
}
}

private fun activateSplat(entity: SpaceObject, splat: SpaceObject) {
splat.active = true
elapsedSplatTime = 0.0
splat.position = entity.position
splat.angle = randomAngle()
}
``````

That took these steps:

1. Extract Function: IDEA just gave it the entity parameter;
2. Change Signature: give the function the splat parameter;
3. Change `Splat` to `splat` in the function;
4. Add the Splat parameter in the call.

Perhaps there was a better way to do that. Test. Commit: refactor out `activateSplat` function.

Let’s rename the Splat to ShipSplat, and create a new SaucerSplat.

``````fun createGame(saucerMissileCount: Int, shipMissileCount: Int, asteroidCount: Int) {
Score = 0
val objects = mutableListOf<SpaceObject>()
for (i in 1..saucerMissileCount) objects.add(newSaucerMissile())
for (i in 1..shipMissileCount) objects.add(newMissile())
Ship = newShip()
objects.add(Ship)
Saucer = newSaucer()
objects.add(Saucer)
for (i in 1..asteroidCount) objects.add(newAsteroid())
ShipSplat = newSplat()
objects.add(ShipSplat)
SaucerSplat = newSplat()
objects.add(SaucerSplat)
SpaceObjects = objects.toTypedArray()
}
``````

Now when we shoot down the saucer, let’s activate the SaucerSplat.

We’re going to have a bit of trouble. Here’s how we check the collision:

``````private fun checkAllMissilesVsSaucer(saucer: SpaceObject) {
for (missile: SpaceObject in activeShipMissiles(SpaceObjects)) {
checkCollisionWithScore(saucer, missile, U.SaucerScore)
}
}

fun checkCollisionWithScore(first: SpaceObject, second: SpaceObject, score: Int) {
if (colliding(first, second)) {
Score += score
deactivate(first)
deactivate(second)
}
}
``````

I don’t think we dare put the code in `deactivate` because I’m afraid that the Saucer gets deactivated by its timer. But does it? We’re in luck! It doesn’t call `deactivate`, it just sets the `active` flag:

``````fun update(component: Component, deltaTime: Double) {
when (component) {
is SaucerTimer -> {
updateSaucerTimer(component, deltaTime)
}
}
}

fun updateSaucerTimer(timer: SaucerTimer, deltaTime: Double) {
with(timer) {
time -= deltaTime
if (time <= 0.0) {
time = U.SaucerDelay
if (entity.active) {
entity.active = false
} else {
activateSaucer(entity)
}
}
}
}
``````

So in `deactivate`:

``````fun deactivate(entity: SpaceObject) {
if (splittable(entity)) {
activateAsteroid(entity, entity.scale / 2, entity.position, randomVelocity())
spawnNewAsteroid(entity)
} else {
entity.active = false
resetComponents(entity)
}
if (entity.type == SpaceObjectType.SHIP) {
activateSplat(entity,ShipSplat)
}
if (entity.type == SpaceObjectType.SAUCER) {
activateSplat(entity,SaucerSplat)
}
}
``````

I think this works. It does. Commit: Saucer explodes with Splat when hit by missile.

## Reflection

The bad news is that I’ve tested the Splats in the game, but have no automated tests for them. We do have some collision tests. Let’s see if we can devise a simple test or two for the Splats, now that we know how they work.

``````    @Test
fun `missile killing saucer activates splat`() {
createGame(4,4,23)
assertThat(SaucerSplat.active).isEqualTo(false)
val missile = newMissile()
Saucer.active = true
missile.position = Saucer.position
checkCollisionWithScore(Saucer, missile, 222)
assertThat(Saucer.active).isEqualTo(false)
assertThat(SaucerSplat.active).isEqualTo(true)
}
``````

That runs green. I think I could have written that in advance. I just didn’t have the idea clearly enough, or I was impatient.

Let’s do similarly for the Ship.

``````    @Test
fun `missile killing ship activates splat`() {
createGame(4,4,23)
assertThat(ShipSplat.active).isEqualTo(false)
val missile = newSaucerMissile()
Ship.active = true
missile.position = Ship.position
checkCollisionWithScore(Ship, missile, 222)
assertThat(Ship.active).isEqualTo(false)
assertThat(ShipSplat.active).isEqualTo(true)
}
``````

OK, I feel better now. Commit: add tests for activating ship and saucer splats.

## Reflection

OK, we have the saucer making a nice happy splat when we hit it and the ship making a sad splat2 when it hits an asteroid or is shot down by the saucer.

Let’s think about how we might approach splats for when we hit an asteroid.

In fact, let’s do a Spike:

## Spike

I have an idea. Here’s where we split an asteroid:

``````fun deactivate(entity: SpaceObject) {
if (splittable(entity)) {
activateAsteroid(entity, entity.scale / 2, entity.position, randomVelocity())
spawnNewAsteroid(entity)
} else {
entity.active = false
resetComponents(entity)
}
if (entity.type == SpaceObjectType.SHIP) {
activateSplat(entity,ShipSplat)
}
if (entity.type == SpaceObjectType.SAUCER) {
activateSplat(entity,SaucerSplat)
}
}
``````

What if we pasted in an activateSplat up there?

``````fun deactivate(entity: SpaceObject) {
if (splittable(entity)) {
activateSplat(entity, SaucerSplat)
activateAsteroid(entity, entity.scale / 2, entity.position, randomVelocity())
spawnNewAsteroid(entity)
} else {
entity.active = false
resetComponents(entity)
}
if (entity.type == SpaceObjectType.SHIP) {
activateSplat(entity,ShipSplat)
}
if (entity.type == SpaceObjectType.SAUCER) {
activateSplat(entity,SaucerSplat)
}
}
``````

Won’t that just work, with a massive splat when we hit an asteroid?

Sure enough, it does. Well, almost. It doesn’t splat the smallest asteroids, because they’re not splittable. It’s nearly that easy, except that we should probably have more splats to use.

Let’s do it like the others, still using the SaucerSplat:

``````fun deactivate(entity: SpaceObject) {
if (splittable(entity)) {
activateAsteroid(entity, entity.scale / 2, entity.position, randomVelocity())
spawnNewAsteroid(entity)
} else {
entity.active = false
resetComponents(entity)
}
if (entity.type == SpaceObjectType.SHIP) {
activateSplat(entity,ShipSplat)
}
if (entity.type == SpaceObjectType.SAUCER) {
activateSplat(entity,SaucerSplat)
}
if (entity.type == SpaceObjectType.ASTEROID) {
activateSplat(entity,SaucerSplat)
}
}
``````

Now let me check the baby asteroids. Yes, they splat now. I notice in playing that even though we are reusing the SaucerSplat, you don’t really notice what happens when you hit two things rapidly. In reality the one splat immediately stops and a new one starts at the new hit. But the eye doesn’t see that happening. It looks perfectly reasonable.

We could nonetheless add a third Splat for asteroids. Let’s do that, it’s almost free.

## We’re not spiking.

I’m calling this good and going for production.

``````var Score: Int = 0
var AsteroidsGoneFor = 0.0
private var currentWaveSize = 0
var dropScale = U.ShipDropInScale
lateinit var Saucer: SpaceObject
var saucerSpeed = U.SaucerSpeed
lateinit var Ship: SpaceObject
lateinit var SpaceObjects: Array<SpaceObject>
lateinit var ShipSplat: SpaceObject
lateinit var SaucerSplat: SpaceObject
lateinit var AsteroidSplat: SpaceObject // new
var TimerTable: List<Timer> = mutableListOf<Timer>()

fun createGame(saucerMissileCount: Int, shipMissileCount: Int, asteroidCount: Int) {
Score = 0
val objects = mutableListOf<SpaceObject>()
for (i in 1..saucerMissileCount) objects.add(newSaucerMissile())
for (i in 1..shipMissileCount) objects.add(newMissile())
Ship = newShip()
objects.add(Ship)
Saucer = newSaucer()
objects.add(Saucer)
for (i in 1..asteroidCount) objects.add(newAsteroid())
ShipSplat = newSplat()
objects.add(ShipSplat)
SaucerSplat = newSplat()
objects.add(SaucerSplat)
AsteroidSplat = newSplat()
objects.add(AsteroidSplat)
SpaceObjects = objects.toTypedArray()
}

fun deactivate(entity: SpaceObject) {
if (splittable(entity)) {
activateAsteroid(entity, entity.scale / 2, entity.position, randomVelocity())
spawnNewAsteroid(entity)
} else {
entity.active = false
resetComponents(entity)
}
if (entity.type == SpaceObjectType.SHIP) {
activateSplat(entity,ShipSplat)
}
if (entity.type == SpaceObjectType.SAUCER) {
activateSplat(entity,SaucerSplat)
}
if (entity.type == SpaceObjectType.ASTEROID) {
activateSplat(entity,AsteroidSplat)
}
}
``````

And let’s add the test since we know how.

``````    @Test
fun `missile killing asteroid activates splat`() {
createGame(4,4,23)
assertThat(AsteroidSplat.active).isEqualTo(false)
val missile = newSaucerMissile()
val asteroid = newAsteroid()
missile.position = asteroid.position
checkCollisionWithScore(asteroid, missile, 222)
assertThat(AsteroidSplat.active).isEqualTo(true)
}
``````

Green. Commit: Asteroid hits share one Splat. Here’s a movie3.

Let’s sum up.

## Summary

Two interesting things this morning.

First, testing the Splats turned out to be pretty easy and yet I didn’t see how to do it, or have the gumption to figure it out. One way or the other, I lost the bit of confidence that goes with tests running, both during development and then later when making other changes. All good now, we do have those tests, and they’ll provide a bit more safety.

Second, I was expecting to have to make a number of splats for the asteroids, so that rapid fire would look OK. But even with just one it looks good to me. If customers or the boss complain, it’ll be easy enough to provide more than one, but I’m pleased that it wasn’t necessary.

Third4, we’re seeing more and more type-checking code in here, such as in the `deactivate` above, which has three explicit type checks and the subordinate one in `splittable`. With explicit types and methods, instead of this constrained “functions only” design, they’re bound to turn up. If you were to review the original Asteroids assembly code, you’d find the same kind of checking and branching. When the language doesn’t help you, that’s what you wind up doing.

It’s not awful. There may be some way to make things a bit more compact. We’ll do some code review within the next couple of articles and see what we can conclude about our three different styles of building the same program.

For now, a good morning’s work. Split Splat all over. See you next time!

1. The repos up at the top are three different designs, essentially the same program, done so that we can compare them. Unfortunately you may have to read around 300 articles to get the entire picture. I apologize for my prolixity.

2. He’s probably projecting. I don’t think the Splats care all that much either way.

3. I’ve had a suggestion to save movies in other than `.mov` format. If you’d prefer another format, tweet or toot me. Thanks!

4. Always happens when I say I have N things, I always come up with at least one more.