2048: Difference between revisions

:*   All tiles move as far as possible in that direction, some move more than others.

:*   Two adjacent tiles (in that direction only) with matching numbers combine into one bearing the sum of those numbers.

:*   The player loses if no valid moves are possible.

 

 

;Requirements:

 

<big><big> [2][2][2][2] </big></big>

<big><big> .........[8] </big></big>

 

 

<big><big> ...[2][2][2] </big></big>

 

 

* &nbsp; Check for a lose condition.

<br><br>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program 2048_64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|Ada}}==

{{works with|GNAT}}

with System.Random_Numbers;

procedure Play_2048 is

end loop Main_Loop;

end Play_2048;

{{out}}

<pre>+----+----+----+----+

 

=={{header|ALGOL 68}}==

main:(

INT side = 4;

lose: print(("you lose!", new line))

)

=={{header|Amazing Hopper}}==

<pre>

VERSION 1: "Hopper" flavour.

</pre>

#context-free select Position of aleatory tail

#context-free show Table

println

back

{{out}}

<pre>

VERSION 2: "Hopper-BASIC" flavour.

</pre>

 

// Definicion de "contextos"

Clear Mark.

Return

 

=={{header|Applesoft BASIC}}==

 

10 REM ************

 

 

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program 2048.s */

/***************************************************/

.include "../affichage.inc"

{{Output}}

<pre>

 

=={{header|AutoHotkey}}==

Gui, font, s%s%

Gui, add, text, y1

Grid[StrSplit(rnd, ",").1, StrSplit(rnd, ",").2] := 2

}

 

=={{header|Batch File}}==

:: Batch File Implementation v2.0.1

 

echo(Press any key to exit . . .

pause>nul

{{out}}

<pre>2048 Game in Batch

 

=={{header|BASIC}}==

El código es de MichD (https://github.com/michd/2048-qbasic)

 

Yo solo lo transcribo.

SCREEN 13

PALETTE 1, pColor(35, 33, 31)

PRINT "Score:" + STR$(gScore)

END SUB

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

Won% = FALSE : Lost% = FALSE

@% = 5

IF Board(z DIV SIZE,z MOD SIZE) = 0 THEN Board(z DIV SIZE,z MOD SIZE) = 2-(RND(10)=1)*2 : EXIT FOR

NEXT

{{out}}

<pre> _ _ _ _

--------------------

You lost :-(</pre>

 

=={{header|C}}==

===Version 1===

Supports limited colours through vt100 escape codes. Requires a posix machine for <tt>termios.h</tt> and <tt>unistd.h</tt> headers. Provides simplistic animations when moving and merging blocks.

#include <stdio.h>

#include <stdlib.h>

return 0;

}

{{out}}

<pre>

 

 

 

#include <stdio.h>

return 0;

}

 

=={{header|C sharp|C#}}==

{{trans|C++}}

 

namespace g2048_csharp

}

}

{{out}}

<pre>

 

=={{header|C++}}==

#include <time.h>

#include <iostream>

return system( "pause" );

}

{{out}}

<pre>

 

=={{header|Clojure}}==

(ns 2048

(:require [clojure.string :as str]))

:default (recur (handle-turn field)))))

 

 

{{out}}

=={{header|Common Lisp}}==

Depends on Windows msvcrt.dll for _getch. Depends on quicklisp. Use arrow keys to make moves and press "Q" to quit. Tested with SBCL.

 

(defpackage :2048-lisp

(format t "~% Score: ~D~%" score)

(print-board board 4)

{{out}}

<pre>* (2048-lisp::prompt)

=={{header|D}}==

{{trans|C++}}

import core.stdc.stdlib: exit;

 

struct G2048 {

addTile;

while (true) {

 

private:

uint val = 0;

bool blocked = false;

uint score = 0;

 

writeln("SCORE: ", score, "\n");

write("+------+------+------+------+\n| ");

if (board[x][y].val)

writef("%4d", board[x][y].val);

writeln;

}

}

 

void waitKey() /*@safe*/ {

moved = false;

 

switch (c) {

}

 

board[x][y].blocked = false;

}

}

 

