aaaaaaaaaaa

import { AxesHelper } from '../three.module.js';
//import { capturePoint } from './player.js';
import { levelsPreSet, levelParam } from './levels.js';
import { capturePoint, gameScene, localPlayers } from './game_logic.js';

export { effects, generateMap, mapState, tileBox, tileActionBox, tileEleminator };

// tech stuff
let     errorPrefix = '[MAP]',
        tileBox = [ {
            p1: {
                x: undefined,
                z: undefined
            },
            p2: {
                x: undefined,
                z: undefined
            },
            tileMeta: undefined
        } ], // tileBox[0] = { p1: { x:?,z:? }, p2: {x:?,z:?}, tileMeta: null } pozycji respawnu graczy
        // each tile in tileBox can be established by knowing whats coordinates of it
        //just like this: tileBox[x + (z*Xsize)]
        //      tileBox[1+] = { obj: THREE.Obj, x:?, z:? }
        effects = [], // same as tileBox but each iteration has object
            // if object.state false then position is safe to walk
            // if object.state true then position have object.func to execute like META point etc.
            // if effects[x] is undefined then kill player
        mapState = {
            Xsize: null,
            Zsize: null,
            metaPos: { x: null, z: null },
            worldOrigin: {
                x: null,
                z: null
            },
            level: null,
            lastState: {
                mode: null,
                Xsize: null,
                Zsize: null
            }
        },
        // array of functions which need to be updated as animation
        tileActionBox = [],
        tileElemination = false;



function generateTiles(Xsize, Zsize, mode='arctic') {
// size of the map must be accessible for tileMeta - just to make things easier
    if( (Xsize < 6) || (Zsize < 8) )
        throw new Error(`${errorPrefix} Tiles generation isnt filling minimal requirements ( X<4 , Z<8 )`);
    else if( levelsPreSet[`${mode}`] === undefined )
        throw new Error(`${errorPrefix} Tiles generation cant be started before levels initialization!`);
    return new Promise( function(res,rej) {
// helper axes...
    let axesHelper = new AxesHelper( 5 );
    gameScene.add( axesHelper );


// tileMeta

    let tileMeta;
    if( tileBox[0].tileMeta !== undefined ) {
        // get tileMeta from levels.js:levelsPreSet object
        tileMeta = levelsPreSet[`${mode}`].tileMeta;
        tileBox[0].tileMeta = tileMeta;
        gameScene.add(tileMeta);
    } else if( tileBox[0].tileMeta == null ) {
        // got wiped out by mapManager('destroy')
        tileMeta = levelsPreSet[`${mode}`].tileMeta;
        tileBox[0].tileMeta = tileMeta;
        gameScene.add(tileMeta);
    } else
        // already exist
        tileMeta = tileBox[0].tileMeta;

    // meta object is symmetric and of size 2 points of x
    //     so we need to place it between two points
    tileMeta.position.set( // x, y, z
        -(mapState.metaPos.x + 0.5),
        0,
        mapState.metaPos.z - 1      // real Z is shifted at scene by 1
    );
    //tileMeta.rotation.set( 0, Math.PI, 0);

    // set META tiles to true to mark them as META points
    effects[ mapState.metaPos.x      + (    (mapState.metaPos.z-1) * Xsize    ) ] = {
        state: true,
        func: capturePoint
    };
    effects[ mapState.metaPos.x + 1  + (    (mapState.metaPos.z-1) * Xsize    ) ] = {
        state: true,
        func: capturePoint
    };


//position of player respawn point
    tileBox[0] = {
        p1: {   //player 1
            x: -((mapState.metaPos.x + 1) + 1), // left part of META + 1 tile gap
            z: 6 - 1
        },
        p2: {   //player 2
            x: -(mapState.metaPos.x - 1),       //right part of META - 1 tile gap
            z: 6 - 1
        }
    };


// tiles
    console.log('metaPos:');
    console.log(mapState.metaPos.x);

    // get tile from levels.js:levelsPreSet object
    let tile = levelsPreSet[`${mode}`].tile;

    // loop to place all tiles at desired positions
    for( let Z = 0; Z < Zsize; Z++ )
        for( let X = 1; X <= Xsize; X++ ) {
            // clone object which fit to choosen mode
            let _tile = tile.clone();
            // set position starting from X:1, Z:0 to X: Xsize, Z: Zsize
            _tile.position.set( -X, 0, Z );
            // make position walkable
            effects[X + ( Z * Xsize )] = {
                state: false,
                func: null,
                decayed: false,
                stateValue: 1,
                i: 1
            };
            // add tile to array to help us in future access it by knowing X and Z pos
            tileBox.push(_tile);
            // add to THREEjs scene
            gameScene.add(_tile);

            // skip 2 tiles to avoid META, Z position is always at 2
            if ( ( (Z+1) == 2 ) && ( X == mapState.metaPos.x - 1 ) )
                X += 2;
        }
    console.log('tileBox:');
    console.log(tileBox);
    res();
    });
}

