v/examples/2048/2048.v

import gg
import gx
import math
import os
import rand
import sokol.sapp
import time

struct App {
mut:
	gg            &gg.Context = 0
	touch         TouchInfo
	ui            Ui
	theme         &Theme = themes[0]
	theme_idx     int
	board         Board
	undo          []Undo
	atickers      [4][4]int
	state         GameState = .play
	tile_format   TileFormat = .normal
	moves         int
	perf          &Perf = 0
	is_ai_mode    bool
}

struct Ui {
mut:
	dpi_scale     f32
	tile_size     int
	border_size   int
	padding_size  int
	header_size   int
	font_size     int
	window_width  int
	window_height int
	x_padding     int
	y_padding     int
}

struct Theme {
	bg_color        gx.Color
	padding_color   gx.Color
	text_color      gx.Color
	game_over_color gx.Color
	victory_color   gx.Color
	tile_colors     []gx.Color
}

const (
	themes = [
		&Theme {
			bg_color: gx.rgb(250, 248, 239)
			padding_color: gx.rgb(143, 130, 119)
			victory_color: gx.rgb(100, 160, 100)
			game_over_color: gx.rgb(190, 50, 50)
			text_color: gx.black
			tile_colors: [
				gx.rgb(205, 193, 180) // Empty / 0 tile
				gx.rgb(238, 228, 218) // 2
				gx.rgb(237, 224, 200) // 4
				gx.rgb(242, 177, 121) // 8
				gx.rgb(245, 149, 99)  // 16
				gx.rgb(246, 124, 95)  // 32
				gx.rgb(246, 94, 59)   // 64
				gx.rgb(237, 207, 114) // 128
				gx.rgb(237, 204, 97)  // 256
				gx.rgb(237, 200, 80)  // 512
				gx.rgb(237, 197, 63)  // 1024
				gx.rgb(237, 194, 46)  // 2048
			]
		},
		&Theme {
			bg_color: gx.rgb(55, 55, 55)
			padding_color: gx.rgb(68, 60, 59)
			victory_color: gx.rgb(100, 160, 100)
			game_over_color: gx.rgb(190, 50, 50)
			text_color: gx.white
			tile_colors: [
				gx.rgb(123, 115, 108)
				gx.rgb(142, 136, 130)
				gx.rgb(142, 134, 120)
				gx.rgb(145, 106, 72)
				gx.rgb(147, 89, 59)
				gx.rgb(147, 74, 57)
				gx.rgb(147, 56, 35)
				gx.rgb(142, 124, 68)
				gx.rgb(142, 122, 58)
				gx.rgb(142, 120, 48)
				gx.rgb(142, 118, 37)
				gx.rgb(142, 116, 27)
			]
		},
		&Theme {
			bg_color: gx.rgb(38, 38, 66)
			padding_color: gx.rgb(58, 50, 74)
			victory_color: gx.rgb(100, 160, 100)
			game_over_color: gx.rgb(190, 50, 50)
			text_color: gx.white
			tile_colors: [
				gx.rgb(92, 86, 140)
				gx.rgb(106, 99, 169)
				gx.rgb(106, 97, 156)
				gx.rgb(108, 79, 93)
				gx.rgb(110, 66, 76)
				gx.rgb(110, 55, 74)
				gx.rgb(110, 42, 45)
				gx.rgb(106, 93, 88)
				gx.rgb(106, 91, 75)
				gx.rgb(106, 90, 62)
				gx.rgb(106, 88, 48)
				gx.rgb(106, 87, 35)
			]
		},
	]
	window_title          = 'V 2048'
	default_window_width  = 544
	default_window_height = 560
	animation_length      = 10 // frames
	frames_per_ai_move    = 8
	possible_moves = [Direction.up, .right, .down, .left]
	predictions_per_move = 200
	prediction_depth = 8
)

