/// @descripton tile_determine_image(grid, grid_x, grid_y, is_sprite)
/// @param grid
/// @param grid_x
/// @param grid_y
/// @param is_sprite

var _grid   = argument0;
var _grid_x = argument1;
var _grid_y = argument2;
var _sprite = argument3;

var _tile_offset = (_sprite) ? 0 : 5;

var _w      = ds_grid_width(_grid);
var _h      = ds_grid_height(_grid);

var _surround;

var _x_off, _y_off, _x, _y, _sx, _sy;

for(_x_off=-1;_x_off<=1;++_x_off){
    for(_y_off=-1;_y_off<=1;++_y_off){

        _sx = _x_off +1;
        _sy = _y_off +1;

        _x  = _grid_x +_x_off;
        _y  = _grid_y +_y_off;

        if(_x <   0 || _y <   0
        || _x >= _w || _y >= _h)
            _surround[_sx,_sy] = 0;
        else
            _surround[_sx,_sy] = _grid[# _x, _y];
    }
}

var _values;

_values[0, 0] = 1;
_values[1, 0] = 2;
_values[2, 0] = 4;
_values[0, 1] = 8;
_values[1, 1] = 0; // center always filled
_values[2, 1] = 16;
_values[0, 2] = 32;
_values[1, 2] = 64;
_values[2, 2] = 128;

var _sum = 0;

for(_sx=0;_sx<=2;++_sx)
    for(_sy=0;_sy<=2;++_sy)
        _sum   += _surround[_sx, _sy]
                ? _values[_sx, _sy]
                : 0;

switch(_sum){

    // single
    case 0:
    case 1:
    case 4:
    case 5:
    case 32:
    case 33:
    case 36:
    case 37:
    case 128:
    case 129:
    case 132:
    case 133:
    case 160:
    case 161:
    case 164:
    case 165:
        return (14 +_tile_offset);
    break;

    // single neighbor above
    case 2:
    case 3:
    case 6:
    case 7:
    case 34:
    case 35:
    case 38:
    case 39:
    case 130:
    case 131:
    case 134:
    case 135:
    case 162:
    case 163:
    case 166:
    case 167:
        return (30 +_tile_offset);
    break;

    // single neighbor left
    case 8:
    case 9:
    case 12:
    case 13:
    case 40:
    case 41:
    case 44:
    case 45:
    case 136:
    case 137:
    case 140:
    case 141:
    case 168:
    case 169:
    case 172:
    case 173:
        return (17 +_tile_offset);
    break;

    // single neighbor right
    case 16:
    case 17:
    case 20:
    case 21:
    case 48:
    case 49:
    case 52:
    case 53:
    case 144:
    case 145:
    case 148:
    case 149:
    case 176:
    case 177:
    case 180:
    case 181:
        return (15 +_tile_offset);
    break;

    // single neighbor below
    case 64:
    case 65:
    case 68:
    case 69:
    case 96:
    case 97:
    case 100:
    case 101:
    case 192:
    case 193:
    case 196:
    case 197:
    case 224:
    case 225:
    case 228:
    case 229:
        return (20 +_tile_offset);
    break;

    // two neighbors above and below
    case 66:
    case 67:
    case 70:
    case 71:
    case 98:
    case 99:
    case 102:
    case 103:
    case 194:
    case 195:
    case 198:
    case 199:
    case 226:
    case 227:
    case 230:
    case 231:
        return (25 +_tile_offset);
    break;

    // two neighbors left and right
    case 24:
    case 25:
    case 28:
    case 29:
    case 56:
    case 57:
    case 60:
    case 61:
    case 152:
    case 153:
    case 156:
    case 157:
    case 184:
    case 185:
    case 188:
    case 189:
        return (16 +_tile_offset);
    break;

    // two neighbors top and left
    case 10:
    case 14:
    case 42:
    case 46:
    case 138:
    case 142:
    case 170:
    case 174:
        // tube corner
        return (44 +_tile_offset);
    break;

    // two neighbors top and right
    case 18:
    case 19:
    case 50:
    case 51:
    case 146:
    case 147:
    case 178:
    case 179:
        // tube corner
        return (39 +_tile_offset);
    break;

    // two neighbors bottom and left
    case 72:
    case 73:
    case 76:
    case 77:
    case 200:
    case 201:
    case 204:
    case 205:
        // tube corner
        return (46 +_tile_offset);
    break;

    // two neighbors bottom and right
    case 80:
    case 81:
    case 84:
    case 85:
    case 112:
    case 113:
    case 116:
    case 117:
        // tube corner
        return (45 +_tile_offset);
    break;

    // three neighbors w, nw, n
    case 11:
    case 15:
    case 43:
    case 47:
    case 139:
    case 143:
    case 171:
    case 175:
        // full corner
        return (12 +_tile_offset);
    break;

    // three neighbors n, ne, e
    case 22:
    case 23:
    case 54:
    case 55:
    case 150:
    case 151:
    case 182:
    case 183:
        // full corner
        return (10 +_tile_offset);
    break;

    // three neighbors e, se, s
    case 208:
    case 209:
    case 212:
    case 213:
    case 240:
    case 241:
    case 244:
    case 245:
        // full corner
        return (0 +_tile_offset);
    break;

    // three neighbors s, sw, w
    case 104:
    case 105:
    case 108:
    case 109:
    case 232:
    case 233:
    case 236:
    case 237:
        // full corner
        return (2 +_tile_offset);
    break;

    // three neighbor T, w, n, e
    case 26:
    case 58:
    case 154:
    case 186:
        // T with edge on bottom
        return (33 +_tile_offset);
    break;

    // three neighbor T n, e, s
    case 82:
    case 83:
    case 114:
    case 115:
        // T with edge on left
        return (34 +_tile_offset);
    break;

    // three neighbor T w, e, s
    case 88:
    case 89:
    case 92:
    case 93:
        // T with edge on top
        return (31 +_tile_offset);
    break;

    // three neighbor T w, n, s
    case 74:
    case 78:
    case 202:
    case 206:
        // T with edge on right
        return (32 +_tile_offset);
    break;

    // four neighbor top edge with bottom left inside corner
    case 216:
    case 217:
    case 220:
    case 221:
        return (36 +_tile_offset);
    break;

    // four neighbor top edge with bottom right inside corner
    case 120:
    case 121:
    case 124:
    case 125:
        return (35 +_tile_offset);
    break;

    // four neighbor right edge with top left inside corner
    case 106:
    case 110:
    case 234:
    case 238:
        return (43 +_tile_offset);
    break;

    // four neighbor right edge with bottom left inside corner
    case 75:
    case 79:
    case 203:
    case 207:
        return (38 +_tile_offset);
    break;

    // four neighbor bottom edge with top left inside corner
    case 30:
    case 62:
    case 158:
    case 190:
        return (41 +_tile_offset);
    break;

    // four neighbor bottom edge with top right inside corner
    case 27:
    case 59:
    case 155:
    case 187:
        return (40 +_tile_offset);
    break;

    // four neighbor left edige with top right inside corner
    case 210:
    case 211:
    case 242:
    case 243:
        return (42 +_tile_offset);
    break;

    // four neighbor left edge with bottom right inside corner
    case 86:
    case 87:
    case 118:
    case 119:
        return (37 +_tile_offset);
    break;

    // four neighbor cross
    case 90:
        return (13 +_tile_offset);
    break;

    // five neighbor left edge
    case 214:
    case 215:
    case 246:
    case 247:
        return (5 +_tile_offset);
    break;

    // five neighbor right edge
    case 107:
    case 111:
    case 235:
    case 239:
        return (7 +_tile_offset);
    break;

    // five neighbor top edge
    case 248:
    case 249:
    case 252:
    case 253:
        return (1 +_tile_offset);
    break;

    // five neighbor bottom edge
    case 31:
    case 63:
    case 159:
    case 191:
        return (11 +_tile_offset);
    break;

    // five neighbor triple inside corner bottom right filled
    case 218:
        return (27 +_tile_offset);
    break;

    // five neighbor triple inside corner bottom left filled
    case 122:
        return (21 +_tile_offset);
    break;

    // five neighbor triple inside corner top left filled
    case 91:
        return (22 +_tile_offset);
    break;

    // five neighbor triple inside corner top right filled
    case 94:
        return (26 +_tile_offset);
    break;

    // six neighbor double inside corners facing up
    case 250:
        return (23 +_tile_offset);
    break;

    // six neighbor double inside corners facing down
    case 95:
        return (29 +_tile_offset);
    break;

    // six neighbor double inside corners facing left
    case 222:
        return (28 +_tile_offset);
    break;

    // six neighbor double inside corners facing right
    case 123:
        return (24 +_tile_offset);
    break;

    // six neighbor double inside corner top left and bottom right
    case 126:
        return (19 +_tile_offset);
    break;

    // six neighbor double inside corner bottom left and top right
    case 219:
        return (18 +_tile_offset);
    break;

    // seven neighbor missing top left
    case 254:
        return (9 +_tile_offset);
    break;

    // seven neighbor missing top right
    case 251:
        return (8 +_tile_offset);
    break;

    // seven neighbor missing bottom right
    case 127:
        return (3 +_tile_offset);
    break;

    // seven neighbor missing bottom left
    case 223:
        return (4 +_tile_offset);
    break;

    // all eight neighbors
    case 255:
        return (6 +_tile_offset);
    break;

    default:
        show_debug_message("no case for sum: "+string(_sum)+" surround: "+string(_surround));
}