Grid factory

import { constructors, entity, styles } from '../core/library.js';

import { doCreate, generateIdForArtefact, isa_number, isa_obj, mergeOver, pushUnique, xt, xta, λnull, Ωempty } from '../helper/utilities.js';

import { releaseCell, requestCell } from '../untracked-factory/cell-fragment.js';
import { releaseCoordinate, requestCoordinate } from '../untracked-factory/coordinate.js';
import { checkForWorkstoreItem } from '../helper/workstore.js';
import { gradientEngine } from '../helper/gradient-engine.js';

import baseMix from '../mixin/base.js';
import entityMix from '../mixin/entity.js';

import { _isArray, _isFinite, _parse, BLACK, COLOR, DRAW, ENTITY, FILL, SOURCE_OVER, T_GRID, WHITE, ZERO_STR } from '../helper/shared-vars.js';

const _isInteger = Number.isSafeInteger || Number.isInteger,
    CELL_GRADIENT = 'cellGradient',
    DESTINATION_IN = 'destination-in',
    GRAY = 'rgb(127 127 127 / 1)',
    GRID_GRADIENT = 'gridGradient',
    GRID_PICTURE = 'gridPicture',
    TILE_PICTURE = 'tilePicture',
    TOP = 'top',
    LEFT = 'left',
    CENTER = 'center',
    BOTTOM = 'bottom',
    RIGHT = 'right',
    HORIZONTAL_POSITIONS = ['left', 'center', 'right'],
    VERTICAL_POSITIONS = ['top', 'center', 'bottom'];

const Grid = function (items = Ωempty) {

    this.tileFill = [];
    this.tileSources = [];

    this.rowLines = null;
    this.columnLines = null;
    this.currentTileWidth = 0;
    this.currentTileHeight = 0;

    this.entityInit(items);

    if (!items.tileSources) {

        this.tileSources = [].concat([{

            type: COLOR,
            source: BLACK,
        },
        {

            type: COLOR,
            source: WHITE,
        }]);
    }

    if (!items.tileFill) {

        this.tileFill.length = this.columns * this.rows;
        this.tileFill.fill(0);
    }
    else if (_isArray(items.tileFill) && this.tileFill.length === items.tileFill.length) {

        this.tileFill = items.tileFill;
    }

    this.tilePaths = [];
    this.tileRealCoordinates = [];
    this.tileVirtualCoordinates = [];

    if (!items.dimensions) {

        if (!items.width) this.currentDimensions[0] = this.dimensions[0] = 20;
        if (!items.height) this.currentDimensions[1] = this.dimensions[1] = 20;
    }

    return this;
};

const P = Grid.prototype = doCreate();
P.type = T_GRID;
P.lib = ENTITY;
P.isArtefact = true;
P.isAsset = false;

baseMix(P);
entityMix(P);

const defaultAttributes = {

    columns: 2,
    rows: 2,

    columnGutterWidth: 1,
    rowGutterWidth: 1,

    tileSources: null,

    tileFill: null,

    gutterColor: GRAY,

    horizontalPivotPosition: LEFT,

    verticalPivotPosition: TOP,
};
P.defs = mergeOver(P.defs, defaultAttributes);

P.packetExclusions = pushUnique(P.packetExclusions, ['tileSources']);

P.finalizePacketOut = function (copy, items) {

    const cSources = copy.tileSources = [],
        tSources = this.tileSources;

    tSources.forEach(item => {

        cSources.push({
            type: item.type,
            source: (isa_obj(item.source)) ? item.source.name : item.source
        });
    });

    if (isa_obj(copy.gutterColor)) copy.gutterColor = copy.gutterColor.name;

    const stateCopy = _parse(this.state.saveAsPacket(items))[3];
    copy = mergeOver(copy, stateCopy);

    copy = this.handlePacketAnchor(copy, items);

    return copy;
};

const S = P.setters,
    D = P.deltaSetters;