// Used for performance monitoring when `-d showfps` is passed, unused / optimized out otherwise
struct Perf {
mut:
	frame     int
	frame_old int
	frame_sw  time.StopWatch = time.new_stopwatch({})
	second_sw time.StopWatch = time.new_stopwatch({})
}

struct Pos {
	x int = -1
	y int = -1
}

struct Board {
mut:
	field  [4][4]int
	points int
	shifts int
}

struct Undo {
	board Board
	state GameState
}

struct TileLine {
	ypos   int
mut:
	field  [5]int
	points int
	shifts int
}

struct TouchInfo {
mut:
	start Touch
	end   Touch
}

struct Touch {
mut:
	pos  Pos
	time time.Time
}

enum TileFormat {
	normal
	log
	exponent
	shifts
	none_
	end_ // To know when to wrap around
}

enum GameState {
	play
	over
	victory
	freeplay
}

enum LabelKind {
	points
	moves
	tile
	victory
	game_over
	score_end
}

enum Direction {
	up
	down
	left
	right
}

// Utility functions
[inline]
fn min(a, b int) int {
	if a < b { return a } else { return b }
}

[inline]
fn max(a, b int) int {
	if a > b { return a } else { return b }
}

[inline]
fn abs(a int) int {
	if a < 0 { return -a } else { return a }
}

[inline]
fn avg(a, b int) int {
	return (a + b) / 2
}

fn (b Board) transpose() Board {
	mut res := b
	for y in 0..4 {
		for x in 0..4 {
			res.field[y][x] = b.field[x][y]
		}
	}
	return res
}

fn (b Board) hmirror() Board {
	mut res := b
	for y in 0..4 {
		for x in 0..4 {
			res.field[y][x] = b.field[y][3 - x]
		}
	}
	return res
}

// GCC optimization bug; inlining fails when compiled with -prod
[no_inline]
fn (t TileLine) to_left() TileLine {
	right_border_idx := 5
	mut res := t
	mut zeros := 0
	mut nonzeros := 0
	// gather meta info about the line:
	for x in res.field {
		if x == 0 { zeros++ } else { nonzeros++ }
	}
	if nonzeros == 0 {
		// when all the tiles are empty, there is nothing left to do
		return res
	}
	if zeros > 0 {
		// we have some 0s, do shifts to compact them:
		mut remaining_zeros := zeros
		for x := 0; x < right_border_idx - 1; x++ {
			for res.field[x] == 0 && remaining_zeros > 0 {
				res.shifts++
				for k := x; k < right_border_idx; k++ {
					res.field[k] = res.field[k + 1]
				}
				remaining_zeros--
			}
		}
	}
	// At this point, the non 0 tiles are all on the left, with no empty spaces
	// between them. we can safely merge them, when they have the same value:
	for x := 0; x < right_border_idx - 1; x++ {
		if res.field[x] == 0 {
			break
		}
		if res.field[x] == res.field[x + 1] {
			for k := x; k < right_border_idx; k++ {
				res.field[k] = res.field[k + 1]
			}
			res.shifts++
			res.field[x]++
			res.points += 1 << res.field[x]
		}
	}
	return res
}

fn (b Board) to_left() Board {
	mut res := b
	for y in 0..4 {
		mut hline := TileLine{ypos: y}
		for x in 0..4 {
			hline.field[x] = b.field[y][x]
		}
		reshline := hline.to_left()
		res.shifts += reshline.shifts
		res.points += reshline.points
		for x in 0..4 {
			res.field[y][x] = reshline.field[x]
		}
	}
	return res
}

fn (b Board) move(d Direction) (Board, bool) {
	new := match d {
		.left  { b.to_left() }
		.right { b.hmirror().to_left().hmirror() }
		.up    { b.transpose().to_left().transpose() }
		.down  { b.transpose().hmirror().to_left().hmirror().transpose() }
	}
	// If the board hasn't changed, it's an illegal move, don't allow it.
	for x in 0..4 {
		for y in 0..4 {
			if b.field[x][y] != new.field[x][y] {
				return new, true
			}
		}
	}
	return new, false
}

