Entwickler-Ecke

Off Topic - 2048


Nersgatt - Do 27.03.14 18:02
Titel: 2048
Moin,

die einfachsten Spielideen sind ja doch immer wieder die besten: :zustimm:
http://gabrielecirulli.github.io/2048/

Gesteuert wird mit den Pfeiltasten.
Bei Tastendruck bewegen sich alle Kästchen in die entsprechende Richtung. Wenn man dabei 2 Kästchen mit der gleichen Zahl "aufeinander" schiebt, so vereinen sich diese Kästchen zu einem einzelnen Kästchen und der Wert des neu entstandenen Kästchens verdoppelt sich.
Ziel ist es, das Kästchen mit der 2048 erscheinen zu lassen.

Ich bin bisher bis zur 512 gekommen. :angel:
Suchtpotential ist vorhanden!

Vielleicht möchte ja mal jemand einen hübschen Delphi-Clon machen.

Jens


Ralf Jansen - Do 27.03.14 18:15

Geil :zustimm:


FinnO - Do 27.03.14 20:08

user profile iconRalf Jansen hat folgendes geschrieben Zum zitierten Posting springen:
Geil

Ich würde soweit gehen und sagen:

Sehr sehr geil.


Martok - Do 27.03.14 20:35

user profile iconFinnO hat folgendes geschrieben Zum zitierten Posting springen:
Sehr sehr geil.
Supergeil.

Und wo wir hier grade unter Devs sind. Bin ich der einzige, bei dem das im Palemoon nicht läuft wegen einer Security Violation?


Xion - Do 27.03.14 22:01

Geschafft :dance2:

Man braucht allerdings schon etwas Glück, mein Feld war mehrmals randvoll


Nersgatt - Fr 28.03.14 08:34

Hat jemand verstanden, nach welchen Regeln das Auftauchen neuer Felder abläuft? Besteht hier ein Zusammenhang zwischen dem Vereinen von Feldern und dem Auftauchen neuer Felder (an welcher Spielfeldposition und welcher Feldwert)? Oder ist das rein Zufallsgesteuert?


Ralf Jansen - Fr 28.03.14 10:54

Aus dem Javascript kann man entnehmen das die Positionierung reiner Zufall ist. Mit 90% Wahrscheinlichkeit ist es dann eine 2 sonst eine 4.


JavaScript-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
// Adds a tile in a random position
GameManager.prototype.addRandomTile = function () {
    if (this.grid.cellsAvailable()) {
        var value = Math.random() < 0.9 ? 2 : 4;
        var tile = new Tile(this.grid.randomAvailableCell(), value);
        this.grid.insertTile(tile);
    }
}; 

// Find the first available random position
Grid.prototype.randomAvailableCell = function () {
    var cells = this.availableCells();
    if (cells.length) {
        return cells[Math.floor(Math.random() * cells.length)];
    }
};
Grid.prototype.availableCells = function () {
    var cells = [];
    this.eachCell(function (x, y, tile) {
       if (!tile) {
           cells.push({ x: x, y: y });
       }
    });
    return cells;
};


Sinspin - Fr 28.03.14 12:08

Sehr schönes Spielchen. Nachdem ich jetzt mehr als einen halben Tag "geopfert" habe und bisher immer nur mal die 512 zu Gesicht bekommen habe muss ich doch erstmal aufgeben. Da die neuen Zahlen zufällig kommen kann ich zumindest dem Zufall die Schuld geben es noch nicht geschafft zu haben. :motz:


Delphi-Laie - Fr 28.03.14 14:57

Nette Spielidee.

Falls es jemand in Delphi & Co. umzusetzen gedenkt: Ich rege an, statt der Zahlen irgendetwas anderes zu nehmen, z.B. Buchstaben im Alphabete aufsteigend. Man muß es dann eben bis zu einem bestimmten Buchstaben schaffen. Grund: Es gibt Leute, die sich allein von Zahlen abgeschreckt fühlen (Aversion gegen Mathematik).

Viel Sympathie wird in dieser Hinsicht beim Sudoku verschenkt, denn das kann man auch mit beliebigen Symbolen "spielen". Wenn ich dann noch die Werbung "Für Freunde der Zahlenlogik" lese, bekomme ich ob dieser Dummheit einen dicken Hals. Mit Mathematik - sofern das Wort "Zahlenlogik" diese suggerieren soll - hat Sudoku nämlich ziemlich wenig zu tun, es zu lösen ist eigentlich nur das Abarbeiten eines Algorithmus'.

Zudem muß bei 2048 nicht Schluß sein (oder ist das Spiel dann zwangsläufig beendet?), sondern "nach oben hin offen". Auch unterschiedliche Spielfeldgrößen wären denkbar.


Sinspin - Fr 28.03.14 20:18

