Conway's Game of Life using JavaFX 3D

I didn't need to change much of the code to run it in 3D - just replace rectangles with boxes, add camera and light - that's it.

What you'll get when using 3D features (in any language) is increased complexity. You have to think about the camera's position, it's field of view, the light sources, their position, the materials, reflections, textures ...

But: What is really impressive concerning JavaFX is that from the programmers viewpoint everything stays the same - for example, you can register your mouseOver actions on a Box in 3D the same way you can use it in 2D with Rectangles. The timelining works the same no matter if you animate 3D or 2D objects etc.

Here is the code for the video above (JDK8 needed!):

	package net.ladstatt.apps
	import scala.collection.JavaConversions.asScalaBuffer
	import scala.collection.JavaConversions.seqAsJavaList
	import scala.util.Random
	import javafx.animation.Animation
	import javafx.animation.KeyFrame
	import javafx.animation.Timeline
	import javafx.application.Application
	import javafx.collections.ObservableList
	import javafx.event.ActionEvent
	import javafx.event.Event
	import javafx.event.EventHandler
	import javafx.scene.Group
	import javafx.scene.Node
	import javafx.scene.Scene
	import javafx.scene.input.MouseEvent
	import javafx.scene.paint.Color
	import javafx.scene.paint.CycleMethod
	import javafx.scene.paint.LinearGradient
	import javafx.scene.paint.Stop
	import javafx.scene.shape.Rectangle
	import javafx.stage.Stage
	import javafx.util.Duration
	import javafx.scene.PerspectiveCamera
	import javafx.scene.paint.PhongMaterial
	import javafx.scene.PointLight
	import javafx.scene.shape.Box
	import javafx.scene.transform.Rotate
	import javafx.geometry.Point3D
	/**
	* John Conway's Game of Life - with JavaFX and Scala using JDK8 3D API
	*/
	object GameOfLife {
	def main(args: Array[String]): Unit = {
	Application.launch(classOf[GameOfLife], args: _*)
	}
	}
	trait JfxUtils {
	def mkEventHandler[E <: Event](f: E => Unit) = new EventHandler[E] { def handle(e: E) = f(e) }
	}
	class GameOfLife extends javafx.application.Application with JfxUtils {
	val canvasWidth = 800
	val canvasHeight = 800
	val canvasDepth = 800
	val cellCount = 20
	val lifeSpeed = 4
	val gap = 4
	// --------------------------------------------------------------------------
	val (width, height, depth) = ((canvasWidth / cellCount) - gap, (canvasHeight / cellCount) - gap, (canvasDepth / cellCount) - gap)
	var anchorX: Double = _
	var anchorY: Double = _
	var anchorAngle: Double = _
	val pointLight = {
	val l = new PointLight(Color.BISQUE)
	l.setTranslateZ(-200)
	l
	}
	val spectatorLight = {
	val l = new PointLight(Color.AZURE)
	l.setTranslateZ(-1500)
	l
	}
	case class Cell(x: Int, y: Int, alive: Boolean = false) extends Box(width, height, depth) {
	setUserData(alive)
	setTranslateX(x * (width + gap))
	setTranslateY(y * (height + gap))
	paint()
	setOnMousePressed(mkEventHandler((e: MouseEvent) => { killOrResurrect() }))
	def paint() =
	if (isAlive) {
	setTranslateZ(depth * 2)
	setMaterial(aliveMaterial)
	} else {
	setMaterial(deadMaterial)
	setTranslateZ(0)
	}
	def isAlive: Boolean = getUserData().asInstanceOf[Boolean]
	def killOrResurrect() = {
	setUserData(!isAlive)
	paint()
	}
	}
	override def start(stage: Stage): Unit = {
	stage.setTitle("Conway's Game of Life")
	val cells = new Group((for {
	x <- 0 to cellCount
	y <- 0 to cellCount
	} yield Cell(x, y, Random.nextBoolean)))
	val drawingArea = new Group(cells, pointLight)
	drawingArea.setTranslateZ(1500)
	drawingArea.setRotationAxis(new Point3D(1, 1, 1))
	val growTimeline = new Timeline
	growTimeline.setRate(lifeSpeed)
	growTimeline.setCycleCount(Animation.INDEFINITE)
	growTimeline.getKeyFrames().add(
	new KeyFrame(Duration.seconds(1),
	new EventHandler[ActionEvent]() {
	def handle(event: ActionEvent) {
	val nextGen = nextGeneration((convert2CellList(cells.getChildren())))
	cells.getChildren().clear()
	cells.getChildren.addAll(nextGen)
	}
	}))
	growTimeline.play()
	val all = new Group(drawingArea, spectatorLight)
	val scene = new Scene(all, canvasWidth, canvasHeight, true)
	scene.setOnMouseMoved(mkEventHandler((e: MouseEvent) => {
	pointLight.setTranslateX(e.getX)
	pointLight.setTranslateY(e.getY)
	}))
	scene.setFill(Color.BLACK)
	scene.setOnMousePressed(mkEventHandler((event: MouseEvent) => {
	anchorX = event.getSceneX()
	anchorAngle = drawingArea.getRotate()
	}))
	scene.setOnMouseDragged(mkEventHandler((event: MouseEvent) => {
	drawingArea.setRotate(anchorAngle + anchorX - event.getSceneX())
	}))
	val perspectiveCamera = new PerspectiveCamera(false)
	scene.setCamera(perspectiveCamera)
	stage.setScene(scene)
	stage.show()
	}
	def nextGeneration(allCells: List[Cell]): List[Cell] = {
	for (c <- allCells) yield {
	if (c.isAlive) {
	getAliveNeighbors(c, allCells).size match {
	case 1 => c.copy(alive = false)
	case 2 => c
	case 3 => c
	case _ => c.copy(alive = false)
	}
	} else {
	if (getAliveNeighbors(c, allCells).size == 3)
	c.copy(alive = true)
	else c
	}
	}
	}
	def getAliveNeighbors(c: Cell, cells: List[Cell]) = getNeighbors(c, cells).filter(_.isAlive)
	def convert2CellList(nodes: ObservableList[Node]): List[Cell] = {
	(for (
	n <- nodes if (n match {
	case c: Cell => true
	case _ => false
	})
	) yield n.asInstanceOf[Cell]).toList
	}
	def getNeighbors(cell: Cell, cells: List[Cell]) =
	cells.filter(c => c != cell && (scala.math.abs(cell.x - c.x) <= 1 && scala.math.abs(cell.y - c.y) <= 1))
	def mkMaterial(color: Color): PhongMaterial = {
	val m = new PhongMaterial()
	m.setDiffuseColor(color)
	m.setSpecularColor(Color.WHITESMOKE)
	m
	}
	val aliveMaterial = mkMaterial(Color.RED)
	val deadMaterial = mkMaterial(Color.WHITE)
	}

view raw GameOfLife3D.scala hosted with ❤ by GitHub