S.columns = function (item) {

    if (isa_number(item)) {

        if (!_isInteger(item)) item = parseInt(item, 10);

        if (item !== this.columns) {

            let i, iz, j;

            const currentFill = this.tileFill,
                currentCols = this.columns,
                newFill = [];

            this.columns = item;

            for (i = 0, iz = this.rows; i < iz; i++) {

                for (j = 0; j < item; j++) {

                    if (j < currentCols) newFill.push(currentFill[(i * currentCols) + j]);
                    else newFill.push(0);
                }
            }
            this.tileFill = newFill;
        }
    }
    this.dirtyPathObject = true;
    this.dirtyFilterIdentifier = true;
};
D.columns = λnull;

S.rows = function (item) {

    if (isa_number(item)) {

        if (!_isInteger(item)) item = parseInt(item, 10);

        if (item !== this.rows) {

            const currentRows = this.rows;

            this.rows = item;

            this.tileFill.length = this.columns * item;

            if (currentRows < item) this.tileFill.fill(0, currentRows * this.columns);
        }
    }
    this.dirtyPathObject = true;
    this.dirtyFilterIdentifier = true;
};
D.rows = λnull;

S.horizontalPivotPosition = function (item) {

    if (item.substring) {

        item = item.toLowerCase();

        if (HORIZONTAL_POSITIONS.includes(item)) this.horizontalPivotPosition = item;
    }
};

S.verticalPivotPosition = function (item) {

    if (item.substring) {

        item = item.toLowerCase();

        if (VERTICAL_POSITIONS.includes(item)) this.verticalPivotPosition = item;
    }
};

P.setAllTilesTo = function (val) {

    if (isa_number(val)) {

        if (!_isInteger(val)) val = parseInt(val, 10);

        this.tileFill.fill(val);
        this.dirtyFilterIdentifier = true;
    }
    return this;
};

P.setTileFill = function (item) {

    const { columns, rows } = this;

    if (_isArray(item) && item.length === columns * rows) {

        this.tileFill = item;
        this.dirtyFilterIdentifier = true;
    }
    return this;
};

P.setTilesTo = function (tiles, val) {

    const tileFill = this.tileFill;

    if (xt(tiles) && isa_number(val)) {

        if (!_isInteger(val)) val = parseInt(val, 10);

        if (isa_number(tiles)) tileFill[tiles] = val;
        else if (_isArray(tiles)) {

            tiles.forEach(tile => {

                if (isa_number(tile)) tileFill[tile] = val;
            });
        }
        this.dirtyFilterIdentifier = true;
    }
    return this;
};

P.setTileSourceTo = function (index, obj) {

    if (isa_number(index) && isa_obj(obj)) {

        if (obj.type && obj.source) this.tileSources[index] = obj;
    }
    return this;
};

P.removeTileSource = function (index) {

    if (_isFinite(index)) {

        this.tileSources[index] = null;

        this.tileFill = this.tileFill.map(item => item === index ? 0 : item);
    }
    return this;
};

P.getTileSource = function (row, col) {

    if (isa_number(row)) {

        if (!isa_number(col)) return this.tileFill[row];
        else return this.tileFill[(row * this.columns) + col];
    }
};

P.getTilesUsingSource = function (key) {

    const res = [];

    if (isa_number(key)) this.tileFill.forEach((val, index) => val === key && res.push(index));

    return res;
};

P.tileIndexFromPosition = function (row, col) {

    if (_isFinite(row) && _isFinite(col) && row >= 0 && col >= 0) {

        const rows = this.rows,
            cols = this.columns;

        row = (row | 0);
        col = (col | 0);

        if (row < rows && col < cols) return (row * cols) + col;
    }

    return -1;
};

P.positionIndices = function (index) {

    if (_isFinite(index) && index >= 0) {

        const rows = this.rows,
            cols = this.columns;

        index = (index | 0);

        if (cols > 0 && index < rows * cols) return [~~(index / cols), index % cols];
    }

    return [];
};

