Draw objects with Drawable interface rather than directly

common/arena.go

@@ -118,17 +118,17 @@ func (a *Arena) Destroy() {
 }
 
 // Draw draws the arena.
-func (a *Arena) Draw(win *turdgl.Window) {
-	win.DrawBackground(a.background)
+func (a *Arena) Draw(buf *turdgl.FrameBuffer) {
+	a.background.Draw(buf)
 
 	for i := range numTiles {
 		for j := range numTiles {
-			win.DrawBackground(a.bgTiles[j][i])
+			a.bgTiles[j][i].Draw(buf)
 		}
 	}
 
 	for _, t := range a.tiles {
-		win.DrawForeground(t.tb)
+		t.tb.Draw(buf)
 	}
 }
 
@@ -189,8 +189,8 @@ func (a *Arena) SetLose() {
 	})
 }
 
-// Animate animates the arena to match the given game state.
-func (a *Arena) Animate(game backend.Game) {
+// Update animates the arena to match the given game state.
+func (a *Arena) Update(game backend.Game) {
 	defer func() {
 		// Update the local state upon exit
 		a.latestState.Grid.Tiles = game.Grid.Tiles

common/textbox.go

@@ -71,9 +71,9 @@ func NewGameTextBox(width, height float64, pos turdgl.Vec, colour color.RGBA) *G
 }
 
 // Draw draws the UI box to the window.
-func (g *GameUIBox) Draw(win *turdgl.Window) {
-	win.Draw(g.body)
-	win.Draw(g.heading)
+func (g *GameUIBox) Draw(buf *turdgl.FrameBuffer) {
+	g.body.Draw(buf)
+	g.heading.Draw(buf)
 }
 
 // SetHeading sets the heading text of the UI box.

screen/multiplayer.go

@@ -211,6 +211,16 @@ func (s *MultiplayerScreen) Deinit() {
 
 // Update updates and draws the singleplayer screen.
 func (s *MultiplayerScreen) Update() {
+	// Check for win or lose
+	switch s.backend.Grid.Outcome() {
+	case grid.None:
+		s.backgroundColour = common.BackgroundColour
+	case grid.Win:
+		s.backgroundColour = common.BackgroundColourWin
+	case grid.Lose:
+		s.backgroundColour = common.BackgroundColourLose
+	}
+
 	s.win.SetBackground(s.backgroundColour)
 
 	// Handle user inputs from user. Only 1 input must be sent per update cycle,
@@ -226,44 +236,29 @@ func (s *MultiplayerScreen) Update() {
 		// No user input; continue
 	}
 
-	// Draw UI widgets
-	s.win.Draw(s.title)
-	s.win.Draw(s.guide)
-	s.win.Draw(s.opponentGuide)
-
-	s.win.Draw(s.menu)
 	s.menu.Update(s.win)
-
-	s.score.Draw(s.win)
 	s.score.SetBody(fmt.Sprint(s.backend.Score.CurrentScore()))
-
-	s.opponentScore.Draw(s.win)
 	s.opponentScore.SetBody(fmt.Sprint(s.opponentBackend.Score.CurrentScore()))
-
-	s.win.Draw(s.newGame)
 	s.newGame.Update(s.win)
-
 	s.timer.SetText(s.backend.Timer.Time.String())
-	s.win.Draw(s.timer)
-
-	// Draw arena of tiles
-	s.arena.Animate(*s.backend)
-	s.arena.Draw(s.win)
-
-	// Draw opponent's arena
-	s.opponentArena.Animate(*s.opponentBackend)
-	s.opponentArena.Draw(s.win)
 
-	// Check for win or lose
-	switch s.backend.Grid.Outcome() {
-	case grid.None:
-		s.backgroundColour = common.BackgroundColour
-	case grid.Win:
-		s.backgroundColour = common.BackgroundColourWin
-	case grid.Lose:
-		s.backgroundColour = common.BackgroundColourLose
+	s.arena.Update(*s.backend)
+	s.opponentArena.Update(*s.opponentBackend)
+
+	for _, d := range []turdgl.Drawable{
+		s.title,
+		s.guide,
+		s.opponentGuide,
+		s.menu,
+		s.score,
+		s.opponentScore,
+		s.newGame,
+		s.timer,
+		s.arena,
+		s.opponentArena,
+	} {
+		s.win.Draw(d)
 	}
-
 }
 
 // sendGameUpdate sends the local game state to the opponent.

screen/singleplayer.go

@@ -229,24 +229,28 @@ func (s *SingleplayerScreen) Update() {
 // Update updates and draws the singleplayer screen in a normal state.
 func (s *SingleplayerScreen) updateNormal(game backend.Game) {
 	s.win.SetBackground(common.BackgroundColour)
-	s.arena.SetNormal()
 
 	s.score.SetBody(fmt.Sprint(game.Score.Current))
 	s.menu.Update(s.win)
 	s.highScore.SetBody(fmt.Sprint(game.Score.High))
-	s.newGame.Update(s.win)
 	s.timer.SetText(game.Timer.Time.String())
+	s.newGame.Update(s.win)
 
-	s.win.Draw(s.logo2048)
-	s.score.Draw(s.win)
-	s.highScore.Draw(s.win)
-	s.win.Draw(s.menu) // TODO: convert these to turdgl.Drawable interface (s.menu.Draw(s.win.Framebuffer))
-	s.win.Draw(s.newGame)
-	s.win.Draw(s.guide)
-	s.win.Draw(s.timer)
-
-	s.arena.Draw(s.win)
-	s.arena.Animate(game)
+	s.arena.SetNormal()
+	s.arena.Update(game)
+
+	for _, d := range []turdgl.Drawable{
+		s.logo2048,
+		s.score,
+		s.highScore,
+		s.menu,
+		s.newGame,
+		s.guide,
+		s.timer,
+		s.arena,
+	} {
+		s.win.Draw(d)
+	}
 }
 
 // updateWin updates and draws the singleplayer screen in a winning state.
@@ -267,12 +271,15 @@ func (s *SingleplayerScreen) updateLose(game backend.Game) {
 
 	s.menu.Update(s.win)
 	s.newGame.Update(s.win)
-
-	s.win.Draw(s.heading)
-	s.win.Draw(s.loseDialog)
-	s.win.Draw(s.menu)
-	s.win.Draw(s.newGame)
-
-	s.arena.Draw(s.win)
-	s.arena.Animate(game)
+	s.arena.Update(game)
+
+	for _, d := range []turdgl.Drawable{
+		s.heading,
+		s.loseDialog,
+		s.menu,
+		s.newGame,
+		s.arena,
+	} {
+		s.win.Draw(d)
+	}
 }