function adjustMap(newXsize, newZsize, mode='arctic') {
    if( mode == mapState.lastState.mode )
        throw new Error(`${errorPrefix} Cant adjust tiles when mode changed`)
    return new Promise( function(res,rej) {

        // if mapSize didnt changed
        if( (newXsize == mapState.lastState.Xsize) && (newZsize == mapState.lastState.Zsize) )
            res();
        else {

            let tileMeta = tileBox[0].tileMeta;

            // meta object is symmetric and of size 2 points of x
            //     so we need to place it between two points
            tileMeta.position.set( // x, y, z
                -(mapState.metaPos.x + 0.5),
                0,
                mapState.metaPos.z - 1      // real Z is shifted at scene by 1
            )

            // calculate missing tiles for new sizes
            let     _newAmount = (newXsize * newZsize) - 2,
                    _oldAmount = tileBox.length - 1,
                    _needed = _newAmount - _oldAmount,
                    _tilePrefab = levelsPreSet[`${mode}`].tile;

            // clear effects
            effects = [];
            // redefine effects
            effects[ mapState.metaPos.x      + (    (mapState.metaPos.z-1) * newXsize    ) ] = {
                state: true,
                func: capturePoint
            };
            effects[ mapState.metaPos.x + 1  + (    (mapState.metaPos.z-1) * newXsize    ) ] = {
                state: true,
                func: capturePoint
            };
            // reposition all old tiles to new design
            //  and on top of that create missing ones and push to tileBox
            for( let Z=0 ; Z < newZsize ; Z++)
                for( let X=1 ; X <= newXsize ; X++ ) {
                    if(_oldAmount > 0) {
                        //get old tiles from tileBox
                            // set position starting from X:1, Z:0 to X: Xsize, Z: Zsize
                            tileBox[X + ( Z * Xsize )].position.set( -X, 0, Z );
                            // make position walkable
                            effects[X + ( Z * Xsize )] = false;
                        _oldAmount--;
                    } else {
                        //create new missing tiles
                            // clone object which fit to choosen mode
                            let _tile = _tilePrefab.clone();
                            // set position starting from X:1, Z:0 to X: Xsize, Z: Zsize
                            _tile.position.set( -X, 0, Z );
                            // make position walkable
                            effects[X + ( Z * Xsize )] = false;
                            // set info about decay state
                            _tile.userData.tileDecayed = false;
                            // add tile to array to help us in future access it by knowing X and Z pos
                            tileBox.push(_tile);
                            // add to THREEjs scene
                            gameScene.add(_tile);
                    }

                    // skip 2 tiles to avoid META, Z position is always at 2
                    if ( ( (Z+1) == 2 ) && ( X == mapState.metaPos.x - 1 ) )
                        X += 2;
                }

            //position of player respawn point
            tileBox[0] = {
                p1: {   //player 1
                    x: -((mapState.metaPos.x + 1) + 1), // left part of META + 1 tile gap
                    z: 6 - 1
                },
                p2: {   //player 2
                    x: -(mapState.metaPos.x - 1),       //right part of META - 1 tile gap
                    z: 6 - 1
                }
            };

            // SKYBOX size adjustment
            let skybox = levelsPreSet[`${mode}`].skybox,
                { textureMode, oldXsize, oldZsize } = skybox.userData.mapData;

            if( textureMode !== mode )
                throw new Error(`${errorPrefix} Adjust skybox with different texture mode?`);
            else if ( (newXsize !== oldXsize) || (newZsize !== oldZsize) )
                skybox.scale.set(newXsize * 5, 50, newZsize * 6.25);

            // WATER size adjustment
            let water = levelsPreSet[`${mode}`].water,
                { water_oldXsize, water_oldZsize } = water.userData.mapData;
            if( (water_oldXsize !== newXsize) || (water_oldZsize !== newZsize) )
                water.scale.set(Xsize * 5, 1, Zsize * 6.25);

                     /* MISSING !

                HERE REPOSITION MISC OBJECTS

                      MISSING !
            */
        }
    });
}