if (!board[x][y].val) {

uint a, b;

}

 

if (!board[x][y].val)

return true;

 

if (testAdd(x + 1, y, board[x][y].val) ||

testAdd(x - 1, y, board[x][y].val) ||

}

 

if (x > 3 || y > 3)

return false;

}

 

if (board[x][y + d].val && board[x][y + d].val == board[x][y].val &&

!board[x][y].blocked && !board[x][y + d].blocked) {

}

 

if (board[x + d][y].val && board[x + d][y].val == board[x][y].val &&

!board[x][y].blocked && !board[x + d][y].blocked) {

}

 

final switch (d) with(moveDir) {

case up:

if (board[x][y].val)

moveVertically(x, y, -1);

break;

case down:

if (board[x][y].val)

moveVertically(x, y, 1);

break;

case left:

if (board[x][y].val)

moveHorizontally(x, y, -1);

break;

case right:

if (board[x][y].val)

moveHorizontally(x, y, 1);

G2048 g;

g.gameLoop;

The output is the same as the C++ version.

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| Velthuis.Console}}Thanks for Rudy Velthuis [https://github.com/rvelthuis/Consoles].

{{Trans|C++}}

program Game2048;

 

Writeln('Press Enter to exit');

Readln;

{{out}}

<pre>

=={{header|Elixir}}==

{{works with|Elixir|1.3}}

@size 4

@range 0..@size-1

end

 

 

{{out}}

{{works with|Elm 0.18.0}}

Try online [https://ellie-app.com/3ZMMpYsbfcMa1/3]

 

import Html exposing (Html, div, p, text, button, span, h2)

viewGrid model.tiles

]

 

=={{header|F Sharp|F#}}==

The following code can be executed as is using F# Interactive from system command line ("fsi.exe 2048.fsx") but not from Visual Studio F# Interactive window due to the way it access keyboard (the System.Console.ReadKey() function).

 

// the board is represented with a list of 16 integers

let empty = List.init 16 (fun _ -> 0)

 

play()

 

=={{header|Factor}}==

 

 

USE: accessors

FROM: arrays => <array> array ;

 

MAIN: start-2048

 

=={{header|Forth}}==

Just like my implementation of [[15 Puzzle Game#Forth|15 Puzzle Game]], this uses Vim's h/j/k/l for movement.

 

: 2D-ARRAY ( height width )

CREATE DUP ,

 

INIT

 

{{out}}

 

===Source===

WRITE (MSG,1) !Roll forth a top/bottom boundary. No corner characters (etc.), damnit.

1 FORMAT ("|",<NC>(<W>("-"),"|")) !Heavy reliance on runtime values in NC and W. But see FORMAT 22.

WRITE (MSG,22) ((" ",L1 = 1,W),"|",C = 1,NC) !Compare to FORMAT 2.

22 FORMAT ("|",666A1) !A constant FORMAT, a tricky WRITE.

This sort of thing is not necessarily accepted by all compilers, so instead the next stage was to convert to using complicated WRITE statements. If one regarded the various sizes (the values of NR, NC, W in the source) as truly fixed, literal constants could be used throughout. This would however mean that they would appear without explanation, and if one eventually attempted to recode with different values, mistakes would be likely. Thus below, FORMAT 3 has <code> (<NC>(A1,I<W>),A1)</code> and if the <> scheme were unavailable, you'd have to use <code>(4(A1,I6),A1)</code> instead, not too troublesome a change. Or, the text of the format sequence could be written to a CHARACTER variable, as demonstrated in [[Multiplication_tables#Traditional_approach]]. Yet another approach might be <code>(666(A1,I6))</code> which relies on the addendum <code>A1</code> happening to be the same as the start of the <code>(A1,I6)</code> pair, but there is still the appearance of the literal constant six instead of <W>, and if there were to be any change to be made, it would have to be remembered...

INTEGER NR,NC !Number of rows and columns.

INTEGER BOARD(NR,NC) !The board. Actual storage is transposed!

601 FORMAT ("None! Oh dear.") !Nothing more can be done.

END !That was fun.

 

===Output===

=={{header|FreeBASIC}}==

Based On MichD's original code (https://github.com/michd/2048-qbasic)

 

'--- Declaration of global variables ---

End Select

Loop

 

 

=={{header|Go}}==

 

 

import (

}

}

 

=={{header|Haskell}}==

import Data.List

import Data.Maybe

setCursorPosition 1 1

putStrLn $ intercalate "\n\n\n\ESC[C" $ concatMap showTile `map` pos

 

=={{header|J}}==

'''Solution'''

NB. =========================================================

NB. 2048 game engine

- start a new game:

grd=: g2048Con ''

'''Usage'''

 

Score is 0

0 0 4 4

0 0 0 2

 

=={{header|Java}}==

[[File:game_2048_java2.png|300px|thumb|right]]

{{works with|Java|8}}

import java.awt.event.*;

import java.util.Random;

return -1;

}

 

=={{header|JavaScript}}==

Uses the P5.js library.

/* Tile object: */

 

game.keyHandler(keyCode);

}

 

=={{header|Julia}}==

Uses the Gtk toolkit. Includes scoring, a choice of board size and toolbar buttons for Undo and New Game.

 

@enum Direction2048 Right Left Up Down

const boardsize = 4

app2048(boardsize)

 

=={{header|Kotlin}}==

Stateless with focus on clarity rather than conciseness.

 

import java.io.InputStreamReader

 

}

println("+----+----+----+----+")

 

Sample output:

Takes input on stdin using the words "left", "right", "up", "down".

 

use 'format import '[format].

use 'random.

$stdout putln: "Better luck next time!".

}.

 