fn (mut b Board) is_game_over() bool {
	for y in 0..4 {
		for x in 0..4 {
			fidx := b.field[y][x]
			if fidx == 0 {
				// there are remaining zeros
				return false
			}
			if (x > 0 && fidx == b.field[y][x - 1])
			|| (x < 4 - 1 && fidx == b.field[y][x + 1])
			|| (y > 0 && fidx == b.field[y - 1][x])
			|| (y < 4 - 1 && fidx == b.field[y + 1][x]) {
				// there are remaining merges
				return false
			}
		}
	}
	return true
}

fn (mut app App) update_tickers() {
	for y in 0..4 {
		for x in 0..4 {
			mut old := app.atickers[y][x]
			if old > 0 {
				old--
				app.atickers[y][x] = old
			}
		}
	}
}

fn (mut app App) new_game() {
	app.board = Board{}
	for y in 0..4 {
		for x in 0..4 {
			app.board.field[y][x] = 0
			app.atickers[y][x] = 0
		}
	}
	app.state = .play
	app.undo = []Undo{cap:4096}
	app.moves = 0
	app.new_random_tile()
	app.new_random_tile()
}

[inline]
fn (mut app App) check_for_victory() {
	for y in 0..4 {
		for x in 0..4 {
			fidx := app.board.field[y][x]
			if fidx == 11 {
				app.state = .victory
				return
			}
		}
	}
}

[inline]
fn (mut app App) check_for_game_over() {
	if app.board.is_game_over() {
		app.state = .over
	}
}

fn (mut b Board) place_random_tile() (Pos, int) {
	mut etiles := [16]Pos{}
	mut empty_tiles_max := 0
	for y in 0..4 {
		for x in 0..4 {
			fidx := b.field[y][x]
			if fidx == 0 {
				etiles[empty_tiles_max] = Pos{x, y}
				empty_tiles_max++
			}
		}
	}
	if empty_tiles_max > 0 {
		new_random_tile_index := rand.intn(empty_tiles_max)
		empty_pos := etiles[new_random_tile_index]
		// 10% chance of getting a `4` tile
		random_value := if rand.f64n(1.0) < 0.9 { 1 } else { 2 }
		b.field[empty_pos.y][empty_pos.x] = random_value
		return empty_pos, random_value
	}
	return Pos{}, 0
}

fn (mut app App) new_random_tile() {
	for y in 0..4 {
		for x in 0..4 {
			fidx := app.board.field[y][x]
			if fidx == 0 {
				app.atickers[y][x] = 0
			}
		}
	}
	empty_pos, random_value := app.board.place_random_tile()
	if random_value > 0 {
		app.atickers[empty_pos.y][empty_pos.x] = animation_length
	}
	if app.state != .freeplay { app.check_for_victory() } 
	app.check_for_game_over()
}

fn (mut app App) apply_new_board(new Board) {
	old := app.board
	app.moves++
	app.board = new
	app.undo << Undo{ old, app.state }
	app.new_random_tile()
}

fn (mut app App) move(d Direction) {
	new, is_valid := app.board.move(d)
	if !is_valid {
		return
	}
	app.apply_new_board(new)
}

struct Prediction {
mut:
	move Direction
	mpoints f64
	mcmoves f64
}

fn (p Prediction) str() string {
	return '{ move: ${p.move:5}, mpoints: ${p.mpoints:6.2f}, mcmoves: ${p.mcmoves:6.2f} }'
}