function deleteTiles(){
    /*
    NOT ONLY REMOVE FROM SCENE AND DELETE ALLOCATION IN APP
        BUT ALSO DISPOSE() EACH geometry, material, texture

    gameScene.remove
    FOR i=1 ; i <= tileBox.length
        gameScene.remove(tileBox[i])    // remove from scene
        delete effects[i]           // turn position into undefined
        delete tileBox[i]           // turn objects into undefined
    */
}

//function generateMap( Xsize, Zsize, mode='arctic') {
function generateMap( action='LAUNCH', level=0 ) {
    return new Promise( function(res,rej) {

    let     Xsize = levelParam.levels[level].mapSize.x,
            Zsize = levelParam.levels[level].mapSize.z,
            mode = levelParam.levels[level].mode,
            resolveMapGeneration = function() {
                mapState.lastState.mode = mode;
                mapState.lastState.Xsize = Xsize;
                mapState.lastState.Zsize = Zsize;
                mapState.lastState.level = level;
                res();
            };

    console.log(`Xsize: ${Xsize} Zsize: ${Zsize}, Mode: ${mode}`);

    // info for other functions/modules
    mapState.Xsize = Xsize;
    mapState.Zsize = Zsize;
    // these X and Z arent translated yet to real scene axis
    mapState.metaPos.x = ( Xsize > 10 ) ? // below Xsize=10 the metaPos.x is 3
                Math.ceil((Xsize/10.8).toFixed(2) * 3) : 3;
    mapState.metaPos.z = 2;    // Z is always relative to edge of map
    mapState.worldOrigin.x = -(Xsize/2),     // X axis is reflected at minus
    mapState.worldOrigin.z =  (Zsize)/2 + (((Zsize%2) == 0) ? 0.5 : 0)    // Z axis is shifted -1, so Z:1 is real Z:0

    mapState.level = level;

    console.log(`worldOrigin: ${mapState.worldOrigin.x}, ${mapState.worldOrigin.z}`);

    switch ( action ) {

        // first game launch
        case 'LAUNCH':
            console.log('generateMap(): LAUNCH 1');
            mapManager('initialize', mode, level ).then( () => {
                console.log('generateMap(): LAUNCH 2');
                generateTiles(Xsize,Zsize,mode).then( () => {
                    console.log('generateMap(): LAUNCH 3');
                    applyInitialStates(mode).then( () => {
                        console.log('generateMap(): LAUNCH 4');
                        resolveMapGeneration();
                    });
                })
            })
        break;

        // re-launch after player death
        case 'RELAUNCH':
            /*
                SO WE HAVE HERE CLEARED MAP WITH ONLY TILES, META, SKYBOX, WATER, CLOUDS
                MAY BE MISSING MISC objects if mapManager() is writen bad
            */
            applyInitialStates(mode).then( () => {
                resolveMapGeneration();
            });
        break;

        // new level, same mode
        case 'NEW-LEVEL':
            mapManager('clear').then( () => {
                // if mapSize changed
                if (
                    ( Xsize !== mapState.lastState.Xsize ) &&
                    ( Zsize !== mapState.lastState.Zsize ) )
                    adjustMap(Xsize,Zsize).then( () => {
                        resolveMapGeneration();
                    });
                else
                    resolveMapGeneration();
            });
        break;

        // new mode
        case 'NEW-MODE':
            mapManager('destroy').then( () => {
                mapManager('initialize', mode, level ).then( () => {
                    resolveMapGeneration();
                });
            })
        break;

        // last level finished
        case 'END':
            //
            // draw loading screen
            //
            mapManager('destroyScene').then( () => {
                //
                //outro();
                //
                resolveMapGeneration();
            });
        break;

        // player death
        case 'DEATH':
            // get sizes of map for level 0
            let { newX, newZ } = levelParam.levels[0].mapSize;
            if( mode !== 'arctic' )
                mapManager('destroy').then( () => {
                    // generate tiles for level 0
                    generateTiles(newX,newZ).then( () => {
                        resolveMapGeneration();
                    });
                    //( player will propably execute re-launch )
                });
            else {
                mapManager('clear').then( () => {
                    adjustMap(newX, newZ).then( () => {
                        resolveMapGeneration();
                    })
                });
            }
        break;

    }

/*    levelsPreSet[`${mode}`] = {
        skybox: skybox,             // mesh
        tile: tile,                 // mesh
        tileMeta: tileMeta,         // mesh
        enemySkins: enemySkins,     // array of meshes
        endAnimation: endAnimation, // AnimationClip from tileMeta
        terrainMisc: terrainMisc    // all visual stuff like big ice bergs, island, ship, snow/rain etc
    }
*/

    /*
        soo ARCTIC MODE creates new objects and position them
        ISLE MODE removes all arctic stuff (everything except water) and creates ISLE, replaces tile
        etc...

        IF terrainMisc exists then reposition it relativly to mapState.Xsize ELSE create relativly to mapState.Xsize

        SCENARIOS:
            FIRST launch:
            ( LAUNCH )
                mapManager('initialize',mode, level:0 ).then
                    generateTiles(Xsize,Zsize,mode).then
                        applyInitialStates(mode)
                ( ready to play )

            RE-launch after death:  (when game_logic.js:needsGameInit == false)
            ( RELAUNCH )
                applyInitialStates(mode)
                ( ready to play )

            NEW level, same mode
            ( NEW-LEVEL )
                IF mapSize changed
                    adjustMap(newX,newY);
                    ( ready to play )
                ELSE
                    mapManager('clear')
                    ( ready to play )

            NEW mode
            ( NEW-MODE )
                mapManager('destroy').then
                    mapManager('initialize',mode, level )
                ( ready to play )

            LAST level finished
            ( END )
                mapManager('destroyScene')
                outro()
                ( ready to play )

            PLAYER death
            ( DEATH )
                IF mode !== 'arctic'
                    mapManager('destroy').then
                        let { Xsize, Zsize } = { levelParam[0].Xsize, levelParam[0].Zsize };
                        generateTiles(Xsize,Zsize)
                    ( player will propably execute re-launch )
                    ( ready to play )
                ELSE
                    let {newX, newZ} = { levelParam[0].Xsize, levelParam[0].Zsize }
                    adjustMap(newX, newZ)
                    mapManager('clear')
                    ( ready to play )

    */
    });
}

