2048: Difference between revisions

Implement a 2D sliding block puzzle game where blocks with numbers are combined to add their values.

 

 

The name comes from the popular open-source implementation of this game mechanic, [https://gabrielecirulli.github.io/2048/ 2048].

 

 

 

 

 

 

 

 

 

 

 

 

 

<br><br>

 

=={{header|Ada}}==

{{works with|GNAT}}

with System.Random_Numbers;

procedure Play_2048 is

when others => Invalid),

when others => Invalid);

-- ----- Game data

function Random_Int is new System.Random_Numbers.Random_Discrete(Integer);

Score : Natural;

Generator : System.Random_Numbers.Generator;

-- ----- Displaying the board

procedure Display_Board is

Put_Line("Score =" & Score'Img);

end Display_Board;

-- ----- Game mechanics

procedure Add_Block is

end loop;

end Add_Block;

procedure Reset_Game is

begin

Add_Block;

end Reset_Game;

-- Moving and merging will always be performed leftward, hence the following transforms

function HFlip (What : in t_Row) return t_Row is

end return;

end Transpose;

-- For moving/merging, recursive expression functions will be used, but they

-- can't contain statements, hence the following sub-function used by Merge

return (1 => 0);

end Add_Blank;

function Move_Row (What : in t_List) return t_List is

(if What'Length = 1 then What

then Move_Row(What(What'First+1..What'Last)) & (1 => 0)

else (1 => What(What'First)) & Move_Row(What(What'First+1..What'Last)));

function Merge (What : in t_List) return t_List is

(if What'Length <= 1 or else What(What'First) = 0 then What

then (1 => 2*What(What'First)) & Merge(What(What'First+2..What'Last)) & Add_Blank(What(What'First))

else (1 => What(What'First)) & Merge(What(What'First+1..What'Last)));

function Move (What : in t_Board) return t_Board is

(Merge(Move_Row(What(1))),Merge(Move_Row(What(2))),Merge(Move_Row(What(3))),Merge(Move_Row(What(4))));

begin

System.Random_Numbers.Reset(Generator);

Display_Board;

Display_Board;

end if;

{{out}}

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

+----+----+----+----+

Score = 184</pre>

 

=={{header|AutoHotkey}}==

Gui, font, s%s%

Gui, add, text, y1

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

}

 

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

 

@echo off

setlocal enabledelayedexpansion

 

:begin_game

 

call :addtile

call :addtile

 

:main_loop

call :display

echo(

 

set "key="

for /f "delims=" %%? in ('xcopy /w "%~f0" "%~f0" 2^>nul') do if not defined key set "key=%%?"

set "key=%key:~-1%"

 

)

)

 

:addtile

goto :EOF

 

:display

cls

echo(

)

echo(

{{out}}

<pre>2048 Game in Batch

 

Keys: WASD (Slide Movement), N (New game), P (Exit)</pre>

 

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

 

srand(time(NULL));

do_newblock();

do_newblock();

return 0;

}

{{out}}

<pre>

 

 

 

#include <stdio.h>

return 0;

}

 

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