304 lines
8.6 KiB
Java
304 lines
8.6 KiB
Java
package twentyfortyeight;
|
|
|
|
import java.awt.Color;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Random;
|
|
import javalib.impworld.*;
|
|
import javalib.worldimages.*;
|
|
import tester.Tester;
|
|
|
|
class ImgUtil {
|
|
static Color color(int n) {
|
|
int r = (int)Math.min(255, 20 * (int)(Math.log(n) / Math.log(2)));
|
|
|
|
return new Color(r, r / 2 + 80, r / 3 + 20);
|
|
}
|
|
|
|
// Create a tile image for a number.
|
|
static WorldImage mktile(int n) {
|
|
return new OverlayImage(
|
|
new TextImage(
|
|
String.valueOf(n), Game.SCALE / 2, FontStyle.BOLD, Color.BLACK
|
|
),
|
|
new RectangleImage(
|
|
Game.SCALE, Game.SCALE, OutlineMode.SOLID, ImgUtil.color(n)
|
|
)
|
|
);
|
|
}
|
|
|
|
// Create a fee space image.
|
|
static WorldImage mkfree() {
|
|
return new RectangleImage(
|
|
Game.SCALE, Game.SCALE, OutlineMode.OUTLINE, Color.GRAY
|
|
);
|
|
}
|
|
}
|
|
|
|
// A game of 2048.
|
|
class Game extends World {
|
|
static int SCALE = 100;
|
|
|
|
int score;
|
|
Grid grid;
|
|
Random rand;
|
|
WorldScene scene;
|
|
int w, h; // The pixel widths and heights.
|
|
|
|
// Convenience constructor for init with default settings.
|
|
Game() {
|
|
this.grid = new Grid(4, 4);
|
|
this.score = 0;
|
|
this.rand = new Random();
|
|
this.w = this.grid.w * SCALE;
|
|
this.h = this.grid.h * SCALE;
|
|
this.scene = new WorldScene(this.w, this.h);
|
|
}
|
|
|
|
// Convenience constructor for init with custom settings.
|
|
Game(int w, int h) {
|
|
this.grid = new Grid(w, h);
|
|
this.score = 0;
|
|
this.rand = new Random();
|
|
this.w = this.grid.w * SCALE;
|
|
this.h = this.grid.h * SCALE;
|
|
this.scene = new WorldScene(this.grid.w, this.grid.h);
|
|
}
|
|
|
|
void launchGame() {
|
|
this.bigBang(this.w, this.h, 0.01);
|
|
this.grid.set(0, 0, 2).set(0, 2, 2);
|
|
}
|
|
|
|
public WorldScene makeScene() {
|
|
this.scene = this.getEmptyScene();
|
|
this.draw();
|
|
return this.scene;
|
|
}
|
|
|
|
public void onKeyEvent(String key) {
|
|
if (key.equals("left") || key.equals("h")) this.grid.mv(0);
|
|
else if (key.equals("down") || key.equals("j")) this.grid.mv(1);
|
|
else if (key.equals("up") || key.equals("k")) this.grid.mv(2);
|
|
else if (key.equals("right") || key.equals("l")) this.grid.mv(3);
|
|
else return; // Don't draw or add tiles if bad key pressed.
|
|
|
|
this.draw();
|
|
|
|
List<Integer> frees = this.grid.freeCellIdxs();
|
|
// Add tiles
|
|
this.grid.buf.set(frees.get(this.rand.nextInt(frees.size())), 2);
|
|
|
|
this.draw();
|
|
}
|
|
|
|
// Draw current game state.
|
|
void draw() { this.scene = this.grid.render(); }
|
|
}
|
|
|
|
// The grid in which the game is played.
|
|
class Grid {
|
|
int w; // The width of the grid.
|
|
int h; // The height of the grid.
|
|
ArrayList<Integer> buf; // The buffer containing the tiles.
|
|
int sz; // The size of the buffer -- always w * h.
|
|
|
|
Grid(int w, int h) {
|
|
if (w < 1 || h < 1)
|
|
throw new IllegalArgumentException("Can't make grid that small.");
|
|
|
|
this.w = w;
|
|
this.h = h;
|
|
this.sz = this.w * this.h;
|
|
this.buf = new ArrayList<>(this.sz);
|
|
|
|
// Fill with zeros.
|
|
for (int i = 0; i < this.sz; this.buf.add(i++ * 0));
|
|
}
|
|
|
|
// Get the indexes of all "free" cells -- those whose value in buf is 0,
|
|
// and are represented as blank tile.
|
|
List<Integer> freeCellIdxs() {
|
|
List<Integer> free = new ArrayList<>();
|
|
for (int i = 0; i < this.sz; i++)
|
|
if (this.buf.get(i) == 0 && free.add(i)) continue;
|
|
|
|
return free;
|
|
}
|
|
|
|
// Get the indexes of all "unfree" cells -- those whose value in buf is not
|
|
// 0, and represent a used tile.
|
|
/*
|
|
List<Integer> unfreeCellIdxs() {
|
|
List<Integer> unfree = new ArrayList<>();
|
|
for (int i = 0; i < this.sz; i++)
|
|
if (this.buf.get(i) != 0 && unfree.add(i)) continue;
|
|
|
|
return unfree;
|
|
}
|
|
*/
|
|
|
|
// Set the tile at the coords.
|
|
Grid set(int x, int y, int v) {
|
|
this.buf.set(this.where(x, y), v);
|
|
return this;
|
|
}
|
|
|
|
// Get the index for the coord.
|
|
int where(int x, int y) { return this.w * y + x; }
|
|
|
|
// Get the value at the coords.
|
|
int get(int x, int y) { return this.buf.get(this.w * y + x); }
|
|
|
|
// Get the x coord for an index.
|
|
int ix(int i) { return i % this.h; }
|
|
|
|
// Get the y coord for an index.
|
|
int iy(int i) { return i % this.w; }
|
|
|
|
void mv(int d) {
|
|
// For each row / col.
|
|
for (int i = 0; i < (d % 3 == 0 ? this.h : this.w); i++) {
|
|
while (this.lnMv(i, d));
|
|
this.squish(i, d);
|
|
while (this.lnMv(i, d));
|
|
}
|
|
}
|
|
|
|
// Get the ith row.
|
|
List<Integer> getRow(int i) {
|
|
return this.buf.subList(
|
|
this.where(0, i), this.where(this.w - 1, i) + 1
|
|
);
|
|
}
|
|
|
|
// Get the ith col. A bit more complex.
|
|
List<Integer> getCol(int i) {
|
|
if (i < 0 || i >= this.w) throw new IndexOutOfBoundsException("No.");
|
|
|
|
return new ArrayList<Integer>() {
|
|
public Integer get(int j) {
|
|
if (j < 0 || j >= h) throw new IndexOutOfBoundsException("No.");
|
|
return buf.get(w * j + i);
|
|
}
|
|
|
|
public Integer set(int j, Integer val) {
|
|
if (j < 0 || j >= h) throw new IndexOutOfBoundsException("No.");
|
|
int prv = buf.get(w * j + i);
|
|
buf.set(w * j + i, val);
|
|
return prv;
|
|
}
|
|
|
|
public int size() { return h; }
|
|
};
|
|
}
|
|
|
|
// Get the line.
|
|
List<Integer> getLn(int i, int d) {
|
|
return d == 0 ? this.getRow(i)
|
|
: d == 1 ? this.getCol(i).reversed()
|
|
: d == 2 ? this.getCol(i)
|
|
: this.getRow(i).reversed();
|
|
}
|
|
|
|
// Move the specified line in the specified direction once. If there is a
|
|
// combination, return false. If there are no more moves possible, return
|
|
// false.
|
|
boolean lnMv(int i, int d) {
|
|
List<Integer> ln = getLn(i, d);
|
|
|
|
int c = 0; // Moves made in line.
|
|
for (int j = 1; j < ln.size(); j++) {
|
|
if (ln.get(j - 1) == 0 && ln.get(j) != 0) {
|
|
ln.set(j - 1, ln.get(j));
|
|
ln.set(j, 0);
|
|
} else c++;
|
|
}
|
|
|
|
// If nothing has been done, give up.
|
|
if (c == ln.size() - 1) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// Squish like tiles together.
|
|
void squish(int i, int d) {
|
|
List<Integer> ln = getLn(i, d);
|
|
for (int j = 0; j < ln.size() - 1; j++) {
|
|
if (ln.get(j) != 0 && ln.get(j) == ln.get(j + 1)) {
|
|
ln.set(j, 2 * ln.get(j));
|
|
ln.set(j + 1, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Render the grid.
|
|
WorldScene render() {
|
|
WorldScene bg =
|
|
new WorldScene(Game.SCALE * this.w, Game.SCALE * this.h);
|
|
for (int i = 0; i < this.w; i++)
|
|
for (int j = 0; j < this.h; j++) {
|
|
int n = this.get(i, j);
|
|
int coordx = i * Game.SCALE + Game.SCALE / 2;
|
|
int coordy = j * Game.SCALE + Game.SCALE / 2;
|
|
if (n == 0) bg.placeImageXY(ImgUtil.mkfree(), coordx, coordy);
|
|
else bg.placeImageXY(ImgUtil.mktile(n), coordx, coordy);
|
|
}
|
|
|
|
return bg;
|
|
}
|
|
}
|
|
|
|
class Examples {
|
|
Grid verySmall, small, oblong, regular;
|
|
|
|
Game game;
|
|
|
|
void init() {
|
|
verySmall = new Grid(1, 1);
|
|
small = new Grid(2, 2);
|
|
oblong = new Grid(1, 3);
|
|
regular = new Grid(4, 4);
|
|
}
|
|
|
|
void testGridFreeCellIdxs(Tester t) {
|
|
init();
|
|
t.checkExpect(
|
|
small.freeCellIdxs(), new ArrayList<Integer>(List.of(0, 1, 2, 3))
|
|
);
|
|
t.checkExpect(
|
|
verySmall.freeCellIdxs(), new ArrayList<Integer>(List.of(0))
|
|
);
|
|
t.checkExpect(
|
|
oblong.freeCellIdxs(), new ArrayList<Integer>(List.of(0, 1, 2))
|
|
);
|
|
}
|
|
|
|
void testGridSet(Tester t) {
|
|
init();
|
|
small.set(0, 0, 1);
|
|
t.checkExpect(small.freeCellIdxs(), new ArrayList<>(List.of(1, 2, 3)));
|
|
small.set(1, 1, 1);
|
|
t.checkExpect(small.freeCellIdxs(), new ArrayList<>(List.of(1, 2)));
|
|
}
|
|
|
|
void testRegular(Tester t) {
|
|
init();
|
|
regular.set(1, 0, 16)
|
|
.set(2, 0, 16)
|
|
.set(3, 0, 32)
|
|
.set(0, 1, 4)
|
|
.set(1, 1, 4)
|
|
.set(4, 1, 2);
|
|
|
|
t.checkExpect(regular.get(1, 0), 16);
|
|
t.checkExpect(regular.get(0, 0), 0);
|
|
t.checkExpect(regular.get(3, 3), 0);
|
|
}
|
|
|
|
void testGame(Tester t) {
|
|
game = new Game(2, 2);
|
|
game.launchGame();
|
|
}
|
|
}
|