fn (mut app App) ai_move() {
	mut predictions := [4]Prediction{}
	mut is_valid := false
	think_watch := time.new_stopwatch({})
	for move in possible_moves {
		move_idx := int(move)
		predictions[move_idx].move = move
		mut mpoints := 0
		mut mshifts := 0
		mut mcmoves := 0
		for _ in 0..predictions_per_move {
			mut cboard := app.board
			cboard, is_valid = cboard.move(move)
			if !is_valid || cboard.is_game_over() { continue }
			mpoints += cboard.points
			cboard.place_random_tile()
			mut cmoves := 0
			for !cboard.is_game_over() {
				nmove := possible_moves[rand.intn(possible_moves.len)]
				cboard, is_valid = cboard.move(nmove)
				if !is_valid { continue }
				cboard.place_random_tile()
				cmoves++
				if cmoves > prediction_depth { break }
			}
			mpoints += cboard.points
			mshifts += cboard.shifts
			mcmoves += cmoves
		}
		predictions[move_idx].mpoints = f64(mpoints) / predictions_per_move
		predictions[move_idx].mcmoves = f64(mcmoves) / predictions_per_move
	}
	think_time := think_watch.elapsed().milliseconds()
	mut bestprediction := Prediction{mpoints:-1}
	for move_idx in 0..possible_moves.len {
		if bestprediction.mpoints < predictions[move_idx].mpoints {
			bestprediction = predictions[move_idx]
		}
	}
	eprintln('Simulation time: ${think_time:4}ms |  best $bestprediction')
	app.move(bestprediction.move)
}

fn (app &App) label_format(kind LabelKind) gx.TextCfg {
	match kind {
		.points {
			return {
				color: if app.state in [.over, .victory] { gx.white } else { app.theme.text_color }
				align: .left
				size: app.ui.font_size / 2
			}
		} .moves {
			return {
				color: if app.state in [.over, .victory] { gx.white } else { app.theme.text_color }
				align: .right
				size: app.ui.font_size / 2
			}
		} .tile {
			return {
				color: app.theme.text_color
				align: .center
				vertical_align: .middle
				size: app.ui.font_size
			}
		} .victory {
			return {
				color: app.theme.victory_color
				align: .center
				vertical_align: .middle
				size: app.ui.font_size * 2
			}
		} .game_over {
			return {
				color: app.theme.game_over_color
				align: .center
				vertical_align: .middle
				size: app.ui.font_size * 2
			}
		} .score_end {
			return {
				color: gx.white
				align: .center
				vertical_align: .middle
				size: app.ui.font_size * 3 / 4
			}
		}
	}
}

[inline]
fn (mut app App) set_theme(idx int) {
	theme := themes[idx]
	app.theme_idx = idx
	app.theme = theme
	app.gg.set_bg_color(theme.bg_color)
}

fn (mut app App) resize() {
	mut s := sapp.dpi_scale()
	if s == 0.0 { s = 1.0 }
	w := int(sapp.width() / s)
	h := int(sapp.height() / s)
	m := f32(min(w, h))

	app.ui.dpi_scale = s
	app.ui.window_width = w
	app.ui.window_height = h
	app.ui.padding_size = int(m / 38)
	app.ui.header_size = app.ui.padding_size
	app.ui.border_size = app.ui.padding_size * 2
	app.ui.tile_size = int((m - app.ui.padding_size * 5 - app.ui.border_size * 2) / 4)
	app.ui.font_size = int(m / 10)

	// If the window's height is greater than its width, center the board vertically.
	// If not, center it horizontally
	if w > h {
		app.ui.y_padding = 0
		app.ui.x_padding = (app.ui.window_width - app.ui.window_height) / 2
	} else {
		app.ui.y_padding = (app.ui.window_height - app.ui.window_width - app.ui.header_size) / 2
		app.ui.x_padding = 0
	}
}