Ich verweise da mal ganz dezent auf unseren Herren Mathematiker [http://www.entwickler-ecke.de/viewtopic.php?t=112877] seine Umsetzung ;-)


Palladin007 - Fr 28.03.14 22:39

Mein Rekord: 5308

Eine 2048 habe ich nicht geschafft, meine höchste Zahl war die 512 :/


Aber echt sehr geiles Spiel, tolle Idee.

Ich werd mal versuchen, das in C# umzusetzen. ^^


papa69 - Do 01.05.14 17:50

heut ist mein "Frei"tag

auch wenn's schon etwas her ist, endlich hab auch ich es geschafft (s.Anhang)


C# - Fr 02.05.14 15:31

5416
512 beim ersten Versuch. Mann wird das schwer :D

P.S. kennt jemand das Spiel Flappy48?


Dhakiyah - Di 03.06.14 10:48

Es gibt einen Trick bei diesem Spiel, wenn man den kennt, kommt man recht schnell zur 2048.
Man spielt immer in eine Ecke, z.B. rechts oben. Dann schiebt man nur rechts, links und hoch, nie runter (außer es geht nicht anders).
War schon mehrfach bei 2048, dazu nochmal eine 512, weiter kam ich noch nicht.
Rekord irgedwas bei 30000...


Hidden - Di 03.06.14 20:09

Moin,


Überarbeitete Spielidee:
1:
2:
3:
4:
5:
6:
1024    x    x    x    Dieses Spielfeld kann relativ konsistent erreicht werden. 
 512   64   32    x    Anschließend muss auf den markierten Feldern eine 16 zusammengesetzt werden,
 256  128   16    x    wonach die Zahlen zu 2048 zusammengeschoben werden können.
   8    x    x    x
                       (In der Reihenfolge C3 - C2 - B2 - B3 - A3 - A2 - A1.)
   A    B    C    D

Gefahren:

Die A-Reihe sollte stets voll besetzt sein, sodass der Zug [down] ausgeführt werden kann ohne zu riskieren, dass auf A1 eine neue Zahl entsteht und das Feld für immer blockiert.

Solange [A] nicht voll besetzt ist, können wie von user profile iconDhakiyah beschrieben nur [left] und [up] gefahrlos ausgeführt werden, was aber nur eingeschränkt oft möglich ist. Ist die 4-Reihe leer und entsteht dort nicht rechtzeitig eine neue Zahl, so muss irgendwann [down] ausgeführt werden. (Das riskiert, dass auf A1 eine Zahl entsteht, was sehr wahrscheinlich bedeutet dass das Spiel verloren ist.)

Sollte irgendwann einmal [right] nötig sein, wird in [A] sofort eine neue Zahl entstehen. Nach [left] verdrängt diese eine der ursprünglich in [A] befindlichen Zahlen. Es kann mehrmals [down] verwendet werden, um zu verändern welche Zahlen verdrängt werden.
Eine große Zahl wie 256 zu verdrängen, bedeutet oft dass das Spiel verloren ist. (Diese verdeckt so lange eines der Register in [A], bis sie unter erschwerten Bedingungen zurück nach [A] addiert werden kann.)


Steine Einrücken (1):
1:
2:
3:
4:
5:
6:
1024    x    x    x    Um die 128 auf A3 mit der auf B2 addieren zu können,
 512  128    x    x    muss zuerst B3 auf B4 addiert werden.
 128   32    x    x
  64    4    x    x    Dazu kann man die B4 von rechts "füttern",
                       bis es gleich B3 ist.
   A    B    C    D    Anschließend folgt ein [down], um B2 auf B3 zu verrücken.
Bem: Das ist nur zwischen den Reihen [2] und [3] möglich, weshalb wir dort die großen Zahlen bauen. Es gibt keine Möglichkeit, einen Stein aus [2] nach [1] zu verschieben, was es erschwert, in [1] oder [4] von rechts zu füttern.


Steine Einrücken (2):
1:
2:
3:
4:
5:
6:
1024   32    4         Man verwende so lange [up] und [down],
 512    8   32         bis in C3 oder C4 (nach [up]) oder B1 oder B2 (nach [down]) eine Zahl entsteht.
 128               
  64               

   A    B    C    D


---

Mich würde mal interessieren, welche Erfolgs-Quote da Programme erreichen. Das Programm von user profile iconMathematiker lässt sich doch sicher gut in einen Bot verwandeln, der dann z.B. user profile iconDhakiyahs Strategie verwendet und den Tasten [up], [->], [down], [<-] eine Rangordnung verpasst. Ein paar 1000 Durchläufe und wir wissen, wie "schaffbar" das Spiel überhaupt ist, und wie viel Glück man braucht.

viele Grüße,
Daniel

Edit: :wall: Ein Blick in den Thread von user profile iconMathematiker zeigt, dass da schon viel passiert ist. (Fehlt eigentlich nur noch eine Berechnung der Quote):
user profile iconMathematiker hat folgendes geschrieben Zum zitierten Posting springen:
Edit 7: eine noch sehr einfache Routine (Selbsttest) versucht eine Lösung zu ermitteln.
Edit 8: neue Version des Selbsttests (löst auch 5x5 "fast" immer).
Edit 9: Selbsttest mit 4 Züge Vorausberechnung (löst auch 4x4, aber ganz selten :cry: )
Edit 10: Algorithmus verbessert, so dass 4x4 häufiger, jedoch noch nicht immer, gelöst wird.
Edit 11: 5 Züge Vorausberechnung und die Lösung von 4x4 wird langsam häufiger.