// prepares map for new level
function mapManager(action=null,mode=null, level=null) {
    return new Promise( function(res,rej) {

    switch( action ) {
        case 'initialize':
            console.log('mapManager: init');
            // check if mode is already defined and his levels
            if( levelsPreSet[`${mode}`].initialized !== false ) {
                console.log('mapManager: that mode is already defined');
                // check skybox textureMode
                if( mode !== levelsPreSet[`${mode}`].skybox.userData.mapData.textureMode ) {
                    // dispatch old material, texutre, shader uniform
                    let {   disp_geometry,
                            disp_textureCube,
                            disp_cubeMat,
                            disp_cubeMatUniform } = levelsPreSet[`${mode}`].skybox.userData.dispatchMem;
                    disp_geometry.dispatch();
                    disp_textureCube.dispatch();
                    disp_cubeMatUniform.dispatch();
                    disp_cubeMat.dispatch();

                    // create new one
                    let r = `lib/textures/sky/${mode}/`;
                    let urls = [ r + "walls.jpg", r + "walls.jpg",
                                r + "posy.jpg", r + "negy.jpg",
                                r + "walls.jpg", r + "walls.jpg" ];
                    let textureCube = new CubeTextureLoader().load( urls );
                    textureCube.format = RGBFormat;
                    textureCube.mapping = CubeReflectionMapping;
                    textureCube.encoding = sRGBEncoding;
                    textureCube.flipY = false;
                    // ---
                    let cubeShader = ShaderLib[ 'cube' ];
                    let cubeMat = new ShaderMaterial( {
                        fragmentShader: cubeShader.fragmentShader,
                        vertexShader: cubeShader.vertexShader,
                        uniforms: cubeShader.uniforms,
                        depthWrite: false,
                        side: BackSide
                    } );
                    cubeMat.uniforms[ "tCube" ].value = textureCube;
                    Object.defineProperty( cubeMat, 'map', {
                        get: function () {
                            return this.uniforms.tCube.value;
                        }
                    } );

                    levelsPreSet[`${mode}`].skybox.material = cubeMat;
                }
                // check given level sizes to skybox, water, clouds
                let { levelXsize, levelZsize } = levelParam.levels[level].mapSize,
                    { textureMode, skyboxXsize, skyboxZsize } = levelsPreSet[`${mode}`].skybox.userData.mapData,
                    { waterXsize, waterZsize } = levelsPreSet[`${mode}`].water.userData.mapData;

                    //skybox
                if( (levelXsize !== skyboxXsize) || (levelZsize !== skyboxZsize) ) {
                    levelsPreSet[`${mode}`].skybox.scale.set(levelXsize * 5, 50, levelZsize * 6.25);
                }
                    //water
                if( (levelXsize !== waterXsize) || (levelZsize !== waterZsize) ) {
                    levelsPreSet[`${mode}`].skybox.scale.set(levelXsize * 5, 50, levelZsize * 6.25);
                }
                    //clouds
                /*
                     SHIT MISSING, not added yet
                     propably also RAIN / SNOW
                 */
                res();
            } else {    // is that else necessary???? levels.js already did that
                console.log('mapManager: defining new mode');
                //initializeLevels(mode).then( () => {
                let water = levelsPreSet[`${mode}`].water,
                    skybox = levelsPreSet[`${mode}`].skybox;
                skybox.position.set( mapState.worldOrigin.x, -0.05, mapState.worldOrigin.z );
                water.position.set( mapState.worldOrigin.x, -0.05, mapState.worldOrigin.z );
                gameScene.add(skybox);
                gameScene.add(water);
                console.log(skybox);
                console.log(water);
                /*
                         gameScene.add( clouds );
                         gameScene.add( rain/snow );
                         gameScene.add( MISC );
                */

                levelsPreSet[`${mode}`].initialized = true;
                res();
                //});
            }
        break;
    }
    /*
    SWITCH ( ACTION )
        initialize:                         [need Xsize and Zsize] - get from levelsPreSet[level].Xsize
            IF mapState.skybox !== null
                change skybox texture           based on levelsPreSet[level]
                reposition water, clouds        based on levelsPreSet[level]
            ELSE
                adds    skybox, water, clouds
                        to scene and posititon them objects from levelsPreSet
            BREAK;
        destroyScene:
            removes everything completly from scene and leaves it ready for outro or new game after death in isle/jungle mode
            leave only camera on scene and position it at (0,2,5)
            remember to dispatch ( or keep tileMeta, MISC loaded in background )
            BREAK;
        destroy:
            >REMOVE AND DISPATCH:
                tiles, tileMeta, all MISC from array: levelsPreSet obj:levels.js
                spawned: (enemy, bonus, fish)

            >DONT REMOVE:
                water, clouds, skybox[needs texture update], player and placeholders(enemy,bonus,fish)
            BREAK;
        clear:
            destroy enemy using method from enemy class
            destroy all remained fishes and bonusBoxes
            heal all tiles which are (tile.userData.tileDecayed == false)
        null:
            THROW NEW ERROR('WTF U DOING');


        PRIORITIES:
            0:  water
                skybox
                clouds
                Player

            1:  tiles
                tileMeta
                MISC

            2:  fish
                bonus
                Enemy
    */

    });
}

