gistfile1.js

var CENTER = [16384, 16384];
var CENTERX = CENTER[0];
var CENTERY = CENTER[1];
var mult = 84;
var DELTA = [[ 2 * mult,  0 * mult],
             [ 1 * mult, -2 * mult],
             [-1 * mult, -2 * mult],
             [-2 * mult,  0 * mult],
             [-1 * mult,  2 * mult],
             [ 1 * mult,  2 * mult]];
var EAST = 0;
var SOUTHEAST = 1;
var SOUTHWEST = 2;
var WEST = 3;
var NORTHWEST = 4;
var NORTHEAST = 5;

function dist(x1, y1, x2, y2) {
  x1 = parseInt(x1);
  y1 = parseInt(y1);
  x2 = parseInt(x2);
  y2 = parseInt(y2);
  
  var distance = 0;
  
  var _x1 = (y1 & 1) ? x1 + 0.5 : x1;
  var _y1 = y1;
  var _x2 = (y2 & 1) ? x2 + 0.5 : x2;
  var _y2 = y2;
  
  var xdif = Math.abs(_x1 - _x2);
  var ydif = Math.abs(_y1 - _y2);
  
  if (ydif * 0.5 >= xdif) {
    distance = ydif;
  } else {
    distance = ydif * 0.5 + xdif;
  }

  return distance;
}

function abs(x, y){
  return dist(CENTERX,CENTERY,x,y);
}

function getRingFromInt(centers){
  var ring = 0;
  while(centers > getHexNumber(ring)){
    ring++;
  }
  ring++;
  return ring;
}

function getRing(centers){
  var len = centers.length;
  var ring = 0;
  while(len > getHexNumber(ring)){
    ring++;
  }
  ring++;
  return ring;
}

function getHexNumber(n){
  return (3*n*n + 3*n + 1);
}

function getNextCenter(centers, direction){
  /* directions:
   * 0: right
   * 1: down right
   * 2: down left
   * 3: left
   * 4: up left
   * 5: up right
  var mult = 84;
  var delta = [[ 2 * mult,  0 * mult],
               [ 1 * mult, -2 * mult],
               [-1 * mult, -2 * mult],
               [-2 * mult,  0 * mult],
               [-1 * mult,  2 * mult],
               [ 1 * mult,  2 * mult]];
   */

  var len = centers.length;
  
  if(len == 0){
    var centers = [[CENTERX,CENTERY]];
    centers[[CENTERX,CENTERY]] = true;
    console.log((centers.length - 1) + ' adding: (' + CENTERX + ', ' + CENTERY + ')');
    return [centers, null]
  }
  
  var currX = centers[len - 1][0];
  var currY = centers[len - 1][1];
  
  var newDir;
  if(len == 1){
    newDir = 5;
    newX = currX + DELTA[newDir][0];
    newY = currY + DELTA[newDir][1];
    centers.push([newX, newY]);
    centers[[newX, newY]] = true;
    console.log((centers.length - 1) + ' last: (' + currX + ', ' + currY + '), adding: (' + newX + ', ' + newY + ')');
    return [centers, 5];
  }
  
  switch(direction){
  case 0:
    //try down right
    newDir = 1;
    break;
  case 1:
    //try down left
    newDir = 2;
    break;
  case 2:
    //try up left
    newDir = 4;
    break;
  case 3:
    //try up left
    newDir = 4;
    break;
  case 4:
    //try up right
    newDir = 5;
    break;
  case 5:
    //try up left
    newDir = 1;
    break;
  }
  var testX = currX + DELTA[newDir][0];
  var testY = currY + DELTA[newDir][1];
  if(centers[[testX, testY]]){
    switch(direction){
    case 0:
      // go right
      newDir = 0;
      break;
    case 1:
      // go down right
      newDir = 1;
      break;
    case 2:
      // go left
      newDir = 3;
      break;
    case 3:
      // go left
      newDir = 3;
      break;
    case 4:
      // go up left
      newDir = 4;
      break;
    case 5:
      // try right
      newDir = 0;
      testX = currX + DELTA[newDir][0];
      testY = currY + DELTA[newDir][1];
      if(centers[[testX, testY]]){
        // go up right
        newDir = 5
      }
      break;
    }
  }
  var newX = currX + DELTA[newDir][0];
  var newY = currY + DELTA[newDir][1];
  centers.push([newX, newY]);
  console.log((centers.length - 1) + ' last: (' + currX + ', ' + currY + '), adding: (' + newX + ', ' + newY + ')');
  centers[[newX, newY]] = true;
  return [centers, newDir]; 
}