fn (app &App) draw() {
	xpad, ypad := app.ui.x_padding, app.ui.y_padding
	ww := app.ui.window_width
	wh := app.ui.window_height
	m := min(ww, wh)
	labelx := xpad + app.ui.border_size
	labely := ypad + app.ui.border_size / 2

	app.draw_tiles()

	// TODO: Make transparency work in `gg`
	if app.state == .over {
		app.gg.draw_rect(0, 0, ww, wh, gx.rgba(10, 0, 0, 180))
		app.gg.draw_text(ww / 2, (m * 4 / 10) + ypad, 'Game Over', app.label_format(.game_over))
		
		f := app.label_format(.tile)
		msg := $if android { 'Tap to restart' } $else { 'Press `r` to restart' }
		app.gg.draw_text(ww / 2, (m * 6 / 10) + ypad, msg, { f | color: gx.white, size: f.size * 3 / 4 })
	}
	if app.state == .victory {
		app.gg.draw_rect(0, 0, ww, wh, gx.rgba(0, 10, 0, 180))
		app.gg.draw_text(ww / 2, (m * 4 / 10) + ypad, 'Victory!', app.label_format(.victory))

		// f := app.label_format(.tile)
		msg1 := $if android { 'Tap to continue' } $else { 'Press `space` to continue' }
		msg2 := $if android { 'Tap to restart' } $else { 'Press `r` to restart' }
		app.gg.draw_text(ww / 2, (m * 6 / 10) + ypad, msg1, app.label_format(.score_end))
		app.gg.draw_text(ww / 2, (m * 8 / 10) + ypad, msg2, app.label_format(.score_end))
	}

	// Draw at the end, so that it's on top of the victory / game over overlays
	app.gg.draw_text(labelx, labely, 'Points: $app.board.points', app.label_format(.points))
	app.gg.draw_text(ww - labelx, labely, 'Moves: $app.moves', app.label_format(.moves))
}

fn (app &App) draw_tiles() {
	xstart := app.ui.x_padding + app.ui.border_size
	ystart := app.ui.y_padding + app.ui.border_size + app.ui.header_size

	toffset := app.ui.tile_size + app.ui.padding_size
	tiles_size := min(app.ui.window_width, app.ui.window_height) - app.ui.border_size * 2

	// Draw the padding around the tiles
	app.gg.draw_rect(xstart, ystart, tiles_size, tiles_size, app.theme.padding_color)
	// Draw the actual tiles
	for y in 0..4 {
		for x in 0..4 {
			tidx := app.board.field[y][x]
			tile_color := if tidx < app.theme.tile_colors.len {
				app.theme.tile_colors[tidx]
			} else {
				// If there isn't a specific color for this tile, reuse the last color available
				app.theme.tile_colors.last()
			}
			anim_size := animation_length - app.atickers[y][x]
			tw := int(f64(app.ui.tile_size) / animation_length * anim_size)
			th := tw // square tiles, w == h
			xoffset := xstart + app.ui.padding_size + x * toffset + (app.ui.tile_size - tw) / 2
			yoffset := ystart + app.ui.padding_size + y * toffset + (app.ui.tile_size - th) / 2
			app.gg.draw_rect(xoffset, yoffset, tw, th, tile_color)

			if tidx != 0 { // 0 == blank spot
				xpos := xoffset + tw / 2
				ypos := yoffset + th / 2
				mut fmt := app.label_format(.tile)
				fmt = { fmt | size: int(f32(fmt.size - 1) / animation_length * anim_size) }

				match app.tile_format {
					.normal {
						app.gg.draw_text(xpos, ypos, '${1 << tidx}', fmt)
					} .log {
						app.gg.draw_text(xpos, ypos, '$tidx', fmt)
					} .exponent {
						app.gg.draw_text(xpos, ypos, '2', fmt)
						fs2 := int(f32(fmt.size) * 0.67)
						app.gg.draw_text(xpos + app.ui.tile_size / 10, ypos - app.ui.tile_size / 8,
							'$tidx', { fmt | size: fs2, align: gx.HorizontalAlign.left })
					} .shifts {
						fs2 := int(f32(fmt.size) * 0.6)
						app.gg.draw_text(xpos, ypos, '2<<${tidx - 1}', { fmt | size: fs2 })
					} .none_ {} // Don't draw any text here, colors only
					.end_ {} // Should never get here
				}
			}
		}
	}
}