function applyInitialStates(mode='arctic') {
    return new Promise( function(res,rej) {
        console.log('Initial values applied?');
    /*
        from levels.js apply:
            add MISC shit
            respawn enemies,
            spawn first fish based on game_logic.js:gameState.level
            renew all old tiles,
            decay on tiles,
            position player at respawn point and player.respawn()
    */
    let current_level = levelParam.modeInfo[`${mode}`];
    let Xsize = levelParam.levels[current_level].mapSize.x,
        Zsize = levelParam.levels[current_level].mapSize.z;
    // MISC SHIT
    levelsPreSet[`${mode}`].terrainMisc.forEach( item => {
        let _loc = {
                x: eval(item.userData.desiredPosition.x),
                y: eval(item.userData.desiredPosition.y),
                z: eval(item.userData.desiredPosition.z)
            },
            _scale;
        if( item.userData.desiredScale ) {
            _scale = {
                x: eval(item.userData.desiredScale.x),
                y: eval(item.userData.desiredScale.y),
                z: eval(item.userData.desiredScale.z)
            }
        } else {
            _scale = {
                x: 1,
                y: 1,
                z: 1
            }
        }
        item.position.set( _loc.x, _loc.y, _loc.z );
        item.scale.set( _scale.x, _scale.y, _scale.z );
        gameScene.add( item );
    });

    res();
    })
}