Sample output:

=={{header|Lua}}==

Sadly, ANSI C doesn't have low-level keyboard input, so neither does vanilla Lua, so the input is a bit cumbersome (wasd PLUS enter).

local unpack = unpack or table.unpack -- for 5.3 +/- compatibility

game = {

end

}

{{out}}

<pre>+----+----+----+----+

 

=={{header|M2000 Interpreter}}==

Module Game2048 {

\\ 10% 4 and 90% 2

}

Game2048

 

Each move copied to clipboard

 

Next is the main body of code:

macro(SP=DocumentTools:-SetProperty, GP=DocumentTools:-GetProperty);

G := module()

end module;

G:-reset();SP("Score/Lose",caption,"Click an Arrow to begin.");

 

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

"LeftArrowKeyDown":>(stat=Coalesce[stat];AddNew[]),

"RightArrowKeyDown":>(stat=Reverse/@Coalesce[Reverse/@stat];AddNew[]),

 

stat=Nest[AddRandomNumber[#,RandomChoice[{2,4}]]&,ConstantArray[0,{n,n}],4];

 

 

=={{header|MATLAB}}==

 

 

if nargin < 1 || isempty(field)

vector(vector==0) = [];

 

 

You can start with an empty 4 x 4 board and save the last state of the playing field with:

 

Or you start from a saved playing field:

 

=={{header|Nim}}==

{{works with|Nim Compiler|0.19.4}}

 

 

const

for i in 1..BoardLength + 7:

eraseLine()

 

=={{header|OCaml}}==

 

let list_make x v =

let rec aux acc i =

loop grid

in

 

{{out}}

 

=={{header|Pascal}}==

program game2048;

uses Crt;

until end_game;

end.

 

=={{header|Perl}}==

 

use strict; # https://rosettacode.org/wiki/2048

add2(2) for 1, 2;

$winner = '';

 

=={{header|Phix}}==

Now I just got figure out how to win...

You can run this online [http://phix.x10.mx/p2js/2048.htm here].

<span style="color: #000080;font-style:italic;">-- demo\rosetta\2048.exw</span>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|PHP}}==

Works from PHP5 and upwards in CLI mode.

<?php

 

 

}

 

=={{header|PicoLisp}}==

 

(symbols 'simul 'pico)

