Now that we have CoffeeScript 2 setup, let's create a simple game with Phaser 3.
js2.coffee
This is my first time writing new CoffeeScript in years, and I quickly discovered how painful lack of working js2.coffee is. The existing converter only handles pre-ES6 JavaScript, and even that often doesn't generate great code. Being able to convert between JavaScript and CoffeeScript easily was a huge part of CoffeeScript's appeal at the time, and it's now completely gone.
Not that there's anything too complicated about converting JavaScript to CoffeeScript manually, but it's pointless tedium in a language whose primary appeal is cutting on pointless tedium.
Asset files
I emptied preload.coffee as we won't need it.
I added star.png and coin.mp3 to public/. There's a lot of free assets on the Internet which you can use in your games.
We'll also need to npm install phaser
public/index.html
Here's the updated index.html file, just loading Phaser, and adding a placeholder div for game canvas to be placed at:
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<link rel="stylesheet" href="app.css">
</head>
<body>
<div id="game"></div>
<script src="../node_modules/phaser/dist/phaser.js"></script>
<script src="./build/app.js"></script>
</body>
</html>
public/app.css
To keep things simple I decided to just center the game canvas in the browser window, without any special styling:
body {
background-color: #444;
color: #fff;
margin: 0;
display: flex;
align-items: center;
justify-content: center;
min-height: 100vh;
}
#game {
}
Game source
Let's go through the game code. It's something I wrote a while ago, and just slightly adapted and converted to CoffeeScript for this episode.
Getters and setters
When CoffeeScript adapted to ES6, a few features were really difficult to add due to syntactic issues.
Dropping some features made sense, like the whole var/let/const mess. JavaScript would do just fine having one way to define variables - namely let. You might have noticed by now that I never use const - if variables declared consts were actually immutable, I might change my mind, but I find it both pointless extra thing to think about, and also intentionally misleading. Declaring mutable state with const, as is the standard React Hooks way (const [counter, setCounter] = useState(0)), looks like a vile abomination to me. So CoffeeScript never bothering with three variable types makes perfect sense.
Much more questionable is not having getters and setters. They can be emulated with calls to Object.defineProperty, but these are ugly and are in wrong place - in constructor instead of being part of class definition. Well, we'll just use what we have, so here's the getter helper:
get = (self, name, getter) ->
Object.defineProperty self, name, {get: getter}
Start game
We define constant size box and create a game using MainScene class.
size_x = 800
size_y = 600
game = new Phaser.Game
backgroundColor: "#AAF"
width: size_x
height: size_y
scene: MainScene
StarEmitter
When a ball hits a brick, we want to do some fancy effects. An easy effect is bursting some stars, and it's so common Phaser already contains particle emitter system. Here's a class that sets up such emitter with some settings how those stars should fly.
class StarEmitter
constructor: (scene) ->
@particles = scene.add.particles("star")
@emitter = @particles.createEmitter
gravityY: -50
on: false
lifespan: 2000
speedX: {min: -50, max: 50}
speedY: {min: -50, max: 50}
alpha: 0.2
rotate: {min: -1000, max: 1000}
burst_at: (x, y) ->
@emitter.emitParticle(40, x, y)
Brick
class Brick
constructor: (scene, x, y) ->
colors_by_row = {
2: 0xFF0000
3: 0xFF0080
4: 0xFF00FF
5: 0xFF80FF
6: 0x8080FF
7: 0x80FFFF
}
@destroyed = false
@brick_x_size = size_x/18
@brick_y_size = size_y/30
@brick = scene.add.graphics()
@brick.x = x*size_x/12
@brick.y = y*size_y/20
@brick.fillStyle(colors_by_row[y])
@brick.fillRect(
-@brick_x_size/2, -@brick_y_size/2,
@brick_x_size, @brick_y_size
)
get @, "x",-> @brick.x
get @, "y",-> @brick.y
destroy: ->
@brick.destroy()
@destroyed = true
Brick is a straightforward class wrapping Phaser brick object. You can see how one can do getters in CoffeeScript. It works, but it's a bit awkward.
The only method Brick has is destroy.
Ball
class Ball
constructor: (scene) ->
@ball = scene.add.graphics()
@ball.x = 0.5*size_x
@ball.y = 0.8*size_y
@ball.fillStyle(0x000000)
@ball.fillRect(-10,-10,20,20)
@dx = 300
@dy = -300
get @, "x", -> @ball.x
get @, "y", -> @ball.y
update: (dt) ->
@ball.x += @dx*dt
@ball.y += @dy*dt
if @ball.x <= 10 && @dx < 0
@dx = - @dx
if @ball.x >= size_x-10 && @dx > 0
@dx = - @dx
if @ball.y <= 10 && @dy < 0
@dy = - @dy
The Ball has similar messy getter. The only method is update which is passed how much time passed since the last update, and it's responsible for ball bouncing off the walls, but not bouncing off paddle or bricks.
Paddle
class Paddle
constructor: (scene) ->
@paddle = scene.add.graphics()
@paddle.x = 0.5*size_x
@paddle.y = size_y-20
@paddle.fillStyle(0x0000FF)
@paddle.fillRect(-50, -10, 100, 20)
get @, "x", -> @paddle.x
update: (dt, direction) ->
@paddle.x += dt * direction * 500
@paddle.x = Phaser.Math.Clamp(@paddle.x, 55, size_x-55)
Paddle follows the same pattern. Its direction is sent to the update method depending on which keys are pressed, and it moves left or right. Phaser.Math.Clamp prevents it from going outside the canvas.
MainScene
class MainScene extends Phaser.Scene
preload: () ->
@load.image("star", "star.png")
@load.audio("coin", "coin.mp3")
create: () ->
@active = true
@paddle = new Paddle(@)
@ball = new Ball(@)
@bricks = []
for x from [1..11]
for y from [2..7]
@bricks.push(new Brick(@, x, y))
@emitter = new StarEmitter(@)
@coin = @sound.add("coin")
@coin.volume = 0.2
handle_brick_colission: (brick) ->
return if brick.destroyed
distance_x = Math.abs((brick.x - @ball.x) / (10 + brick.brick_x_size/2))
distance_y = Math.abs((brick.y - @ball.y) / (10 + brick.brick_y_size/2))
if distance_x <= 1.0 && distance_y <= 1.0
brick.destroy()
@emitter.burst_at(@ball.x, @ball.y)
@coin.play()
if distance_x < distance_y
@ball_bounce_y = true
else
@ball_bounce_x = true
is_game_won: () ->
@bricks.every((b) => b.destroyed)
update: (_, dts) ->
return unless @active
dt = dts / 1000.0
@ball.update(dt)
if @input.keyboard.addKey("RIGHT").isDown
@paddle.update(dt, 1)
else if @input.keyboard.addKey("LEFT").isDown
@paddle.update(dt, -1)
@ball_bounce_x = false
@ball_bounce_y = false
for brick from @bricks
@handle_brick_colission(brick)
@ball.dx = -@ball.dx if @ball_bounce_x
@ball.dy = -@ball.dy if @ball_bounce_y
paddle_distance = Math.abs(@paddle.x - @ball.x)
bottom_distance = size_y - @ball.y
if @ball.dy > 0
if bottom_distance <= 30 && paddle_distance <= 60
@ball.dy = -300
@ball.dx = 7 * (@ball.x - @paddle.x)
else if bottom_distance <= 10 && paddle_distance >= 60
@cameras.main.setBackgroundColor("#FAA")
@active = false
if @is_game_won()
@cameras.main.setBackgroundColor("#FFF")
@active = false
And finally the MainScene. preload, create, and update are Phaser methods. Everything else we just created ourselves.
I think everything should be fairly readable, as long as you remember that @foo means this.foo, so it's used for both instance variables and instance methods.
Is CoffeeScript dead?
While I feel nostalgia for it, the unfortunate answer is yes. I mentioned some historical background in previous episode, but ES6 adopted most of the features people used CoffeeScript for, and available tooling did not keep up with the times.
That's not to say the idea is dead. In particular Imba is a CoffeeScript-inspired language and framework that's absolutely worth checking out. It comes with an extremely expressive and performant framework. For some less extreme cases, Svelte, Vue, React, and so on all come with their own extended versions of JavaScript, so nobody really writes app in plain JavaScript anymore.
Results
Here's the results:
It's time to say goodbye to CoffeeScript, in the next episode we start another small project.
As usual, all the code for the episode is here.
Top comments (0)