// creates Interval
function tileEleminator( action='stop', delay=-1 ) {
    let _freq = levelParam.levels[ mapState.level ].tileDecay.freq;

    if(action=='stop'){
        tileElemination = false;
    // else start if level fail isnt 100%
    } else if( _freq.fail !== 100 ) {
        let _randTile = Math.floor(Math.random() * (tileBox.length - 1)) + 1;
        // if first execution
        if( delay !== -1 ){
            let _firstDelay = Math.floor(Math.random() * (_freq.to - _freq.from)) + _freq.from;
            setTimeout( () => {
                tileSwitchState( _randTile, _freq );
            }, _firstDelay);
        } else {
            setTimeout( () => {
                tileSwitchState( _randTile, _freq );
            }, delay);
        }
    }
}
function tileSwitchState( tileID, freq ){
    let _newDelay = Math.floor(Math.random() * (freq.to - freq.from)) + freq.from,
        _chance = Math.floor(Math.random() * 100);

    console.log( 'TILE CHECK' );
    console.log( `tileID: ${tileID}, tileBoxLen: ${tileBox.length}, tileActLen: ${tileActionBox.length}`);

    if( _chance <= (100 - freq.fail) ) {
        // get duration for tile
        let _durStep = levelParam.levels[ mapState.level ].tileDecay.durStep;
        let _step = Math.floor(Math.random() * (_durStep.to - _durStep.from)) + _durStep.from;
        let action;
        // check state and execute heal / decay on that
        if( effects[ tileID ].decayed ) {
            action = new CreateTileAction( 'heal', _step, tileID );
        } else {
            action = new CreateTileAction( 'decay', _step, tileID );
        }

        tileActionBox.push( action );
    };

    tileEleminator( 'continue', _newDelay );
}

// problemem były pozostałości po starych zmiennych z tileActionBox. Powstrzymaj rozrost arr tileActionBox...ehh
// rozwiązanie: 2 listy naprzemian czyszczące się gdy przekroczą swoją wielkość

class CreateTileAction {
    act_tileID = tileActionBox.length;
    tileID = null;
    animFunc = null;
    durStep = null;
    tile = null;
    duration = 64;
    i=1;
    stateValue=1;