P.rowIndex = function (index) {

    if (_isFinite(index) && index >= 0) {

        const rows = this.rows,
            cols = this.columns;

        index = (index | 0);

        if (cols > 0 && index < rows * cols) return ~~(index / cols);
    }

    return -1;
};

P.columnIndex = function (index) {

    if (_isFinite(index) && index >= 0) {

        const rows = this.rows,
            cols = this.columns;

        index = (index | 0);

        if (cols > 0 && index < rows * cols) return index % cols;
    }

    return -1;
};

P.fillRow = function (items = Ωempty) {

    let { row, index } = items;

    if (_isFinite(row) && _isFinite(index) && row >= 0 && index >= 0) {

        const cols = this.columns,
            rows = this.rows;

        row = (row | 0);
        index = (index | 0);

        if (cols > 0 && rows > 0 && row < rows) {

            const start = row * cols,
                fill = this.tileFill;

            for (let c = 0; c < cols; c++) {

                fill[start + c] = index;
            }

            this.dirtyFilterIdentifier = true;
        }
    }
    return this;
};

P.fillColumn = function (items = Ωempty) {

    let { column, index } = items;

    if (_isFinite(column) && _isFinite(index) && column >= 0 && index >= 0) {

        const cols = this.columns,
            rows = this.rows;

        column = (column | 0);
        index = (index | 0);

        if (cols > 0 && rows > 0 && column < cols) {

            const fill = this.tileFill;

            for (let r = 0; r < rows; r++) {

                fill[(r * cols) + column] = index;
            }

            this.dirtyFilterIdentifier = true;
        }
    }
    return this;
};

P.fillRect = function (items = Ωempty) {

    let { rowStart, columnStart, rowEnd, columnEnd, index } = items;

    if (_isFinite(rowStart) && _isFinite(rowEnd) && _isFinite(columnStart) && _isFinite(columnEnd) && _isFinite(index)) {

        rowStart = (rowStart | 0);
        rowEnd = (rowEnd | 0);
        columnStart = (columnStart | 0);
        columnEnd = (columnEnd | 0);
        index = (index | 0);

        if (rowStart > rowEnd) [rowStart, rowEnd] = [rowEnd, rowStart];
        if (columnStart > columnEnd) [columnStart, columnEnd] = [columnEnd, columnStart];

        const cols = this.columns,
            rows = this.rows;

        if (
            rowStart >= 0 && rowStart < rows &&
            rowEnd >= 0 && rowEnd < rows &&
            columnStart >= 0 && columnStart < cols &&
            columnEnd >= 0 && columnEnd < cols &&
            index >= 0
        ) {

            const fill = this.tileFill;

            let r, c, base;

            for (r = rowStart; r <= rowEnd; r++) {

                base = r * cols;

                for (c = columnStart; c <= columnEnd; c++) {

                    fill[base + c] = index;
                }
            }

            this.dirtyFilterIdentifier = true;
        }
    }
    return this;
};

