diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..9d6087a
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,11 @@
+
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+[*.{js,hjson}]
+charset = utf-8
+indent_style = space
+indent_size = 4
diff --git a/README.md b/README.md
index fb54bec..1ca725a 100644
--- a/README.md
+++ b/README.md
@@ -36,8 +36,6 @@ marked with a ⬆, that is used for jumping.
 
 *The following things can crash your game.*
 
-- Toggling parkour mode in a flying unit
-
 - Falling into the void / outside the map
 
 <br>
diff --git a/mod.hjson b/mod.hjson
index ce468b5..03dd533 100644
--- a/mod.hjson
+++ b/mod.hjson
@@ -1,9 +1,21 @@
-name: "parkour-mod"
-displayName: "[orange]Parkour[] mod"
-author: "Benry/Deftry"
-description: "This mod adds some new movement mechanics, gravity and jump to player. WIP, report all bugs to Benry#5935"
-version: "2.5"
-minGameVersion: "136"
-dependencies: []
-repo: "Def-Try/parkour-mod"
-hidden: true
+{
+    displayName : "[orange]Parkour[] mod"
+    author : Benry/Deftry
+    repo : Def-Try/parkour-mod
+    name : parkour-mod
+
+
+    description:
+        '''
+        
+        This mod adds some new movement mechanics, gravity and jump to player.
+        
+        WIP, report all bugs to Benry#5935
+        
+        '''
+    
+    minGameVersion : 136
+    version :  2.5
+    
+    hidden : true
+}
diff --git a/scripts/Debug.js b/scripts/Debug.js
new file mode 100644
index 0000000..75b15aa
--- /dev/null
+++ b/scripts/Debug.js
@@ -0,0 +1,2 @@
+
+module.exports = true;
diff --git a/scripts/Gravity.js b/scripts/Gravity.js
new file mode 100644
index 0000000..7c324c1
--- /dev/null
+++ b/scripts/Gravity.js
@@ -0,0 +1,31 @@
+
+module.exports = (() => {
+    
+    const { access } = require('JS');
+    
+
+    /*
+     *  0 : →
+     *  1 : ←
+     *  2 : ↑
+     *  3 : ↓
+     */
+
+    let 
+        direction = 3 ,
+        strength = .5 ;
+
+
+    const Gravity = {};
+
+    access(Gravity,{
+        direction : () => direction ,
+        strength : () => strength
+    },{
+        direction : (value) => direction = value,
+        strength : (value) => strength = value
+    });
+    
+    return Gravity;
+    
+})();
diff --git a/scripts/Interface.js b/scripts/Interface.js
new file mode 100644
index 0000000..f429ed8
--- /dev/null
+++ b/scripts/Interface.js
@@ -0,0 +1,116 @@
+
+module.exports = (() => {
+    
+    const { button , table } = require('UI');
+    const { log , object } = require('Logger');
+    
+    const Player = require('Player');
+    const Debug = require('Debug');
+    const Mod = require('Mod');
+    
+    
+    Mod.onToggle(updateEnableButton);
+    
+    
+    const onMobile = 
+        Vars.mobile || Debug;
+        
+    let 
+        button_enable ,
+        label_stamina ;
+    
+    
+    function build(){
+
+        log('Building UI');
+
+        buildMainMenu();
+        buildSubMenu();
+        buildStaminaMenu();
+    }
+
+    function buildMainMenu(){
+        
+        const menu = table();
+        menu.y = 75;
+        
+        button_enable = button({
+            menu : menu ,
+            name : 'Enable Parkour Mode' ,
+            click : Mod.toggle
+        });
+    }
+
+    function buildSubMenu(){
+        
+        const menu = table();
+        menu.visibility = () => Mod.enabled;
+        
+        button({
+            menu : menu ,
+            name : 'Change Mode' ,
+            click : Mod.toggleMode
+        });
+
+        if(onMobile)
+            button({
+                menu : menu ,
+                name : 'Jump' ,
+                click : Player.jump
+            });
+            
+        button({
+            menu : menu ,
+            name : 'Hold' ,
+            click : Player.toggleHold
+        });
+    }
+
+
+    function buildStaminaMenu(){
+        
+        log('Builing Stamina Menu')
+        
+        const menu_stamina = new Table()
+            .left()
+            .bottom();
+            
+        menu_stamina.visibility = () => Mod.enabled;
+        menu_stamina.y = 400;
+        
+        label_stamina = Label('');
+        label_stamina.setStyle(Styles.outlineLabel);
+        
+        menu_stamina.add(label_stamina)
+        .size(150,75)
+        .padLeft(6);
+            
+        Vars.ui.hudGroup.addChild(menu_stamina);
+    }
+    
+    
+    function updateEnableButton(){
+        
+        const action = (Mod.enabled)
+            ? 'Disable' 
+            : 'Enable' ;
+        
+        button_enable.setText(action + 'Parkour Mode');
+    }
+    
+    function updateStamina(){
+        
+        const percent = Math.round(Player.stamina / 100);
+        
+        label_stamina.setText('Stamina: ' + percent + '%');
+    }
+
+
+    return {
+        updateEnableButton : updateEnableButton ,
+        updateStamina : updateStamina ,
+        build : build ,
+        test : 1
+    }
+
+})();
diff --git a/scripts/JS.js b/scripts/JS.js
new file mode 100644
index 0000000..c0cde46
--- /dev/null
+++ b/scripts/JS.js
@@ -0,0 +1,28 @@
+
+
+module.exports = (() => {
+
+    function get(object,getters){
+        
+        for(let name in getters)
+            object.__defineGetter__(name,getters[name]);
+    }
+    
+    function set(object,setters){
+    
+        for(let name in setters)
+            object.__defineSetter__(name,setters[name]);
+    }
+    
+    function access(object,getters,setters){
+        get(object,getters);
+        set(object,setters);
+    }
+    
+    
+    return {
+        access : access ,
+        get : get ,
+        set : set
+    };
+})();
diff --git a/scripts/Jump.js b/scripts/Jump.js
new file mode 100644
index 0000000..19007ce
--- /dev/null
+++ b/scripts/Jump.js
@@ -0,0 +1,30 @@
+
+(() => {
+    
+    const { debug } = require('Logger');
+    const Gravity = require('Gravity');
+    
+    
+    const offsets = [
+        [ -1 ,  0 ] ,
+        [  0 , -1 ] ,
+        [ +1 ,  0 ] ,
+        [  0 , +1 ]
+    ]
+
+    function jump(unit,velocity){
+        
+        debug('Jumped:',velocity);
+        
+        const offset = offsets[Gravity.direction];
+        
+        unit.vel.add(
+            velocity * offset[0] ,
+            velocity * offset[1]
+        );
+    }
+    
+    
+    exports.jump = jump;
+
+})();
diff --git a/scripts/Logger.js b/scripts/Logger.js
new file mode 100644
index 0000000..a830d49
--- /dev/null
+++ b/scripts/Logger.js
@@ -0,0 +1,94 @@
+
+(() => {
+    
+    const Debug = require('Debug');
+    
+    
+    function exception(error){
+        Log.err(
+            '[  Ｐａｒｋｏｕｒ　Ｍｏｄ  ]\n\n' + 
+            error.message + 
+            '\n\n' + 
+            error.stack + 
+            '\n'
+        );
+    }
+
+
+    function parse(values){
+        
+        let value;
+
+        while(!(value = values.pop()))
+            continue;
+
+        values.push(value); 
+        
+        return values.join(' ');
+    }
+
+    function debug(a,b,c,d,e,f){
+        debugText(parse([ a , b , c , d , e , f ]));
+    }
+
+    function log(a,b,c,d,e,f){
+        logText(parse([ a , b , c , d , e , f ]));
+    }
+    
+    function debugText(text){
+        print('[#dfb317] Parkour  [#DDDDDD]' + text);
+    }
+    
+    function logText(text){
+        print('[#1e8cbe] Parkour  [#DDDDDD]' + text);
+    }
+
+    function print(text){
+        Log.log(Log.LogLevel.none,text);
+    }
+
+
+
+    function valueToString(key,value,depth){
+        
+        switch(typeof value){
+        default:
+            return 'Unknown Type : ' + typeof value;
+        case 'undefined':
+        case 'string':
+        case 'number':
+            return key + ' : ' + value;
+        case 'object':
+            return layer(value,depth - 1);
+        case 'array':
+            return value.join(' : ');
+        case 'function':
+            return key + '()';
+        }
+    }
+
+    function layer(object,depth,string){
+        
+        string = string || '{';
+        
+        if(depth > 0)
+            for(let key in object)
+                string += '\n' + valueToString(key,object[key],depth);
+            
+        return string + '}';
+    }
+
+    function object(object,depth){
+        return layer(object,depth || 1);
+    }
+
+
+    exports.exception = exception;
+    exports.object = object;
+    exports.log = log;
+    
+    exports.debug = Debug 
+        ? debug 
+        : () => {};
+    
+})();
diff --git a/scripts/Math.js b/scripts/Math.js
new file mode 100644
index 0000000..218386c
--- /dev/null
+++ b/scripts/Math.js
@@ -0,0 +1,18 @@
+
+(() => {
+    
+    const square = (value) =>
+        value * value;
+    
+    function delta(ax,ay,bx,by){
+        return Math.sqrt(
+            square(ax + bx) +
+            square(ay + by)
+        );
+    }
+    
+    
+    exports.square = square;
+    exports.delta = delta;
+
+})();
diff --git a/scripts/Mod.js b/scripts/Mod.js
new file mode 100644
index 0000000..6d7849e
--- /dev/null
+++ b/scripts/Mod.js
@@ -0,0 +1,96 @@
+
+module.exports = (() => {
+    
+    const { log , object } = require('Logger');
+    const Player = require('Player');
+
+
+    /*
+     *  Gravity
+     *  0 : Downwards
+     *  1 : Central 
+     */
+
+    let mode = 0;
+    
+    let enabled = false;
+    const listeners_onToggle = new Set;
+    
+
+    function inParkour(){
+        return mode === 0;
+    }
+    
+    function onPlanet(){
+        return mode === 1;
+    }
+    
+    function toggle(){
+
+        const unit = Player.unit();
+        
+        if(!unit || unit.type.flying){
+            Vars.ui.announce('You cannot use parkour mode inside of a flying unit.');
+            return;
+        }
+        
+        enabled = ! enabled;
+
+        listeners_onToggle.forEach((listener) => listener());
+    }
+    
+    function toggleMode(){
+        
+        if(onPlanet())
+            return parkour();
+        
+        Vars.ui.showCustomConfirm(
+            'IN DEVELOPMENT!' ,
+            'You trying to select [accent]Planet[] mode, but it is still buggy and in very development.' ,
+            'Turn this thing on!' ,
+            'Back' ,
+            planet,
+            () => {}
+        );
+    }
+    
+    function parkour(){
+        mode = 0;
+        Vars.ui.announce('Parkour Mode');
+    }
+    
+    function planet(){
+        mode = 1;
+        Vars.ui.announce('Planet mode');
+    }
+    
+    
+    function onToggle(listener){
+        listeners_onToggle.add(listener);
+    }
+    
+    function downwardGravity(){
+        return mode === 0;
+    }
+
+
+    const Mod = {
+        toggleMode : toggleMode ,
+        inParkour : inParkour ,
+        onPlanet : onPlanet ,
+        parkour : parkour ,
+        toggle : toggle ,
+        planet : planet ,
+        onToggle : onToggle ,
+        downwardGravity : downwardGravity
+    }
+    
+    Mod.__defineGetter__('mode',() => mode);
+    Mod.__defineGetter__('enabled',() => enabled);
+    
+    Mod.__defineSetter__('mode',(value) => mode = value);
+    Mod.__defineSetter__('enabled',(value) => enabled = value);
+    
+    return Mod;
+    
+})();
diff --git a/scripts/Player.js b/scripts/Player.js
new file mode 100644
index 0000000..639c019
--- /dev/null
+++ b/scripts/Player.js
@@ -0,0 +1,91 @@
+
+module.exports = (() => {
+    
+    const { access } = require('JS');
+    const { debug } = require('Logger');
+    const Jump = require('Jump');
+
+
+    let
+        bjumpvel = 15 ,
+        ajumpvel = 0 ,
+        holding = false ,
+        onfloor = false , 
+        stamina = 10000 ;
+        
+    let x , y ;
+
+        
+    function toggleHold(){
+        
+        debug('Holding:',holding);
+        
+        holding = ! holding;
+    }
+    
+    function jump(){
+        
+        debug('Pressed Jump')
+        
+        if(stamina < 100)
+            return;
+            
+        if(!onfloor)
+            return;
+        
+        Jump.jump(unit(),bjumpvel + ajumpvel); 
+
+        stamina -= 100;
+    }
+    
+    function unit(){
+        return Vars.player.unit();
+    }
+    
+    function hasStamina(){
+        return stamina > 99;
+    }
+    
+    function updatePosition(){
+        
+        const player = unit();
+        
+        x = player.tileX();
+        y = player.tileY();
+    }
+
+    function canParkour(){
+
+        const player = unit();
+
+        return player && ! player.type.flying;
+    }
+
+
+    const Player = {
+        updatePosition : updatePosition ,
+        hasStamina : hasStamina ,
+        toggleHold : toggleHold ,
+        canParkour : canParkour ,
+        unit : unit ,
+        jump : jump
+    }
+    
+    access(Player,{
+        bjumpvel : () => bjumpvel ,
+        ajumpvel : () => ajumpvel ,
+        holding : () => holding ,
+        onfloor : () => onfloor ,
+        stamina : () => stamina
+    },{
+        bjumpvel : (value) => bjumpvel = value ,
+        ajumpvel : (value) => ajumpvel = value ,
+        holding : (value) => holding = value ,
+        onfloor : (value) => onfloor = value ,
+        stamina : (value) => stamina = value
+    })
+    
+    
+    return Player;
+    
+})();
diff --git a/scripts/Tile.js b/scripts/Tile.js
new file mode 100644
index 0000000..75dd075
--- /dev/null
+++ b/scripts/Tile.js
@@ -0,0 +1,26 @@
+
+
+(() => {
+    
+    function tileAt(x,y){
+        return Vars.world.tile(x,y) || false;
+    }
+
+    function blockAt(x,y){
+        
+        const block = tileAt(x,y);
+
+        return (block && block.type != Blocks.air)
+            ? block : false ;
+    }
+
+    function tileIs(x,y,type){
+        return tileAt(x,y) == type;
+    }
+
+
+    exports.blockAt = blockAt;
+    exports.tileAt = tileAt;
+    exports.tileIs = tileIs;
+    
+})();
diff --git a/scripts/UI.js b/scripts/UI.js
new file mode 100644
index 0000000..2b1b8a9
--- /dev/null
+++ b/scripts/UI.js
@@ -0,0 +1,35 @@
+
+(() => {
+    
+    function table(){
+        
+        const table = new Table()
+            .bottom()
+            .left();
+            
+        Vars.ui.hudGroup.addChild(table);
+        
+        return table;
+    }
+
+    function button(options){
+        
+        const { menu , name , click } = options;
+        
+        const button = TextButton(name);
+        
+        menu
+        .add(button)
+        .size(150,75)
+        .padLeft(6);
+        
+        button.clicked(click);
+        
+        return button;
+    }
+
+
+    exports.button = button;
+    exports.table = table;
+    
+})();
diff --git a/scripts/main.js b/scripts/main.js
index 902c222..6bab070 100644
--- a/scripts/main.js
+++ b/scripts/main.js
@@ -1,479 +1,383 @@
-//by Deftry, ADI and TheEE
-
-let indev = true;
-let basebuttonw = 150
-let basebuttonh = basebuttonw / 2
-
-
-Log.info("Started loading of parkour mechanics");
-Log.info("Loading ui elements");
-
-Events.on(ClientLoadEvent, () => {
-
-    // ebtn
-    // cbtn jbtn hbtn
-    var table = new Table().bottom().left();
-    var tablem = new Table().bottom().left();
-    let hbtn = TextButton("Hold");
-    let ebtn = TextButton("Enable Parkour Mode");
-    tablem.y = basebuttonh
-    let cbtn = TextButton("Change Mode");
-    
-    tablem.add(ebtn).size(basebuttonw, basebuttonh).padLeft(6);
-    ebtn.clicked(() => {
-        lock = !lock;
-        ebtn.setText(!lock ? "Disable Parkour mod" : "Enable parkour mod");
-    });
-    table.add(cbtn).size(basebuttonw, basebuttonh).padLeft(6);
-    cbtn.clicked(() => {
-        if(mode) {
-            mode=0; 
-            Vars.ui.announce("Parkour mode")
-        } else {
-            Vars.ui.showCustomConfirm("IN DEVELOPMENT!", "You trying to select [accent]Planet[] mode, but it is still buggy and in very development.", "Turn this thing on!", "Back", () => {
-                mode=1; Vars.ui.announce("Planet mode");
-            }, () => {
-                mode=0; Vars.ui.announce("Parkour mode");
-            });
-        };
-    });
-
-    if (Vars.mobile || indev) { 
-        let jbtn = TextButton("Jump");
-        table.add(jbtn).size(basebuttonw, basebuttonh).padLeft(6);
-        
-        jbtn.clicked(() => {
-            if((stamina > 99) && onfloor) { 
-                jump(bjumpvel + ajumpvel); 
-                stamina -= 100; 
-            };
-        });
-    };
-
-    table.add(hbtn).size(basebuttonw, basebuttonh).padLeft(6);
-    hbtn.clicked(() => { 
-        holding = !holding;
-    });
-
-    
-    table.visibility = () => {
-        return !lock;
-
-        /*
-            if (!lock) {
-                return true
-            };
-        
-            return false;    
-        */
-        // то что в коменте выше кринж
-    };
-
-    Vars.ui.hudGroup.addChild(tablem);
-    Vars.ui.hudGroup.addChild(table);
-});
-
-Log.info("Loading variables");
-
-let gravity = .5; // скорость гравитации
-let bjumpvel = 15; // скорость прыжка
-let ajumpvel = 0; // доп. скорость прыжка
-let direction = 0; // 0 - Y, 1 - X
-let lock = true; // системная блокировка
-let stamina = 10000; // выносливость
-let onfloor = false; 
-let gravdirect = 3;
-let hold = false;
-let lastx;
-let lasty;
-let ltilex;
-let ltiley;
-let unit;
-let mode = 0; // 0 - обычный, 1 - центр тяжести
-let holding = false;
-
-Log.info("Loading main content");
-
-let getBlock = (x, y) => {
-    var block = Vars.world.tile(x, y);
-    if(block != null && block.block() != Blocks.air) {
-        return block.block();
-    } else {
-        return false;
-    };
-};
-
-let getTile = (x, y) => {
-    var block = Vars.world.tile(x, y);
-    if(block != null) {
-        return block;
-    } else { 
-        return false;
-    };
-};
-
-let setGravity = (grav) => {
-    gravity = grav; 
-    jump = -grav * 10
-};
-
-let updateHud = () => {
-    Vars.ui.showInfoToast("Stamina:" + stamina / 100 + "%", .04);
-};
-
-//region util functions
-
-let getBlockBot = () => {
-    switch(gravdirect) {
-        case 0: {
-            return Vars.world.tile(lastx + 1, lasty).block();
-        };
-
-        case 1: {
-            return Vars.world.tile(lastx, lasty + 1).block();
-        };
-
-        case 2: {
-            return Vars.world.tile(lastx - 1, lasty).block();
-        };
-
-        case 3: {
-            return Vars.world.tile(lastx, lasty - 1).block();
-        };
-    };
-
-    //if(gravdirect==0){return Vars.world.tile(lastx+1, lasty).block()}
-    //if(gravdirect==1){return Vars.world.tile(lastx, lasty+1).block()}
-    //if(gravdirect==2){return Vars.world.tile(lastx-1, lasty).block()}
-    //if(gravdirect==3){return Vars.world.tile(lastx, lasty-1).block()}
-    //очень тупо и ненормально
-};
-
-let updateFloor = () => { 
-    if(gravdirect == 0) {
-        if(getBlock(lastx + 1, lasty).solid) { 
-            if(stamina < 10000) {
-                stamina += 100
-            } else {
-                stamina=10000
-            }; 
-            
-            onfloor = true; 
-            ltilex = lastx; 
-            ltiley = lasty;
-        } else{ 
-            onfloor = false;
-        };
-    } else { 
-        if(gravdirect == 2) {
-            if(getBlock(lastx - 1, lasty).solid) { 
-                if(stamina < 10000) {
-                    stamina += 100;
-                } else {
-                    stamina = 10000
-                }; 
-                
-                onfloor = true; 
-                ltilex = lastx; 
-                ltiley = lasty;
-            } else {
-                onfloor = false;
-            };
-        } else {
-            if(gravdirect == 1) {
-                if(getBlock(lastx, lasty + 1).solid) { 
-                    if(stamina < 10000) {
-                        stamina += 100
-                    } else { 
-                        stamina=10000
-                    }; 
-                    
-                    onfloor = true; 
-                    ltilex = lastx; 
-                    ltiley = lasty;
-                } else{ 
-                    onfloor=false;
-                };
-            } else {
-                if(getBlock(lastx, lasty - 1).solid) { 
-                    if(stamina < 10000) {
-                        stamina += 100
-                    } else { 
-                        stamina = 10000;
-                    }; 
-                    
-                    onfloor = true; 
-                    ltilex = lastx; 
-                    ltiley = lasty;
-                } else{
-                    onfloor=false;
-                };
-            };
-        };
-    };
-};
-
-let updateGravity = () => {
-    if(gravdirect == 0) {
-        unit.vel.add(gravity, 0);
-    };
-
-    if(gravdirect == 1) {
-        unit.vel.add(0, gravity);
-    };
-
-    if(gravdirect == 2) {
-        unit.vel.add(-gravity, 0);
-    };
-
-    if(gravdirect == 3) {
-        unit.vel.add(0, -gravity);
-    };
-}
-
-let jump = (vel) => {
-    if(gravdirect == 0) {
-        unit.vel.add(-vel, 0);
-    };
-    
-    if(gravdirect == 1) {
-        unit.vel.add(0, -vel);
-    };
-
-    if(gravdirect == 2) {
-        unit.vel.add(vel, 0);
-    };
-
-    if(gravdirect == 3) {
-        unit.vel.add(0, vel);
-    };
-};
-
-//endregion
-//region mechanics
-let gravipad = (unit) => {
-    lastx = unit.tileX();
-    lasty = unit.tileY();
-
-    if(getBlock(lastx, lasty) == Blocks.conveyor) { // гравипад
-        //может gravdirect = getTile(lastx, lasty).build.rotation;
-        if(getTile(lastx, lasty).build.rotation == 0) { // гравитация вправо
-            gravdirect = 0;
-        } else {
-            if(getTile(lastx, lasty).build.rotation == 1) { // гравитация вверх
-                gravdirect = 1;
-            } else {
-                if(getTile(lastx, lasty).build.rotation == 2) { // гравитация влево
-                    gravdirect = 2;
-                } else {
-                    if(getTile(lastx, lasty).build.rotation == 3) { // гравитация вниз
-                        gravdirect = 3;
-                    };
-                };
-            };
-        };
-    };
-};
-
-let gravityCenter = (unit) => {
-    let coordinates = [];
-    let distances = [];
-    let nolock = false;
-
-    if(!onfloor && !hold){
-        for(let y = -15; y < 16; y++) {
-            for(let i = -15; i < 16; i++) {
-                if(getBlock(lastx+i, lasty + y) == Blocks.thoriumWall) {
-                    coordinates.push({
-                        x: i, 
-                        y: y
-                    });
-
-                    nolock = true;
-                };
-            };
-        };
-
-        if(nolock) {
-            for(let j = 0; j < coordinates.length; j++) {
-                var dist = Math.sqrt(((lastx + coordinates[j].x - lastx) ^ 2) + ((lasty + coordinates[j].y - lasty) ^ 2));
-                distances.push( dist );
-            };
-
-            let mini = 0;
-            for(let j = 0; j < distances.length; j++){
-                if(distances[j] < distances[mini]) {
-                    mini = j;
-                };
-            };
-
-            if (coordinates[mini].x < 0 && gravdirect != 3 && gravdirect != 1) { 
-                unit.vel.add(-gravity, 0); 
-                gravdirect = 2;
-            };
-
-            if (coordinates[mini].x > 0 && gravdirect != 3 && gravdirect != 1) { 
-                unit.vel.add(gravity, 0); 
-                gravdirect = 0;
-            };
-            
-            if (coordinates[mini].y < 0 && gravdirect != 2 && gravdirect != 0) { 
-                unit.vel.add(0, -gravity); 
-                gravdirect = 3;
-            };
-
-            if (coordinates[mini].y > 0 && gravdirect != 2 && gravdirect != 0) { 
-                unit.vel.add(0, gravity); 
-                gravdirect = 1;
-            };
-        };
-    };
-};
-
-//Я ЭТО МЕНЯТЬ НЕ БУДУ, Я УВОЛЬНЯЮСЬ
-var gelJump = (unit) => {
-    lastx = unit.tileX();
-    lasty = unit.tileY();
-    if(getBlockBot()==Blocks.titaniumWall){
-        if(gravdirect == 0 || gravdirect == 2){
-            if(ltilex == lastx){
-                ajumpvel = 15;
-            }else{
-                override = false;
-                ajumpvel = 0;
-                jump(bjumpvel+15);
-            }
-        }else{
-            if(ltiley == lasty){
-                ajumpvel = 15;
-            }else{
-                ajumpvel = 0;
-                jump(bjumpvel+15);
-            }
-        }
-    }else{ajumpvel = 0;}
-}
-var gelStick = (unit) => {
-    lastx = unit.tileX();
-    lasty = unit.tileY();
-    if(getBlock(lastx+1, lasty)==Blocks.plastaniumWall){
-        hold = true;
-        if(Core.input.keyTap(Binding.pause) && stamina > 99){unit.vel.add(-15, 0);}
-    }else if(getBlock(lastx-1, lasty)==Blocks.plastaniumWall){
-        hold = true;
-        if(Core.input.keyTap(Binding.pause) && stamina > 99){unit.vel.add(15, 0);}
-    }else if(getBlock(lastx, lasty+1)==Blocks.plastaniumWall){
-        hold = true;
-        if(Core.input.keyTap(Binding.pause) && stamina > 99){unit.vel.add(0, -15);}
-    }else if(getBlock(lastx, lasty-1)==Blocks.plastaniumWall){
-        hold = true;
-        if(Core.input.keyTap(Binding.pause) && stamina > 99){unit.vel.add(0, 15);}
-    }else if(getBlock(lastx-1, lasty-1)==Blocks.plastaniumWall){
-        hold = true;
-        if(Core.input.keyTap(Binding.pause) && stamina > 99){unit.vel.add(15, 15);}
-    }else if(getBlock(lastx+1, lasty-1)==Blocks.plastaniumWall){
-        hold = true;
-        if(Core.input.keyTap(Binding.pause) && stamina > 99){unit.vel.add(-15, 15);}
-    }else if(getBlock(lastx+1, lasty+1)==Blocks.plastaniumWall){
-        hold = true;
-        if(Core.input.keyTap(Binding.pause) && stamina > 99){unit.vel.add(-15, -15);}
-    }else if(getBlock(lastx-1, lasty+1)==Blocks.plastaniumWall){
-        hold = true;
-        if(Core.input.keyTap(Binding.pause) && stamina > 99){unit.vel.add(15, -15);}
-    }
-}
-var wallHolding = () => {
-    if (holding) {
-        if(stamina>99){
-            if(getBlock(lastx+1, lasty)!=false){
-                hold = true;
-                stamina -= 10;
-            }else if(getBlock(lastx-1, lasty)!=false){
-                hold = true;
-                stamina -= 10;
-            }else if(getBlock(lastx, lasty+1)!=false){
-                hold = true;
-                stamina -= 10;
-            }else if(getBlock(lastx, lasty-1)!=false){
-                hold = true;
-                stamina -= 10;
-            }
-        }else{
-            hold = false;
-        }
-    }
-}
-var graviFunnel = (unit) => {
-    lastx = unit.tileX();
-    lasty = unit.tileY();
-    if(getBlock(lastx, lasty)==Blocks.pulseConduit){ // грави воронка
-        hold = true;
-        if(getTile(lastx, lasty).build.rotation==0){
-            unit.vel.add(.55, 0);
-        }else if(getTile(lastx, lasty).build.rotation==1){
-            unit.vel.add(0, .55);
-        }else if(getTile(lastx, lasty).build.rotation==2){
-            unit.vel.add(-.55, 0);
-        }else if(getTile(lastx, lasty).build.rotation==3){
-            unit.vel.add(0, -.55);
-        };
-    };
-};
-
-//не мусор
-var antiGravField = (unit) => {
-    lastx = unit.tileX();
-    lasty = unit.tileY();
-
-    if(getBlock(lastx, lasty) == Blocks.shockMine){
-        hold = true;
-    };
-};
-
-//endregion
-var update = () => { // главный цикл
-    unit = Vars.player.unit();
-    if (unit == null || unit.type.flying) return;
-    try {
-        lastx = unit.tileX();
-        lasty = unit.tileY();
-
-        if(Core.input.keyTap(Binding.pause) && stamina > 99 && onfloor) {
-            jump(bjumpvel + ajumpvel); 
-            stamina -= 100; 
-        }; // работа прыжка
-
-        gravipad(unit);
-        gelJump(unit);
-        gelStick(unit);
-        wallHolding();
-        graviFunnel(unit);
-        antiGravField(unit);
-        
-        if(!hold && mode==0) { 
-            updateGravity();
-        };
-    } catch(e){
-        Log.err("parkour-mod: " + e + ". Maybe you in the void?")
-    };
-
-    hold = false;
-};
-
-Log.info("Running update task");
-Timer.schedule(() => {
-    if (lock) { 
-        return
-    };
-
-    update();
-    updateHud();
-    updateFloor();
-
-    if(!hold && mode == 1) {
-        gravityCenter(unit);
-    };
-}, 0, .02);
-
-
-Log.info("Done initialisation of parkour-mod.");
+/*
+ *  Original code had been written by Deftry, ADI and TheEE
+ */
+
+(() => {
+
+    const { blockAt , tileIs , tileAt } = require('Tile');
+    const { exception , log , debug } = require('Logger');
+    const Interface = require('Interface');
+    const { delta } = require('Math');
+    const { jump } = require('Jump');
+    const Gravity = require('Gravity');
+    const Player = require('Player');
+    const Debug = require('Debug');
+    const Mod = require('Mod');
+
+
+    const offsets = [
+        [ +1 ,  0 ] ,
+        [  0 , +1 ] ,
+        [ -1 ,  0 ] ,
+        [  0 , -1 ]
+    ]
+
+    const directToOffset = (direction) =>
+        offsets[direction];
+
+    function relativeTile(){
+
+        const offset = directToOffset(Gravity.direction);
+
+        return tileAt(
+            lastx + offset[0] ,
+            lasty + offset[1]
+        );
+    }
+
+    function relativeBlock(){
+
+        const tile = relativeTile();
+
+        return (tile)
+            ? tile.block()
+            : false ;
+    }
+
+    function isFloorSolid(){
+
+        const block = relativeBlock();
+
+        return (block)
+            ? block.solid
+            : false ;
+    }
+
+    function unitNear(unit,type){
+        return relativeBlock() == type;
+    }
+
+
+
+    Events.on(ClientLoadEvent,Interface.build);
+
+
+    log('Loading variables');
+
+
+    let lastx;
+    let lasty;
+    let ltilex;
+    let ltiley;
+    let unit;
+
+
+    let hold = false;
+
+
+    function holdOn(){
+        hold = true;
+    }
+
+    function letGo(){
+        hold = false;
+    }
+
+
+    log('Loading main content');
+
+
+    function unitOn(unit,type){
+        return tileIs(unit.tileX(),unit.tileY(),type);
+    }
+
+    function updateHud(){
+
+        if(!canWork())
+            return;
+
+        Interface.updateStamina();
+    }
+
+
+    const updateFloor = () => {
+
+        Player.onfloor = isFloorSolid();
+
+        if(Player.onfloor){
+
+            Player.stamina += 100;
+
+            if(Player.stamina > 10000)
+                Player.stamina = 10000;
+
+            ltilex = lastx;
+            ltiley = lasty;
+
+            const vertical = Gravity.direction % 2;
+
+            let
+                x = unit.vel.x ,
+                y = unit.vel.y ;
+
+            if(vertical && (Gravity.direction === 1 ? y > 0 : y < 0))
+                y = 0;
+
+            if(!vertical && (Gravity.direction === 0 ? x > 0 : x < 0))
+                y = 0;
+
+
+            unit.vel.set(x,y);
+        }
+    }
+
+
+    function updateGravity(){
+
+        const offset = directToOffset(Gravity.direction);
+
+        unit.vel.add(
+            Gravity.strength * offset[0] ,
+            Gravity.strength * offset[1] 
+        );
+    }
+
+    function gravipad(unit){
+        if(unitOn(unit,Blocks.conveyor))
+            Gravity.direction = tileAt(lastx,lasty).build.rotation;
+    }
+
+    function gravityCenter(){
+
+        if(Player.onfloor || hold)
+            return;
+
+        const coordinates = [];
+        let nolock = false;
+
+        for(let y = -15;y < 16;y++)
+            for(let x = -15;x < 16;x++)
+                if(blockAt(lastx + x,lasty + y) == Blocks.thoriumWall){
+                    coordinates.push({ x : x , y : y });
+                    nolock = true;
+                }
+
+        if(!nolock)
+            return;
+
+        const distances = [];
+
+        for(let c = 0;c < coordinates.length;c++){
+
+            const cord = coordinates[c];
+
+            const distance = delta(
+                cord.x , cord.y ,
+                lastx , lasty
+            );
+
+            distances.push(distance);
+        }
+
+        let shortest = 0;
+
+        for(let d = 0;d < distances.length;d++)
+            if(distances[d] < distances[shortest])
+                shortest = d;
+
+        const
+            x = coordinates[shortest].x ,
+            y = coordinates[shortest].y ;
+
+        const vertical = Gravity.direction % 2;
+
+        const position = vertical
+            ? y : x ;
+
+        if(position === 0)
+            return;
+
+        unit.vel.add(
+            ! vertical * Gravity.strength ,
+              vertical * Gravity.strength
+        );
+
+        Gravity.direction = vertical + (position < 0) * 2;
+    }
+
+
+    function gelJump(unit){
+
+        if(!unitNear(unit,Blocks.titaniumWall)){
+            Player.ajumpvel = 0;
+            return;
+        }
+
+        const vertical = Gravity.direction % 2;
+
+
+        const isSame = (vertical)
+            ? ltiley == lasty
+            : ltilex == lastx ;
+
+        Player.ajumpvel = (isSame)
+            ? 15 : 0 ;
+
+        if(isSame)
+            return;
+
+        jump(unit,Player.bjumpvel + 15);
+    }
+
+
+    function gelStick(unit){
+
+        const offsets = [ -1 , 0 , +1 ];
+
+        for(let x = 0;x < 2;x++)
+            for(let y = 0;y < 2;y++){
+
+                const
+                    offsetX = offsets[x] ,
+                    offsetY = offsets[y] ;
+
+                if(blockAt(lastx + offsetX,lasty + offsetY) !== Blocks.plastaniumWall)
+                    return;
+
+                holdOn();
+
+                if(!Core.input.keyTab(Binding.pause))
+                    continue;
+
+                if(!Player.hasStamina())
+                    continue;
+
+                unit.vel.add(
+                    - offsetX * 15 ,
+                    - offsetY * 15
+                );
+
+                return;
+            }
+    }
+
+
+    function nextToAnyBlock(){
+        return blockAt(lastx,lasty + 1)
+            || blockAt(lastx,lasty - 1)
+            || blockAt(lastx + 1,lasty)
+            || blockAt(lastx - 1,lasty) ;
+    }
+
+    function wallHolding(){
+
+        if(!Player.holding)
+            return;
+
+        if(!Player.hasStamina()){
+            letGo();
+            return;
+        }
+
+        if(nextToAnyBlock()){
+            holdOn();
+            Player.stamina -= 10;
+        }
+    }
+
+
+    function graviFunnel(unit){
+
+        const block = blockAt(lastx,lasty);
+
+        if(block != Blocks.pulseConduit)
+            return;
+
+        holdOn();
+
+        const offset = directToOffset(block.build.rotation);
+
+        unit.vel.add(
+            -.55 * offset[0] ,
+            -.55 * offset[1] 
+        );
+    }
+
+
+    function antiGravField(unit){
+
+        if(unitOn(unit,Blocks.shockMine))
+            holdOn();
+    }
+
+
+    function checkInteractables(unit){
+
+        gravipad(unit);
+        gelJump(unit);
+        gelStick(unit);
+        wallHolding();
+        graviFunnel(unit);
+        antiGravField(unit);
+    }
+
+
+    function update(){
+
+        unit = Player.unit();
+
+        if(!Player.canParkour())
+            return;
+
+        try {
+
+            Player.updatePosition();
+
+            lastx = unit.tileX();
+            lasty = unit.tileY();
+
+            if(Core.input.keyTap(Binding.pause) && Player.hasStamina() && Player.onfloor){
+                jump(unit,Player.bjumpvel + Player.ajumpvel);
+                Player.stamina -= 100;
+            }
+
+            checkInteractables(unit);
+
+            if(!hold && Mod.downwardGravity())
+                updateGravity();
+
+        } catch(error) { exception(error) }
+
+        letGo();
+    }
+
+    function canWork(){
+        return Mod.enabled && Player.canParkour();
+    }
+
+    function tick(){
+
+        if(!canWork())
+            return;
+
+        unit = Player.unit();
+
+        update();
+        updateFloor();
+
+        if(hold || Mod.downwardGravity())
+            return;
+
+        gravityCenter();
+    }
+
+
+    log('Starting schedulers');
+
+    Timer.schedule(tick,0,.02);
+
+    Timer.schedule(updateHud,0,.1);
+
+    log('Finished setup');
+
+})();