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 */

=={{header|Ada}}==

{{works with|GNAT}}

with System.Random_Numbers;

procedure Play_2048 is

 

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

main:(

INT side = 4;

VERSION 1: "Hopper" flavour.

</pre>

#context-free select Position of aleatory tail

#context-free show Table

VERSION 2: "Hopper-BASIC" flavour.

</pre>

 

// Definicion de "contextos"

Return

</syntaxhighlight>

 

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

 

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

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program 2048.s */

 

=={{header|AutoHotkey}}==

Gui, font, s%s%

Gui, add, text, y1

 

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

:: Batch File Implementation v2.0.1

 

 

=={{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)

END SUB

</syntaxhighlight>

 

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

{{works with|BBC BASIC for Windows}}

Won% = FALSE : Lost% = FALSE

@% = 5

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

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>

 

 

 

#include <stdio.h>

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

{{trans|C++}}

 

namespace g2048_csharp

 

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

#include <time.h>

#include <iostream>

 

=={{header|Clojure}}==

(ns 2048

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

=={{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

=={{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);

}</syntaxhighlight>

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;

 

=={{header|Elixir}}==

{{works with|Elixir|1.3}}

@size 4

@range 0..@size-1

{{works with|Elm 0.18.0}}

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

 

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

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)

 

 

USE: accessors

FROM: arrays => <array> array ;

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 ,

 

===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.

4 FORMAT ("|",<NC - 1>(<W>("-"),"+"),<W>("-"),"|") !With internal + rather than |.</syntaxhighlight>

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!

=={{header|FreeBASIC}}==

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

 

'--- Declaration of global variables ---

Loop</syntaxhighlight>

 

 

=={{header|Go}}==

 

 

import (

 

=={{header|Haskell}}==

import Data.List

import Data.Maybe

=={{header|J}}==

'''Solution'''

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

NB. 2048 game engine

)</syntaxhighlight>

'''Usage'''

 

Score is 0

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

{{works with|Java|8}}

import java.awt.event.*;

import java.util.Random;

=={{header|JavaScript}}==

Uses the P5.js library.

/* Tile object: */

 

=={{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)

</syntaxhighlight>

 

Stateless with focus on clarity rather than conciseness.

 

import java.io.InputStreamReader

 

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

 

use 'format import '[format].

use 'random.

=={{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 = {

 

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

Module Game2048 {

\\ 10% 4 and 90% 2

 

Next is the main body of code:

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

G := module()

 

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

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

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

=={{header|MATLAB}}==

 

 

if nargin < 1 || isempty(field)

 

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

=={{header|OCaml}}==

 

let list_make x v =

let rec aux acc i =

 

=={{header|Pascal}}==

program game2048;

uses Crt;

 

=={{header|Perl}}==

 

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

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>

=={{header|PHP}}==

Works from PHP5 and upwards in CLI mode.

<?php

 

 

=={{header|PicoLisp}}==

 

(symbols 'simul 'pico)

=={{header|Pony}}==

{{works with|ponyc|0.10.0}}

use "term"

use "random"

=={{header|Prolog}}==

Works with swi-prolog, any version.

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

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

=={{header|Python}}==

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

 

import curses

 

===Python: using tkinter===

 

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

 

=={{header|QB64}}==

_DEFINE A-Z AS _INTEGER64

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

=={{header|R}}==

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

GD <- function(vec) {

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

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

 

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

;;

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;

{{works with|Red|0.6.4}}

 

 

random/seed now

::* &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.*/

 

=={{header|Ring}}==

# Project : 2048 Game

 

=={{header|Ruby}}==

inspired by the Raku version

#!/usr/bin/ruby

 

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

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

 

include "console.s7i";

include "keybd.s7i";

=={{header|Tcl}}==

===Text mode===

# A minimal implementation of the game 2048 in Tcl.

# For a maintained version with expanded functionality see

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

{{trans|C#}}

Public Sub New()

Me.Value = 0

{{libheader|Wren-fmt}}

{{libheader|Wren-str}}

import "random" for Random

 

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

 

=={{header|XPL0}}==

int Box(16), Moved;