P.cleanPathObject = function () {

    this.dirtyPathObject = false;

    if (!this.noPathUpdates || !this.pathObject) {

        const p = this.pathObject = new Path2D(),
            rowLines = new Path2D(),
            colLines = new Path2D();

        const handle = this.currentStampHandlePosition,
            scale = this.currentScale,
            dims = this.currentDimensions;

        const x = -handle[0] * scale,
            y = -handle[1] * scale,
            w = dims[0] * scale,
            h = dims[1] * scale;

        p.rect(x, y, w, h);

        const cols = this.columns,
            rows = this.rows,
            colWidth = w / cols,
            rowHeight = h / rows,
            paths = this.tilePaths,
            real = this.tileRealCoordinates,
            virtual = this.tileVirtualCoordinates;

        let i, j, cx, cy;

        rowLines.moveTo(x, y);
        rowLines.lineTo(x + w, y);

        for (i = 1; i <= rows; i++) {

            const ry = y + (i * rowHeight);

            rowLines.moveTo(x, ry);
            rowLines.lineTo(x + w, ry);
        }
        this.rowLines = rowLines;

        colLines.moveTo(x, y);
        colLines.lineTo(x, y + h);

        for (j = 1; j <= cols; j++) {

            cx = x + (j * colWidth);

            colLines.moveTo(cx, y);
            colLines.lineTo(cx, y + h);
        }
        this.columnLines = colLines;

        paths.length = 0;
        real.length = 0;
        virtual.length = 0;

        for (i = 0; i < rows; i++) {

            for (j = 0; j < cols; j++) {

                const path = new Path2D();

                cx = j * colWidth;
                cy = i * rowHeight;

                path.rect(x + cx, y + cy, colWidth, rowHeight);
                paths.push(path);

                virtual.push([cx, cy]);
                real.push([x + cx, y + cy]);
            }
        }

        this.currentTileWidth = colWidth;
        this.currentTileHeight = rowHeight;
    }
};

P.getTilePivotCoordsAt = function (index) {

    if (_isFinite(index) && index >= 0) {

        const tiles = this.tileRealCoordinates;

        if (index < tiles.length) {

            const start = this.currentStampPosition,
                offset = [...tiles[index]],
                angle = this.currentRotation,
                horizontalPivotPosition = this.horizontalPivotPosition,
                verticalPivotPosition = this.verticalPivotPosition,
                width = this.currentTileWidth,
                height = this.currentTileHeight;

            if (horizontalPivotPosition === RIGHT) offset[0] += width;
            else if (horizontalPivotPosition === CENTER) offset[0] += width / 2;

            if (verticalPivotPosition === BOTTOM) offset[1] += height;
            else if (verticalPivotPosition === CENTER) offset[1] += height / 2;

            if (this.flipReverse) offset[0] = -offset[0];
            if (this.flipUpend) offset[1] = -offset[1];

            const coord = requestCoordinate();
            coord.setFromArray(offset).rotate(angle).add(start);

            const res = [...coord];

            releaseCoordinate(coord);

            return res;
        }
    }

    return [...this.currentStampPosition];
};

