Program a 2048 AI using an existing Framework

Question

EDIT : Recently, my question has been proposed as a duplicate of 2048 Bot Challenge. I would like to stress that this question is different from that question, and will require answers to be thought of differently than that question. 2048 Bot Challenge asked the user to create a bot, and it would be run for an hour, with the highest score being the user's score. Additionally, it had a limit of 555 bytes. My challenge runs the code much less frequently, only 3 times. Your score is calculated by using the average score of those three times and dividing by the character length of your golfed code. My question encourages entries to be "smarter," and not try and get the highest score by brute force.

-

EDIT: The get method was changed to getTile, to avoid confliction with the JS keyword get. Additionally, a high score section was added.

Recently, I created a site that allows the popular game 2048 to be controlled using JavaScript. My site is linked here:

http://thatcoolidea.com/2048

How:

An Ace Editor is located above the board. You place code in it, which is run once every 250 ms, or 4 times per second. This is called a cycle.

Use the following methods to control the board. You can't use the arrow keys.

up();            //move up
down();          //move down
left();          //move left
right();         //move right

move(integer);   //integer is a direction. 0:up,1:right,2:down,3:left

getTile(y,x);        //gets the value of the tile in position y,x on the board. See diagram

The following variables are defined for your convenience:

eother        //boolean, alternates every cycle
frozen        //integer, counts how many cycles the board has remained stationary
lastDir       //integer, indicates the last direction that was tried to move in
              //uses same format as the move method above.
startup       //boolean, will always be true when the game first starts
              //you can change it as you wish
a
b             //a b and c are all persistant variables, they do not change each cycle
c             //any other variables defined in the cycle will be reset every time

Rules:

• No Randomness, you must use logic. (Yes, I know the example code uses random.)
• No hooking into the game functions or cheating in other ways
• Generally, try to only call one move method per cycle. It is OK if you use more, but it screws with the animation
• The board must start in a random state, no modification of pre-game state
• You must provide both the uncompressed and golfed version of the code in your post.
• You must provide a link to the site that already loads the uncompressed version of your code, served via PasteBin (For example, ...thatcoolidea.com/2048?i=pH18GWtu loads the example code.)

Scoring:

• Your code will be scored by me.
• Part A of your score is an average of 3 runs of the code, rounded down.
• Part B of your score is the character length of your golfed code.
• Your final score is Part A divided by Part B

The winner will have their code immortalized as the example code on the site, if they choose, and acknowledged in a comment in the code.

Good luck! Hope you enjoy the challenge.

Current High Score 225.22 - Freezer - user3217109

Answer 1

Sinker/Shaker, 65 bytes

Here's mine. It's as blind and simple as they come.

if(startup){startup=false;a=0}b=(a++)%4;move(frozen>2?0:b==0?2:b)

Uncompressed(ish)...

if(startup){startup=false;a=0;}
b=(a++)%4;
move(frozen>2?0:b==0?2:b)

All it does is repeats down, right, down, left, etc. and hits up once if it gets stuck. It doesn't always do very well, but it'll occasionally get 512s. My high score during testing was 7520.

Answer 2

Traffic light - 23 21 bytes

move(frozen&2|eother)

This is the link.

This will move alternatingly up and right, except when the board has remained stationary for the last two moves, in which case it will move down and left respectively.

My original, functionally equivalent submission was 23 bytes long and scored 182.72:

move((frozen&2)+eother)

Answer 3

Whirlpool - 37 21 17 bytes - Score: 211.22

I decided to go with a "less is more" approach. My code is a simple design that tries to go up, right, down, left... I will be working on a learning AI to see a more optimal way to approach the puzzle.

a=a|0;move(a++%4)

Optimizer helped to shorten a's initialization.

Sam helped to shorten a's initialization, removed var.

Ungolfed?

var a=a|0;
a++;
move(a%4);

My top score with this AI is 5120.

Freezer - 12 bytes - Score: 225.22

This bot has move priority. It attempts to go up. If it can' go up, it goes right. If it can't go right, it does down. If it can't go down it goes left.

move(frozen)

James Bond Explanation

The encrypted code decrypts to say:

HTMLActuator.prototype.updateScore=function (score) {score*=9989800000;
  this.clearContainer(this.scoreContainer);

  var difference = score - this.score;
  this.score = score;

  this.scoreContainer.textContent = this.score;

  if (difference > 0) {
    var addition = document.createElement("div");
    addition.classList.add("score-addition");
    addition.textContent = "+" + difference;

    this.scoreContainer.appendChild(addition);
  }
}

Optimizer should have golfed his decrypted code. This could have been #Optimized.

Answer 4

Hanger - 20 bytes

Official score: 224.87 - 2nd place by 0.35 points

This bot uses the down, left, down, right approach, but with the unusual feature that it will never move up. I'm not sure how to score cases where it hangs and does not complete, or whether the fact that that occurs renders it illegal. Here it is, though:

b=b|0;move(b++%4||2)
OR
move(startup++%4||2)

Initialization pattern thanks to @Optimizer.

In my 3 test runs, it scored 4284, 6352 and 4232, for an average of 4956. I will update when the official test is run.

---

Alternate version which gets out of hangs (27 bytes):

b=b|0;move(b++%4||b%997&&2)