fn (mut app App) handle_touches() {
	s, e := app.touch.start, app.touch.end
	adx, ady := abs(e.pos.x - s.pos.x), abs(e.pos.y - s.pos.y)
	
	if max(adx, ady) < 10 {
		app.handle_tap()
	} else {
		app.handle_swipe()
	}
}

fn (mut app App) handle_tap() {
	_, ypad := app.ui.x_padding, app.ui.y_padding
	w, h := app.ui.window_width, app.ui.window_height
	m := min(w, h)
	s, e := app.touch.start, app.touch.end
	avgx, avgy := avg(s.pos.x, e.pos.x), avg(s.pos.y, e.pos.y)

	// TODO: Replace "touch spots" with actual buttons
	// bottom left -> change theme
	if avgx < 200 && h - avgy < 200 { app.next_theme() }
	// bottom right -> change tile format
	if w - avgx < 200 && h - avgy < 200 { app.next_tile_format() }

	if app.state == .victory {
		if avgy > (m / 2) + ypad {
			if avgy < (m * 7 / 10) + ypad {
				app.state = .freeplay
			} else if avgy < (m * 9 / 10) + ypad {
				app.new_game()
			} else {
				// TODO remove and implement an actual way to toggle themes on mobile
			}
		}
	} else if app.state == .over {
		if avgy > (m / 2) + ypad && avgy < (m * 7 / 10) + ypad {
			app.new_game()
		}
	}
}

fn (mut app App) handle_swipe() {
	// Currently, swipes are only used to move the tiles. 
	// If the user's not playing, exit early to avoid all the unnecessary calculations
	if app.state !in [.play, .freeplay] { return }

	s, e := app.touch.start, app.touch.end
	w, h := app.ui.window_width, app.ui.window_height
	dx, dy := e.pos.x - s.pos.x, e.pos.y - s.pos.y
	adx, ady := abs(dx), abs(dy)
	dmin := if min(adx, ady) > 0 { min(adx, ady) } else { 1 }
	dmax := if max(adx, ady) > 0 { max(adx, ady) } else { 1 }
	tdiff := int(e.time.unix_time_milli() - s.time.unix_time_milli())

	// TODO: make this calculation more accurate (don't use arbitrary numbers)
	min_swipe_distance := int(math.sqrt(min(w, h) * tdiff / 60)) + 20

	if dmax < min_swipe_distance { return } // Swipe was too short
	if dmax / dmin < 2 { return } // Swiped diagonally

	if adx > ady {
		if dx < 0 { app.move(.left) } else { app.move(.right) }
	} else {
		if dy < 0 { app.move(.up) } else { app.move(.down) }
	}
}

[inline]
fn (mut app App) next_theme() {
	app.set_theme(if app.theme_idx == themes.len - 1 { 0 } else { app.theme_idx + 1 })
}

[inline]
fn (mut app App) next_tile_format() {
	app.tile_format = int(app.tile_format) + 1
	if app.tile_format == .end_ {
		app.tile_format = .normal
	}
}

[inline]
fn (mut app App) undo() {
	if app.undo.len > 0 {
		undo := app.undo.pop()
		app.board = undo.board
		app.state = undo.state
		app.moves--
	}
}


fn (mut app App) on_key_down(key sapp.KeyCode) {
	// these keys are independent from the game state:
	match key {
		.a {
			app.is_ai_mode = !app.is_ai_mode
		} .escape {
			exit(0)
		} .n, .r {
			app.new_game()
		} .backspace {
			app.undo()
		} .enter {
			app.next_tile_format()
		} .j {
			app.state = .over
		} .t {
			app.next_theme()
		} else {}
	}

	if app.state in [.play, .freeplay] {
		match key {
			.w, .up    { app.move(.up) }
			.a, .left  { app.move(.left) }
			.s, .down  { app.move(.down) }
			.d, .right { app.move(.right) }
			else {}
		}
	}

	if app.state == .victory {
		if key == .space { app.state = .freeplay }
	}
}