P.performFill = function (engine) {

    const currentScale = this.currentScale || 0;

    if (currentScale > 0) {

        engine.save();

        const composer = requestCell(),
            compEngine = composer.engine,
            compCanvas = composer.element;

        const tileSources = this.tileSources,
            tileFill = this.tileFill,
            tilePaths = this.tilePaths,
            tileRealCoords = this.tileRealCoordinates,
            tileVirtualCoords = this.tileVirtualCoordinates,
            winding = this.winding,
            tileWidth = this.currentTileWidth,
            tileHeight = this.currentTileHeight,
            dims = this.currentDimensions,
            applyGridGradient = this.applyGridGradient.bind(this);

        const getGradientObject = function (source) {

            return source && source.substring ? styles[source] : source;
        };

        const buildTileGradientIdentifier = (grad, index, lockedToEntity) => {

            return [
                this.name,
                'grid-tile-gradient',
                index,
                lockedToEntity ? GRID_GRADIENT : CELL_GRADIENT,
                grad.identifier,
                this.currentScale,
                this.currentRotation,
                this.currentStampPosition.join(':'),
                this.currentDimensions.join(':'),
                this.columns,
                this.rows,
                tileFill.join(':'),
            ].join('-');
        };

        const buildGutterGradientIdentifier = (grad, lockedToEntity) => {

            return [
                this.name,
                'grid-gutter-gradient',
                lockedToEntity ? GRID_GRADIENT : CELL_GRADIENT,
                grad.identifier,
                this.currentScale,
                this.currentRotation,
                this.currentStampPosition.join(':'),
                this.currentDimensions.join(':'),
                this.columns,
                this.rows,
                this.rowGutterWidth,
                this.columnGutterWidth,
            ].join('-');
        };

        const setClassicFillGradient = (grad, lockedToEntity) => {

            const currentLock = this.lockFillStyleToEntity;

            this.lockFillStyleToEntity = lockedToEntity;
            engine.fillStyle = grad.getData(this, this.currentHost, FILL);
            this.lockFillStyleToEntity = currentLock;
        };

        const setClassicStrokeGradient = (grad, lockedToEntity) => {

            const currentLock = this.lockStrokeStyleToEntity;

            this.lockStrokeStyleToEntity = lockedToEntity;
            engine.strokeStyle = grad.getData(this, this.currentHost, DRAW);
            this.lockStrokeStyleToEntity = currentLock;
        };

        let currentPicture;

        tileSources.forEach((obj, index) => {

            if (!obj || !obj.type) return;

            const validTiles = tileFill.map(item => item === index ? true : false);

            if (!validTiles.length) return;

            switch (obj.type) {

                case COLOR :

                    engine.fillStyle = obj.source;
                    validTiles.forEach((tile, pos) => tile && engine.fill(tilePaths[pos], winding));
                    break;

                case CELL_GRADIENT :
                case GRID_GRADIENT : {

                    const grad = getGradientObject(obj.source),
                        lockedToEntity = obj.type === GRID_GRADIENT;

                    if (!grad) break;

                    if (!grad.isClassic) {

                        const identifier = buildTileGradientIdentifier(grad, index, lockedToEntity);

                        applyGridGradient(engine, grad, function (maskEngine) {

                            validTiles.forEach((tile, pos) => {

                                if (tile) maskEngine.fill(tilePaths[pos], winding);
                            });

                        }, lockedToEntity, identifier);
                    }
                    else {

                        setClassicFillGradient(grad, lockedToEntity);
                        validTiles.forEach((tile, pos) => tile && engine.fill(tilePaths[pos], winding));
                    }
                    break;
                }

                case GRID_PICTURE : {

                    currentPicture = (obj.source.substring) ? entity[obj.source] : obj.source;

                    if (currentPicture.simpleStamp) {

                        const W = dims[0] * currentScale,
                            H = dims[1] * currentScale;

                        compCanvas.width = W;
                        compCanvas.height = H;
                        compEngine.globalCompositeOperation = SOURCE_OVER;

                        currentPicture.simpleStamp(composer, {
                            startX: 0,
                            startY: 0,
                            width: W,
                            height: H,
                            method: FILL,
                        });

                        const masker = requestCell(),
                            mEngine = masker.engine,
                            mCanvas = masker.element;

                        mCanvas.width = W;
                        mCanvas.height = H;

                        mEngine.fillStyle = WHITE;

                        let use, ux, uy;

                        for (let i = 0, iz = validTiles.length; i < iz; i++) {

                            use = validTiles[i];

                            if (use) {

                                [ux, uy] = tileVirtualCoords[i];

                                mEngine.fillRect(ux, uy, tileWidth, tileHeight);
                            }
                        }

                        compEngine.globalCompositeOperation = DESTINATION_IN;
                        compEngine.drawImage(mCanvas, 0, 0);

                        engine.drawImage(compCanvas, ~~tileRealCoords[0][0], ~~tileRealCoords[0][1]);

                        releaseCell(masker);
                    }
                    break;
                }

                case TILE_PICTURE :

                    currentPicture = (obj.source.substring) ? entity[obj.source] : obj.source;

                    if (currentPicture.simpleStamp) {

                        compCanvas.width = tileWidth;
                        compCanvas.height = tileHeight;
                        compEngine.globalCompositeOperation = SOURCE_OVER;

                        currentPicture.simpleStamp(composer, {
                            startX: 0,
                            startY: 0,
                            width: tileWidth,
                            height: tileHeight,
                            method: FILL,
                        });

                        validTiles.forEach((tile, pos) => tile && engine.drawImage(compCanvas, ~~tileRealCoords[pos][0], ~~tileRealCoords[pos][1]));
                    }
                    break;
            }
        });

        const gColor = this.gutterColor,
            gRow = this.rowGutterWidth,
            gCol = this.columnGutterWidth;

        let gObject;

        if (xt(gColor)) {

            if (gColor.substring) {

                gObject = {
                    type: COLOR,
                    source: this.gutterColor
                };
            }
            else if (isa_obj(gColor)) gObject = gColor;
            else if (isa_number(gColor) && isa_obj(tileSources[gColor])) gObject = tileSources[gColor];

            if (gObject && gObject.type) {

                switch (gObject.type) {

                    case COLOR :

                        engine.strokeStyle = gObject.source;

                        if (gRow) {

                            engine.lineWidth = gRow;
                            engine.stroke(this.rowLines);
                        }

                        if (gCol) {

                            engine.lineWidth = gCol;
                            engine.stroke(this.columnLines);
                        }
                        break;

                    case CELL_GRADIENT :
                    case GRID_GRADIENT : {

                        const grad = getGradientObject(gObject.source),
                            lockedToEntity = gObject.type === GRID_GRADIENT;

                        if (!grad) break;

                        if (!grad.isClassic) {

                            const identifier = buildGutterGradientIdentifier(grad, lockedToEntity);

                            applyGridGradient(engine, grad, function (maskEngine) {

                                if (gRow) {

                                    maskEngine.lineWidth = gRow;
                                    maskEngine.stroke(this.rowLines);
                                }

                                if (gCol) {

                                    maskEngine.lineWidth = gCol;
                                    maskEngine.stroke(this.columnLines);
                                }

                            }.bind(this), lockedToEntity, identifier);
                        }
                        else {

                            setClassicStrokeGradient(grad, lockedToEntity);

                            if (gRow) {

                                engine.lineWidth = gRow;
                                engine.stroke(this.rowLines);
                            }

                            if (gCol) {

                                engine.lineWidth = gCol;
                                engine.stroke(this.columnLines);
                            }
                        }
                        break;
                    }

                    case GRID_PICTURE :
                    case TILE_PICTURE : {

                        if (gRow || gCol) {

                            currentPicture = (gObject.source.substring) ? entity[gObject.source] : gObject.source;

                            if (currentPicture.simpleStamp) {

                                const handle = this.currentStampHandlePosition,
                                    x = handle[0] * currentScale,
                                    y = handle[1] * currentScale,
                                    W = dims[0] * currentScale,
                                    H = dims[1] * currentScale;

                                compCanvas.width = W;
                                compCanvas.height = H;
                                compEngine.globalCompositeOperation = SOURCE_OVER;

                                currentPicture.simpleStamp(composer, {
                                    startX: 0,
                                    startY: 0,
                                    width: W,
                                    height: H,
                                    method: FILL,
                                });

                                const masker = requestCell(),
                                    mEngine = masker.engine,
                                    mCanvas = masker.element;

                                mCanvas.width = W;
                                mCanvas.height = H;

                                mEngine.translate(x, y);
                                mEngine.strokeStyle = WHITE;

                                if (gRow) {

                                    mEngine.lineWidth = gRow;
                                    mEngine.stroke(this.rowLines);
                                }

                                if (gCol) {

                                    mEngine.lineWidth = gCol;
                                    mEngine.stroke(this.columnLines);
                                }

                                compEngine.globalCompositeOperation = DESTINATION_IN;
                                compEngine.drawImage(mCanvas, 0, 0);

                                engine.drawImage(compCanvas, ~~tileRealCoords[0][0], ~~tileRealCoords[0][1]);

                                releaseCell(masker);
                            }
                        }
                        break;
                    }
                }
            }
        }

        releaseCell(composer);

        engine.restore();
    }
};