function getSector(x, y){
  var nextCenter = getNextCenter([], null);
  var centers = nextCenter[0];
  var prevDir = nextCenter[1];
  var currSect = centers.length - 1;
  while(dist(x, y, centers[currSect][0], centers[currSect][1]) >= 144){
    nextCenter = getNextCenter(centers, prevDir);
    centers = nextCenter[0];
    prevDir = nextCenter[1];
    currSect = centers.length - 1;
  }
  if(dist(centers[currSect][0], centers[currSect][1], x, y) <= 125){
    return currSect;
  }
  var currSectHold = currSect;
  nextCenter = getNextCenter(centers, prevDir);
  centers = nextCenter[0];
  prevDir = nextCenter[1];
  currSect = centers.length - 1;
  while(dist(x, y, centers[currSect][0], centers[currSect][1]) >= 176){
    nextCenter = getNextCenter(centers, prevDir);
    centers = nextCenter[0];
    prevDir = nextCenter[1];
    currSect = centers.length - 1;
  }
  
  if(dist(x, y, centers[currSect][0], centers[currSect][1]) <
     dist(x, y, centers[currSectHold][0], centers[currSectHold][1])){
    return currSect;
  } else {
    return currSectHold;
  }
}

function moveTo(currentCoordinates, direction, compDist){
  var coordinate = currentCoordinates[0];
  var center     = currentCoordinates[1];
  var times      = currentCoordinates[2];
  var sector     = currentCoordinates[3];
  var runAway    = currentCoordinates[4];
  if(runAway){
    currentCoordinates[2]++;
    return currentCoordinates;
  }
  if(Array.isArray(coordinate) && coordinate.length == 2 &&
     Array.isArray(center) && center.length == 2){
    // do nothing
  } else {
    return null;
  }
  var newCenter;
  if(times != 0){
    newCenter = moveTo([coordinate, center, times - 1, sector, runAway], direction);
    if(newCenter[4]){
      return newCenter;
    }
    return moveTo(newCenter, direction);
  }
  //if(dist(coordinate[0], coordinate[1], center[0], center[1]) < 144){
  //  return [coordinate, center, times, true];
  //}
  var newX = center[0] + DELTA[direction][0];
  var newY = center[1] + DELTA[direction][1];
  console.log('moving to (' + newX + ', ' + newY + ')');
  newCenter = [newX, newY];
  if(dist(coordinate[0], coordinate[1], newX, newY) <= compDist){
    return [coordinate, newCenter, times + 1, sector + 1, true];
  }
  return [coordinate, newCenter, times, sector + 1, false];
}

function getSectorNew(x, y){
  var ring = 0;
  var sector = 0;
  var distance = dist(x,y,CENTERX,CENTERY);
  var current = [[x, y], [CENTERX, CENTERY], ring, sector, false];
  if(distance <= 144){
    current[4] = true;
  }
  current = moveTo(current, NORTHEAST, 144);
  ring++;
  while(!current[4]){
    current[2] = ring;
    current = moveTo(current, SOUTHEAST, 144);
    current[2] = ring;
    current = moveTo(current, SOUTHWEST, 144);
    current[2] = ring;
    current = moveTo(current, WEST, 144);
    current[2] = ring;
    current = moveTo(current, NORTHWEST, 144);
    current[2] = ring + 1;
    current = moveTo(current, NORTHEAST, 144);
    current[2] = ring;
    current = moveTo(current, EAST, 144);
    ring++;
  }
  var centX = current[1][0];
  var centY = current[1][1];
  distance = dist(x, y, current[1][0], current[1][1])
  if(distance < 125){
    return current[3];
  }
  var originalCenter = current[1];
  var originalSector = current[3];
  current[4] = false;
  while(!current[4]){
    // this will only go around once.
    current[2] = ring;
    current = moveTo(current, SOUTHEAST, 176);
    current[2] = ring;
    current = moveTo(current, SOUTHWEST, 176);
    current[2] = ring;
    current = moveTo(current, WEST, 176);
    current[2] = ring;
    current = moveTo(current, NORTHWEST, 176);
    current[2] = ring + 1;
    current = moveTo(current, NORTHEAST, 176);
    current[2] = ring;
    current = moveTo(current, EAST, 176);
    ring++;
  }
  
}