(T (fish '((This) (= 512 (: N))) *G)

(println 'Maximum) ) )

 

=={{header|Pony}}==

{{works with|ponyc|0.10.0}}

use "term"

use "random"

 

input(consume notify)

 

=={{header|Prolog}}==

Works with swi-prolog, any version.

Entry point, just create a blank grid and enter a 'game loop'

-------------------------------------------------------------*/

dbl(' ', ' ').

dbl(2,4). dbl(4,8). dbl(8,16). dbl(16,32). dbl(32,64). dbl(64,128). dbl(128,256). dbl(256,512). dbl(512,1028). dbl(1028,2048).

{{out}}

<pre>?- play_2048.

=={{header|Python}}==

===Python: Original, with output===

 

import curses

 

curses.wrapper(main)

 

===Python: using tkinter===

 

''' Python 3.6.5 code using Tkinter graphical user interface.

root.bind_all('<Key>', g.key)

root.mainloop()

 

=={{header|QB64}}==

_DEFINE A-Z AS _INTEGER64

DIM SHARED Grid(0 TO 5, 0 TO 5) AS INTEGER

COLOR dc&, bg&

END SUB

 

=={{header|R}}==

orginal R package : https://github.com/ThinkRstat/r2048

GD <- function(vec) {

c(vec[vec != 0], vec[vec == 0])

}

 

 

=={{header|Racket}}==

Play the RacketScript fork online here: http://rapture.twistedplane.com:8080/#example/2048-game

 

;; LICENSE: See License file LICENSE (MIT license)

;;

 

(start)

 

=={{header|Raku}}==

Uses termios to set the terminal options, so only compatible with POSIX terminals. This version does not include a specific "win" or "lose" condition. (though it would be trivial to add them.) You can continue to play this even after getting a 2048 tile; and if there is no valid move you can make, you can't do anything but quit.

{{works with|Rakudo|2018.05}}

 

constant $saved = Term::termios.new(fd => 1).getattr;

move %dir{$key} if so %dir{$key};

last if $key eq 'q'; # (q)uit

Sample output:

<pre>

{{works with|Red|0.6.4}}

 

 

random/seed now

display

view lay

 

{{out}}

::* &nbsp; displays a message if a winning move was entered.

::* &nbsp; displays the game board as a grid &nbsp; (with boxes).

parse arg N win seed . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N= 4 /*Not specified? Then use the default.*/

do s=r to sTo by #; @.s.c= @(s + #, c) /*slide ↑ or ↓ */

end /*s*/; @.sTo.c= b /*handle the last one.*/

Programming note: &nbsp; with a little more program complexity, &nbsp; the &nbsp; '''moveLR''' &nbsp; and &nbsp; '''moveUD''' &nbsp; subroutines could've

<br>been combined, &nbsp; as well as the &nbsp; '''packLR''' &nbsp; and &nbsp; '''packUD''' &nbsp; subroutines.

 

=={{header|Ring}}==

# Project : 2048 Game

 

on '2048' setStylesheet(C_BUTTON2048STYLE)

off

 

=={{header|Ruby}}==

inspired by the Raku version

#!/usr/bin/ruby

 

end

end

 

=={{header|Rust}}==

A simple implementation in rust. The user has to input an endline since i did not find a way to read a key press

{{libheader|rand}}

use std::io::{self,BufRead};

extern crate rand;

}

}

 

=={{header|Scala}}==

import java.awt.{BorderLayout, Color, Dimension, Font, Graphics2D, Graphics, RenderingHints}

import java.util.Random

}

 

 

=={{header|Seed7}}==

STD_CONSOLE works also always the same, independent from the operating system or terminal/console.

 

include "console.s7i";

include "keybd.s7i";

until moveOkay;

until quit;

 

=={{header|Tcl}}==

===Text mode===

# A minimal implementation of the game 2048 in Tcl.

# For a maintained version with expanded functionality see

 

main

 

===Tk===

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Public Sub New()

Me.Value = 0

End Sub

End Module

{{out}}

<pre>

{{libheader|Wren-fmt}}

{{libheader|Wren-str}}

import "random" for Random

 

var MoveDirection = Enum.create("MoveDirection", ["up", "down", "left", "right"])

}

 

 

{{out}}

 

=={{header|XPL0}}==

int Box(16), Moved;

 

until Moved;

];