P.applyGridGradient = function (engine, grad, maskStamp, lockedToEntity = false, identifier = ZERO_STR) {

    if (!grad || !maskStamp) return false;

    const refCell = this.currentHost;

    if (!refCell) return false;

    if (!identifier || identifier === ZERO_STR) identifier = generateIdForArtefact(this);

    if (!checkForWorkstoreItem(identifier)) {

        const myCell = requestCell(),
            element = myCell.element,
            maskEngine = myCell.engine;

        const [width, height] = refCell.get('dimensions'),
            [x, y] = this.currentStampPosition,
            matrix = refCell.engine.getTransform();

        element.width = width;
        element.height = height;

        myCell.rotateDestination(maskEngine, x, y, this);
        myCell.setEngine(this);

        maskEngine.shadowOffsetY = 0;
        maskEngine.shadowOffsetX = 0;
        maskEngine.shadowBlur = 0;

        maskEngine.fillStyle = BLACK;
        maskEngine.strokeStyle = BLACK;

        maskStamp(maskEngine);

        const data = maskEngine.getImageData(0, 0, width, height);

        const success = gradientEngine.action({

            fixedGradientData: this.getFixedGradientData(grad, FILL, lockedToEntity),
            identifier,
            imageData: data,
            entity: this,
            matrix,
        });

        releaseCell(myCell);

        if (!success) return false;
    }

    this.applyFromWorkstore(engine, identifier);

    return identifier;
};