fn on_event(e &sapp.Event, mut app App) {
	match e.typ {
		.key_down {
			app.on_key_down(e.key_code)
		} .resized, .restored, .resumed {
			app.resize()
		} .touches_began {
			if e.num_touches > 0 {
				t := e.touches[0]
				app.touch.start = {
					pos: {
						x: int(t.pos_x / app.ui.dpi_scale),
						y: int(t.pos_y / app.ui.dpi_scale)
					},
					time: time.now()
				}
			}
		} .touches_ended {
			if e.num_touches > 0 {
				t := e.touches[0]
				app.touch.end = {
					pos: {
						x: int(t.pos_x / app.ui.dpi_scale),
						y: int(t.pos_y / app.ui.dpi_scale)
					},
					time: time.now()
				}
				app.handle_touches()
			}
		} .mouse_down {
			app.touch.start = {
				pos: {
					x: int(e.mouse_x / app.ui.dpi_scale),
					y: int(e.mouse_y / app.ui.dpi_scale)
				},
				time: time.now()
			}
		} .mouse_up {
			app.touch.end = {
				pos: {
					x: int(e.mouse_x / app.ui.dpi_scale),
					y: int(e.mouse_y / app.ui.dpi_scale)
				},
				time: time.now()
			}
			app.handle_touches()
		} else {}
	}
}

fn frame(mut app App) {
	$if showfps? { app.perf.frame_sw.restart() }
	app.gg.begin()
	app.update_tickers()
	app.draw()
	app.perf.frame++
	if app.is_ai_mode && app.state in [.play, .freeplay] && app.perf.frame % frames_per_ai_move == 0 {
		app.ai_move()
	}
	$if showfps? { app.showfps() }
	app.gg.end()
}

fn init(mut app App) {
	app.resize()
	$if showfps? {
		app.perf.frame_sw.restart()
		app.perf.second_sw.restart()
	}
}

fn (mut app App) showfps() {
	println(app.perf.frame_sw.elapsed().microseconds())
	f := app.perf.frame
	if (f & 127) == 0 {
		last_frame_us := app.perf.frame_sw.elapsed().microseconds()
		ticks := f64(app.perf.second_sw.elapsed().milliseconds())
		fps := f64(app.perf.frame - app.perf.frame_old) * ticks / 1000 / 4.5
		last_fps := 128_000.0 / ticks
		eprintln('frame ${f:-5} | avg. fps: ${fps:-5.1f} | avg. last 128 fps: ${last_fps:-5.1f} | last frame time: ${last_frame_us:-4}µs')
		app.perf.second_sw.restart()
		app.perf.frame_old = f
	}
}

// TODO: Move this somewhere else (vlib?) once Android support is merged
$if android {
	#include <android/log.h>
	#define LOG_TAG "v_logcat_test"
	#define printf(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
	#define fprintf(a, ...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
}

fn main() {
	mut app := &App{}
	app.new_game()

	mut font_path := os.resource_abs_path(os.join_path('../assets/fonts/', 'RobotoMono-Regular.ttf'))
	$if android {
		font_path = 'fonts/RobotoMono-Regular.ttf'
	}

	mut window_title := 'V 2048'
	// TODO: Make emcc a real platform ifdef
	$if emscripten? {
		// in emscripten, sokol uses `window_title` as the selector to the canvas it'll render to,
		// and since `document.querySelector('V 2048')` isn't valid JS, we use `canvas` instead
		window_title = 'canvas'
	}

	app.perf = &Perf{}

	app.gg = gg.new_context({
		bg_color: app.theme.bg_color
		width: default_window_width
		height: default_window_height
		create_window: true
		window_title: window_title
		frame_fn: frame
		event_fn: on_event
		init_fn: init
		user_data: app
		font_path: font_path
	})
	app.gg.run()
}