1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00

examples/2048: some updates and improvements (#6343)

This commit is contained in:
spaceface777 2020-09-11 12:19:38 +02:00 committed by GitHub
parent 17882db635
commit 4aaeaa4331
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 484 additions and 264 deletions

View File

@ -3,11 +3,125 @@ import gx
import os
import rand
import sokol.sapp
import time
struct Tile {
id int
points int
picname string
struct App {
mut:
gg &gg.Context = 0
touch TouchInfo
ui Ui
theme &Theme = themes[0]
theme_idx int
board Board
undo []Board
atickers [4][4]int
state GameState = .play
tile_format TileFormat = .normal
moves int
perf &Perf = 0
}
struct Ui {
mut:
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
)
// 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 {
@ -15,74 +129,6 @@ struct Pos {
y int = -1
}
struct ImageLabel {
pos Pos
dim Pos
}
struct TextLabel {
text string
pos Pos
cfg gx.TextCfg
}
const (
window_title = 'V 2048'
window_width = 562
window_height = 580
points_label = TextLabel{
text: 'Points: '
pos: Pos{10, 5}
cfg: gx.TextCfg{
align: .left
size: 24
color: gx.rgb(0, 0, 0)
}
}
moves_label = TextLabel{
text: 'Moves: '
pos: Pos{window_width - 160, 5}
cfg: gx.TextCfg{
align: .left
size: 24
color: gx.rgb(0, 0, 0)
}
}
game_over_label = TextLabel{
text: 'Game Over'
pos: Pos{80, 220}
cfg: gx.TextCfg{
align: .left
size: 100
color: gx.rgb(0, 0, 255)
}
}
victory_image_label = ImageLabel{
pos: Pos{80, 220}
dim: Pos{430, 130}
}
all_tiles = [
Tile{0, 0, '1.png'},
Tile{1, 2, '2.png'},
Tile{2, 4, '4.png'},
Tile{3, 8, '8.png'},
Tile{4, 16, '16.png'},
Tile{5, 32, '32.png'},
Tile{6, 64, '64.png'},
Tile{7, 128, '128.png'},
Tile{8, 256, '256.png'},
Tile{9, 512, '512.png'},
Tile{10, 1024, '1024.png'},
Tile{11, 2048, '2048.png'},
]
)
struct TileImage {
tile Tile
mut:
image gg.Image
}
struct Board {
mut:
field [4][4]int
@ -90,36 +136,6 @@ mut:
shifts int
}
fn new_board(sb []string) Board {
mut b := Board{}
for y := 0; y < 4; y++ {
for x := 0; x < 4; x++ {
b.field[y][x] = sb[y][x] - 64
}
}
return b
}
fn (b Board) transpose() Board {
mut res := b
for y := 0; y < 4; y++ {
for x := 0; x < 4; x++ {
res.field[y][x] = b.field[x][y]
}
}
return res
}
fn (b Board) hmirror() Board {
mut res := b
for y := 0; y < 4; y++ {
for x := 0; x < 4; x++ {
res.field[y][x] = b.field[y][4 - x - 1]
}
}
return res
}
struct TileLine {
ypos int
mut:
@ -128,6 +144,78 @@ mut:
shifts int
}
struct TouchInfo {
mut:
start_pos Pos
}
enum TileFormat {
normal
log
exponent
shifts
none_
end_ // To know when to wrap around
}
enum GameState {
play
over
victory
}
enum LabelKind {
points
moves
tile
victory
game_over
}
enum Direction {
up
down
left
right
}
// Utility functions, to avoid importing `math`
[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 }
}
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
@ -135,12 +223,8 @@ fn (t TileLine) to_left() TileLine {
mut zeros := 0
mut nonzeros := 0
// gather meta info about the line:
for x := 0; x < 4; x++ {
if res.field[x] == 0 {
zeros++
} else {
nonzeros++
}
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
@ -171,7 +255,7 @@ fn (t TileLine) to_left() TileLine {
}
res.shifts++
res.field[x]++
res.points += all_tiles[res.field[x]].points
res.points += 1 << res.field[x]
}
}
return res
@ -179,65 +263,24 @@ fn (t TileLine) to_left() TileLine {
fn (b Board) to_left() Board {
mut res := b
for y := 0; y < 4; y++ {
mut hline := TileLine{
ypos: y
}
for x := 0; x < 4; x++ {
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 := 0; x < 4; x++ {
for x in 0..4 {
res.field[y][x] = reshline.field[x]
}
}
return res
}
//
enum GameState {
play
over
victory
}
struct App {
mut:
gg &gg.Context
tiles []TileImage
victory_image gg.Image
//
board Board
undo []Board
atickers [4][4]int
state GameState = .play
moves int
}
fn (mut app App) new_image(imagename string) gg.Image {
ipath := os.resource_abs_path(os.join_path('assets', imagename))
return app.gg.create_image(ipath)
}
fn (mut app App) new_tile(t Tile) TileImage {
mut timage := TileImage{
tile: t
}
timage.image = app.new_image(t.picname)
return timage
}
fn (mut app App) load_tiles() {
for t in all_tiles {
app.tiles << app.new_tile(t)
}
}
fn (mut app App) update_tickers() {
for y := 0; y < 4; y++ {
for x := 0; x < 4; x++ {
for y in 0..4 {
for x in 0..4 {
mut old := app.atickers[y][x]
if old > 0 {
old--
@ -247,57 +290,10 @@ fn (mut app App) update_tickers() {
}
}
fn (app &App) draw() {
app.draw_background()
app.draw_tiles()
plabel := '$points_label.text ${app.board.points:08}'
mlabel := '$moves_label.text ${app.moves:5d}'
app.gg.draw_text(points_label.pos.x, points_label.pos.y, plabel, points_label.cfg)
app.gg.draw_text(moves_label.pos.x, moves_label.pos.y, mlabel, moves_label.cfg)
if app.state == .over {
app.gg.draw_text(game_over_label.pos.x, game_over_label.pos.y, game_over_label.text,
game_over_label.cfg)
}
if app.state == .victory {
app.gg.draw_image(victory_image_label.pos.x, victory_image_label.pos.y, victory_image_label.dim.x,
victory_image_label.dim.y, app.victory_image)
}
}
fn (app &App) draw_background() {
tw, th := 128, 128
for y := 30; y <= window_height; y += tw {
for x := 0; x <= window_width; x += th {
app.gg.draw_image(x, y, tw, th, app.tiles[0].image)
}
}
}
fn (app &App) draw_tiles() {
border := 10
xstart := 10
ystart := 30
tsize := 128
for y := 0; y < 4; y++ {
for x := 0; x < 4; x++ {
tidx := app.board.field[y][x]
if tidx == 0 {
continue
}
tile := app.tiles[tidx]
tw := tsize - 10 * app.atickers[y][x]
th := tsize - 10 * app.atickers[y][x]
tx := xstart + x * (tsize + border) + (tsize - tw) / 2
ty := ystart + y * (tsize + border) + (tsize - th) / 2
app.gg.draw_image(tx, ty, tw, th, tile.image)
}
}
}
fn (mut app App) new_game() {
app.board = Board{}
for y := 0; y < 4; y++ {
for x := 0; x < 4; x++ {
for y in 0..4 {
for x in 0..4 {
app.board.field[y][x] = 0
app.atickers[y][x] = 0
}
@ -310,8 +306,8 @@ fn (mut app App) new_game() {
}
fn (mut app App) check_for_victory() {
for y := 0; y < 4; y++ {
for x := 0; x < 4; x++ {
for y in 0..4 {
for x in 0..4 {
fidx := app.board.field[y][x]
if fidx == 11 {
app.victory()
@ -324,23 +320,17 @@ fn (mut app App) check_for_victory() {
fn (mut app App) check_for_game_over() {
mut zeros := 0
mut remaining_merges := 0
for y := 0; y < 4; y++ {
for x := 0; x < 4; x++ {
for y in 0..4 {
for x in 0..4 {
fidx := app.board.field[y][x]
if fidx == 0 {
zeros++
continue
}
if x > 0 && fidx == app.board.field[y][x - 1] {
remaining_merges++
}
if x < 4 - 1 && fidx == app.board.field[y][x + 1] {
remaining_merges++
}
if y > 0 && fidx == app.board.field[y - 1][x] {
remaining_merges++
}
if y < 4 - 1 && fidx == app.board.field[y + 1][x] {
if (x > 0 && fidx == app.board.field[y][x - 1])
|| (x < 4 - 1 && fidx == app.board.field[y][x + 1])
|| (y > 0 && fidx == app.board.field[y - 1][x])
|| (y < 4 - 1 && fidx == app.board.field[y + 1][x]) {
remaining_merges++
}
}
@ -353,11 +343,12 @@ fn (mut app App) check_for_game_over() {
fn (mut app App) new_random_tile() {
mut etiles := [16]Pos{}
mut empty_tiles_max := 0
for y := 0; y < 4; y++ {
for x := 0; x < 4; x++ {
for y in 0..4 {
for x in 0..4 {
fidx := app.board.field[y][x]
if fidx == 0 {
etiles[empty_tiles_max] = Pos{x, y}
app.atickers[y][x] = 0
empty_tiles_max++
}
}
@ -365,9 +356,10 @@ fn (mut app App) new_random_tile() {
if empty_tiles_max > 0 {
new_random_tile_index := rand.intn(empty_tiles_max)
empty_pos := etiles[new_random_tile_index]
random_value := 1 + rand.intn(2)
// 1/8 chance of creating a `4` tile
random_value := if rand.intn(8) == 0 { 2 } else { 1 }
app.board.field[empty_pos.y][empty_pos.x] = random_value
app.atickers[empty_pos.y][empty_pos.x] = 30
app.atickers[empty_pos.y][empty_pos.x] = animation_length
}
app.check_for_victory()
app.check_for_game_over()
@ -381,11 +373,14 @@ fn (mut app App) game_over() {
app.state = .over
}
type BoardMoveFN = fn (b Board) Board
fn (mut app App) move(move_fn BoardMoveFN) {
fn (mut app App) move(d Direction) {
old := app.board
new := move_fn(old)
new := match d {
.left { old.to_left() }
.right { old.hmirror().to_left().hmirror() }
.up { old.transpose().to_left().transpose() }
.down { old.transpose().hmirror().to_left().hmirror().transpose() }
}
if old.shifts != new.shifts {
app.moves++
app.board = new
@ -394,78 +389,301 @@ fn (mut app App) move(move_fn BoardMoveFN) {
}
}
fn (app &App) label_format(kind LabelKind) gx.TextCfg {
match kind {
.points {
return {
color: app.theme.text_color
align: .left
size: app.ui.font_size / 2
}
} .moves {
return {
color: 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
}
}
}
}
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() || 1
w := int(sapp.width() / s)
h := int(sapp.height() / s)
m := f32(min(w, h))
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() {
ww := app.ui.window_width
wh := app.ui.window_height
labelx := app.ui.x_padding + app.ui.border_size
labely := app.ui.y_padding + app.ui.border_size / 2
app.draw_tiles()
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))
// TODO: Make transparency work in `gg`
if app.state == .over {
app.gg.draw_rect(0, 0, ww, wh, gx.rgba(15, 0, 0, 44))
app.gg.draw_text(ww / 2, wh / 2, 'Game Over', app.label_format(.game_over))
}
if app.state == .victory {
app.gg.draw_rect(0, 0, ww, wh, gx.rgba(0, 15, 0, 44))
app.gg.draw_text(ww / 2, wh / 2, 'Victory!', app.label_format(.victory))
}
}
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_swipe(start, end Pos) {
min_swipe_distance := min(app.ui.window_width, app.ui.window_height) / 10
dx := end.x - start.x
dy := end.y - start.y
adx := abs(dx)
ady := abs(dy)
dmax := max(adx, ady)
dmin := min(adx, ady)
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) }
}
}
fn (mut app App) on_key_down(key sapp.KeyCode) {
// these keys are independent from the game state:
match key {
.escape {
exit(0)
}
.n {
} .n {
app.new_game()
}
// .t {/* fast setup for a victory situation: */ app.board = new_board(['JJ@@', '@@@@', '@@@@', '@@@@'])}
.backspace {
} .backspace {
if app.undo.len > 0 {
app.state = .play
app.board = app.undo.pop()
app.moves--
return
}
}
else {}
} .enter {
app.tile_format = int(app.tile_format) + 1
if app.tile_format == .end_ {
app.tile_format = .normal
}
} .j {
app.game_over()
} .t {
app.set_theme(if app.theme_idx == themes.len - 1 { 0 } else { app.theme_idx + 1 })
} else {}
}
if app.state == .play {
match key {
.up, .w { app.move(fn (b Board) Board {
return b.transpose().to_left().transpose()
}) }
.left, .a { app.move(fn (b Board) Board {
return b.to_left()
}) }
.down, .s { app.move(fn (b Board) Board {
return b.transpose().hmirror().to_left().hmirror().transpose()
}) }
.right, .d { app.move(fn (b Board) Board {
return b.hmirror().to_left().hmirror()
}) }
.w, .up { app.move(.up) }
.a, .left { app.move(.left) }
.s, .down { app.move(.down) }
.d, .right { app.move(.right) }
else {}
}
}
}
//
fn on_event(e &sapp.Event, mut app App) {
if e.typ == .key_down {
app.on_key_down(e.key_code)
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), y: int(t.pos_y) }
}
} .touches_ended {
if e.num_touches > 0 {
t := e.touches[0]
end_pos := Pos{ x: int(t.pos_x), y: int(t.pos_y) }
app.handle_swipe(app.touch.start_pos, end_pos)
}
} else {}
}
}
fn frame(mut app App) {
app.update_tickers()
$if showfps? { app.perf.frame_sw.restart() }
app.gg.begin()
app.update_tickers()
app.draw()
app.gg.end()
$if showfps? { app.showfps() }
}
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())
app.perf.frame++
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{
gg: 0
state: .play
}
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 = 'assets/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'
}
$if showfps? {
app.perf = &Perf{}
}
app.gg = gg.new_context({
bg_color: gx.white
width: window_width
height: window_height
use_ortho: true
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: os.resource_abs_path('../assets/fonts/RobotoMono-Regular.ttf')
font_path: font_path
})
app.load_tiles()
app.victory_image = app.new_image('victory.png')
app.gg.run()
}
}

View File

@ -1,7 +1,7 @@
# V 2048
This is a simple [2048 game](https://play2048.co/), written in [the V programming language](https://vlang.io/).
![2048 Game Screenshot](https://url4e.com/gyazo/images/1ad829cf.png)
![screenshot](demo.png)
## Description:
Merge tiles by moving them.
@ -12,8 +12,10 @@ The goal of the game is to create a tile with a value of 2048.
Escape - exit the game
Backspace - undo last move
n - restart the game
t - toggle the UI theme
Enter - toggle the tile text format
UP,LEFT,DOWN,RIGHT or W,A,S,D - move the tiles
UP,LEFT,DOWN,RIGHT / W,A,S,D / touchscreen swipes - move the tiles
## Running instructions:
Compile & run the game with `./v run examples/2048`

Binary file not shown.

Before

Width:  |  Height:  |  Size: 8.3 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.1 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.2 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.6 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.9 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.2 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.8 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.9 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.5 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 9.6 KiB

BIN
examples/2048/demo.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 25 KiB