P.fill = function (engine) {

    this.performFill(engine);
};

P.drawAndFill = function (engine) {

    const p = this.pathObject;

    engine.stroke(p);
    this.currentHost.clearShadow();
    this.performFill(engine);
};

P.fillAndDraw = function (engine) {

    const p = this.pathObject;

    engine.stroke(p);
    this.currentHost.clearShadow();
    this.performFill(engine);
    engine.stroke(p);
};

P.drawThenFill = function (engine) {

    const p = this.pathObject;

    engine.stroke(p);
    this.performFill(engine);
};

P.fillThenDraw = function (engine) {

    const p = this.pathObject;

    this.performFill(engine);
    engine.stroke(p);
};

P.checkHit = function (items = []) {

    if (this.noUserInteraction) return false;

    if (!this.pathObject || this.dirtyPathObject) {

        this.cleanPathObject();
    }

    const tests = (!_isArray(items)) ?  [items] : items;

    const mycell = requestCell(),
        engine = mycell.engine,
        stamp = this.currentStampPosition,
        x = stamp[0],
        y = stamp[1],
        tiles = new Set(),
        tilePaths = this.tilePaths;

    let isGood, tx, ty;

    const getCoords = (coords) => {

        let x, y;

        if (_isArray(coords)) {

            x = coords[0];
            y = coords[1];
        }
        else if (xta(coords, coords.x, coords.y)) {

            x = coords.x;
            y = coords.y;
        }
        else return [false];

        if (!_isFinite(x) || !_isFinite(y)) return [false];

        return [true, x, y];
    }

    mycell.rotateDestination(engine, x, y, this);

    if (tests.some(test => {

        [isGood, tx, ty] = getCoords(test);

        if (!isGood) return false;
        else return engine.isPointInPath(this.pathObject, tx, ty, this.winding);

    }, this)) {

        tests.forEach(test => {

            [isGood, tx, ty] = getCoords(test);

            if (isGood) {

                tilePaths.some((path, index) => {

                    if (engine.isPointInPath(path, tx, ty, this.winding)) {

                        tiles.add(index);
                        return true;
                    }
                    return false;
                })
            }
        });

        releaseCell(mycell);

        return {
            x: tx,
            y: ty,
            tiles: [...tiles],
            artefact: this
        };
    }

    releaseCell(mycell);
    return false;
};

export const makeGrid = function (items) {

    if (!items) return false;
    return new Grid(items);
};

constructors.Grid = Grid;