    constructor( action='heal', step, tileID ) {
        this.tileID = tileID;
        this.durStep = step;
        this.tile = tileBox[tileID];

        if( action == 'decay' ) {
            console.log( ' DECAY ' );
            this.tile.userData.tileData.inProgress = 'decay';
            this.animFunc = ( step, ID, localID ) => {
                if( this.i > this.duration * step ) {

                    // update effects[]
                    effects[ID].state = true;
                    effects[ID].func = {
                        p1: localPlayers[0].death,
                        p2: (localPlayers[1]) ? localPlayers[0].death : null,
                    }
                    effects[ID].decayed = true;

                    this.i=1;
                    tileActionBox[localID] = null;
                    this.tile.userData.tileData.inProgress = null;
                } else if( this.i%step == 0 ) {
                    // ???
                    this.stateValue = (this.stateValue - 1/(this.duration-1)).toFixed(2);
                    let _sc = this.stateValue;
                    this.tile.scale.set(_sc,1,_sc);
                    console.log( `stateVal: ${this.stateValue}, i: ${this.i}, step: ${step}, i/step: ${this.i/step}` );
                }
                this.i++;
            }
        } else {
            this.tile.userData.tileData.inProgress = 'heal';
            console.log( ' HEAL ' );
            this.animFunc = ( step, ID, localID ) => {
                if( this.i > this.duration * step ) {

                    // update effects[]
                    effects[ID].state = false;
                    effects[ID].func = null;
                    effects[ID].decayed = false;

                    this.i=1;
                    tileActionBox[localID] = null;
                    this.tile.userData.tileData.inProgress = null;
                } else if( this.i%step == 0 ) {
                    // state = state - ( state / ( i / step ) )
                    this.stateValue = (1 / (this.i/step)).toFixed(2);
                    let _sc = this.stateValue;
                    this.tile.scale.set(_sc,1,_sc);
                }
                this.i++;
            }
        }
    }
}
/*
// function which will be used in game_logic.js to operate on tiles elimination in given freq
function tileCreateAction( action='heal', step, tileID ) {
    this.act_tileID = tileActionBox.length;
    this.tileID = tileID;
    this.animFunc = null;
    this.durStep = step;

    this.tile = tileBox[this.tileID];
    // LVL INFO:
    // levelParam.levles[mapState.level].tileDecay
    /*      !   freq: { from: 0, to: 0, fail: 100 },
                durStep: { from: 0, to: 0 },
            !   alreadyDecayed: 0
    */


 /*
                WARTOŚĆ i jest wykorzystywana przez wszystkie działajace funkcje w danym momencie. Wiele funkcji jedna wartosc i... xd
     NIE MAM PEWNOŚCI CO TYCH ANIMACJI \/
*/
 /*   // duration ACTS LIKE STEPS in which animation will end
    this.duration = 64 ;
    if( action == 'decay' ) {
        console.log( ' DECAY ' );
        this.tile.userData.tileData.inProgress = 'decay';
        this.animFunc = ( step, ID, localID ) => {
            if( this.i > this.duration * step ) {

                // update effects[]
                effects[ID].state = true;
                effects[ID].func = {
                    p1: localPlayers[0].death,
                    p2: (localPlayers[1]) ? localPlayers[0].death : null,
                }
                effects[ID].decayed = true;

                this.i=1;
                tileActionBox.splice( localID ,1 );
                this.tile.userData.tileData.inProgress = null;
            } else if( this.i%step == 0 ) {
                // state = state - ( state / ( i / step ) )
                this.stateValue = (this.stateValue - 1/(this.duration-1)).toFixed(2);
                let _sc = this.stateValue;
                this.tile.scale.set(_sc,1,_sc);
                console.log( `stateVal: ${this.stateValue}, i: ${this.i}, step: ${step}, i/step: ${this.i/step}` );
            }
            this.i++;
        }
    } else {
        this.tile.userData.tileData.inProgress = 'heal';
        console.log( ' HEAL ' );
        func.animFunc = ( step, ID, localID ) => {
            if( this.i > this.duration * step ) {

                // update effects[]
                effects[ID].state = false;
                effects[ID].func = null;
                effects[ID].decayed = false;

                this.i=1;
                tileActionBox.splice( localID ,1 );
                this.tile.userData.tileData.inProgress = null;
            } else if( this.i%step == 0 ) {
                // state = state - ( state / ( i / step ) )
                this.stateValue = (1 / (this.i/step)).toFixed(2);
                let _sc = this.stateValue;
                this.tile.scale.set(_sc,1,_sc);
            }
            this.i++;
        }
    }
}*/


    /* COMMON RULES

        MAPA ZACZYNA SIE logicznie OD X:1, Z:1
        KAŻDA logiczna POZYCJA KRY X i Z przekłada się na FIZYCZNIE odbity -X i Z+1

        pozycja META będzie odpowiadać proporcjonalnie dla wielkości mapy
            Z będzie stałe, czyli Z: 2
            X będzie się zaczynać na 3 gdy Xsize=(6,10) a dalej proporcjonalnie:
                formułka dla X: IF X > 10 => Math.ceil((x/10.8).toFixed(2) * 3) ELSE X = 3
            Pozycja obiektu META to metaX + 0.5
            Obiekt META będzie się znajdować na metaX i metaX+1 na Z:2

        pozycja RESPAWN graczy relatywna do pozycji META
            Z będzie stałe, czyli Z: 6
            X będzie to
                DLA P1: (metaX + 1) + 1     [lewa granica mety + odstęp 1]
                DLA P2: metaX - 1           [prawa granica mety - odstep 1]

    */