/*
function moveNorthEast(currentCoordinates){
  var coordinate = currentCoordinates[0];
  var center     = currentCoordinates[1];
  var times      = currentCoordinates[2];
  var runAway    = currentCoordinates[3];
  if(Array.isArray(coordinate) && coordinate.length == 2 &&
     Array.isArray(center) && center.length == 2){
    // do nothing 
  } else {
    return null;
  }
  var newCenter;
  if(times != 0){
    newCenter = moveNorthEast([coordinate, center, times - 1, runAway]);
    if(newCenter[3]){
      return newCenter;
    }
  }
  var newX = center[0] + DELTA[NORTHEAST][0];
  var newY = center[1] + DELTA[NORTHEAST][1];
  console.log('moving to (' + newX + ', ' + newY + ')');
  newCenter = [newX, newY];
  if(dist(coordinate[0], coordinate[1], newX, newY) <= 144){
    return [coordinate, newCenter, times, true];
  }
  return [coordinate, newCenter, times, false];
}

function moveEast(currentCoordinates){
  var coordinate = currentCoordinates[0];
  var center     = currentCoordinates[1];
  var times      = currentCoordinates[2];
  var runAway    = currentCoordinates[3];
  if(Array.isArray(coordinate) && coordinate.length == 2 &&
     Array.isArray(center) && center.length == 2){
    // do nothing
  } else {
    return null;
  }
  var newCenter;
  if(times != 0){
    newCenter = moveEast([coordinate, center, times - 1, runAway]);
    if(runAway){
      return newCenter;
    }
  }
  var newX = center[0] + DELTA[EAST][0];
  var newY = center[1] + DELTA[EAST][1];
  console.log('moving to (' + newX + ', ' + newY + ')');
  newCenter = [newX, newY];
  if(dist(coordinate[0], coordinate[1], newX, newY) <= 144){
    return [coordinate, newCenter, times, true];
  }
  return [coordinate, newCenter, times, false];
}

function moveSouthEast(currentCoordinates){
  var coordinate = currentCoordinates[0];
  var center     = currentCoordinates[1];
  var times      = currentCoordinates[2];
  var runAway    = currentCoordinates[3];
  if(Array.isArray(coordinate) && coordinate.length == 2 &&
     Array.isArray(center) && center.length == 2){
    // do nothing
  } else {
    return null;
  }
  var newCenter;
  if(times != 0){
    newCenter = moveSouthEast([coordinate, center, times - 1, runAway]);
    if(runAway){
      return newCenter;
    }
  }
  var newX = center[0] + DELTA[SOUTHEAST][0];
  var newY = center[1] + DELTA[SOUTHEAST][1];
  console.log('moving to (' + newX + ', ' + newY + ')');
  newCenter = [newX, newY];
  if(dist(coordinate[0], coordinate[1], newX, newY) <= 144){
    return [coordinate, newCenter, times, true];
  }
  return [coordinate, newCenter, times, false];
}

function moveSouthWest(currentCoordinates){
  var coordinate = currentCoordinates[0];
  var center     = currentCoordinates[1];
  var times      = currentCoordinates[2];
  var runAway    = currentCoordinates[3];
  if(Array.isArray(coordinate) && coordinate.length == 2 &&
     Array.isArray(center) && center.length == 2){
    // do nothing
  } else {
    return null;
  }
  var newCenter;
  if(times != 0){
    newCenter = moveSouthWest([coordinate, center, times - 1, runAway]);
    if(runAway){
      return newCenter;
    }
  }
  var newX = center[0] + DELTA[SOUTHWEST][0];
  var newY = center[1] + DELTA[SOUTHWEST][1];
  console.log('moving to (' + newX + ', ' + newY + ')');
  newCenter = [newX, newY];
  if(dist(coordinate[0], coordinate[1], newX, newY) <= 144){
    return [coordinate, newCenter, times, true];
  }
  return [coordinate, newCenter, times, false];
}

function moveWest(currentCoordinates){
  var coordinate = currentCoordinates[0];
  var center     = currentCoordinates[1];
  var times      = currentCoordinates[2];
  var runAway    = currentCoordinates[3];
  if(Array.isArray(coordinate) && coordinate.length == 2 &&
     Array.isArray(center) && center.length == 2){
    // do nothing
  } else {
    return null;
  }
  var newCenter;
  if(times != 0){
    newCenter = moveWest([coordinate, center, times - 1, runAway]);
    if(runAway){
      return newCenter;
    }
  }
  var newX = center[0] + DELTA[WEST][0];
  var newY = center[1] + DELTA[WEST][1];
  console.log('moving to (' + newX + ', ' + newY + ')');
  newCenter = [newX, newY];
  if(dist(coordinate[0], coordinate[1], newX, newY) <= 144){
    return [coordinate, newCenter, times, true];
  }
  return [coordinate, newCenter, times, false];
}

function moveNorthWest(currentCoordinates){
  var coordinate = currentCoordinates[0];
  var center     = currentCoordinates[1];
  var times      = currentCoordinates[2];
  var runAway    = currentCoordinates[3];
  if(Array.isArray(coordinate) && coordinate.length == 2 &&
     Array.isArray(center) && center.length == 2){
    // do nothing
  } else {
    return null;
  }
  var newCenter;
  if(times != 0){
    newCenter = moveNorthWest([coordinate, center, times - 1, runAway]);
    if(runAway){
      return newCenter;
    }
  }
  var newX = center[0] + DELTA[NORTHWEST][0];
  var newY = center[1] + DELTA[NORTHWEST][1];
  console.log('moving to (' + newX + ', ' + newY + ')');
  newCenter = [newX, newY];
  if(dist(coordinate[0], coordinate[1], newX, newY) <= 144){
    return [coordinate, newCenter, times, true];
  }
  return [coordinate, newCenter, times, false];
}
*/