From 2211113e24f2e388f4bde75de7dc74c6895127d7 Mon Sep 17 00:00:00 2001
From: Steven Snoeijen <stevensnoeijen@gmail.com>
Date: Sun, 24 Jul 2022 16:34:11 +0200
Subject: [PATCH] refactor: format all src files feat: add

---
 .eslintrc.js                                  |  27 +-
 package-lock.json                             |  46 +++
 package.json                                  |   1 +
 src/components/pixi/PixiApplication.vue       | 192 ++++-----
 src/components/pixi/PixiViewport.vue          |   9 +-
 src/components/pixi/types.ts                  |   6 +-
 .../worldeditor/AnimatorPreview.vue           |  89 ++--
 src/game/Constants.tsx                        |  10 +-
 src/game/Engine.ts                            | 185 +++++----
 src/game/EntityFactory.ts                     | 138 ++++---
 src/game/EntityHelper.ts                      | 143 +++----
 src/game/EventBus.ts                          |  56 ++-
 src/game/Events.ts                            |   6 +-
 src/game/GameTime.ts                          |  14 +-
 src/game/Input.ts                             | 124 +++---
 src/game/Optional.ts                          |   2 +-
 src/game/__tests__/utils.ts                   |  47 ++-
 src/game/ai/behaviortree/Tree.ts              |  14 +-
 src/game/ai/behaviortree/nodes/Node.spec.ts   | 153 ++++---
 src/game/ai/behaviortree/nodes/Node.ts        | 116 +++---
 .../ai/behaviortree/nodes/core/Always.spec.ts |  21 +-
 src/game/ai/behaviortree/nodes/core/Always.ts |  12 +-
 .../behaviortree/nodes/core/Inventer.spec.ts  |  72 ++--
 .../ai/behaviortree/nodes/core/Inventer.ts    |  30 +-
 .../behaviortree/nodes/core/Parallel.spec.ts  | 108 ++---
 .../ai/behaviortree/nodes/core/Parallel.ts    |  61 +--
 .../behaviortree/nodes/core/Selector.spec.ts  |  94 ++---
 .../ai/behaviortree/nodes/core/Selector.ts    |  42 +-
 .../behaviortree/nodes/core/Sequence.spec.ts  |  74 ++--
 .../ai/behaviortree/nodes/core/Sequence.ts    |  36 +-
 .../ai/behaviortree/nodes/core/Timer.spec.ts  | 231 ++++++-----
 src/game/ai/behaviortree/nodes/core/Timer.ts  |  86 ++--
 src/game/ai/behaviortree/nodes/core/index.ts  |   2 +-
 .../behaviortree/nodes/entity/Attack.spec.ts  |  38 +-
 .../ai/behaviortree/nodes/entity/Attack.ts    |  22 +-
 .../nodes/entity/EntityNode.spec.ts           |  40 +-
 .../behaviortree/nodes/entity/EntityNode.ts   |  22 +-
 .../behaviortree/nodes/entity/Follow.spec.ts  |  61 +--
 .../ai/behaviortree/nodes/entity/Follow.ts    |  26 +-
 .../nodes/entity/HasTarget.spec.ts            |  59 ++-
 .../ai/behaviortree/nodes/entity/HasTarget.ts |  26 +-
 .../nodes/entity/IsControlledBy.ts            |  37 +-
 .../nodes/entity/IsControlledByAi.ts          |  10 +-
 .../nodes/entity/IsControlledByPlayer.ts      |  10 +-
 .../nodes/entity/IsEnemyInAggroRange.spec.ts  |  14 +-
 .../nodes/entity/IsEnemyInAggroRange.ts       |  14 +-
 .../nodes/entity/IsEnemyInAttackRange.spec.ts |  12 +-
 .../nodes/entity/IsEnemyInAttackRange.ts      |  11 +-
 .../nodes/entity/IsEnemyInRange.spec.ts       | 121 +++---
 .../nodes/entity/IsEnemyInRange.ts            |  50 ++-
 .../nodes/entity/IsMoving.spec.ts             |  55 +--
 .../ai/behaviortree/nodes/entity/IsMoving.ts  |  33 +-
 .../nodes/entity/SetTarget.spec.ts            |  59 ++-
 .../ai/behaviortree/nodes/entity/SetTarget.ts |  22 +-
 .../nodes/entity/UnsetTarget.spec.ts          |  75 ++--
 .../behaviortree/nodes/entity/UnsetTarget.ts  |  28 +-
 .../ai/behaviortree/nodes/entity/index.ts     |   2 +-
 .../behaviortree/nodes/entity/utils.spec.ts   |  58 +--
 .../ai/behaviortree/nodes/entity/utils.ts     |  28 +-
 src/game/ai/pathfinding.spec.ts               | 380 +++++++++---------
 src/game/ai/pathfinding.ts                    | 293 +++++++-------
 src/game/animation/Animation.ts               |   6 +-
 src/game/animation/AnimationManager.ts        |  10 +-
 src/game/animation/Animator.ts                |  12 +-
 src/game/animation/Model.ts                   |  10 +-
 src/game/animation/utils.ts                   | 176 +++++---
 src/game/env.d.ts                             |   6 +-
 src/game/levels/BehaviorTreeLevel.ts          | 158 ++++----
 src/game/levels/Level.ts                      |  19 +-
 src/game/levels/PathFindingLevel.ts           |  74 ++--
 src/game/levels/RandomUnitsLevel.ts           |  79 ++--
 src/game/levels/utils.spec.ts                 |  28 +-
 src/game/levels/utils.ts                      |  72 ++--
 src/game/math/IPosition.ts                    |   5 +-
 src/game/math/ISize.ts                        |   6 +-
 src/game/math/Vector2.spec.ts                 | 251 ++++++------
 src/game/math/Vector2.ts                      | 200 ++++-----
 src/game/math/collision/Bounds.ts             |  55 ++-
 src/game/systems/AttackComponent.spec.ts      |  32 +-
 src/game/systems/AttackComponent.ts           |  30 +-
 src/game/systems/ControlledComponent.ts       |  11 +-
 src/game/systems/DefaultAttributes.ts         |   6 +-
 src/game/systems/GameTimeSystem.ts            |   8 +-
 src/game/systems/InputSystem.ts               |  97 ++---
 src/game/systems/PixiJsSystem.ts              |  12 +-
 src/game/systems/SizeComponent.ts             |  16 +-
 src/game/systems/TeamComponent.ts             |  11 +-
 src/game/systems/TransformComponent.ts        |  36 +-
 src/game/systems/ai/BehaviorTreeComponent.ts  |  12 +-
 src/game/systems/ai/BehaviorTreeSystem.ts     |  28 +-
 src/game/systems/ai/TargetComponent.ts        |  12 +-
 src/game/systems/ai/TargetSystem.ts           |  46 +--
 src/game/systems/alive/AliveComponent.ts      |  12 +-
 src/game/systems/alive/AliveSystem.ts         |  74 ++--
 .../systems/health/HealthComponent.spec.ts    |  20 +-
 src/game/systems/health/HealthComponent.ts    |  26 +-
 src/game/systems/health/HealthSystem.ts       |  65 +--
 src/game/systems/health/utils.ts              |  16 +-
 .../systems/movement/CollidableComponent.ts   |   2 +-
 src/game/systems/movement/FollowComponent.ts  |  10 +-
 src/game/systems/movement/FollowSystem.ts     |  99 ++---
 src/game/systems/movement/MovableComponent.ts |  10 +-
 .../systems/movement/MovePathComponent.ts     |  12 +-
 src/game/systems/movement/MovePathSystem.ts   | 126 +++---
 .../movement/MovePositionDirectComponent.ts   |  10 +-
 .../movement/MovePositionDirectSystem.ts      | 138 ++++---
 .../MoveTransformVelocityComponent.ts         |  22 +-
 .../systems/movement/MoveVelocityComponent.ts |  24 +-
 .../systems/movement/MoveVelocitySystem.ts    |  52 +--
 .../player/PlayerMovementKeysComponent.ts     |   2 +-
 .../player/PlayerMovementKeysSystem.ts        | 115 +++---
 .../player/PlayerMovementMouseComponent.ts    |   2 +-
 .../player/PlayerMovementMouseSystem.ts       | 115 +++---
 src/game/systems/render/AssetComponent.ts     |  12 +-
 src/game/systems/render/GridSystem.ts         |  78 ++--
 src/game/systems/render/MapSystem.ts          |  59 ++-
 .../render/graphics/GraphicsComponent.ts      |  14 +-
 .../systems/render/graphics/GraphicsSystem.ts | 211 +++++-----
 .../render/sprite/AnimatedSpriteComponent.ts  |  19 +-
 .../systems/render/sprite/SpriteComponent.ts  |  12 +-
 .../systems/render/sprite/SpriteSystem.ts     | 119 +++---
 src/game/systems/render/sprite/utils.ts       |  42 +-
 .../selection/PlayerSelectionSystem.ts        | 273 +++++++------
 .../systems/selection/SelectableComponent.ts  |  12 +-
 src/game/systems/utils/index.spec.ts          | 100 +++--
 src/game/systems/utils/index.ts               |  41 +-
 src/game/systems/utils/transform.spec.ts      | 170 ++++----
 src/game/systems/utils/transform.ts           |  87 ++--
 src/game/utils.spec.ts                        | 208 +++++-----
 src/game/utils.ts                             |  86 ++--
 src/index.css                                 |   2 +-
 src/shims-vue.d.ts                            |  10 +-
 src/types/global.d.ts                         |   8 +-
 src/views/GameView.vue                        |   8 +-
 134 files changed, 4167 insertions(+), 3733 deletions(-)

diff --git a/.eslintrc.js b/.eslintrc.js
index 0e772df..68c0cd9 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -2,17 +2,40 @@
 require('@rushstack/eslint-patch/modern-module-resolution');
 
 module.exports = {
+  env: {
+    browser: true,
+    node: true,
+  },
+  globals: {
+    document: false,
+  },
   extends: [
     'eslint:recommended',
     'plugin:vue/vue3-essential',
     '@vue/eslint-config-typescript',
   ],
-  plugins: ['import'],
+  plugins: ['import', 'unused-imports'],
   rules: {
     'max-len': ['warn', { code: 80, ignorePattern: '^import\\W.*' }],
     quotes: ['warn', 'single'],
     semi: ['warn', 'always'],
-    'import/order': ['warn'],
+    'import/order': [
+      'warn',
+      {
+        'newlines-between': 'always',
+      },
+    ],
     'spaced-comment': ['warn', 'always'],
+    'unused-imports/no-unused-imports': 'warn',
+    'no-unused-vars': 'off',
+    'unused-imports/no-unused-vars': [
+      'warn',
+      {
+        vars: 'all',
+        varsIgnorePattern: '^_',
+        args: 'after-used',
+        argsIgnorePattern: '^_',
+      },
+    ],
   },
 };
diff --git a/package-lock.json b/package-lock.json
index 791bbee..3a0c2b2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -28,6 +28,7 @@
         "autoprefixer": "^10.4.7",
         "eslint": "^8.20.0",
         "eslint-plugin-import": "^2.26.0",
+        "eslint-plugin-unused-imports": "^2.0.0",
         "eslint-plugin-vue": "^9.2.0",
         "gh-pages": "^3.2.3",
         "jest": "^28.1.3",
@@ -4510,6 +4511,27 @@
       "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
       "dev": true
     },
+    "node_modules/eslint-plugin-unused-imports": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-unused-imports/-/eslint-plugin-unused-imports-2.0.0.tgz",
+      "integrity": "sha512-3APeS/tQlTrFa167ThtP0Zm0vctjr4M44HMpeg1P4bK6wItarumq0Ma82xorMKdFsWpphQBlRPzw/pxiVELX1A==",
+      "dev": true,
+      "dependencies": {
+        "eslint-rule-composer": "^0.3.0"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/eslint-plugin": "^5.0.0",
+        "eslint": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@typescript-eslint/eslint-plugin": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/eslint-plugin-vue": {
       "version": "9.2.0",
       "resolved": "https://registry.npmjs.org/eslint-plugin-vue/-/eslint-plugin-vue-9.2.0.tgz",
@@ -4531,6 +4553,15 @@
         "eslint": "^6.2.0 || ^7.0.0 || ^8.0.0"
       }
     },
+    "node_modules/eslint-rule-composer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/eslint-rule-composer/-/eslint-rule-composer-0.3.0.tgz",
+      "integrity": "sha512-bt+Sh8CtDmn2OajxvNO+BX7Wn4CIWMpTRm3MaiKPCQcnnlm0CS2mhui6QaoeQugs+3Kj2ESKEEGJUdVafwhiCg==",
+      "dev": true,
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
     "node_modules/eslint-scope": {
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz",
@@ -13154,6 +13185,15 @@
         }
       }
     },
+    "eslint-plugin-unused-imports": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-unused-imports/-/eslint-plugin-unused-imports-2.0.0.tgz",
+      "integrity": "sha512-3APeS/tQlTrFa167ThtP0Zm0vctjr4M44HMpeg1P4bK6wItarumq0Ma82xorMKdFsWpphQBlRPzw/pxiVELX1A==",
+      "dev": true,
+      "requires": {
+        "eslint-rule-composer": "^0.3.0"
+      }
+    },
     "eslint-plugin-vue": {
       "version": "9.2.0",
       "resolved": "https://registry.npmjs.org/eslint-plugin-vue/-/eslint-plugin-vue-9.2.0.tgz",
@@ -13169,6 +13209,12 @@
         "xml-name-validator": "^4.0.0"
       }
     },
+    "eslint-rule-composer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/eslint-rule-composer/-/eslint-rule-composer-0.3.0.tgz",
+      "integrity": "sha512-bt+Sh8CtDmn2OajxvNO+BX7Wn4CIWMpTRm3MaiKPCQcnnlm0CS2mhui6QaoeQugs+3Kj2ESKEEGJUdVafwhiCg==",
+      "dev": true
+    },
     "eslint-scope": {
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz",
diff --git a/package.json b/package.json
index 1deb044..dc3ec42 100644
--- a/package.json
+++ b/package.json
@@ -33,6 +33,7 @@
     "autoprefixer": "^10.4.7",
     "eslint": "^8.20.0",
     "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
     "eslint-plugin-vue": "^9.2.0",
     "gh-pages": "^3.2.3",
     "jest": "^28.1.3",
diff --git a/src/components/pixi/PixiApplication.vue b/src/components/pixi/PixiApplication.vue
index 769d7ab..7660361 100644
--- a/src/components/pixi/PixiApplication.vue
+++ b/src/components/pixi/PixiApplication.vue
@@ -1,11 +1,11 @@
 <template>
-    <div ref="container">
-        <slot name="default" :application="application"/>
-    </div>
+  <div ref="container">
+    <slot name="default" :application="application" />
+  </div>
 </template>
 
 <script lang="ts" setup>
-import { defineProps, onMounted, PropType } from 'vue';
+import { onMounted, PropType } from 'vue';
 import { $ref } from 'vue/macros';
 import * as PIXI from 'pixi.js';
 import { Dict } from '@pixi/utils';
@@ -16,106 +16,110 @@ const container = $ref<HTMLDivElement>();
 
 // prop types, if required and defaults adopted from pixi.js code
 const props = defineProps({
-    autoStart: {
-        type: Boolean,
-        required: false,
-        default: true,
-    },
-    width: {
-        type: Number,
-        required: false,
-        default: 800,
-    },
-    height: {
-        type: Number,
-        required: false,
-        default: 600,
-    },
-    view: {
-        type: HTMLCanvasElement,
-        required: false,
-    },
-    useContextAlpha: {
-        type: Boolean,
-        required: false,
-        default: true,
-    },
-    autoDensity: {
-        type: Boolean,
-        required: false,
-        default: false,
-    },
-    antialias: {
-        type: Boolean,
-        required: false,
-        default: false,
-    },
-    preserveDrawingBuffer: {
-        type: Boolean,
-        required: false,
-        default: false,
-    },
-    resolution: {
-        type: Number,
-        required: false,
-        default: PIXI.settings.RESOLUTION,
-    },
-    forceCanvas: {
-        type: Boolean,
-        required: false,
-        default: false,
-    },
-    backgroundColor: {
-        type: Number,
-        required: false,
-        default: 0x000000,
-    },
-    backgroundAlpha: {
-        type: Number,
-        required: false,
-        default: 1,
-    },
-    clearBeforeRender: {
-        type: Boolean,
-        required: false,
-        default: true,
-    },
-    powerPreference: {
-        type: String as PropType<WebGLPowerPreference>,
-        required: false,
-        default: 'high-performance',
-    },
-    sharedTicker: {
-        type: Boolean,
-        required: false,
-        default: false,
-    },
-    sharedLoader: {
-        type: Boolean,
-        required: false,
-        default: false,
-    },
-    resizeTo: {
-        type: Object as PropType<Window|HTMLElement>,
-        required: false,
-    },
+  autoStart: {
+    type: Boolean,
+    required: false,
+    default: true,
+  },
+  width: {
+    type: Number,
+    required: false,
+    default: 800,
+  },
+  height: {
+    type: Number,
+    required: false,
+    default: 600,
+  },
+  view: {
+    type: HTMLCanvasElement,
+    required: false,
+  },
+  useContextAlpha: {
+    type: Boolean,
+    required: false,
+    default: true,
+  },
+  autoDensity: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  antialias: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  preserveDrawingBuffer: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  resolution: {
+    type: Number,
+    required: false,
+    default: PIXI.settings.RESOLUTION,
+  },
+  forceCanvas: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  backgroundColor: {
+    type: Number,
+    required: false,
+    default: 0x000000,
+  },
+  backgroundAlpha: {
+    type: Number,
+    required: false,
+    default: 1,
+  },
+  clearBeforeRender: {
+    type: Boolean,
+    required: false,
+    default: true,
+  },
+  powerPreference: {
+    type: String as PropType<WebGLPowerPreference>,
+    required: false,
+    default: 'high-performance',
+  },
+  sharedTicker: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  sharedLoader: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  resizeTo: {
+    type: Object as PropType<Window | HTMLElement>,
+    required: false,
+  },
 });
 
 const emits = defineEmits<{
-    (event: 'tick', delta: number): void,
-    (event: 'load', loader: PIXI.Loader, resources: Dict<PIXI.LoaderResource>): void,
+  (event: 'tick', delta: number): void;
+  (
+    event: 'load',
+    loader: PIXI.Loader,
+    resources: Dict<PIXI.LoaderResource>
+  ): void;
 }>();
 
 const application = new PIXI.Application(props);
 
 defineExpose<PixiApplicationInstance>({
-	application,
+  application,
 });
 
 onMounted(() => {
-    container.appendChild(application.view);
+  container.appendChild(application.view);
 
-    application.ticker.add((delta: number) => emits('tick', delta));
-    application.loader.load((...args) => emits('load', ...args));
+  application.ticker.add((delta: number) => emits('tick', delta));
+  application.loader.load((...args) => emits('load', ...args));
 });
-</script>
\ No newline at end of file
+</script>
diff --git a/src/components/pixi/PixiViewport.vue b/src/components/pixi/PixiViewport.vue
index 57a1a1f..5b238d4 100644
--- a/src/components/pixi/PixiViewport.vue
+++ b/src/components/pixi/PixiViewport.vue
@@ -15,7 +15,7 @@ const props = defineProps({
     type: Number,
     required: false,
   },
-   /** @default window.innerHeight */
+  /** @default window.innerHeight */
   screenHeight: {
     type: Number,
     required: false,
@@ -48,7 +48,7 @@ const props = defineProps({
   },
   forceHitArea: {
     type: PIXI.Rectangle as PropType<PIXI.Rectangle | null>,
-    required: false
+    required: false,
   },
   /** @default false */
   noTicker: {
@@ -63,7 +63,6 @@ const props = defineProps({
   disableOnContextMenu: {
     type: Boolean,
     required: false,
-    
   },
   /** @default document.body */
   divWheel: {
@@ -102,6 +101,6 @@ onUnmounted(() => {
 });
 
 defineExpose<PixiViewportInstance>({
-    viewport
+  viewport,
 });
-</script>
\ No newline at end of file
+</script>
diff --git a/src/components/pixi/types.ts b/src/components/pixi/types.ts
index 39383e1..29613bb 100644
--- a/src/components/pixi/types.ts
+++ b/src/components/pixi/types.ts
@@ -2,9 +2,9 @@ import { Viewport } from 'pixi-viewport';
 import * as PIXI from 'pixi.js';
 
 export type PixiApplicationInstance = {
-	application: PIXI.Application;
+  application: PIXI.Application;
 };
 
 export type PixiViewportInstance = {
-	viewport: Viewport,
-}
\ No newline at end of file
+  viewport: Viewport;
+};
diff --git a/src/components/worldeditor/AnimatorPreview.vue b/src/components/worldeditor/AnimatorPreview.vue
index 98a26b9..8147deb 100644
--- a/src/components/worldeditor/AnimatorPreview.vue
+++ b/src/components/worldeditor/AnimatorPreview.vue
@@ -4,23 +4,34 @@
     <div>
       <label for="color">Color: </label>
       <select id="color" v-model="color">
-        <option v-for="color of animations.colors" :value="color">{{color}}</option>
+        <option v-for="color of animations.colors" :value="color" :key="color">
+          {{ color }}
+        </option>
       </select>
 
-
       <label for="unit">Unit: </label>
       <select id="unit" v-model="unit">
-        <option v-for="unit of animations.units" :value="unit">{{unit}}</option>
+        <option v-for="unit of animations.units" :value="unit" :key="unit">
+          {{ unit }}
+        </option>
       </select>
 
       <label for="animation">Animation: </label>
       <select id="animation" v-model="state">
-        <option v-for="state of animations.states" :value="state">{{state}}</option>
+        <option v-for="state of animations.states" :value="state" :key="state">
+          {{ state }}
+        </option>
       </select>
 
       <label for="direction">Direction: </label>
       <select id="direction" v-model="direction">
-        <option v-for="direction of animations.directions" :value="direction">{{direction}}</option>
+        <option
+          v-for="direction of animations.directions"
+          :value="direction"
+          :key="direction"
+        >
+          {{ direction }}
+        </option>
       </select>
 
       <pixi-application ref="applicationInstance" :width="500" :height="500">
@@ -31,8 +42,12 @@
             :screen-height="application.view.height"
             :interaction="application.renderer.plugins.interaction"
             :wheel="{
-              center: new PIXI.Point(application.view.width / 2, application.view.height / 2)
-            }"/>
+              center: new PIXI.Point(
+                application.view.width / 2,
+                application.view.height / 2
+              ),
+            }"
+          />
         </template>
       </pixi-application>
     </div>
@@ -40,33 +55,45 @@
 </template>
 
 <script setup lang="ts">
-import { onMounted, onUnmounted, ref, watch } from "vue";
+import { onMounted, onUnmounted, ref, watch } from 'vue';
 import * as PIXI from 'pixi.js';
-import { $ref } from "vue/macros";
+import { $ref } from 'vue/macros';
 
-import { PixiApplicationInstance, PixiViewportInstance } from "../pixi/types";
+import { PixiApplicationInstance, PixiViewportInstance } from '../pixi/types';
 import * as animations from '../../game/animation/utils';
-import { AnimationManager } from "../../game/animation/AnimationManager";
-import { Animator } from "../../game/animation/Animator";
+import { AnimationManager } from '../../game/animation/AnimationManager';
+import { Animator } from '../../game/animation/Animator';
 
 const applicationInstance = ref<PixiApplicationInstance>();
 const viewportInstance = $ref<PixiViewportInstance>();
 
 const color = $ref<animations.Color>(animations.colors[0]);
-watch(() => color, () => handleChangeSkin());
+watch(
+  () => color,
+  () => handleChangeSkin()
+);
 
 const unit = $ref<animations.Unit>(animations.units[0]);
-watch(() => unit, () => handleChangeSkin());
+watch(
+  () => unit,
+  () => handleChangeSkin()
+);
 
 const state = $ref<animations.State>(animations.states[0]);
-watch(() => state, () => handleChangeAnimation());
+watch(
+  () => state,
+  () => handleChangeAnimation()
+);
 
 const direction = $ref<animations.Direction>(animations.directions[0]);
-watch(() => direction, () => handleChangeAnimation());
+watch(
+  () => direction,
+  () => handleChangeAnimation()
+);
 
 let animationManager: AnimationManager;
 let animator: Animator;
-let sprite: PIXI.AnimatedSprite; 
+let sprite: PIXI.AnimatedSprite;
 
 onMounted(() => {
   const app = applicationInstance.value!.application;
@@ -74,24 +101,32 @@ onMounted(() => {
   if (app.loader.resources['unit'] != null) {
     loadSprite();
   } else {
-    app.loader.add('unit', '/assets/unit.json')
-      .load(() => {
-        animationManager = new AnimationManager(app.loader.resources.unit.spritesheet!);
-        loadSprite();
-      }); 
-    }
+    app.loader.add('unit', '/assets/unit.json').load(() => {
+      animationManager = new AnimationManager(
+        app.loader.resources.unit.spritesheet!
+      );
+      loadSprite();
+    });
+  }
 });
 
 const loadSprite = () => {
-  sprite = new PIXI.AnimatedSprite(animationManager.getModel('blue', 'swordsmen').getAnimation('idle', 'north').textures);// TODO: refactor to not load something...
+  sprite = new PIXI.AnimatedSprite(
+    animationManager
+      .getModel('blue', 'swordsmen')
+      .getAnimation('idle', 'north').textures
+  ); // TODO: refactor to not load something...
   sprite.anchor.set(0.5);
-  sprite.position.set(applicationInstance.value!.application.view.width / 2, applicationInstance.value!.application.view.height / 2);
+  sprite.position.set(
+    applicationInstance.value!.application.view.width / 2,
+    applicationInstance.value!.application.view.height / 2
+  );
 
   animator = animationManager.createAnimator(sprite, color, unit);
   animator.set(state, direction);
-  
+
   viewportInstance.viewport.addChild(sprite);
-}
+};
 
 onUnmounted(() => {
   viewportInstance.viewport.removeChild(sprite);
diff --git a/src/game/Constants.tsx b/src/game/Constants.tsx
index 1a2d9b1..fbcb564 100644
--- a/src/game/Constants.tsx
+++ b/src/game/Constants.tsx
@@ -1,8 +1,8 @@
 export class Constants {
-	public static readonly CELL_SIZE = 16;
+  public static readonly CELL_SIZE = 16;
 
-	/**
-	 * in ms, movement per cell
-	 */
-	public static readonly ANIMATION_UNIT_SPEED = 250;
+  /**
+   * in ms, movement per cell
+   */
+  public static readonly ANIMATION_UNIT_SPEED = 250;
 }
diff --git a/src/game/Engine.ts b/src/game/Engine.ts
index 1708481..cb42919 100644
--- a/src/game/Engine.ts
+++ b/src/game/Engine.ts
@@ -48,109 +48,106 @@ import { ControlledComponent } from './systems/ControlledComponent';
 import { AnimatedSpriteComponent } from './systems/render/sprite/AnimatedSpriteComponent';
 import { AssetComponent } from './systems/render/AssetComponent';
 
-
 export class Engine {
-	private readonly world: World;
-	private readonly eventBus: EventBus<Events>;
-
-	constructor(
-		private readonly app: PIXI.Application) {
-		this.world = new World();
-		const eventBus = this.eventBus = new EventBus<Events>();
+  private readonly world: World;
+  private readonly eventBus: EventBus<Events>;
 
-		let lastFrameTime = 0;
+  constructor(private readonly app: PIXI.Application) {
+    this.world = new World();
+    const eventBus = (this.eventBus = new EventBus<Events>());
 
-		const options = getOptions();
+    let lastFrameTime = 0;
 
+    const options = getOptions();
 
-		lastFrameTime = performance.now();
-		this.app.ticker.add(() => {
-			frame();
-		});
+    lastFrameTime = performance.now();
+    this.app.ticker.add(() => {
+      frame();
+    });
 
-		this.app.loader
-			.add('swordsmen_blue', 'assets/swordsmen.blue.move.west_06.png')
-			.add('swordsmen_red', 'assets/swordsmen.red.move.west_06.png')
-			.add('dead', 'assets/swordsmen.blue.dead.south.png')
-			.add('unit', 'assets/unit.json')
-			.load(() => {
-				loadLevel();
-			});
+    this.app.loader
+      .add('swordsmen_blue', 'assets/swordsmen.blue.move.west_06.png')
+      .add('swordsmen_red', 'assets/swordsmen.red.move.west_06.png')
+      .add('dead', 'assets/swordsmen.blue.dead.south.png')
+      .add('unit', 'assets/unit.json')
+      .load(() => {
+        loadLevel();
+      });
 
-		this.world
-			.registerComponent(TransformComponent)
-			.registerComponent(SizeComponent)
-			.registerComponent(SelectableComponent)
-			.registerComponent(MovableComponent)
-			.registerComponent(HealthComponent)
-			.registerComponent(AliveComponent)
-			.registerComponent(MoveTransformVelocityComponent)
-			.registerComponent(MovePositionDirectComponent)
-			.registerComponent(PlayerMovementMouseComponent)
-			.registerComponent(PlayerMovementKeysComponent)
-			.registerComponent(MoveVelocityComponent)
-			.registerComponent(SpriteComponent)
-			.registerComponent(AnimatedSpriteComponent)
-			.registerComponent(GraphicsComponent)
-			.registerComponent(MovePathComponent)
-			.registerComponent(CollidableComponent)
-			.registerComponent(TeamComponent)
-			.registerComponent(AttackComponent)
-			.registerComponent(FollowComponent)
-			.registerComponent(BehaviorTreeComponent)
-			.registerComponent(TargetComponent)
-			.registerComponent(ControlledComponent)
-			.registerComponent(AssetComponent)
-			.registerSystem(PlayerSelectionSystem, { app, eventBus })
-			.registerSystem(HealthSystem, { eventBus })
-			.registerSystem(AliveSystem, { app, eventBus })
-			.registerSystem(InputSystem, { canvas: app.view })
-			// .registerSystem(PlayerMovementKeysSystem, { eventBus }) // disabled for now, not working with (map) collision atm
-			.registerSystem(MovePositionDirectSystem)
-			.registerSystem(PlayerMovementMouseSystem, { app, eventBus })
-			.registerSystem(MoveVelocitySystem, { eventBus })
-			.registerSystem(SpriteSystem, { app, eventBus })
-			.registerSystem(GraphicsSystem, { app, options, eventBus })
-			.registerSystem(GridSystem, { app, options, eventBus })
-			.registerSystem(MapSystem, { app, eventBus })
-			.registerSystem(MovePathSystem, { eventBus })
-			.registerSystem(GameTimeSystem)
-			.registerSystem(FollowSystem, { app, eventBus })
-			.registerSystem(BehaviorTreeSystem)
-			.registerSystem(TargetSystem);
+    this.world
+      .registerComponent(TransformComponent)
+      .registerComponent(SizeComponent)
+      .registerComponent(SelectableComponent)
+      .registerComponent(MovableComponent)
+      .registerComponent(HealthComponent)
+      .registerComponent(AliveComponent)
+      .registerComponent(MoveTransformVelocityComponent)
+      .registerComponent(MovePositionDirectComponent)
+      .registerComponent(PlayerMovementMouseComponent)
+      .registerComponent(PlayerMovementKeysComponent)
+      .registerComponent(MoveVelocityComponent)
+      .registerComponent(SpriteComponent)
+      .registerComponent(AnimatedSpriteComponent)
+      .registerComponent(GraphicsComponent)
+      .registerComponent(MovePathComponent)
+      .registerComponent(CollidableComponent)
+      .registerComponent(TeamComponent)
+      .registerComponent(AttackComponent)
+      .registerComponent(FollowComponent)
+      .registerComponent(BehaviorTreeComponent)
+      .registerComponent(TargetComponent)
+      .registerComponent(ControlledComponent)
+      .registerComponent(AssetComponent)
+      .registerSystem(PlayerSelectionSystem, { app, eventBus })
+      .registerSystem(HealthSystem, { eventBus })
+      .registerSystem(AliveSystem, { app, eventBus })
+      .registerSystem(InputSystem, { canvas: app.view })
+      // .registerSystem(PlayerMovementKeysSystem, { eventBus }) // disabled for now, not working with (map) collision atm
+      .registerSystem(MovePositionDirectSystem)
+      .registerSystem(PlayerMovementMouseSystem, { app, eventBus })
+      .registerSystem(MoveVelocitySystem, { eventBus })
+      .registerSystem(SpriteSystem, { app, eventBus })
+      .registerSystem(GraphicsSystem, { app, options, eventBus })
+      .registerSystem(GridSystem, { app, options, eventBus })
+      .registerSystem(MapSystem, { app, eventBus })
+      .registerSystem(MovePathSystem, { eventBus })
+      .registerSystem(GameTimeSystem)
+      .registerSystem(FollowSystem, { app, eventBus })
+      .registerSystem(BehaviorTreeSystem)
+      .registerSystem(TargetSystem);
 
-		let level;
-		const loadLevel = (): void => {
-			if (options.level != null && options.level[0] != null) {
-				const levelName = options.level[0].toLowerCase();
-				if (levelName === 'randomunits') {
-					level = new RandomUnitsLevel(app, this.world);
-				} else if (levelName === 'pathfinding') {
-					level = new PathFindingLevel(app, this.world);
-				} else if (levelName === 'behaviortree') {
-					level = new BehaviorTreeLevel(app, this.world);
-				} else {
-					alert('level not found');
-					return;
-				}
-			} else {
-				// default
-				level = new RandomUnitsLevel(app, this.world);
-			}
+    let level;
+    const loadLevel = (): void => {
+      if (options.level != null && options.level[0] != null) {
+        const levelName = options.level[0].toLowerCase();
+        if (levelName === 'randomunits') {
+          level = new RandomUnitsLevel(app, this.world);
+        } else if (levelName === 'pathfinding') {
+          level = new PathFindingLevel(app, this.world);
+        } else if (levelName === 'behaviortree') {
+          level = new BehaviorTreeLevel(app, this.world);
+        } else {
+          alert('level not found');
+          return;
+        }
+      } else {
+        // default
+        level = new RandomUnitsLevel(app, this.world);
+      }
 
-			level.load();
-			eventBus.emit<LevelLoadedEvent>('level:loaded', { level });
-		}
+      level.load();
+      eventBus.emit<LevelLoadedEvent>('level:loaded', { level });
+    };
 
-		const frame = (): void => {
-			// Compute delta and elapsed time
-			const time = performance.now();
-			const delta = time - lastFrameTime;
+    const frame = (): void => {
+      // Compute delta and elapsed time
+      const time = performance.now();
+      const delta = time - lastFrameTime;
 
-			// Run all the systems
-			this.world.execute(delta, time);
+      // Run all the systems
+      this.world.execute(delta, time);
 
-			lastFrameTime = time;
-		}
-	}
-}
\ No newline at end of file
+      lastFrameTime = time;
+    };
+  }
+}
diff --git a/src/game/EntityFactory.ts b/src/game/EntityFactory.ts
index e4e1e00..edd63ee 100644
--- a/src/game/EntityFactory.ts
+++ b/src/game/EntityFactory.ts
@@ -1,11 +1,10 @@
+import { Entity, World } from 'ecsy';
+import * as PIXI from 'pixi.js';
+
 import { AssetComponent } from './systems/render/AssetComponent';
 import { AnimatedSpriteComponent } from './systems/render/sprite/AnimatedSpriteComponent';
 import { ControlledComponent } from './systems/ControlledComponent';
 import { TargetComponent } from './systems/ai/TargetComponent';
-import { Entity, World } from 'ecsy';
-import * as PIXI from 'pixi.js';
-
-import { SpriteComponent } from './systems/render/sprite/SpriteComponent';
 import { MovableComponent } from './systems/movement/MovableComponent';
 import { SizeComponent } from './systems/SizeComponent';
 import { TransformComponent } from './systems//TransformComponent';
@@ -28,77 +27,76 @@ import { AttackComponent } from './systems/AttackComponent';
 import * as animations from './animation/utils';
 
 interface IUnitProps {
-	position: Position;
-	color: 'red' | 'blue';
-	team: {
-		number: number;
-	};
+  position: Position;
+  color: 'red' | 'blue';
+  team: {
+    number: number;
+  };
 }
 
 export class EntityFactory {
-	constructor(
-		private readonly world: World,
-		private readonly animations: animations.UnitAnimations) {
-	}
-
-	public createUnit(props: IUnitProps): Entity {
-		const width = Constants.CELL_SIZE;
-		const height = Constants.CELL_SIZE;
-		let rotation = Math.random() * 360;
-		rotation -= rotation % 90;
+  constructor(
+    private readonly world: World,
+    private readonly animations: animations.UnitAnimations
+  ) {}
 
-		const unitAnimations = this.animations[props.color].swordsmen;
+  public createUnit(props: IUnitProps): Entity {
+    const width = Constants.CELL_SIZE;
+    const height = Constants.CELL_SIZE;
+    let rotation = Math.random() * 360;
+    rotation -= rotation % 90;
 
-		const sprite = new PIXI.AnimatedSprite(unitAnimations.idle.north.textures);
-		sprite.anchor.set(0.5);
-		sprite.position.set(props.position.x, props.position.y);
-		sprite.animationSpeed = .25;
-        sprite.play();
+    const unitAnimations = this.animations[props.color].swordsmen;
 
-		return this.world
-			.createEntity()
-			.addComponent(TransformComponent, {
-				position: new Vector2(props.position.x, props.position.y),
-				rotation: rotation,
-			})
-			.addComponent(SizeComponent, {
-				width: width,
-				height: height,
-			})
-			.addComponent(MovableComponent)
-			.addComponent(SelectableComponent)
-			.addComponent(HealthComponent, {
-				points: 10,
-				maxPoints: 10,
-			})
-			.addComponent(AliveComponent)
-			.addComponent(MoveVelocityComponent, {
-				moveSpeed: 50,
-			})
-			.addComponent(PlayerMovementKeysComponent)
-			.addComponent(MovePositionDirectComponent)
-			.addComponent(PlayerMovementMouseComponent)
-			.addComponent(AnimatedSpriteComponent, {
-				sprite: sprite,
-				state: 'idle_north',
-			})
-			.addComponent(GraphicsComponent, {
-				graphics: new PIXI.Graphics(),
-			})
-			.addComponent(MovePathComponent, { path: [] })
-			.addComponent(CollidableComponent)
-			.addComponent(TeamComponent, props.team)
-			.addComponent(FollowComponent)
-			.addComponent(AttackComponent, {
-				aggroRange: 80,
-				attackRange: 16,
-				attackDamage: 1,
-			})
-			.addComponent(TargetComponent)
-			.addComponent(ControlledComponent)
-			.addComponent(AssetComponent, {
-				animations: unitAnimations,
-			});
+    const sprite = new PIXI.AnimatedSprite(unitAnimations.idle.north.textures);
+    sprite.anchor.set(0.5);
+    sprite.position.set(props.position.x, props.position.y);
+    sprite.animationSpeed = 0.25;
+    sprite.play();
 
-	}
+    return this.world
+      .createEntity()
+      .addComponent(TransformComponent, {
+        position: new Vector2(props.position.x, props.position.y),
+        rotation: rotation,
+      })
+      .addComponent(SizeComponent, {
+        width: width,
+        height: height,
+      })
+      .addComponent(MovableComponent)
+      .addComponent(SelectableComponent)
+      .addComponent(HealthComponent, {
+        points: 10,
+        maxPoints: 10,
+      })
+      .addComponent(AliveComponent)
+      .addComponent(MoveVelocityComponent, {
+        moveSpeed: 50,
+      })
+      .addComponent(PlayerMovementKeysComponent)
+      .addComponent(MovePositionDirectComponent)
+      .addComponent(PlayerMovementMouseComponent)
+      .addComponent(AnimatedSpriteComponent, {
+        sprite: sprite,
+        state: 'idle_north',
+      })
+      .addComponent(GraphicsComponent, {
+        graphics: new PIXI.Graphics(),
+      })
+      .addComponent(MovePathComponent, { path: [] })
+      .addComponent(CollidableComponent)
+      .addComponent(TeamComponent, props.team)
+      .addComponent(FollowComponent)
+      .addComponent(AttackComponent, {
+        aggroRange: 80,
+        attackRange: 16,
+        attackDamage: 1,
+      })
+      .addComponent(TargetComponent)
+      .addComponent(ControlledComponent)
+      .addComponent(AssetComponent, {
+        animations: unitAnimations,
+      });
+  }
 }
diff --git a/src/game/EntityHelper.ts b/src/game/EntityHelper.ts
index 6233c31..0ba9b96 100644
--- a/src/game/EntityHelper.ts
+++ b/src/game/EntityHelper.ts
@@ -8,85 +8,90 @@ import { Vector2 } from './math/Vector2';
 import { AliveComponent } from './systems/alive/AliveComponent';
 
 export class EntityHelper {
-	public static isAlive(entity: Entity): boolean {
-		const aliveComponent = entity.getComponent(AliveComponent);
+  public static isAlive(entity: Entity): boolean {
+    const aliveComponent = entity.getComponent(AliveComponent);
 
-		return aliveComponent?.alive || false;
-	}
+    return aliveComponent?.alive || false;
+  }
 
-	public static isPositionInsideEntity(
-		entity: Entity,
-		x: number,
-		y: number
-	): boolean {
-		const transform = entity.getComponent(TransformComponent);
-		const size = entity.getComponent(SizeComponent);
+  public static isPositionInsideEntity(
+    entity: Entity,
+    x: number,
+    y: number
+  ): boolean {
+    const transform = entity.getComponent(TransformComponent);
+    const size = entity.getComponent(SizeComponent);
 
-		if (!transform || !size) {
-			// position or/and size isnt set
-			return false;
-		}
+    if (!transform || !size) {
+      // position or/and size isnt set
+      return false;
+    }
 
-		const bounds = new Bounds(transform.position, new Vector2(size.width, size.height));
-		return bounds.contains(new Vector2(x, y));
-	}
+    const bounds = new Bounds(
+      transform.position,
+      new Vector2(size.width, size.height)
+    );
+    return bounds.contains(new Vector2(x, y));
+  }
 
-	/**
-	 * Based on {@link Position} and {@link Size}.
-	 *
-	 * @param {Entity} container
-	 * @param {Entity} object is contained in the container
-	 *
-	 * @returns {boolean} true if the objects is inside the container
-	 */
-	public static isObjectInsideContainer(
-		object: Entity,
-		container: { x: number; y: number; width: number; height: number; }
-	): boolean {
-		const objectTransform = object.getComponent(TransformComponent);
-		if (!objectTransform) {
-			return false;
-		}
+  /**
+   * Based on {@link Position} and {@link Size}.
+   *
+   * @param {Entity} container
+   * @param {Entity} object is contained in the container
+   *
+   * @returns {boolean} true if the objects is inside the container
+   */
+  public static isObjectInsideContainer(
+    object: Entity,
+    container: { x: number; y: number; width: number; height: number }
+  ): boolean {
+    const objectTransform = object.getComponent(TransformComponent);
+    if (!objectTransform) {
+      return false;
+    }
 
-		return (
-			objectTransform.position.x >= container.x &&
-			objectTransform.position.x <= container.x + container.width &&
-			objectTransform.position.y >= container.y &&
-			objectTransform.position.y <= container.y + container.height
-		);
-	}
+    return (
+      objectTransform.position.x >= container.x &&
+      objectTransform.position.x <= container.x + container.width &&
+      objectTransform.position.y >= container.y &&
+      objectTransform.position.y <= container.y + container.height
+    );
+  }
 
-	public static deselect(entity: Entity): void {
-		const selectable = entity.getMutableComponent(SelectableComponent);
-		if (!selectable) {
-			return;
-		}
-		selectable.selected = false;
-	}
+  public static deselect(entity: Entity): void {
+    const selectable = entity.getMutableComponent(SelectableComponent);
+    if (!selectable) {
+      return;
+    }
+    selectable.selected = false;
+  }
 
-	public static select(entity: Entity): void {
-		const selectable = entity.getMutableComponent(SelectableComponent);
-		if (!selectable) {
-			return;
-		}
-		selectable.selected = true;
-	}
+  public static select(entity: Entity): void {
+    const selectable = entity.getMutableComponent(SelectableComponent);
+    if (!selectable) {
+      return;
+    }
+    selectable.selected = true;
+  }
 
-	public static isSelected(entity: Entity): boolean {
-		const selectable = entity.getComponent(SelectableComponent);
-		if (!selectable) {
-			return false;
-		}
+  public static isSelected(entity: Entity): boolean {
+    const selectable = entity.getComponent(SelectableComponent);
+    if (!selectable) {
+      return false;
+    }
 
-		return selectable.selected;
-	}
+    return selectable.selected;
+  }
 
-	public static isMoving(entity: Entity): boolean {
-		const movePositionDirectComponent = entity.getComponent(MovePositionDirectComponent);
-		if (!movePositionDirectComponent) {
-			return false;
-		}
+  public static isMoving(entity: Entity): boolean {
+    const movePositionDirectComponent = entity.getComponent(
+      MovePositionDirectComponent
+    );
+    if (!movePositionDirectComponent) {
+      return false;
+    }
 
-		return movePositionDirectComponent.movePosition !== null;
-	}
+    return movePositionDirectComponent.movePosition !== null;
+  }
 }
diff --git a/src/game/EventBus.ts b/src/game/EventBus.ts
index c98a9d0..5254a48 100644
--- a/src/game/EventBus.ts
+++ b/src/game/EventBus.ts
@@ -4,30 +4,42 @@ type CustomEventListener<Detail> = (event: CustomEvent<Detail>) => void;
  * Source: https://css-tricks.com/lets-create-a-lightweight-native-event-bus-in-javascript/
  */
 export class EventBus<DetailOptions> {
-	private static counter = 0;
-	private readonly eventTarget: EventTarget;
+  private static counter = 0;
+  private readonly eventTarget: EventTarget;
 
-	constructor(name?: string) {
-		name = name || '' + ++EventBus.counter;
-		this.eventTarget = document.appendChild(
-			document.createComment('EventBus: ' + name)
-		);
-	}
-	public on<Detail extends DetailOptions>(type: string, listener: CustomEventListener<Detail>): void {
-		this.eventTarget.addEventListener(type, listener as EventListener);
-	}
+  constructor(name?: string) {
+    name = name || '' + ++EventBus.counter;
+    this.eventTarget = document.appendChild(
+      document.createComment('EventBus: ' + name)
+    );
+  }
+  public on<Detail extends DetailOptions>(
+    type: string,
+    listener: CustomEventListener<Detail>
+  ): void {
+    this.eventTarget.addEventListener(type, listener as EventListener);
+  }
 
-	public once<Detail extends DetailOptions>(type: string, listener: CustomEventListener<Detail>): void {
-		this.eventTarget.addEventListener(type, listener as EventListener, {
-			once: true,
-		});
-	}
+  public once<Detail extends DetailOptions>(
+    type: string,
+    listener: CustomEventListener<Detail>
+  ): void {
+    this.eventTarget.addEventListener(type, listener as EventListener, {
+      once: true,
+    });
+  }
 
-	public off<Detail extends DetailOptions>(type: string, listener: CustomEventListener<Detail>): void {
-		this.eventTarget.removeEventListener(type, listener as EventListener);
-	}
+  public off<Detail extends DetailOptions>(
+    type: string,
+    listener: CustomEventListener<Detail>
+  ): void {
+    this.eventTarget.removeEventListener(type, listener as EventListener);
+  }
 
-	public emit<Detail extends DetailOptions>(type: string, detail?: Detail): boolean {
-		return this.eventTarget.dispatchEvent(new CustomEvent(type, { detail }));
-	}
+  public emit<Detail extends DetailOptions>(
+    type: string,
+    detail?: Detail
+  ): boolean {
+    return this.eventTarget.dispatchEvent(new CustomEvent(type, { detail }));
+  }
 }
diff --git a/src/game/Events.ts b/src/game/Events.ts
index f7527ae..a6a1eb9 100644
--- a/src/game/Events.ts
+++ b/src/game/Events.ts
@@ -1,7 +1,7 @@
-import { Level } from "./levels/Level";
+import { Level } from './levels/Level';
 
 export interface LevelLoadedEvent {
-    level: Level;
+  level: Level;
 }
 
-export type Events = LevelLoadedEvent;
\ No newline at end of file
+export type Events = LevelLoadedEvent;
diff --git a/src/game/GameTime.ts b/src/game/GameTime.ts
index 450021e..fe49494 100644
--- a/src/game/GameTime.ts
+++ b/src/game/GameTime.ts
@@ -1,8 +1,8 @@
 export class GameTime {
-    /**
-     * Elapsed game time,
-     * this is the time that the game is running.
-     * When the game is paused this time is not updated.
-     */
-    public static delta: number = 0;
-}
\ No newline at end of file
+  /**
+   * Elapsed game time,
+   * this is the time that the game is running.
+   * When the game is paused this time is not updated.
+   */
+  public static delta: number = 0;
+}
diff --git a/src/game/Input.ts b/src/game/Input.ts
index 5babd1f..ccba34a 100644
--- a/src/game/Input.ts
+++ b/src/game/Input.ts
@@ -5,80 +5,82 @@ type KeysStatus = { [key: string]: KeyStatus | undefined };
 export type MouseButtonStatus = 'click' | 'dblclick' | 'mouseup' | 'mousedown';
 type MouseButtons = { [button: number]: MouseButtonStatus | undefined };
 
-
 export class Input {
-    private static keysStatus: KeysStatus = {};
-    public static mousePosition: Vector2 = Vector2.ZERO;
-    private static mouseButtons: MouseButtons = {};
-    private static mouseClick = 0;
+  private static keysStatus: KeysStatus = {};
+  public static mousePosition: Vector2 = Vector2.ZERO;
+  private static mouseButtons: MouseButtons = {};
+  private static mouseClick = 0;
 
-    public static addKeyStatus(key: string, type: KeyStatus): void {
-        this.keysStatus[key] = type;
-    }
+  public static addKeyStatus(key: string, type: KeyStatus): void {
+    this.keysStatus[key] = type;
+  }
 
-    public static setMouseButton(button: number, status: MouseButtonStatus): void {
-        if ('click' === status) {
-            this.mouseClick = 1;
-        } else if ('dblclick' === status) {
-            this.mouseClick = 2;
-        } else {
-            this.mouseButtons[button] = status;
-        }
+  public static setMouseButton(
+    button: number,
+    status: MouseButtonStatus
+  ): void {
+    if ('click' === status) {
+      this.mouseClick = 1;
+    } else if ('dblclick' === status) {
+      this.mouseClick = 2;
+    } else {
+      this.mouseButtons[button] = status;
     }
+  }
 
-    /**
-     * Cleans up key statussen that should be cleaned after a frame.
-     */
-    public static clearKeysStatus(): void {
-        for (const key of Object.keys(this.keysStatus)) {
-            if (this.keysStatus[key] === 'keyup') {
-                this.keysStatus[key] = undefined;
-            }
-        }
+  /**
+   * Cleans up key statussen that should be cleaned after a frame.
+   */
+  public static clearKeysStatus(): void {
+    for (const key of Object.keys(this.keysStatus)) {
+      if (this.keysStatus[key] === 'keyup') {
+        this.keysStatus[key] = undefined;
+      }
     }
+  }
 
-    /**
-     * Cleans up mouse statusses that should be cleaned after a frame.
-     */
-    public static clearMouseStatuses(): void {
-        for (const buttonString of (Object.keys(this.mouseButtons))) {
-            const button = parseInt(buttonString);
-            if (this.mouseButtons[button] === 'mouseup') {
-                this.mouseButtons[button] = undefined;
-            }
-        }
-        this.mouseClick = 0;
+  /**
+   * Cleans up mouse statusses that should be cleaned after a frame.
+   */
+  public static clearMouseStatuses(): void {
+    for (const buttonString of Object.keys(this.mouseButtons)) {
+      const button = parseInt(buttonString);
+      if (this.mouseButtons[button] === 'mouseup') {
+        this.mouseButtons[button] = undefined;
+      }
     }
+    this.mouseClick = 0;
+  }
 
-    private static isKey(key: string, type: KeyStatus): boolean {
-        return this.keysStatus[key] === type;
-    }
+  private static isKey(key: string, type: KeyStatus): boolean {
+    return this.keysStatus[key] === type;
+  }
 
-    public static isKeyPressed(key: string): boolean {
-        return this.isKey(key, 'keypress');
-    }
+  public static isKeyPressed(key: string): boolean {
+    return this.isKey(key, 'keypress');
+  }
 
-    public static isKeyDown(key: string): boolean {
-        return this.isKey(key, 'keydown');
-    }
+  public static isKeyDown(key: string): boolean {
+    return this.isKey(key, 'keydown');
+  }
 
-    public static isKeyUp(key: string): boolean {
-        return this.isKey(key, 'keyup');
-    }
+  public static isKeyUp(key: string): boolean {
+    return this.isKey(key, 'keyup');
+  }
 
-    public static isMouseButtonUp(button: number): boolean {
-        return this.mouseButtons[button] === 'mouseup';
-    }
+  public static isMouseButtonUp(button: number): boolean {
+    return this.mouseButtons[button] === 'mouseup';
+  }
 
-    public static isMouseButtonDown(button: number): boolean {
-        return this.mouseButtons[button] === 'mousedown';
-    }
+  public static isMouseButtonDown(button: number): boolean {
+    return this.mouseButtons[button] === 'mousedown';
+  }
 
-    public static isMouseClick(): boolean {
-        return this.mouseClick === 1;
-    }
+  public static isMouseClick(): boolean {
+    return this.mouseClick === 1;
+  }
 
-    public static isMouseDblClick(): boolean {
-        return this.mouseClick === 2;
-    }
-}
\ No newline at end of file
+  public static isMouseDblClick(): boolean {
+    return this.mouseClick === 2;
+  }
+}
diff --git a/src/game/Optional.ts b/src/game/Optional.ts
index d2b8bd1..3aafb59 100644
--- a/src/game/Optional.ts
+++ b/src/game/Optional.ts
@@ -1 +1 @@
-export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
\ No newline at end of file
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
diff --git a/src/game/__tests__/utils.ts b/src/game/__tests__/utils.ts
index 8dd60e0..e46f8bf 100644
--- a/src/game/__tests__/utils.ts
+++ b/src/game/__tests__/utils.ts
@@ -5,23 +5,34 @@ import { TransformComponent } from './../systems/TransformComponent';
 import { Position } from '../utils';
 import { Vector2 } from '../math/Vector2';
 
+export type CreateRandomEntities = (
+  length?: number,
+  minPosition?: Position,
+  maxPosition?: Position,
+  team?: number
+) => Entity[];
 
-export type CreateRandomEntities = (length?: number, minPosition?: Position, maxPosition?: Position, team?: number) => Entity[];
-
-export const constructCreateRandomEntities = (world: World): CreateRandomEntities => {
-    return (length: number = 30, minPosition: Position = { x: 3, y: 3}, maxPosition: Position = { x: 100, y: 100 }, team: number = 2) => {
-        return Array.from({ length: length }).map(() => {
-            return world.createEntity()
-                .addComponent(TransformComponent, {
-                    position: new Vector2(
-                        Math.round(Math.random() * maxPosition.x) + minPosition.x,
-                        Math.round(Math.random() * maxPosition.y) + minPosition.y
-                    ),
-                })
-                .addComponent(TeamComponent, {
-                    number: team
-                });
+export const constructCreateRandomEntities = (
+  world: World
+): CreateRandomEntities => {
+  return (
+    length: number = 30,
+    minPosition: Position = { x: 3, y: 3 },
+    maxPosition: Position = { x: 100, y: 100 },
+    team: number = 2
+  ) => {
+    return Array.from({ length: length }).map(() => {
+      return world
+        .createEntity()
+        .addComponent(TransformComponent, {
+          position: new Vector2(
+            Math.round(Math.random() * maxPosition.x) + minPosition.x,
+            Math.round(Math.random() * maxPosition.y) + minPosition.y
+          ),
+        })
+        .addComponent(TeamComponent, {
+          number: team,
         });
-    };
-}
-
+    });
+  };
+};
diff --git a/src/game/ai/behaviortree/Tree.ts b/src/game/ai/behaviortree/Tree.ts
index aba90e3..dbca2f9 100644
--- a/src/game/ai/behaviortree/Tree.ts
+++ b/src/game/ai/behaviortree/Tree.ts
@@ -1,11 +1,9 @@
-import { Node } from "./nodes/Node";
+import { Node } from './nodes/Node';
 
 export class Tree {
-    constructor(public readonly root: Node) {
+  constructor(public readonly root: Node) {}
 
-    }
-
-    public update(): void {
-        this.root.evaluate();
-    }
-}
\ No newline at end of file
+  public update(): void {
+    this.root.evaluate();
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/Node.spec.ts b/src/game/ai/behaviortree/nodes/Node.spec.ts
index 7dbb5e3..d6a1a11 100644
--- a/src/game/ai/behaviortree/nodes/Node.spec.ts
+++ b/src/game/ai/behaviortree/nodes/Node.spec.ts
@@ -1,101 +1,96 @@
-import { Node, State } from "./Node";
+import { Node, State } from './Node';
 
 describe('Node', () => {
-    describe('constructor', () => {
-        it('should set 0 children no children are given', () => {
-            const node = new Node();
-
-            expect(node.children).toHaveLength(0);
-        });
-
-        it('should set all children\'s parents', () => {
-            const node = new Node([
-                new Node([]),
-            ]);
-
-            expect(node.children[0].parent).toEqual(node);
-        });
-    })
-
-    describe('set children', () => {
-        it('should set 0 children if 0 are given', () => {
-            const node = new Node([]);
-
-            expect(node.children).toHaveLength(0);
-        });
-
-        it('should set children when given', () => {
-            const node = new Node([]);
-            node.children = [
-                new Node([]),
-            ];
-
-            expect(node.children).toHaveLength(1);
-            expect(node.children[0].parent).toEqual(node);
-        });
+  describe('constructor', () => {
+    it('should set 0 children no children are given', () => {
+      const node = new Node();
+
+      expect(node.children).toHaveLength(0);
+    });
+
+    it("should set all children's parents", () => {
+      const node = new Node([new Node([])]);
+
+      expect(node.children[0].parent).toEqual(node);
+    });
+  });
+
+  describe('set children', () => {
+    it('should set 0 children if 0 are given', () => {
+      const node = new Node([]);
+
+      expect(node.children).toHaveLength(0);
     });
 
-    describe('attach', () => {
-        it('should add to parent and set parent', () => {
-            const parent = new Node([]);
-            const child = new Node([]);
-            parent.attach(child);
+    it('should set children when given', () => {
+      const node = new Node([]);
+      node.children = [new Node([])];
 
-            expect(parent.children).toHaveLength(1);
-            expect(child.parent).toEqual(parent);
-        });
+      expect(node.children).toHaveLength(1);
+      expect(node.children[0].parent).toEqual(node);
     });
+  });
 
-    describe('detatch', () => {
-        it('should remove from children and remove parent', () => {
-            const child = new Node([]);
-            const parent = new Node([child]);
-            parent.detach(child);
+  describe('attach', () => {
+    it('should add to parent and set parent', () => {
+      const parent = new Node([]);
+      const child = new Node([]);
+      parent.attach(child);
 
-            expect(parent.children).toHaveLength(0);
-            expect(child.parent).toEqual(null);
-        });
+      expect(parent.children).toHaveLength(1);
+      expect(child.parent).toEqual(parent);
     });
+  });
 
-    describe('getData', () => {
-        it('should get data from node', () => {
-            const child = new Node([]);
-            child.data.set('test', true);
+  describe('detatch', () => {
+    it('should remove from children and remove parent', () => {
+      const child = new Node([]);
+      const parent = new Node([child]);
+      parent.detach(child);
 
-            expect(child.getData('test')).toEqual(true);
-        });
+      expect(parent.children).toHaveLength(0);
+      expect(child.parent).toEqual(null);
+    });
+  });
 
-        it('should get data from node\'s parent', () => {
-            const child = new Node([]);
-            const parent = new Node([child]);
-            parent.data.set('test', true);
+  describe('getData', () => {
+    it('should get data from node', () => {
+      const child = new Node([]);
+      child.data.set('test', true);
 
-            expect(child.getData('test')).toEqual(true);
-        });
+      expect(child.getData('test')).toEqual(true);
+    });
 
-        it('should get data from node\'s parent\'s parent', () => {
-            const child = new Node([]);
-            const parent = new Node([child]);
-            const parentsParent = new Node([parent]);
-            parentsParent.data.set('test', true);
+    it("should get data from node's parent", () => {
+      const child = new Node([]);
+      const parent = new Node([child]);
+      parent.data.set('test', true);
 
-            expect(child.getData('test')).toEqual(true);
-        });
+      expect(child.getData('test')).toEqual(true);
+    });
 
-        it('should not get data from node or any parent', () => {
-            const child = new Node([]);
-            const parent = new Node([child]);
+    it("should get data from node's parent's parent", () => {
+      const child = new Node([]);
+      const parent = new Node([child]);
+      const parentsParent = new Node([parent]);
+      parentsParent.data.set('test', true);
 
-            expect(child.getData('test')).toBeNull();
-        });
+      expect(child.getData('test')).toEqual(true);
     });
 
-    describe('evaluate', () => {
-        it('should return default state', () => {
-            const node = new Node([]);
+    it('should not get data from node or any parent', () => {
+      const child = new Node([]);
+      const parent = new Node([child]);
 
-            expect(node.evaluate()).toEqual(State.FAILURE);
-        });
+      expect(child.getData('test')).toBeNull();
     });
+  });
+
+  describe('evaluate', () => {
+    it('should return default state', () => {
+      const node = new Node([]);
 
-});
\ No newline at end of file
+      expect(node.evaluate()).toEqual(State.FAILURE);
+    });
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/Node.ts b/src/game/ai/behaviortree/nodes/Node.ts
index a7c8f96..fd41c6c 100644
--- a/src/game/ai/behaviortree/nodes/Node.ts
+++ b/src/game/ai/behaviortree/nodes/Node.ts
@@ -1,81 +1,81 @@
 export enum State {
-    RUNNING = 'running',
-    SUCCESS = 'success',
-    FAILURE = 'failure',
+  RUNNING = 'running',
+  SUCCESS = 'success',
+  FAILURE = 'failure',
 }
 
 export class Node {
-    private _state = State.FAILURE;
+  private _state = State.FAILURE;
 
-    public parent: Node|null = null; 
+  public parent: Node | null = null;
 
-    protected _children: Node[] = [];
+  protected _children: Node[] = [];
 
-    public readonly data: Map<string, unknown> = new Map();
+  public readonly data: Map<string, unknown> = new Map();
 
-    constructor(children: Node[] = []) {
-        this.children = children;
-    }
-    
-    public get state (): State {
-        return this._state;
-    }
+  constructor(children: Node[] = []) {
+    this.children = children;
+  }
 
-    protected set state(value: State) {
-        this._state = value;
-    }
+  public get state(): State {
+    return this._state;
+  }
 
-    public get children(): Node[] {
-        return this._children;
-    }
+  protected set state(value: State) {
+    this._state = value;
+  }
 
-    public set children(children: Node[]) {
-        children.forEach((child => this.attach(child)));
-    }
+  public get children(): Node[] {
+    return this._children;
+  }
 
-    public attach(child: Node): void {
-        this._children.push(child);
-        child.parent = this;
-    }
+  public set children(children: Node[]) {
+    children.forEach((child) => this.attach(child));
+  }
 
-    public detach(child: Node): void {
-        this._children = this._children.filter((c) => c !== child);
-        child.parent = null;
-    }
+  public attach(child: Node): void {
+    this._children.push(child);
+    child.parent = this;
+  }
 
-    public evaluate(): State {
-        return this.state;
-    }
+  public detach(child: Node): void {
+    this._children = this._children.filter((c) => c !== child);
+    child.parent = null;
+  }
 
-    public getData(key: string): unknown|null {
-        if (this.data.has(key)) {
-            return this.data.get(key);
-        }
+  public evaluate(): State {
+    return this.state;
+  }
 
-        return this.getDataOfParent(key);
+  public getData(key: string): unknown | null {
+    if (this.data.has(key)) {
+      return this.data.get(key);
     }
 
-    private getDataOfParent(key: string): unknown|null {
-        return this.parent?.getData(key) ?? null;
-    }
+    return this.getDataOfParent(key);
+  }
 
-    public setData(key: string, value: unknown): void {
-        this.data.set(key, value);
-    }
+  private getDataOfParent(key: string): unknown | null {
+    return this.parent?.getData(key) ?? null;
+  }
 
-    public hasChildren(): boolean {
-        return this.children.length > 0;
-    }
+  public setData(key: string, value: unknown): void {
+    this.data.set(key, value);
+  }
 
-    protected running(): State.RUNNING {
-        return this.state = State.RUNNING;
-    }
+  public hasChildren(): boolean {
+    return this.children.length > 0;
+  }
 
-    protected success(): State.SUCCESS {
-        return this.state = State.SUCCESS;
-    }
+  protected running(): State.RUNNING {
+    return (this.state = State.RUNNING);
+  }
 
-    protected failure(): State.FAILURE {
-        return this.state = State.FAILURE;
-    }
-}
\ No newline at end of file
+  protected success(): State.SUCCESS {
+    return (this.state = State.SUCCESS);
+  }
+
+  protected failure(): State.FAILURE {
+    return (this.state = State.FAILURE);
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/core/Always.spec.ts b/src/game/ai/behaviortree/nodes/core/Always.spec.ts
index 8038d42..2cc26b0 100644
--- a/src/game/ai/behaviortree/nodes/core/Always.spec.ts
+++ b/src/game/ai/behaviortree/nodes/core/Always.spec.ts
@@ -2,15 +2,14 @@ import { State } from '../Node';
 import { Always } from './Always';
 
 describe('Always', () => {
-    describe('evaluate', () => {
-        it.each([
-            [State.FAILURE],
-            [State.RUNNING],
-            [State.SUCCESS],
-        ])('should return %s when set', (state) => {
-            const always = new Always(state);
+  describe('evaluate', () => {
+    it.each([[State.FAILURE], [State.RUNNING], [State.SUCCESS]])(
+      'should return %s when set',
+      (state) => {
+        const always = new Always(state);
 
-            expect(always.evaluate()).toEqual(state);
-        });
-    });
-});
\ No newline at end of file
+        expect(always.evaluate()).toEqual(state);
+      }
+    );
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/core/Always.ts b/src/game/ai/behaviortree/nodes/core/Always.ts
index 76b1f93..1d84454 100644
--- a/src/game/ai/behaviortree/nodes/core/Always.ts
+++ b/src/game/ai/behaviortree/nodes/core/Always.ts
@@ -1,9 +1,9 @@
-import { Node, State } from "../Node";
+import { Node, State } from '../Node';
 
 export class Always extends Node {
-    constructor(state: State) {
-        super([]);
+  constructor(state: State) {
+    super([]);
 
-        this.state = state;
-    }
-}
\ No newline at end of file
+    this.state = state;
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/core/Inventer.spec.ts b/src/game/ai/behaviortree/nodes/core/Inventer.spec.ts
index e91df1e..9151dfe 100644
--- a/src/game/ai/behaviortree/nodes/core/Inventer.spec.ts
+++ b/src/game/ai/behaviortree/nodes/core/Inventer.spec.ts
@@ -1,42 +1,40 @@
 import { Always } from './Always';
 import { Inventer } from './Inventer';
-import { State } from "../Node";
+import { State } from '../Node';
 
 describe('Inventer', () => {
-    describe('evaluate', () => {
-        it('should return failure when there are no children', () => {
-            const inventer = new Inventer([]);
-
-            expect(inventer.evaluate()).toEqual(State.FAILURE);
-        });
-
-        it('should invert first child when multiple are given', () => {
-            const inventer = new Inventer([
-                new Always(State.FAILURE),
-                new Always(State.RUNNING),
-            ]);
-
-            expect(inventer.evaluate()).toEqual(State.SUCCESS);
-        });
-
-        it('should return failure when child has no state', () => {
-            const inventer = new Inventer([
-                new Always(undefined as unknown as State),
-            ]);
-
-            expect(inventer.evaluate()).toEqual(State.FAILURE);
-        });
-
-        it.each([
-            [State.FAILURE, State.SUCCESS],
-            [State.SUCCESS, State.FAILURE],
-            [State.RUNNING, State.RUNNING],
-        ])('should return %s when %s is given', (childState, returnValue) => {
-            const inventer = new Inventer([
-                new Always(childState),
-            ]);
-
-            expect(inventer.evaluate()).toEqual(returnValue);
-        });
+  describe('evaluate', () => {
+    it('should return failure when there are no children', () => {
+      const inventer = new Inventer([]);
+
+      expect(inventer.evaluate()).toEqual(State.FAILURE);
+    });
+
+    it('should invert first child when multiple are given', () => {
+      const inventer = new Inventer([
+        new Always(State.FAILURE),
+        new Always(State.RUNNING),
+      ]);
+
+      expect(inventer.evaluate()).toEqual(State.SUCCESS);
+    });
+
+    it('should return failure when child has no state', () => {
+      const inventer = new Inventer([
+        new Always(undefined as unknown as State),
+      ]);
+
+      expect(inventer.evaluate()).toEqual(State.FAILURE);
+    });
+
+    it.each([
+      [State.FAILURE, State.SUCCESS],
+      [State.SUCCESS, State.FAILURE],
+      [State.RUNNING, State.RUNNING],
+    ])('should return %s when %s is given', (childState, returnValue) => {
+      const inventer = new Inventer([new Always(childState)]);
+
+      expect(inventer.evaluate()).toEqual(returnValue);
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/core/Inventer.ts b/src/game/ai/behaviortree/nodes/core/Inventer.ts
index ffbe94f..d2d7852 100644
--- a/src/game/ai/behaviortree/nodes/core/Inventer.ts
+++ b/src/game/ai/behaviortree/nodes/core/Inventer.ts
@@ -1,25 +1,25 @@
-import { Node, State } from "../Node";
+import { Node, State } from '../Node';
 
 const invertStateMap = new Map<State, State>([
-    [State.FAILURE, State.SUCCESS],
-    [State.SUCCESS, State.FAILURE],
-    [State.RUNNING, State.RUNNING],
+  [State.FAILURE, State.SUCCESS],
+  [State.SUCCESS, State.FAILURE],
+  [State.RUNNING, State.RUNNING],
 ]);
 
 /**
  * This is the "Not" operator (!).
  */
 export class Inventer extends Node {
-    public evaluate(): State {
-        if (!this.hasChildren()) {
-            return this.failure();
-        }
-        
-        const childState = this.children[0].evaluate();
-        if (!invertStateMap.has(childState)) {
-            return this.failure();
-        }
+  public evaluate(): State {
+    if (!this.hasChildren()) {
+      return this.failure();
+    }
 
-        return this.state = invertStateMap.get(childState)!;
+    const childState = this.children[0].evaluate();
+    if (!invertStateMap.has(childState)) {
+      return this.failure();
     }
-}
\ No newline at end of file
+
+    return (this.state = invertStateMap.get(childState)!);
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/core/Parallel.spec.ts b/src/game/ai/behaviortree/nodes/core/Parallel.spec.ts
index 460b187..ba8bd60 100644
--- a/src/game/ai/behaviortree/nodes/core/Parallel.spec.ts
+++ b/src/game/ai/behaviortree/nodes/core/Parallel.spec.ts
@@ -3,58 +3,64 @@ import { Parallel } from './Parallel';
 import { Always } from './Always';
 
 describe('Parallel', () => {
-    describe('constructor', () => {
-        it('should set defaults', () => {
-            const parallel = new Parallel([]);
+  describe('constructor', () => {
+    it('should set defaults', () => {
+      const parallel = new Parallel([]);
 
-            expect(parallel.requireAllSuccess).toBe(false);
-        });
+      expect(parallel.requireAllSuccess).toBe(false);
     });
+  });
 
-    describe('evaluate', () => {
-        it('should return success when there are 0 children', () => {
-            const parallel = new Parallel([]);
-
-            expect(parallel.evaluate()).toEqual(State.SUCCESS);
-        });
-
-        it('should return failure when all children are failed', () => {
-            const parallel = new Parallel([
-                new Always(State.FAILURE),
-                new Always(State.FAILURE),
-                new Always(State.FAILURE),
-            ]);
-
-            expect(parallel.evaluate()).toEqual(State.FAILURE);
-        });
-
-        it('should return running when any child is running and requireAllSuccess is true', () => {
-            const parallel = new Parallel([
-                new Always(State.RUNNING),
-                new Always(State.FAILURE),
-            ], true);
-
-            expect(parallel.evaluate()).toEqual(State.FAILURE);
-        });
-
-        it('should return success if all children are success and requireAllSuccess is true', () => {
-            const parallel = new Parallel([
-                new Always(State.SUCCESS),
-                new Always(State.SUCCESS),
-                new Always(State.SUCCESS),
-            ], true);
-
-            expect(parallel.evaluate()).toEqual(State.SUCCESS);
-        });
-
-        it('should return success if one child is success and requireAllSuccess is false', () => {
-            const parallel = new Parallel([
-                new Always(State.SUCCESS),
-                new Always(State.FAILURE),
-                new Always(State.FAILURE),
-            ], false);
-
-            expect(parallel.evaluate()).toEqual(State.SUCCESS);
-        });
+  describe('evaluate', () => {
+    it('should return success when there are 0 children', () => {
+      const parallel = new Parallel([]);
+
+      expect(parallel.evaluate()).toEqual(State.SUCCESS);
+    });
+
+    it('should return failure when all children are failed', () => {
+      const parallel = new Parallel([
+        new Always(State.FAILURE),
+        new Always(State.FAILURE),
+        new Always(State.FAILURE),
+      ]);
+
+      expect(parallel.evaluate()).toEqual(State.FAILURE);
+    });
+
+    it('should return running when any child is running and requireAllSuccess is true', () => {
+      const parallel = new Parallel(
+        [new Always(State.RUNNING), new Always(State.FAILURE)],
+        true
+      );
+
+      expect(parallel.evaluate()).toEqual(State.FAILURE);
+    });
+
+    it('should return success if all children are success and requireAllSuccess is true', () => {
+      const parallel = new Parallel(
+        [
+          new Always(State.SUCCESS),
+          new Always(State.SUCCESS),
+          new Always(State.SUCCESS),
+        ],
+        true
+      );
+
+      expect(parallel.evaluate()).toEqual(State.SUCCESS);
+    });
+
+    it('should return success if one child is success and requireAllSuccess is false', () => {
+      const parallel = new Parallel(
+        [
+          new Always(State.SUCCESS),
+          new Always(State.FAILURE),
+          new Always(State.FAILURE),
+        ],
+        false
+      );
+
+      expect(parallel.evaluate()).toEqual(State.SUCCESS);
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/core/Parallel.ts b/src/game/ai/behaviortree/nodes/core/Parallel.ts
index d42dbb6..9d505c3 100644
--- a/src/game/ai/behaviortree/nodes/core/Parallel.ts
+++ b/src/game/ai/behaviortree/nodes/core/Parallel.ts
@@ -1,39 +1,42 @@
-import { Node, State } from "../Node";
+import { Node, State } from '../Node';
 
 /**
  * Processes all of its children at the same time and only "computes" its success/failure state at the end of all child executions
  */
 export class Parallel extends Node {
-    constructor(children: Node[], public readonly requireAllSuccess = false) {
-        super(children);
-    }
+  constructor(children: Node[], public readonly requireAllSuccess = false) {
+    super(children);
+  }
 
-    public evaluate(): State {
-        if (!this.hasChildren()) {
-            return this.success();
-        }
+  public evaluate(): State {
+    if (!this.hasChildren()) {
+      return this.success();
+    }
 
-        let failedChildren = 0;
-        let runningChildren = 0;
+    let failedChildren = 0;
+    let runningChildren = 0;
 
-        for(const child of this.children) {
-            switch(child.evaluate()) {
-                case State.SUCCESS:
-                    continue;
-                case State.RUNNING:
-                    runningChildren++;
-                    continue;
-                case State.FAILURE:
-                default:
-                    failedChildren++;
-                    continue;
-            }
-        }
+    for (const child of this.children) {
+      switch (child.evaluate()) {
+        case State.SUCCESS:
+          continue;
+        case State.RUNNING:
+          runningChildren++;
+          continue;
+        case State.FAILURE:
+        default:
+          failedChildren++;
+          continue;
+      }
+    }
 
-        if ((this.requireAllSuccess && failedChildren > 0) || failedChildren === this.children.length) {
-            return this.failure();
-        } else {
-            return runningChildren > 0 ? this.running() : this.success();
-        }
+    if (
+      (this.requireAllSuccess && failedChildren > 0) ||
+      failedChildren === this.children.length
+    ) {
+      return this.failure();
+    } else {
+      return runningChildren > 0 ? this.running() : this.success();
     }
-}
\ No newline at end of file
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/core/Selector.spec.ts b/src/game/ai/behaviortree/nodes/core/Selector.spec.ts
index 67774be..e62d29d 100644
--- a/src/game/ai/behaviortree/nodes/core/Selector.spec.ts
+++ b/src/game/ai/behaviortree/nodes/core/Selector.spec.ts
@@ -1,50 +1,50 @@
-import { Node, State } from "../Node";
-import { Selector } from "./Selector";
-import { Always } from "./Always";
+import { Node, State } from '../Node';
+import { Selector } from './Selector';
+import { Always } from './Always';
 
 describe('Selector', () => {
-    describe('evaluate', () => {
-        it('should fail when no children are set', () => {
-            const selector = new Selector([]);
-
-            expect(selector.evaluate()).toEqual(State.SUCCESS);
-        });
-
-        it('should fail when all children fail', () => {
-            const selector = new Selector([
-                new Always(State.FAILURE),
-                new Always(State.FAILURE),
-                new Always(State.FAILURE),
-            ]);
-
-            expect(selector.evaluate()).toEqual(State.FAILURE);
-        });
-
-        it('should return success when one of the children returned success', () => {
-            const selector = new Selector([
-                new Always(State.FAILURE),
-                new Always(State.SUCCESS),
-            ]);
-
-            expect(selector.evaluate()).toEqual(State.SUCCESS);
-        });
-
-        it('should return running when one of the children returned running', () => {
-            const selector = new Selector([
-                new Always(State.FAILURE),
-                new Always(State.RUNNING),
-            ]);
-
-            expect(selector.evaluate()).toEqual(State.RUNNING);
-        });
-
-        it('should return success when there are also running children', () => {
-            const selector = new Selector([
-                new Always(State.RUNNING),
-                new Always(State.SUCCESS),
-            ]);
-
-            expect(selector.evaluate()).toEqual(State.SUCCESS);
-        });
+  describe('evaluate', () => {
+    it('should fail when no children are set', () => {
+      const selector = new Selector([]);
+
+      expect(selector.evaluate()).toEqual(State.SUCCESS);
+    });
+
+    it('should fail when all children fail', () => {
+      const selector = new Selector([
+        new Always(State.FAILURE),
+        new Always(State.FAILURE),
+        new Always(State.FAILURE),
+      ]);
+
+      expect(selector.evaluate()).toEqual(State.FAILURE);
+    });
+
+    it('should return success when one of the children returned success', () => {
+      const selector = new Selector([
+        new Always(State.FAILURE),
+        new Always(State.SUCCESS),
+      ]);
+
+      expect(selector.evaluate()).toEqual(State.SUCCESS);
+    });
+
+    it('should return running when one of the children returned running', () => {
+      const selector = new Selector([
+        new Always(State.FAILURE),
+        new Always(State.RUNNING),
+      ]);
+
+      expect(selector.evaluate()).toEqual(State.RUNNING);
+    });
+
+    it('should return success when there are also running children', () => {
+      const selector = new Selector([
+        new Always(State.RUNNING),
+        new Always(State.SUCCESS),
+      ]);
+
+      expect(selector.evaluate()).toEqual(State.SUCCESS);
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/core/Selector.ts b/src/game/ai/behaviortree/nodes/core/Selector.ts
index 798b835..50934d3 100644
--- a/src/game/ai/behaviortree/nodes/core/Selector.ts
+++ b/src/game/ai/behaviortree/nodes/core/Selector.ts
@@ -1,29 +1,29 @@
-import { Node, State } from "../Node";
+import { Node, State } from '../Node';
 
 /**
  * This is the "Or" operator.
  */
 export class Selector extends Node {
-    public evaluate(): State {
-        if (!this.hasChildren()) {
-            return this.success();
-        }
+  public evaluate(): State {
+    if (!this.hasChildren()) {
+      return this.success();
+    }
+
+    for (const child of this.children) {
+      const state = child.evaluate();
 
-        for(const child of this.children) {
-            const state = child.evaluate();
+      if (state === State.SUCCESS) {
+        return this.success();
+      } else if (state === State.RUNNING) {
+        this.state = State.RUNNING;
+      }
+    }
 
-            if (state === State.SUCCESS) {
-                return this.success();
-            } else if (state === State.RUNNING) {
-                this.state = State.RUNNING;
-            }
-        }
-    
-        if (this.state === State.FAILURE) {
-            return this.failure();
-        } else if (this.children.length === 0) {
-            return this.success();
-        }
-        return this.state;
+    if (this.state === State.FAILURE) {
+      return this.failure();
+    } else if (this.children.length === 0) {
+      return this.success();
     }
-}
\ No newline at end of file
+    return this.state;
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/core/Sequence.spec.ts b/src/game/ai/behaviortree/nodes/core/Sequence.spec.ts
index 421952b..5277085 100644
--- a/src/game/ai/behaviortree/nodes/core/Sequence.spec.ts
+++ b/src/game/ai/behaviortree/nodes/core/Sequence.spec.ts
@@ -1,41 +1,41 @@
 import { Always } from './Always';
-import { State } from "../Node";
-import { Sequence } from "./Sequence";
+import { State } from '../Node';
+import { Sequence } from './Sequence';
 
 describe('Sequence', () => {
-    describe('evaluate', () => {
-        it('should return success when there are 0 children', () => {
-            const sequence = new Sequence([]);
-
-            expect(sequence.evaluate()).toEqual(State.SUCCESS);
-        });
-
-        it('should return failure when any child is failure', () => {
-            const sequence = new Sequence([
-                new Always(State.RUNNING),
-                new Always(State.FAILURE),
-                new Always(State.SUCCESS),
-            ]);
-
-            expect(sequence.evaluate()).toEqual(State.FAILURE);
-        });
-
-        it('should return running when any child is running', () => {
-            const sequence = new Sequence([
-                new Always(State.SUCCESS),
-                new Always(State.RUNNING),
-            ]);
-
-            expect(sequence.evaluate()).toEqual(State.RUNNING);
-        });
-
-        it('should return success when there all children are success', () => {
-            const sequence = new Sequence([
-                new Always(State.SUCCESS),
-                new Always(State.SUCCESS),
-            ]);
-
-            expect(sequence.evaluate()).toEqual(State.SUCCESS);
-        });
+  describe('evaluate', () => {
+    it('should return success when there are 0 children', () => {
+      const sequence = new Sequence([]);
+
+      expect(sequence.evaluate()).toEqual(State.SUCCESS);
+    });
+
+    it('should return failure when any child is failure', () => {
+      const sequence = new Sequence([
+        new Always(State.RUNNING),
+        new Always(State.FAILURE),
+        new Always(State.SUCCESS),
+      ]);
+
+      expect(sequence.evaluate()).toEqual(State.FAILURE);
+    });
+
+    it('should return running when any child is running', () => {
+      const sequence = new Sequence([
+        new Always(State.SUCCESS),
+        new Always(State.RUNNING),
+      ]);
+
+      expect(sequence.evaluate()).toEqual(State.RUNNING);
+    });
+
+    it('should return success when there all children are success', () => {
+      const sequence = new Sequence([
+        new Always(State.SUCCESS),
+        new Always(State.SUCCESS),
+      ]);
+
+      expect(sequence.evaluate()).toEqual(State.SUCCESS);
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/core/Sequence.ts b/src/game/ai/behaviortree/nodes/core/Sequence.ts
index 70ee0ae..d390195 100644
--- a/src/game/ai/behaviortree/nodes/core/Sequence.ts
+++ b/src/game/ai/behaviortree/nodes/core/Sequence.ts
@@ -1,25 +1,25 @@
-import { Node, State } from "../Node";
+import { Node, State } from '../Node';
 
 /**
  * This is the "And" operator.
  */
 export class Sequence extends Node {
-    public evaluate(): State {
-        let anyChildIsRunning = false;
+  public evaluate(): State {
+    let anyChildIsRunning = false;
 
-        for(const child of this.children) {
-            switch(child.evaluate()) {
-                case State.RUNNING:
-                    anyChildIsRunning = true;
-                    continue;
-                case State.SUCCESS:
-                    continue;
-                case State.FAILURE:
-                default:
-                    return this.failure();
-            }
-        }
-
-        return anyChildIsRunning ? this.running() : this.success();
+    for (const child of this.children) {
+      switch (child.evaluate()) {
+        case State.RUNNING:
+          anyChildIsRunning = true;
+          continue;
+        case State.SUCCESS:
+          continue;
+        case State.FAILURE:
+        default:
+          return this.failure();
+      }
     }
-}
\ No newline at end of file
+
+    return anyChildIsRunning ? this.running() : this.success();
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/core/Timer.spec.ts b/src/game/ai/behaviortree/nodes/core/Timer.spec.ts
index f32850a..cb080f8 100644
--- a/src/game/ai/behaviortree/nodes/core/Timer.spec.ts
+++ b/src/game/ai/behaviortree/nodes/core/Timer.spec.ts
@@ -4,131 +4,126 @@ import { Always } from './Always';
 import { Timer } from './Timer';
 
 describe('Timer', () => {
-    const successChildren = [
-        new Always(State.SUCCESS),
-    ];
-    const successProps = {
+  const successChildren = [new Always(State.SUCCESS)];
+  const successProps = {
+    delay: 1000,
+    children: successChildren,
+  };
+
+  describe('constructor', () => {
+    it('should set values', () => {
+      const elapsedCallback = () => {};
+      const timer = new Timer({
+        ...successProps,
+        elapsedCallback,
+      });
+
+      expect(timer.delay).toBe(1000);
+      expect(timer.countdownTimer).toBe(1000);
+      expect(timer.elapsedCallback).toEqual(elapsedCallback);
+      expect(timer.children).toHaveLength(1);
+    });
+
+    it('should set defaults', () => {
+      const timer = new Timer({
         delay: 1000,
-        children: successChildren
-    };
-
-    describe('constructor', () => {
-        it('should set values', () => {
-            const elapsedCallback = () => {};
-            const timer = new Timer({
-                ...successProps,
-                elapsedCallback,
-            });
-
-            expect(timer.delay).toBe(1000);
-            expect(timer.countdownTimer).toBe(1000);
-            expect(timer.elapsedCallback).toEqual(elapsedCallback);
-            expect(timer.children).toHaveLength(1);
-        });
-
-        it('should set defaults', () => {
-            const timer = new Timer({
-                delay: 1000,
-            });
-
-            expect(timer.delay).toBe(1000);
-            expect(timer.countdownTimer).toBe(1000);
-            expect(timer.elapsedCallback).toBeNull();
-        });
+      });
+
+      expect(timer.delay).toBe(1000);
+      expect(timer.countdownTimer).toBe(1000);
+      expect(timer.elapsedCallback).toBeNull();
+    });
+  });
+
+  describe('isElapsed', () => {
+    it('should return false if time is higher than 0', () => {
+      const timer = new Timer({
+        ...successProps,
+      });
+
+      expect(timer.isElapsed()).toBe(false);
+    });
+
+    it('should return true if time is 0', () => {
+      const timer = new Timer({
+        ...successProps,
+      });
+      GameTime.delta = 1000;
+      timer.evaluate();
+
+      expect(timer.isElapsed()).toBe(true);
     });
 
-    describe('isElapsed', () => {
-        it('should return false if time is higher than 0', () => {
-            const timer = new Timer({
-                ...successProps,
-            });
-
-            expect(timer.isElapsed()).toBe(false);
-        });
-
-        it('should return true if time is 0', () => {
-            const timer = new Timer({
-                ...successProps,
-            });
-            GameTime.delta = 1000;
-            timer.evaluate();
-
-            expect(timer.isElapsed()).toBe(true);
-        });
-
-        it('should return true if time is lower than 0', () => {
-            const timer = new Timer({
-                ...successProps,
-            });
-            GameTime.delta = 1100;
-            timer.evaluate();
-
-            expect(timer.isElapsed()).toBe(true);
-        });
+    it('should return true if time is lower than 0', () => {
+      const timer = new Timer({
+        ...successProps,
+      });
+      GameTime.delta = 1100;
+      timer.evaluate();
+
+      expect(timer.isElapsed()).toBe(true);
     });
+  });
+
+  describe('reset', () => {
+    it('should set countdownTimer to the given delay', () => {
+      const timer = new Timer(successProps);
+      GameTime.delta = 500;
+      timer.evaluate();
 
-    describe('reset', () => {
-        it('should set countdownTimer to the given delay', () => {
-            const timer = new Timer(successProps);
-            GameTime.delta = 500;
-            timer.evaluate();
+      timer.reset();
 
-            timer.reset();
+      expect(timer.countdownTimer).toEqual(1000);
+    });
+  });
+
+  describe('evaluate', () => {
+    it('should return failure if it has no children', () => {
+      const timer = new Timer({
+        delay: 1000,
+      });
 
-            expect(timer.countdownTimer).toEqual(1000);
-        });
+      expect(timer.evaluate()).toEqual(State.FAILURE);
     });
 
-    describe('evaluate', () => {
-        it('should return failure if it has no children', () => {
-            const timer = new Timer({
-                delay: 1000, 
-            });
-
-            expect(timer.evaluate()).toEqual(State.FAILURE);
-        });
-
-        it('should be running and time subtracted when called', () => {
-            const timer = new Timer(successProps);
-            GameTime.delta = 100;
-
-            expect(timer.evaluate()).toBe(State.RUNNING);
-            expect(timer.countdownTimer).toEqual(900);
-        });
-
-        it('should evaluate first child when time is elapsed', () => {
-            const timer = new Timer({
-                delay: 1000,
-                children: [
-                    new Always(State.SUCCESS),
-                    new Always(State.FAILURE),
-                ]
-            });
-            GameTime.delta = 1000;
-
-            expect(timer.evaluate()).toEqual(State.SUCCESS);
-        });
-
-        it('should call endedCallback when time is elapsed', () => {
-            const elapsedCallback = jest.fn();
-            const timer = new Timer({
-                ...successProps,
-                elapsedCallback, 
-            });
-            GameTime.delta = 1000;
-
-            timer.evaluate();
-
-            expect(elapsedCallback).toBeCalled();
-        });
-
-        it('should set countdownTimer when evalated', () => {
-            const timer = new Timer(successProps);
-            GameTime.delta = 1000;
-
-            timer.evaluate();
-
-            expect(timer.countdownTimer).toEqual(0);
-        });
+    it('should be running and time subtracted when called', () => {
+      const timer = new Timer(successProps);
+      GameTime.delta = 100;
+
+      expect(timer.evaluate()).toBe(State.RUNNING);
+      expect(timer.countdownTimer).toEqual(900);
+    });
+
+    it('should evaluate first child when time is elapsed', () => {
+      const timer = new Timer({
+        delay: 1000,
+        children: [new Always(State.SUCCESS), new Always(State.FAILURE)],
+      });
+      GameTime.delta = 1000;
+
+      expect(timer.evaluate()).toEqual(State.SUCCESS);
+    });
+
+    it('should call endedCallback when time is elapsed', () => {
+      const elapsedCallback = jest.fn();
+      const timer = new Timer({
+        ...successProps,
+        elapsedCallback,
+      });
+      GameTime.delta = 1000;
+
+      timer.evaluate();
+
+      expect(elapsedCallback).toBeCalled();
+    });
+
+    it('should set countdownTimer when evalated', () => {
+      const timer = new Timer(successProps);
+      GameTime.delta = 1000;
+
+      timer.evaluate();
+
+      expect(timer.countdownTimer).toEqual(0);
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/core/Timer.ts b/src/game/ai/behaviortree/nodes/core/Timer.ts
index ad0d01d..dfe8ff6 100644
--- a/src/game/ai/behaviortree/nodes/core/Timer.ts
+++ b/src/game/ai/behaviortree/nodes/core/Timer.ts
@@ -1,58 +1,58 @@
 import { GameTime } from './../../../../GameTime';
-import { Node, State } from "../Node";
+import { Node, State } from '../Node';
 
 type ElapsedCallback = () => void;
 
 type TimerProps = {
-    delay: number;
-    elapsedCallback?: ElapsedCallback|null;
-    children?: Node[];
+  delay: number;
+  elapsedCallback?: ElapsedCallback | null;
+  children?: Node[];
 };
 
 export class Timer extends Node {
-    public readonly delay: number;
-    public readonly elapsedCallback: ElapsedCallback|null;
-    private _countdownTimer: number;
-
-    constructor(props: TimerProps) {
-        super(props.children);
-        
-        this.delay = props.delay;
-        this._countdownTimer = this.delay;
-        this.elapsedCallback = props.elapsedCallback ?? null;
-    }
+  public readonly delay: number;
+  public readonly elapsedCallback: ElapsedCallback | null;
+  private _countdownTimer: number;
 
-    public get countdownTimer () {
-        return this._countdownTimer;
-    }
+  constructor(props: TimerProps) {
+    super(props.children);
+
+    this.delay = props.delay;
+    this._countdownTimer = this.delay;
+    this.elapsedCallback = props.elapsedCallback ?? null;
+  }
+
+  public get countdownTimer() {
+    return this._countdownTimer;
+  }
 
-    public isElapsed(): boolean {
-        return this.countdownTimer <= 0;
+  public isElapsed(): boolean {
+    return this.countdownTimer <= 0;
+  }
+
+  public reset(): void {
+    this._countdownTimer = this.delay;
+  }
+
+  public evaluate(): State {
+    if (this.isElapsed()) {
+      this.reset();
     }
 
-    public reset(): void {
-        this._countdownTimer = this.delay;
+    if (!this.hasChildren()) {
+      return this.failure();
     }
+    this._countdownTimer -= GameTime.delta;
+
+    if (this.isElapsed()) {
+      this.state = this.children[0].evaluate();
+      if (this.elapsedCallback) {
+        this.elapsedCallback();
+      }
 
-    public evaluate(): State {
-        if (this.isElapsed()) {
-            this.reset();
-        }
-
-        if (!this.hasChildren()) {
-            return this.failure();
-        }
-        this._countdownTimer -= GameTime.delta;
-
-        if (this.isElapsed()) {
-            this.state = this.children[0].evaluate();
-            if (this.elapsedCallback) {
-                this.elapsedCallback();
-            }
-            
-            return this.state;
-        } else {
-            return this.running();
-        }
+      return this.state;
+    } else {
+      return this.running();
     }
-}
\ No newline at end of file
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/core/index.ts b/src/game/ai/behaviortree/nodes/core/index.ts
index 7633836..6533998 100644
--- a/src/game/ai/behaviortree/nodes/core/index.ts
+++ b/src/game/ai/behaviortree/nodes/core/index.ts
@@ -3,4 +3,4 @@ export * from './Inventer';
 export * from './Parallel';
 export * from './Selector';
 export * from './Sequence';
-export * from './Timer';
\ No newline at end of file
+export * from './Timer';
diff --git a/src/game/ai/behaviortree/nodes/entity/Attack.spec.ts b/src/game/ai/behaviortree/nodes/entity/Attack.spec.ts
index 5babb08..08a2f32 100644
--- a/src/game/ai/behaviortree/nodes/entity/Attack.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/Attack.spec.ts
@@ -4,27 +4,25 @@ import { World } from 'ecsy';
 import { State } from '../Node';
 import { Attack } from './Attack';
 describe('Attack', () => {
-    describe('evaluate', () => {
-        const world = new World()
-            .registerComponent(AttackComponent)
-            .registerComponent(HealthComponent);
+  describe('evaluate', () => {
+    const world = new World()
+      .registerComponent(AttackComponent)
+      .registerComponent(HealthComponent);
 
-        it('should substracts entity\'s attackDamage from target health', () => {
-            const entity = world.createEntity()
-                .addComponent(AttackComponent, {
-                    attackDamage: 10
-                });
-            const target = world.createEntity()
-                .addComponent(HealthComponent, {
-                    points: 100,
-                });
+    it("should substracts entity's attackDamage from target health", () => {
+      const entity = world.createEntity().addComponent(AttackComponent, {
+        attackDamage: 10,
+      });
+      const target = world.createEntity().addComponent(HealthComponent, {
+        points: 100,
+      });
 
-            const attack = new Attack();
-            attack.setData('entity', entity);
-            attack.setData('target', target);
+      const attack = new Attack();
+      attack.setData('entity', entity);
+      attack.setData('target', target);
 
-            expect(attack.evaluate()).toBe(State.SUCCESS);
-            expect(target.getComponent(HealthComponent)!.points).toEqual(90);
-        });
+      expect(attack.evaluate()).toBe(State.SUCCESS);
+      expect(target.getComponent(HealthComponent)!.points).toEqual(90);
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/Attack.ts b/src/game/ai/behaviortree/nodes/entity/Attack.ts
index f75c18a..b5d1b0d 100644
--- a/src/game/ai/behaviortree/nodes/entity/Attack.ts
+++ b/src/game/ai/behaviortree/nodes/entity/Attack.ts
@@ -1,18 +1,18 @@
 import { setEntityAnimation } from './../../../../systems/render/sprite/utils';
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
-import { State } from "../Node";
-import { EntityNode } from "./EntityNode";
+import { State } from '../Node';
+import { EntityNode } from './EntityNode';
 import { AttackComponent } from './../../../../systems/AttackComponent';
 
 export class Attack extends EntityNode {
-    protected evaluateByEntity(entity: Entity): State {
-        const attackComponent = entity.getComponent(AttackComponent)!;
-        const target = this.getData('target') as Entity;
+  protected evaluateByEntity(entity: Entity): State {
+    const attackComponent = entity.getComponent(AttackComponent)!;
+    const target = this.getData('target') as Entity;
 
-        setEntityAnimation(entity, 'attack');
-        attackComponent.attack(target);
+    setEntityAnimation(entity, 'attack');
+    attackComponent.attack(target);
 
-        return this.success();
-    }
-}
\ No newline at end of file
+    return this.success();
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/EntityNode.spec.ts b/src/game/ai/behaviortree/nodes/entity/EntityNode.spec.ts
index 8daba1b..2474bb2 100644
--- a/src/game/ai/behaviortree/nodes/entity/EntityNode.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/EntityNode.spec.ts
@@ -1,31 +1,31 @@
 import { Entity, World } from 'ecsy';
-import { State } from "../Node";
-import { EntityNode } from "./EntityNode";
+import { State } from '../Node';
+import { EntityNode } from './EntityNode';
 
 class ImplementedEntityNode extends EntityNode {
-    protected evaluateByEntity(entity: Entity): State {
-        return this.success();
-    }
+  protected evaluateByEntity(entity: Entity): State {
+    return this.success();
+  }
 }
 
 describe('EntityNode', () => {
-    describe('evaluate', () => {
-        const world = new World();
+  describe('evaluate', () => {
+    const world = new World();
 
-        it('should return failure when no entity is set', () => {
-            const node = new ImplementedEntityNode();
+    it('should return failure when no entity is set', () => {
+      const node = new ImplementedEntityNode();
 
-            expect(node.evaluate()).toBe(State.FAILURE);
-        });
+      expect(node.evaluate()).toBe(State.FAILURE);
+    });
 
-        it('should return success and call evaluateByEntity when entity is set', () => {
-            const node = new ImplementedEntityNode();
-            // @ts-ignore
-            const spyEvaluateByEntity = jest.spyOn(node, 'evaluateByEntity');
-            node.setData('entity', world.createEntity());
+    it('should return success and call evaluateByEntity when entity is set', () => {
+      const node = new ImplementedEntityNode();
+      // @ts-ignore
+      const spyEvaluateByEntity = jest.spyOn(node, 'evaluateByEntity');
+      node.setData('entity', world.createEntity());
 
-            expect(node.evaluate()).toBe(State.SUCCESS);
-            expect(spyEvaluateByEntity).toBeCalled();
-        });
+      expect(node.evaluate()).toBe(State.SUCCESS);
+      expect(spyEvaluateByEntity).toBeCalled();
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/EntityNode.ts b/src/game/ai/behaviortree/nodes/entity/EntityNode.ts
index 0b9114f..555e9dc 100644
--- a/src/game/ai/behaviortree/nodes/entity/EntityNode.ts
+++ b/src/game/ai/behaviortree/nodes/entity/EntityNode.ts
@@ -1,16 +1,16 @@
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
-import { Node, State } from "../Node";
+import { Node, State } from '../Node';
 
 export abstract class EntityNode extends Node {
-    public evaluate(): State {
-        const entity = this.getData('entity') as Entity|null;
-        if (entity == null) {
-            return this.failure();
-        }
-
-        return this.evaluateByEntity(entity);
+  public evaluate(): State {
+    const entity = this.getData('entity') as Entity | null;
+    if (entity == null) {
+      return this.failure();
     }
 
-    protected abstract evaluateByEntity(entity: Entity): State;
-}
\ No newline at end of file
+    return this.evaluateByEntity(entity);
+  }
+
+  protected abstract evaluateByEntity(entity: Entity): State;
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/Follow.spec.ts b/src/game/ai/behaviortree/nodes/entity/Follow.spec.ts
index 6f912da..752e6b4 100644
--- a/src/game/ai/behaviortree/nodes/entity/Follow.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/Follow.spec.ts
@@ -6,34 +6,35 @@ import { FollowComponent } from './../../../../systems/movement/FollowComponent'
 import { Follow } from './Follow';
 
 describe('Follow', () => {
-    describe('evaluate', () => {
-        const world = new World()
-            .registerComponent(TargetComponent)
-            .registerComponent(FollowComponent);
-
-        it('should fail when entity has no FollowComponent or TargetComponent', () => {
-            const target = world.createEntity();
-            const entity = world.createEntity();
-
-            const follow = new Follow();
-            follow.setData('entity', entity);
-
-            expect(follow.evaluate()).toBe(State.FAILURE);
-        });
-
-        it('should success with setting FollowComponent when with TargetComponent', () => {
-            const target = world.createEntity();
-            const entity = world.createEntity()
-                .addComponent(TargetComponent, {
-                    target: target
-                })
-                .addComponent(FollowComponent);
-
-            const follow = new Follow();
-            follow.setData('entity', entity);
-
-            expect(follow.evaluate()).toBe(State.SUCCESS);
-            expect(entity.getComponent(FollowComponent)!.follow).toEqual(target);
-        });
+  describe('evaluate', () => {
+    const world = new World()
+      .registerComponent(TargetComponent)
+      .registerComponent(FollowComponent);
+
+    it('should fail when entity has no FollowComponent or TargetComponent', () => {
+      const target = world.createEntity();
+      const entity = world.createEntity();
+
+      const follow = new Follow();
+      follow.setData('entity', entity);
+
+      expect(follow.evaluate()).toBe(State.FAILURE);
+    });
+
+    it('should success with setting FollowComponent when with TargetComponent', () => {
+      const target = world.createEntity();
+      const entity = world
+        .createEntity()
+        .addComponent(TargetComponent, {
+          target: target,
+        })
+        .addComponent(FollowComponent);
+
+      const follow = new Follow();
+      follow.setData('entity', entity);
+
+      expect(follow.evaluate()).toBe(State.SUCCESS);
+      expect(entity.getComponent(FollowComponent)!.follow).toEqual(target);
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/Follow.ts b/src/game/ai/behaviortree/nodes/entity/Follow.ts
index d580cd1..dd53788 100644
--- a/src/game/ai/behaviortree/nodes/entity/Follow.ts
+++ b/src/game/ai/behaviortree/nodes/entity/Follow.ts
@@ -1,21 +1,21 @@
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
-import { State } from "../Node";
-import { EntityNode } from "./EntityNode";
+import { State } from '../Node';
+import { EntityNode } from './EntityNode';
 import { FollowComponent } from './../../../../systems/movement/FollowComponent';
 import { TargetComponent } from '../../../../systems/ai/TargetComponent';
 
 export class Follow extends EntityNode {
-    protected evaluateByEntity(entity: Entity): State {
-        const targetComponent = entity.getComponent(TargetComponent);
-        const followComponent = entity.getMutableComponent(FollowComponent);
+  protected evaluateByEntity(entity: Entity): State {
+    const targetComponent = entity.getComponent(TargetComponent);
+    const followComponent = entity.getMutableComponent(FollowComponent);
 
-        if (targetComponent == null || followComponent == null) {
-            return this.failure();
-        }
+    if (targetComponent == null || followComponent == null) {
+      return this.failure();
+    }
 
-        followComponent.follow = targetComponent.target;
+    followComponent.follow = targetComponent.target;
 
-        return this.success();
-    }
-}
\ No newline at end of file
+    return this.success();
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/HasTarget.spec.ts b/src/game/ai/behaviortree/nodes/entity/HasTarget.spec.ts
index 3d2ad1d..520da9b 100644
--- a/src/game/ai/behaviortree/nodes/entity/HasTarget.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/HasTarget.spec.ts
@@ -1,45 +1,42 @@
-import { World } from "ecsy";
+import { World } from 'ecsy';
 
-import { TargetComponent } from "../../../../systems/ai/TargetComponent";
+import { TargetComponent } from '../../../../systems/ai/TargetComponent';
 import { State } from '../Node';
-import { HasTarget } from "./HasTarget";
+import { HasTarget } from './HasTarget';
 
 describe('HasTarget', () => {
-    describe('evaluate', () => {
-        const world = new World()
-            .registerComponent(TargetComponent);
+  describe('evaluate', () => {
+    const world = new World().registerComponent(TargetComponent);
 
-        it('should return failure when entity has no TargetComponent', () => {
-            const entity = world.createEntity();
+    it('should return failure when entity has no TargetComponent', () => {
+      const entity = world.createEntity();
 
-            const hasTarget = new HasTarget();
-            hasTarget.setData('entity', entity);
+      const hasTarget = new HasTarget();
+      hasTarget.setData('entity', entity);
 
-            expect(hasTarget.evaluate()).toBe(State.FAILURE);
-        });
+      expect(hasTarget.evaluate()).toBe(State.FAILURE);
+    });
 
-        it('should return failure when entity has no target set in TargetComponent', () => {
-            const entity = world.createEntity()
-                .addComponent(TargetComponent, {
-                    target: null,
-                });
+    it('should return failure when entity has no target set in TargetComponent', () => {
+      const entity = world.createEntity().addComponent(TargetComponent, {
+        target: null,
+      });
 
-            const hasTarget = new HasTarget();
-            hasTarget.setData('entity', entity);
+      const hasTarget = new HasTarget();
+      hasTarget.setData('entity', entity);
 
-            expect(hasTarget.evaluate()).toBe(State.FAILURE);
-        });
+      expect(hasTarget.evaluate()).toBe(State.FAILURE);
+    });
 
-        it('should return success when entity has target set in TargetComponent', () => {
-            const entity = world.createEntity()
-                .addComponent(TargetComponent, {
-                    target: world.createEntity(),
-                });
+    it('should return success when entity has target set in TargetComponent', () => {
+      const entity = world.createEntity().addComponent(TargetComponent, {
+        target: world.createEntity(),
+      });
 
-            const hasTarget = new HasTarget();
-            hasTarget.setData('entity', entity);
+      const hasTarget = new HasTarget();
+      hasTarget.setData('entity', entity);
 
-            expect(hasTarget.evaluate()).toBe(State.SUCCESS);
-        });
+      expect(hasTarget.evaluate()).toBe(State.SUCCESS);
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/HasTarget.ts b/src/game/ai/behaviortree/nodes/entity/HasTarget.ts
index f995cf0..cf28546 100644
--- a/src/game/ai/behaviortree/nodes/entity/HasTarget.ts
+++ b/src/game/ai/behaviortree/nodes/entity/HasTarget.ts
@@ -1,19 +1,19 @@
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
-import { State } from "../Node";
+import { State } from '../Node';
 import { EntityNode } from './EntityNode';
 import { TargetComponent } from '../../../../systems/ai/TargetComponent';
 
 export class HasTarget extends EntityNode {
-    protected evaluateByEntity(entity: Entity): State {
-        if (!entity.hasComponent(TargetComponent)) {
-            return this.failure();
-        }
-        const targetComponent = entity.getComponent(TargetComponent)!;
-        if (targetComponent.target == null) {
-            return this.failure();
-        }
-        
-        return this.success();
+  protected evaluateByEntity(entity: Entity): State {
+    if (!entity.hasComponent(TargetComponent)) {
+      return this.failure();
     }
-}
\ No newline at end of file
+    const targetComponent = entity.getComponent(TargetComponent)!;
+    if (targetComponent.target == null) {
+      return this.failure();
+    }
+
+    return this.success();
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/IsControlledBy.ts b/src/game/ai/behaviortree/nodes/entity/IsControlledBy.ts
index ff38c16..666a92b 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsControlledBy.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsControlledBy.ts
@@ -1,23 +1,26 @@
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
-import { State } from "../Node";
+import { State } from '../Node';
 import { EntityNode } from './EntityNode';
-import { By, ControlledComponent } from '../../../../systems/ControlledComponent';
+import {
+  By,
+  ControlledComponent,
+} from '../../../../systems/ControlledComponent';
 
 export abstract class IsControlledBy extends EntityNode {
-    constructor(private readonly by: By) {
-        super([]);
-    }
+  constructor(private readonly by: By) {
+    super([]);
+  }
 
-    protected evaluateByEntity(entity: Entity): State {
-        if (!entity.hasComponent(ControlledComponent)) {
-            return this.failure();
-        }
-        const controlledComponent = entity.getComponent(ControlledComponent)!;
-        if (controlledComponent.by === this.by) {
-            return this.success();
-        }
-        
-        return this.failure();
+  protected evaluateByEntity(entity: Entity): State {
+    if (!entity.hasComponent(ControlledComponent)) {
+      return this.failure();
+    }
+    const controlledComponent = entity.getComponent(ControlledComponent)!;
+    if (controlledComponent.by === this.by) {
+      return this.success();
     }
-}
\ No newline at end of file
+
+    return this.failure();
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/IsControlledByAi.ts b/src/game/ai/behaviortree/nodes/entity/IsControlledByAi.ts
index 5289a65..cd3efb9 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsControlledByAi.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsControlledByAi.ts
@@ -1,7 +1,7 @@
-import { IsControlledBy } from "./IsControlledBy";
+import { IsControlledBy } from './IsControlledBy';
 
 export class IsControlledByAi extends IsControlledBy {
-    constructor() {
-        super('ai');
-    }
-}
\ No newline at end of file
+  constructor() {
+    super('ai');
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/IsControlledByPlayer.ts b/src/game/ai/behaviortree/nodes/entity/IsControlledByPlayer.ts
index 87bf2c9..711880d 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsControlledByPlayer.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsControlledByPlayer.ts
@@ -1,7 +1,7 @@
-import { IsControlledBy } from "./IsControlledBy";
+import { IsControlledBy } from './IsControlledBy';
 
 export class IsControlledByPlayer extends IsControlledBy {
-    constructor() {
-        super('player');
-    }
-}
\ No newline at end of file
+  constructor() {
+    super('player');
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/IsEnemyInAggroRange.spec.ts b/src/game/ai/behaviortree/nodes/entity/IsEnemyInAggroRange.spec.ts
index ee2d059..384fef7 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsEnemyInAggroRange.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsEnemyInAggroRange.spec.ts
@@ -2,12 +2,12 @@ import { AttackComponent } from '../../../../systems/AttackComponent';
 import { IsEnemyInAggroRange } from './IsEnemyInAggroRange';
 
 describe('IsEnemyInAggroRange', () => {
-    describe('constructor', () => {
-        it('should set range to 100', () => {
-            const node = new IsEnemyInAggroRange([]);
+  describe('constructor', () => {
+    it('should set range to 100', () => {
+      const node = new IsEnemyInAggroRange([]);
 
-            expect(node['componentConstructor']).toBe(AttackComponent);
-        expect(node['componentProperty']).toBe('aggroRange');
-        });
+      expect(node['componentConstructor']).toBe(AttackComponent);
+      expect(node['componentProperty']).toBe('aggroRange');
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/IsEnemyInAggroRange.ts b/src/game/ai/behaviortree/nodes/entity/IsEnemyInAggroRange.ts
index 31cf90e..69799f1 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsEnemyInAggroRange.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsEnemyInAggroRange.ts
@@ -1,10 +1,10 @@
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
-import { AttackComponent } from "../../../../systems/AttackComponent";
-import { IsEnemyInRange } from "./IsEnemyInRange";
+import { AttackComponent } from '../../../../systems/AttackComponent';
+import { IsEnemyInRange } from './IsEnemyInRange';
 
 export class IsEnemyInAggroRange extends IsEnemyInRange<AttackComponent> {
-    constructor(entities: Entity[]) {
-        super(entities, AttackComponent, 'aggroRange');
-    }
-}
\ No newline at end of file
+  constructor(entities: Entity[]) {
+    super(entities, AttackComponent, 'aggroRange');
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/IsEnemyInAttackRange.spec.ts b/src/game/ai/behaviortree/nodes/entity/IsEnemyInAttackRange.spec.ts
index 6c80583..ac25e59 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsEnemyInAttackRange.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsEnemyInAttackRange.spec.ts
@@ -2,10 +2,10 @@ import { AttackComponent } from '../../../../systems/AttackComponent';
 import { IsEnemyInAttackRange } from './IsEnemyInAttackRange';
 
 describe('IsEnemyInAttackRange', () => {
-    it('should set range to 16', () => {
-        const node = new IsEnemyInAttackRange([]);
+  it('should set range to 16', () => {
+    const node = new IsEnemyInAttackRange([]);
 
-        expect(node['componentConstructor']).toBe(AttackComponent);
-        expect(node['componentProperty']).toBe('attackRange');
-    });
-});
\ No newline at end of file
+    expect(node['componentConstructor']).toBe(AttackComponent);
+    expect(node['componentProperty']).toBe('attackRange');
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/IsEnemyInAttackRange.ts b/src/game/ai/behaviortree/nodes/entity/IsEnemyInAttackRange.ts
index a95f81a..e9d15a2 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsEnemyInAttackRange.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsEnemyInAttackRange.ts
@@ -1,11 +1,10 @@
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
 import { AttackComponent } from './../../../../systems/AttackComponent';
-import { IsEnemyInRange } from "./IsEnemyInRange";
+import { IsEnemyInRange } from './IsEnemyInRange';
 
 export class IsEnemyInAttackRange extends IsEnemyInRange<AttackComponent> {
-    constructor(entities: Entity[]) {
-        super(entities, AttackComponent, 'attackRange');
-    }
+  constructor(entities: Entity[]) {
+    super(entities, AttackComponent, 'attackRange');
+  }
 }
-
diff --git a/src/game/ai/behaviortree/nodes/entity/IsEnemyInRange.spec.ts b/src/game/ai/behaviortree/nodes/entity/IsEnemyInRange.spec.ts
index 00a4566..329b4f1 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsEnemyInRange.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsEnemyInRange.spec.ts
@@ -11,69 +11,76 @@ import { IsEnemyInRange } from './IsEnemyInRange';
 jest.mock('./utils');
 
 describe('IsEnemyInRange', () => {
-    describe('evaluate', () => {
-        
-        let world: World;
+  describe('evaluate', () => {
+    let world: World;
 
-        beforeEach(() => {
-            world = new World()
-                .registerComponent(AttackComponent)
-                .registerComponent(TransformComponent)
-                .registerComponent(TeamComponent);
+    beforeEach(() => {
+      world = new World()
+        .registerComponent(AttackComponent)
+        .registerComponent(TransformComponent)
+        .registerComponent(TeamComponent);
 
-            (getEntitiesInRange as jest.MockedFunction<any>).mockClear();
-        });
-
-        it('should success set target when there is an enemy within range', () => {
-            const entitiesInRange = [
-                world.createEntity()
-                    .addComponent(TransformComponent, {
-                        position: new Vector2(0, 0),
-                    })
-                    .addComponent(TeamComponent, {
-                        number: 2
-                    })
-            ];
-            (getEntitiesInRange as jest.MockedFunction<any>).mockReturnValue(entitiesInRange);
+      (getEntitiesInRange as jest.MockedFunction<any>).mockClear();
+    });
 
-            const entity = world.createEntity()
-                .addComponent(AttackComponent, {
-                    aggroRange: 100,
-                })
-                .addComponent(TransformComponent, {
-                    position: new Vector2(0, 0),
-                })
-                .addComponent(TeamComponent, {
-                    number: 1
-                });
-            const node = new IsEnemyInRange([], AttackComponent, 'aggroRange');
-            const parent = new Node();
-            parent.setData('entity', entity);
-            parent.attach(node);
+    it('should success set target when there is an enemy within range', () => {
+      const entitiesInRange = [
+        world
+          .createEntity()
+          .addComponent(TransformComponent, {
+            position: new Vector2(0, 0),
+          })
+          .addComponent(TeamComponent, {
+            number: 2,
+          }),
+      ];
+      (getEntitiesInRange as jest.MockedFunction<any>).mockReturnValue(
+        entitiesInRange
+      );
 
-            expect(node.evaluate()).toBe(State.SUCCESS);
-            expect(parent.getData('target')).not.toBeNull();
-            expect(getEntitiesInRange).toBeCalledWith(expect.anything(), expect.anything(), 100);
+      const entity = world
+        .createEntity()
+        .addComponent(AttackComponent, {
+          aggroRange: 100,
+        })
+        .addComponent(TransformComponent, {
+          position: new Vector2(0, 0),
+        })
+        .addComponent(TeamComponent, {
+          number: 1,
         });
+      const node = new IsEnemyInRange([], AttackComponent, 'aggroRange');
+      const parent = new Node();
+      parent.setData('entity', entity);
+      parent.attach(node);
 
-        // it('should fail and not set target when there is no enemy within range', () => {
-        //     (getEntitiesInRange as jest.MockedFunction<any>).mockReturnValue([]);
+      expect(node.evaluate()).toBe(State.SUCCESS);
+      expect(parent.getData('target')).not.toBeNull();
+      expect(getEntitiesInRange).toBeCalledWith(
+        expect.anything(),
+        expect.anything(),
+        100
+      );
+    });
 
-        //     const entity = world.createEntity()
-        //         .addComponent(TransformComponent, {
-        //             position: new Vector2(0, 0),
-        //         })
-        //         .addComponent(TeamComponent, {
-        //             number: 1
-        //         });
+    // it('should fail and not set target when there is no enemy within range', () => {
+    //     (getEntitiesInRange as jest.MockedFunction<any>).mockReturnValue([]);
 
-        //     const node = new IsEnemyInRange([], 100);
-        //     const parent = new Node();
-        //     parent.setData('entity', entity);
-        //     parent.attach(node);
+    //     const entity = world.createEntity()
+    //         .addComponent(TransformComponent, {
+    //             position: new Vector2(0, 0),
+    //         })
+    //         .addComponent(TeamComponent, {
+    //             number: 1
+    //         });
 
-        //     expect(node.evaluate()).toBe(State.FAILURE);
-        //     expect(parent.getData('target')).toBeNull();
-        // });
-    });
-});
\ No newline at end of file
+    //     const node = new IsEnemyInRange([], 100);
+    //     const parent = new Node();
+    //     parent.setData('entity', entity);
+    //     parent.attach(node);
+
+    //     expect(node.evaluate()).toBe(State.FAILURE);
+    //     expect(parent.getData('target')).toBeNull();
+    // });
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/IsEnemyInRange.ts b/src/game/ai/behaviortree/nodes/entity/IsEnemyInRange.ts
index 92e912b..cfeefde 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsEnemyInRange.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsEnemyInRange.ts
@@ -1,27 +1,33 @@
-import { Component, ComponentConstructor, Entity } from "ecsy";
+import { Component, ComponentConstructor, Entity } from 'ecsy';
 
-import { State } from "../Node";
-import { EntityNode } from "./EntityNode";
-import { getEntitiesInRange } from "./utils";
+import { State } from '../Node';
+import { EntityNode } from './EntityNode';
+import { getEntitiesInRange } from './utils';
 
-export class IsEnemyInRange<TComponent extends Component<any>, TProperty extends keyof TComponent = keyof TComponent> extends EntityNode {
-    constructor(
-        private readonly entities: Entity[],
-        private readonly componentConstructor: ComponentConstructor<TComponent>,
-        private readonly componentProperty: TProperty) {
-        super();
-    }
-
-    protected evaluateByEntity(entity: Entity): State {
-        const range = entity.getComponent(this.componentConstructor)![this.componentProperty] as unknown as number;
+export class IsEnemyInRange<
+  TComponent extends Component<any>,
+  TProperty extends keyof TComponent = keyof TComponent
+> extends EntityNode {
+  constructor(
+    private readonly entities: Entity[],
+    private readonly componentConstructor: ComponentConstructor<TComponent>,
+    private readonly componentProperty: TProperty
+  ) {
+    super();
+  }
 
-        const inRangeEntities = getEntitiesInRange(entity, this.entities, range);
-        if (inRangeEntities.length == 0) {
-            return this.failure();
-        }
-        
-        this.parent!.setData('target', inRangeEntities[0]);
+  protected evaluateByEntity(entity: Entity): State {
+    const range = entity.getComponent(this.componentConstructor)![
+      this.componentProperty
+    ] as unknown as number;
 
-        return this.success();
+    const inRangeEntities = getEntitiesInRange(entity, this.entities, range);
+    if (inRangeEntities.length == 0) {
+      return this.failure();
     }
-}
\ No newline at end of file
+
+    this.parent!.setData('target', inRangeEntities[0]);
+
+    return this.success();
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/IsMoving.spec.ts b/src/game/ai/behaviortree/nodes/entity/IsMoving.spec.ts
index 6173651..bc5af04 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsMoving.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsMoving.spec.ts
@@ -6,38 +6,39 @@ import { State } from '../Node';
 import { IsMoving } from './IsMoving';
 
 describe('IsMoving', () => {
-    describe('evaluate', () => {
-        const world = new World()
-            .registerComponent(MovePositionDirectComponent);
+  describe('evaluate', () => {
+    const world = new World().registerComponent(MovePositionDirectComponent);
 
-        it('should return failure when entity has no MovePositionDirectComponent', () => {
-            const entity = world.createEntity();
-            const setTarget = new IsMoving();
-            setTarget.setData('entity', entity)
+    it('should return failure when entity has no MovePositionDirectComponent', () => {
+      const entity = world.createEntity();
+      const setTarget = new IsMoving();
+      setTarget.setData('entity', entity);
 
-            expect(setTarget.evaluate()).toBe(State.FAILURE);
-        });
-
-        it('should return failure when entity\'s MovePositionDirectComponent movePosition is null', () => {
-            const entity = world.createEntity()
-                .addComponent(MovePositionDirectComponent, {
-                    movePosition: null,
-                });
-            const setTarget = new IsMoving();
-            setTarget.setData('entity', entity)
+      expect(setTarget.evaluate()).toBe(State.FAILURE);
+    });
 
-            expect(setTarget.evaluate()).toBe(State.FAILURE);
+    it("should return failure when entity's MovePositionDirectComponent movePosition is null", () => {
+      const entity = world
+        .createEntity()
+        .addComponent(MovePositionDirectComponent, {
+          movePosition: null,
         });
+      const setTarget = new IsMoving();
+      setTarget.setData('entity', entity);
 
-        it('should return success when entity\'s MovePositionDirectComponent movePosition is null', () => {
-            const entity = world.createEntity()
-                .addComponent(MovePositionDirectComponent, {
-                    movePosition: new Vector2(1, 2),
-                });
-            const setTarget = new IsMoving();
-            setTarget.setData('entity', entity)
+      expect(setTarget.evaluate()).toBe(State.FAILURE);
+    });
 
-            expect(setTarget.evaluate()).toBe(State.SUCCESS);
+    it("should return success when entity's MovePositionDirectComponent movePosition is null", () => {
+      const entity = world
+        .createEntity()
+        .addComponent(MovePositionDirectComponent, {
+          movePosition: new Vector2(1, 2),
         });
+      const setTarget = new IsMoving();
+      setTarget.setData('entity', entity);
+
+      expect(setTarget.evaluate()).toBe(State.SUCCESS);
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/IsMoving.ts b/src/game/ai/behaviortree/nodes/entity/IsMoving.ts
index ca3b404..790c94e 100644
--- a/src/game/ai/behaviortree/nodes/entity/IsMoving.ts
+++ b/src/game/ai/behaviortree/nodes/entity/IsMoving.ts
@@ -1,20 +1,21 @@
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
-import { MovePositionDirectComponent } from "../../../../systems/movement/MovePositionDirectComponent";
-import { State } from "../Node";
-import { EntityNode } from "./EntityNode";
+import { MovePositionDirectComponent } from '../../../../systems/movement/MovePositionDirectComponent';
+import { State } from '../Node';
+import { EntityNode } from './EntityNode';
 
 export class IsMoving extends EntityNode {
-    protected evaluateByEntity(entity: Entity): State {
-        if (!entity.hasComponent(MovePositionDirectComponent)) {
-            return this.failure();
-        }
-        const movePositionDirectComponent = entity.getComponent(MovePositionDirectComponent)!;
-        if (movePositionDirectComponent.movePosition == null) {
-            return this.failure();
-        }
-
-
-        return this.success();
+  protected evaluateByEntity(entity: Entity): State {
+    if (!entity.hasComponent(MovePositionDirectComponent)) {
+      return this.failure();
     }
-}
\ No newline at end of file
+    const movePositionDirectComponent = entity.getComponent(
+      MovePositionDirectComponent
+    )!;
+    if (movePositionDirectComponent.movePosition == null) {
+      return this.failure();
+    }
+
+    return this.success();
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/SetTarget.spec.ts b/src/game/ai/behaviortree/nodes/entity/SetTarget.spec.ts
index f365df7..7f2e170 100644
--- a/src/game/ai/behaviortree/nodes/entity/SetTarget.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/SetTarget.spec.ts
@@ -5,45 +5,40 @@ import { TargetComponent } from '../../../../systems/ai/TargetComponent';
 import { State } from '../Node';
 
 describe('SetTarget', () => {
-    describe('evaluate', () => {
-        const world = new World()
-            .registerComponent(TargetComponent);
+  describe('evaluate', () => {
+    const world = new World().registerComponent(TargetComponent);
 
-        it('should return failure when entity has no TargetComponent', () => {
-            const entity = world.createEntity();
-            const target = world.createEntity();
+    it('should return failure when entity has no TargetComponent', () => {
+      const entity = world.createEntity();
+      const target = world.createEntity();
 
-            const setTarget = new SetTarget();
-            setTarget.setData('entity', entity);
-            setTarget.setData('target', target);
+      const setTarget = new SetTarget();
+      setTarget.setData('entity', entity);
+      setTarget.setData('target', target);
 
-            expect(setTarget.evaluate()).toBe(State.FAILURE);
-        });
-
-        it('should return failure when no target is set', () => {
-            const entity = world.createEntity()
-                .addComponent(TargetComponent);
+      expect(setTarget.evaluate()).toBe(State.FAILURE);
+    });
 
-            const setTarget = new SetTarget();
-            setTarget.setData('entity', entity);
+    it('should return failure when no target is set', () => {
+      const entity = world.createEntity().addComponent(TargetComponent);
 
-            expect(setTarget.evaluate()).toBe(State.FAILURE);
-            expect(entity.getComponent(TargetComponent)!.target).toBeNull();
-        });
-        
+      const setTarget = new SetTarget();
+      setTarget.setData('entity', entity);
 
+      expect(setTarget.evaluate()).toBe(State.FAILURE);
+      expect(entity.getComponent(TargetComponent)!.target).toBeNull();
+    });
 
-        it('should set entity\'s TargetComponent and return success', () => {
-            const entity = world.createEntity()
-                .addComponent(TargetComponent);
-            const target = world.createEntity();
+    it("should set entity's TargetComponent and return success", () => {
+      const entity = world.createEntity().addComponent(TargetComponent);
+      const target = world.createEntity();
 
-            const setTarget = new SetTarget();
-            setTarget.setData('entity', entity);
-            setTarget.setData('target', target);
+      const setTarget = new SetTarget();
+      setTarget.setData('entity', entity);
+      setTarget.setData('target', target);
 
-            expect(setTarget.evaluate()).toBe(State.SUCCESS);
-            expect(entity.getComponent(TargetComponent)!.target).toBe(target);
-        });
+      expect(setTarget.evaluate()).toBe(State.SUCCESS);
+      expect(entity.getComponent(TargetComponent)!.target).toBe(target);
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/SetTarget.ts b/src/game/ai/behaviortree/nodes/entity/SetTarget.ts
index 834a556..31a0825 100644
--- a/src/game/ai/behaviortree/nodes/entity/SetTarget.ts
+++ b/src/game/ai/behaviortree/nodes/entity/SetTarget.ts
@@ -1,20 +1,20 @@
 import { Entity } from 'ecsy';
 
-import { Node, State } from "../Node";
+import { Node, State } from '../Node';
 import { EntityNode } from './EntityNode';
 import { TargetComponent } from '../../../../systems/ai/TargetComponent';
 
 export class SetTarget extends EntityNode {
-    protected evaluateByEntity(entity: Entity): State {
-        const target = this.getData('target') as Entity|null;
+  protected evaluateByEntity(entity: Entity): State {
+    const target = this.getData('target') as Entity | null;
 
-        if (target == null || !entity.hasComponent(TargetComponent)) {
-            return this.failure();
-        }
+    if (target == null || !entity.hasComponent(TargetComponent)) {
+      return this.failure();
+    }
 
-        const targetComponent = entity.getMutableComponent(TargetComponent)!;
-        targetComponent.target = target;
+    const targetComponent = entity.getMutableComponent(TargetComponent)!;
+    targetComponent.target = target;
 
-        return this.success();
-    }
-}
\ No newline at end of file
+    return this.success();
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/UnsetTarget.spec.ts b/src/game/ai/behaviortree/nodes/entity/UnsetTarget.spec.ts
index c14d12c..daff8b4 100644
--- a/src/game/ai/behaviortree/nodes/entity/UnsetTarget.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/UnsetTarget.spec.ts
@@ -1,45 +1,42 @@
-import { World } from "ecsy";
+import { World } from 'ecsy';
 
 import { UnsetTarget } from './UnsetTarget';
-import { TargetComponent } from "../../../../systems/ai/TargetComponent";
+import { TargetComponent } from '../../../../systems/ai/TargetComponent';
 import { State } from '../Node';
 
 describe('UnsetTarget', () => {
-    describe('evaluate', () => {
-        const world = new World()
-            .registerComponent(TargetComponent);
-        it('should return failure when entity has no TargetComponent', () => {
-            const entity = world.createEntity();
-
-            const unsetTarget = new UnsetTarget();
-            unsetTarget.setData('entity', entity);
-
-            expect(unsetTarget.evaluate()).toBe(State.FAILURE);
-        });
-
-        it('should return failure when entity has no target set in TargetComponent', () => {
-            const entity = world.createEntity()
-                .addComponent(TargetComponent, {
-                    target: null,
-                });
-
-            const unsetTarget = new UnsetTarget();
-            unsetTarget.setData('entity', entity);
-
-            expect(unsetTarget.evaluate()).toBe(State.FAILURE);
-        });
-
-        it('should return success when entity has unset target in TargetComponent', () => {
-            const entity = world.createEntity()
-                .addComponent(TargetComponent, {
-                    target: world.createEntity(),
-                });
-
-            const unsetTarget = new UnsetTarget();
-            unsetTarget.setData('entity', entity);
-
-            expect(unsetTarget.evaluate()).toBe(State.SUCCESS);
-            expect(entity.getComponent(TargetComponent)!.target).toBeNull();
-        });
+  describe('evaluate', () => {
+    const world = new World().registerComponent(TargetComponent);
+    it('should return failure when entity has no TargetComponent', () => {
+      const entity = world.createEntity();
+
+      const unsetTarget = new UnsetTarget();
+      unsetTarget.setData('entity', entity);
+
+      expect(unsetTarget.evaluate()).toBe(State.FAILURE);
+    });
+
+    it('should return failure when entity has no target set in TargetComponent', () => {
+      const entity = world.createEntity().addComponent(TargetComponent, {
+        target: null,
+      });
+
+      const unsetTarget = new UnsetTarget();
+      unsetTarget.setData('entity', entity);
+
+      expect(unsetTarget.evaluate()).toBe(State.FAILURE);
+    });
+
+    it('should return success when entity has unset target in TargetComponent', () => {
+      const entity = world.createEntity().addComponent(TargetComponent, {
+        target: world.createEntity(),
+      });
+
+      const unsetTarget = new UnsetTarget();
+      unsetTarget.setData('entity', entity);
+
+      expect(unsetTarget.evaluate()).toBe(State.SUCCESS);
+      expect(entity.getComponent(TargetComponent)!.target).toBeNull();
     });
-});
\ No newline at end of file
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/UnsetTarget.ts b/src/game/ai/behaviortree/nodes/entity/UnsetTarget.ts
index 91059a0..35d24e8 100644
--- a/src/game/ai/behaviortree/nodes/entity/UnsetTarget.ts
+++ b/src/game/ai/behaviortree/nodes/entity/UnsetTarget.ts
@@ -1,20 +1,20 @@
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
-import { State } from "../Node";
+import { State } from '../Node';
 import { EntityNode } from './EntityNode';
 import { TargetComponent } from '../../../../systems/ai/TargetComponent';
 
 export class UnsetTarget extends EntityNode {
-    protected evaluateByEntity(entity: Entity): State {
-        if (!entity.hasComponent(TargetComponent)) {
-            return this.failure();
-        }
-        const targetComponent = entity.getMutableComponent(TargetComponent)!;
-        if (targetComponent.target == null) {
-            return this.failure();
-        }
-        targetComponent.target = null;
-        
-        return this.success();
+  protected evaluateByEntity(entity: Entity): State {
+    if (!entity.hasComponent(TargetComponent)) {
+      return this.failure();
     }
-}
\ No newline at end of file
+    const targetComponent = entity.getMutableComponent(TargetComponent)!;
+    if (targetComponent.target == null) {
+      return this.failure();
+    }
+    targetComponent.target = null;
+
+    return this.success();
+  }
+}
diff --git a/src/game/ai/behaviortree/nodes/entity/index.ts b/src/game/ai/behaviortree/nodes/entity/index.ts
index 2d2a23d..b6591f9 100644
--- a/src/game/ai/behaviortree/nodes/entity/index.ts
+++ b/src/game/ai/behaviortree/nodes/entity/index.ts
@@ -7,4 +7,4 @@ export * from './IsEnemyInAggroRange';
 export * from './IsEnemyInAttackRange';
 export * from './IsMoving';
 export * from './SetTarget';
-export * from './UnsetTarget';
\ No newline at end of file
+export * from './UnsetTarget';
diff --git a/src/game/ai/behaviortree/nodes/entity/utils.spec.ts b/src/game/ai/behaviortree/nodes/entity/utils.spec.ts
index 5cce90d..00f6bda 100644
--- a/src/game/ai/behaviortree/nodes/entity/utils.spec.ts
+++ b/src/game/ai/behaviortree/nodes/entity/utils.spec.ts
@@ -1,39 +1,39 @@
 import { Vector2 } from './../../../../math/Vector2';
 import { constructCreateRandomEntities } from './../../../../__tests__/utils';
-import { World } from "ecsy";
-import { TeamComponent } from "../../../../systems/TeamComponent";
-import { TransformComponent } from "../../../../systems/TransformComponent";
-import { CreateRandomEntities } from "../../../../__tests__/utils";
+import { World } from 'ecsy';
+import { TeamComponent } from '../../../../systems/TeamComponent';
+import { TransformComponent } from '../../../../systems/TransformComponent';
+import { CreateRandomEntities } from '../../../../__tests__/utils';
 import { getEntitiesInRange } from './utils';
 
 describe('getEntitiesInRange', () => {
-    
-    let world: World;
-    let createRandomEntities: CreateRandomEntities;
+  let world: World;
+  let createRandomEntities: CreateRandomEntities;
 
-    beforeEach(() => {
-        world = new World()
-            .registerComponent(TransformComponent)
-            .registerComponent(TeamComponent);
-        createRandomEntities = constructCreateRandomEntities(world);    
-    });
+  beforeEach(() => {
+    world = new World()
+      .registerComponent(TransformComponent)
+      .registerComponent(TeamComponent);
+    createRandomEntities = constructCreateRandomEntities(world);
+  });
 
-    it('should success set target when there is an enemy within range', () => {
-        const entity = world.createEntity()
-            .addComponent(TransformComponent, {
-                position: new Vector2(0, 0),
-            })
-            .addComponent(TeamComponent, {
-                number: 1
-            });
+  it('should success set target when there is an enemy within range', () => {
+    const entity = world
+      .createEntity()
+      .addComponent(TransformComponent, {
+        position: new Vector2(0, 0),
+      })
+      .addComponent(TeamComponent, {
+        number: 1,
+      });
 
-        const entities = [
-            ...createRandomEntities(10, { x: 5, y: 5, }, { x: 50, y: 50 }),
-            entity,
-        ];
+    const entities = [
+      ...createRandomEntities(10, { x: 5, y: 5 }, { x: 50, y: 50 }),
+      entity,
+    ];
 
-        const foundEntities = getEntitiesInRange(entity, entities, 100);
+    const foundEntities = getEntitiesInRange(entity, entities, 100);
 
-        expect(foundEntities.length).toBeGreaterThan(1);
-    });
-});
\ No newline at end of file
+    expect(foundEntities.length).toBeGreaterThan(1);
+  });
+});
diff --git a/src/game/ai/behaviortree/nodes/entity/utils.ts b/src/game/ai/behaviortree/nodes/entity/utils.ts
index 25f4ad9..9eef5d0 100644
--- a/src/game/ai/behaviortree/nodes/entity/utils.ts
+++ b/src/game/ai/behaviortree/nodes/entity/utils.ts
@@ -1,14 +1,24 @@
 import { Entity } from 'ecsy';
 import { TeamComponent } from '../../../../systems/TeamComponent';
 
-import { isOnTeam, byClosestDistance, isInRange, isSameEntity, isAlive } from '../../../../systems/utils/index';
+import {
+  isOnTeam,
+  byClosestDistance,
+  isInRange,
+  isSameEntity,
+  isAlive,
+} from '../../../../systems/utils/index';
 import { not } from '../../../../utils';
 
-export const getEntitiesInRange = (sourceEntity: Entity, entities: Entity[], range: number): Entity[] => {
-    return entities
-        .filter(not(isSameEntity(sourceEntity)))
-        .filter(not(isOnTeam(sourceEntity.getComponent(TeamComponent)!.number)))
-        .filter(isAlive())
-        .filter(isInRange(sourceEntity, range))
-        .sort(byClosestDistance(sourceEntity));
-};
\ No newline at end of file
+export const getEntitiesInRange = (
+  sourceEntity: Entity,
+  entities: Entity[],
+  range: number
+): Entity[] => {
+  return entities
+    .filter(not(isSameEntity(sourceEntity)))
+    .filter(not(isOnTeam(sourceEntity.getComponent(TeamComponent)!.number)))
+    .filter(isAlive())
+    .filter(isInRange(sourceEntity, range))
+    .sort(byClosestDistance(sourceEntity));
+};
diff --git a/src/game/ai/pathfinding.spec.ts b/src/game/ai/pathfinding.spec.ts
index c312e4a..f026386 100644
--- a/src/game/ai/pathfinding.spec.ts
+++ b/src/game/ai/pathfinding.spec.ts
@@ -1,232 +1,234 @@
 import {
-    astar,
-    createPathFromEndNode,
-    getLowestFNode,
-    isPositionEqual,
-    isPositionInsideGrid,
-    Node,
-    generateAdjacentNodes,
-    calculateDistanceCost,
+  astar,
+  createPathFromEndNode,
+  getLowestFNode,
+  isPositionEqual,
+  isPositionInsideGrid,
+  Node,
+  generateAdjacentNodes,
+  calculateDistanceCost,
 } from './pathfinding';
 
 describe('isPositionEqual', () => {
-    it('should return false when values differ', () => {
-        expect(isPositionEqual({ x: 0, y: 0 }, { x: 1, y: 1 })).toBe(false);
-    });
+  it('should return false when values differ', () => {
+    expect(isPositionEqual({ x: 0, y: 0 }, { x: 1, y: 1 })).toBe(false);
+  });
 
-    it('should return false when values differ in float', () => {
-        expect(isPositionEqual({ x: 1.1, y: 1.1 }, { x: 1, y: 1 })).toBe(false);
-    });
+  it('should return false when values differ in float', () => {
+    expect(isPositionEqual({ x: 1.1, y: 1.1 }, { x: 1, y: 1 })).toBe(false);
+  });
 
-    it('should return true when values are the same', () => {
-        expect(isPositionEqual({ x: 123, y: 123 }, { x: 123, y: 123 })).toBe(true);
-    });
+  it('should return true when values are the same', () => {
+    expect(isPositionEqual({ x: 123, y: 123 }, { x: 123, y: 123 })).toBe(true);
+  });
 });
 
 describe('getLowestFCostNode', () => {
-    it('should return null when array is empty', () => {
-        expect(getLowestFNode([])).toEqual(null);
+  it('should return null when array is empty', () => {
+    expect(getLowestFNode([])).toEqual(null);
+  });
 
+  it('should return lowest fCost node', () => {
+    const randomNodes = Array.from({ length: 100 }, (value, index) => {
+      const node = new Node(null, { x: index, y: index });
+      node.f = Math.random() * 100 + 1;
+      return node;
     });
 
-    it('should return lowest fCost node', () => {
-        const randomNodes = Array.from({ length: 100 }, (value, index) => {
-            const node = new Node(null, { x: index, y: index });
-            node.f = Math.random() * 100 + 1;
-            return node;
-        });
+    const lowestNode = new Node(null, { x: 2, y: 2 });
+    lowestNode.f = 1;
 
-        const lowestNode = new Node(null, { x: 2, y: 2 });
-        lowestNode.f = 1;
-
-        expect(getLowestFNode([...randomNodes, lowestNode])).toEqual(lowestNode);
-    });
+    expect(getLowestFNode([...randomNodes, lowestNode])).toEqual(lowestNode);
+  });
 });
 
 describe('createPathFromEndNode', () => {
-    it('should return node when only one is given', () => {
-        const node = new Node(null, { x: 1, y: 2 });
+  it('should return node when only one is given', () => {
+    const node = new Node(null, { x: 1, y: 2 });
 
-        const path = createPathFromEndNode(node);
+    const path = createPathFromEndNode(node);
 
-        expect(path).toHaveLength(1);
-    });
+    expect(path).toHaveLength(1);
+  });
 
-    it('should return reversed path when nodes with parents are given', () => {
-        let lastNode: Node|null = null;
-        Array.from({ length: 10 }, (value, index) => lastNode = new Node(lastNode, { x: index, y: index }));
-        
-        const path = createPathFromEndNode(lastNode!);
+  it('should return reversed path when nodes with parents are given', () => {
+    let lastNode: Node | null = null;
+    Array.from(
+      { length: 10 },
+      (value, index) => (lastNode = new Node(lastNode, { x: index, y: index }))
+    );
 
-        expect(path).toHaveLength(10);
-        expect(path.at(0)?.parent).toEqual(null);
-        expect(path.at(-1)).toEqual(lastNode);
-    });
+    const path = createPathFromEndNode(lastNode!);
+
+    expect(path).toHaveLength(10);
+    expect(path.at(0)?.parent).toEqual(null);
+    expect(path.at(-1)).toEqual(lastNode);
+  });
 });
 
 describe('isPositionInsideGrid', () => {
-    it('should return false if the grid is empty', () => {
-        expect(isPositionInsideGrid([], { x: 1, y: 1 })).toBe(false);
-    });
-
-    const grid: readonly number[][] = [
-        [0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0],
-    ];
-
-    it('should return false when x is lower than 0', () => {
-        expect(isPositionInsideGrid(grid, { x: -1, y: 1 })).toBe(false);
-    });
-
-    it('should return false when y is lower than 0', () => {
-        expect(isPositionInsideGrid(grid, { x: 1, y: -1 })).toBe(false);
-    });
-
-    it('should return false when x is higher than the grid\'s width', () => {
-        expect(isPositionInsideGrid(grid, { x: 5, y: 1 })).toBe(false);
-    });
-
-    it('should return false when y is higher than the grid\'s height', () => {
-        expect(isPositionInsideGrid(grid, { x: 1, y: 5 })).toBe(false);
-    });
-
-    it('should return true when x and y is 0 and the grid has at least 1 item', () => {
-        expect(isPositionInsideGrid(grid, { x: 0, y: 0 })).toBe(true);
-    });
-
-    it('should return true when x is the same as the grid\'s width', () => {
-        expect(isPositionInsideGrid(grid, { x: 4, y: 0 })).toBe(true);
-    });
-
-    it('should return true when y is the same as the grid\'s height', () => {
-        expect(isPositionInsideGrid(grid, { x: 0, y: 4 })).toBe(true);
-    });
+  it('should return false if the grid is empty', () => {
+    expect(isPositionInsideGrid([], { x: 1, y: 1 })).toBe(false);
+  });
+
+  const grid: readonly number[][] = [
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0],
+  ];
+
+  it('should return false when x is lower than 0', () => {
+    expect(isPositionInsideGrid(grid, { x: -1, y: 1 })).toBe(false);
+  });
+
+  it('should return false when y is lower than 0', () => {
+    expect(isPositionInsideGrid(grid, { x: 1, y: -1 })).toBe(false);
+  });
+
+  it("should return false when x is higher than the grid's width", () => {
+    expect(isPositionInsideGrid(grid, { x: 5, y: 1 })).toBe(false);
+  });
+
+  it("should return false when y is higher than the grid's height", () => {
+    expect(isPositionInsideGrid(grid, { x: 1, y: 5 })).toBe(false);
+  });
+
+  it('should return true when x and y is 0 and the grid has at least 1 item', () => {
+    expect(isPositionInsideGrid(grid, { x: 0, y: 0 })).toBe(true);
+  });
+
+  it("should return true when x is the same as the grid's width", () => {
+    expect(isPositionInsideGrid(grid, { x: 4, y: 0 })).toBe(true);
+  });
+
+  it("should return true when y is the same as the grid's height", () => {
+    expect(isPositionInsideGrid(grid, { x: 0, y: 4 })).toBe(true);
+  });
 });
 
 describe('generateAdjacentNodes', () => {
-    const grid = [
-        [0, 0, 0, 0],
-        [0, 0, 0, 0],
-        [0, 0, 0, 0],
-        [0, 0, 0, 1],
-    ];
+  const grid = [
+    [0, 0, 0, 0],
+    [0, 0, 0, 0],
+    [0, 0, 0, 0],
+    [0, 0, 0, 1],
+  ];
 
-    it('should generate all nodes around the current node when inside the grid', () => {
-        const nodes = generateAdjacentNodes(grid, new Node(null, { x: 1, y: 1 }));
+  it('should generate all nodes around the current node when inside the grid', () => {
+    const nodes = generateAdjacentNodes(grid, new Node(null, { x: 1, y: 1 }));
 
-        expect(nodes).toHaveLength(8);
-    });
+    expect(nodes).toHaveLength(8);
+  });
 
-    it('should generate nodes inside the grid when at the edge of the grid', () => {
-        const nodes = generateAdjacentNodes(grid, new Node(null, { x: 0, y: 0 }));
+  it('should generate nodes inside the grid when at the edge of the grid', () => {
+    const nodes = generateAdjacentNodes(grid, new Node(null, { x: 0, y: 0 }));
 
-        expect(nodes).toHaveLength(3);
-    });
+    expect(nodes).toHaveLength(3);
+  });
 
-    it('should generate all walkable nodes', () => {
-        const nodes = generateAdjacentNodes(grid, new Node(null, { x: 2, y: 2 }));
+  it('should generate all walkable nodes', () => {
+    const nodes = generateAdjacentNodes(grid, new Node(null, { x: 2, y: 2 }));
 
-        expect(nodes).toHaveLength(7);
-    });
+    expect(nodes).toHaveLength(7);
+  });
 });
 
 describe('calculateDistanceCost', () => {
-    it('should calculate by straight route', () => {
-        expect(
-            calculateDistanceCost(
-                new Node(null, { x: 0, y: 0 }),
-                new Node(null, { x: 3, y: 0 })
-            )
-        ).toEqual(30);
-    });
+  it('should calculate by straight route', () => {
+    expect(
+      calculateDistanceCost(
+        new Node(null, { x: 0, y: 0 }),
+        new Node(null, { x: 3, y: 0 })
+      )
+    ).toEqual(30);
+  });
+
+  it('should calculate by diagonal route', () => {
+    expect(
+      calculateDistanceCost(
+        new Node(null, { x: 0, y: 0 }),
+        new Node(null, { x: 3, y: 3 })
+      )
+    ).toEqual(42);
+  });
+
+  it('should calculate by combined route', () => {
+    expect(
+      calculateDistanceCost(
+        new Node(null, { x: 0, y: 0 }),
+        new Node(null, { x: 3, y: 5 })
+      )
+    ).toEqual(62);
+  });
+});
 
-    it('should calculate by diagonal route', () => {
-        expect(
-            calculateDistanceCost(
-                new Node(null, { x: 0, y: 0 }),
-                new Node(null, { x: 3, y: 3 })
-            )
-        ).toEqual(42);
-    });
+describe('astar', () => {
+  it('should return empty array because there is no way to the given end', () => {
+    const grid = [
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 1, 1],
+      [0, 0, 0, 1, 0],
+    ];
 
-    it('should calculate by combined route', () => {
-        expect(
-            calculateDistanceCost(
-                new Node(null, { x: 0, y: 0 }),
-                new Node(null, { x: 3, y: 5 })
-            )
-        ).toEqual(62);
-    });
-});
+    const start = { x: 0, y: 0 };
+    const end = { x: 4, y: 4 };
 
-describe('astar', () => {   
-    it('should return empty array because there is no way to the given end', () => {
-        const grid = [
-            [0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 0],
-            [0, 0, 0, 1, 1],
-            [0, 0, 0, 1, 0],
-        ];
+    const path = astar(grid, start, end);
 
-        const start = { x: 0, y: 0 };
-        const end = { x: 4, y: 4 };
+    expect(path).toHaveLength(0);
+  });
 
-        const path = astar(grid, start, end);
+  it('should go around obstruction', () => {
+    const grid = [
+      [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    ];
 
-        expect(path).toHaveLength(0);
-    });
+    const start = { x: 0, y: 0 };
+    const end = { x: 7, y: 6 };
+
+    const path = astar(grid, start, end);
+
+    expect(path).toHaveLength(9);
+    expect(path[1].position).toEqual({ x: 1, y: 1 });
+    expect(path[2].position).toEqual({ x: 2, y: 2 });
+    expect(path[3].position).toEqual({ x: 3, y: 3 });
+    expect(path[4].position).toEqual({ x: 3, y: 4 });
+    expect(path[5].position).toEqual({ x: 4, y: 5 });
+    expect(path[6].position).toEqual({ x: 5, y: 6 });
+    expect(path[7].position).toEqual({ x: 6, y: 6 });
+  });
+
+  it('should go though the maze', () => {
+    const maze = [
+      [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+      [0, 1, 0, 1, 1, 1, 1, 1, 1, 0],
+      [0, 0, 0, 1, 0, 0, 0, 0, 1, 0],
+      [1, 1, 1, 1, 0, 1, 1, 0, 1, 0],
+      [0, 0, 0, 0, 0, 0, 1, 0, 1, 0],
+      [0, 1, 1, 0, 1, 1, 1, 0, 1, 0],
+      [0, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+      [1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
+      [1, 0, 1, 1, 1, 1, 1, 1, 1, 1],
+      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    ];
+    const start = { x: 0, y: 0 };
+    const end = { x: 9, y: 9 };
 
-    it('should go around obstruction', () => {
-        const grid = [
-            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
-            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        ];
-
-        const start = { x: 0, y: 0 };
-        const end = { x: 7, y: 6 };
-
-        const path = astar(grid, start, end);
-
-        expect(path).toHaveLength(9);
-        expect(path[1].position).toEqual({ x: 1, y: 1 });
-        expect(path[2].position).toEqual({ x: 2, y: 2 });
-        expect(path[3].position).toEqual({ x: 3, y: 3 });
-        expect(path[4].position).toEqual({ x: 3, y: 4 });
-        expect(path[5].position).toEqual({ x: 4, y: 5 });
-        expect(path[6].position).toEqual({ x: 5, y: 6 });
-        expect(path[7].position).toEqual({ x: 6, y: 6 });
-    });
+    const path = astar(maze, start, end);
 
-    it('should go though the maze', () => {
-        const maze = [
-            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
-            [0, 1, 0, 1, 1, 1, 1, 1, 1, 0],
-            [0, 0, 0, 1, 0, 0, 0, 0, 1, 0],
-            [1, 1, 1, 1, 0, 1, 1, 0, 1, 0],
-            [0, 0, 0, 0, 0, 0, 1, 0, 1, 0],
-            [0, 1, 1, 0, 1, 1, 1, 0, 1, 0],
-            [0, 0, 1, 0, 1, 0, 1, 0, 1, 0],
-            [1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
-            [1, 0, 1, 1, 1, 1, 1, 1, 1, 1],
-            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        ];
-        const start = { x: 0, y: 0 };
-        const end = { x: 9, y: 9 };
-
-        const path = astar(maze, start, end);
-
-        expect(path).toHaveLength(39);
-    });
-});
\ No newline at end of file
+    expect(path).toHaveLength(39);
+  });
+});
diff --git a/src/game/ai/pathfinding.ts b/src/game/ai/pathfinding.ts
index 59cc2c2..5412621 100644
--- a/src/game/ai/pathfinding.ts
+++ b/src/game/ai/pathfinding.ts
@@ -1,178 +1,193 @@
-import { arrayIncludesByEquals, filterEmpty, toEqual, Position } from "../utils";
+import {
+  arrayIncludesByEquals,
+  filterEmpty,
+  toEqual,
+  Position,
+} from '../utils';
 
 export const isPositionEqual = (a: Position, b: Position): boolean => {
-    return a.x === b.x 
-        && a.y === b.y;
-}
+  return a.x === b.x && a.y === b.y;
+};
 
 export class Node {
-	/**
-	 * The distance between the current node and the start node.
-	 */
-	public g = 0;
-
-	/**
-	 * The heuristic — estimated distance from the current node to the end node.
-	 */
-	public h = 0;
-
-	/**
-	 * The total cost of the node.
-	 */
-	public f = 0;
-	
-	constructor(
-        public readonly parent: Node | null = null,
-		public readonly position: Position,
-	) {}
-
-	public calculateF(): void {
-		this.f = this.g + this.h;
-	}
-
-	public equals(other: unknown): boolean {
-		if (other instanceof Node) {
-			return isPositionEqual(this.position, other.position);
-		}
-
-		return false;
-	}
-
-	public toString(): string {
-		return this.position.x + ',' + this.position.y;
-	}
+  /**
+   * The distance between the current node and the start node.
+   */
+  public g = 0;
+
+  /**
+   * The heuristic — estimated distance from the current node to the end node.
+   */
+  public h = 0;
+
+  /**
+   * The total cost of the node.
+   */
+  public f = 0;
+
+  constructor(
+    public readonly parent: Node | null = null,
+    public readonly position: Position
+  ) {}
+
+  public calculateF(): void {
+    this.f = this.g + this.h;
+  }
+
+  public equals(other: unknown): boolean {
+    if (other instanceof Node) {
+      return isPositionEqual(this.position, other.position);
+    }
+
+    return false;
+  }
+
+  public toString(): string {
+    return this.position.x + ',' + this.position.y;
+  }
 }
 
-export const getLowestFNode = (nodes: Node[]): Node|null => {
-	let lowestFNode = nodes[0];
-	for (let i = 1; i < nodes.length; i++) {
-		const node = nodes[i];
-		if (node.f < lowestFNode.f) {
-			lowestFNode = node;
-		}
-	}
+export const getLowestFNode = (nodes: Node[]): Node | null => {
+  let lowestFNode = nodes[0];
+  for (let i = 1; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.f < lowestFNode.f) {
+      lowestFNode = node;
+    }
+  }
 
-	return lowestFNode ?? null;
-}
+  return lowestFNode ?? null;
+};
 
 export type Path = Node[];
 
 export const createPathFromEndNode = (endNode: Node): Path => {
-	const path = [];
-	path.push(endNode);
+  const path = [];
+  path.push(endNode);
 
-	let currentNode = endNode;
-	while (currentNode.parent !== null) {
-		path.push(currentNode.parent);
-		currentNode = currentNode.parent;
-	}
+  let currentNode = endNode;
+  while (currentNode.parent !== null) {
+    path.push(currentNode.parent);
+    currentNode = currentNode.parent;
+  }
 
-	path.reverse();
+  path.reverse();
 
-	return path;
-}
+  return path;
+};
 
 const relativeAdjacentPositions: readonly Position[] = [
-	{ x: 0, y: -1 },
-	{ x: 0, y: 1 },
-	{ x: -1, y: 0 },
-	{ x: 1, y: 0 },
-	{ x: -1, y: -1 },
-	{ x: -1, y: 1 },
-	{ x: 1, y: -1 },
-	{ x: 1, y: 1 },
+  { x: 0, y: -1 },
+  { x: 0, y: 1 },
+  { x: -1, y: 0 },
+  { x: 1, y: 0 },
+  { x: -1, y: -1 },
+  { x: -1, y: 1 },
+  { x: 1, y: -1 },
+  { x: 1, y: 1 },
 ];
 
 type Grid = number[][];
 
-export const isPositionInsideGrid = (grid: Readonly<Grid>, position: Position): boolean => {
-	return position.y >= 0 && position.y < grid.length
-		&& position.x >= 0 && position.x < grid[position.y].length;
-}
-
-export const generateAdjacentNodes = (grid: Grid, currentNode: Node): Node[] => {
-	return relativeAdjacentPositions.map((relativeAdjacentPosition) => {
-		const position: Position = {
-			x: currentNode.position.x + relativeAdjacentPosition.x,
-			y: currentNode.position.y + relativeAdjacentPosition.y,
-		};
-
-		// check if position is in range of the grid
-		if (!isPositionInsideGrid(grid, position)) {
-			return;
-		}
-
-		// check if walkable terrain
-		if (grid[position.y][position.x] !== 0) {
-			return;
-		}
-
-		return new Node(currentNode, position);
-	}).filter(filterEmpty) as Node[];
-}
-
+export const isPositionInsideGrid = (
+  grid: Readonly<Grid>,
+  position: Position
+): boolean => {
+  return (
+    position.y >= 0 &&
+    position.y < grid.length &&
+    position.x >= 0 &&
+    position.x < grid[position.y].length
+  );
+};
+
+export const generateAdjacentNodes = (
+  grid: Grid,
+  currentNode: Node
+): Node[] => {
+  return relativeAdjacentPositions
+    .map((relativeAdjacentPosition) => {
+      const position: Position = {
+        x: currentNode.position.x + relativeAdjacentPosition.x,
+        y: currentNode.position.y + relativeAdjacentPosition.y,
+      };
+
+      // check if position is in range of the grid
+      if (!isPositionInsideGrid(grid, position)) {
+        return;
+      }
+
+      // check if walkable terrain
+      if (grid[position.y][position.x] !== 0) {
+        return;
+      }
+
+      return new Node(currentNode, position);
+    })
+    .filter(filterEmpty) as Node[];
+};
 
 const MOVE_STRAIGHT_COST = 10;
 const MOVE_DIAGONAL_COST = 14;
 
 export const calculateDistanceCost = (from: Node, to: Node): number => {
-	const xDistance = Math.abs(from.position.x - to.position.x);
-	const yDistance = Math.abs(from.position.y - to.position.y);
-	const remaining = Math.abs(xDistance - yDistance);
-
-	return (
-		MOVE_DIAGONAL_COST * Math.min(xDistance, yDistance) +
-		MOVE_STRAIGHT_COST * remaining
-	);
-}
+  const xDistance = Math.abs(from.position.x - to.position.x);
+  const yDistance = Math.abs(from.position.y - to.position.y);
+  const remaining = Math.abs(xDistance - yDistance);
+
+  return (
+    MOVE_DIAGONAL_COST * Math.min(xDistance, yDistance) +
+    MOVE_STRAIGHT_COST * remaining
+  );
+};
 
 export const astar = (grid: Grid, start: Position, end: Position): Path => {
-    const startNode = new Node(null, start);
-	const endNode = new Node(null, end);
+  const startNode = new Node(null, start);
+  const endNode = new Node(null, end);
 
-	const openList: Node[] = [];
-	const closedList: Node[] = [];
+  const openList: Node[] = [];
+  const closedList: Node[] = [];
 
-	openList.push(startNode);
+  openList.push(startNode);
 
-	while(openList.length > 0) {
-		const currentNode = getLowestFNode(openList);
-		if (currentNode == null) {
-			break;
-		}
+  while (openList.length > 0) {
+    const currentNode = getLowestFNode(openList);
+    if (currentNode == null) {
+      break;
+    }
 
-		// remove from openList
-		openList.splice(openList.indexOf(currentNode), 1);
+    // remove from openList
+    openList.splice(openList.indexOf(currentNode), 1);
 
-		closedList.push(currentNode);
+    closedList.push(currentNode);
 
-		if (currentNode.equals(endNode)) {		
-			return createPathFromEndNode(currentNode);
-		}
+    if (currentNode.equals(endNode)) {
+      return createPathFromEndNode(currentNode);
+    }
 
-		const adjacentNodes = generateAdjacentNodes(grid, currentNode);
+    const adjacentNodes = generateAdjacentNodes(grid, currentNode);
 
-		for(const adjacentNode of adjacentNodes) {
-			if (arrayIncludesByEquals(closedList, adjacentNode)){
-				continue;
-			};
+    for (const adjacentNode of adjacentNodes) {
+      if (arrayIncludesByEquals(closedList, adjacentNode)) {
+        continue;
+      }
 
-			// set cost values
-			adjacentNode.g = currentNode.g + 1;
-			adjacentNode.h = calculateDistanceCost(adjacentNode, endNode);
-			adjacentNode.calculateF();
+      // set cost values
+      adjacentNode.g = currentNode.g + 1;
+      adjacentNode.h = calculateDistanceCost(adjacentNode, endNode);
+      adjacentNode.calculateF();
 
-			if (arrayIncludesByEquals(openList, adjacentNode)) {
-				const openNode = openList.find(toEqual(adjacentNode))!;
-				// 
-				if (adjacentNode.g > openNode.g) {
-					continue;
-				}
-			}
+      if (arrayIncludesByEquals(openList, adjacentNode)) {
+        const openNode = openList.find(toEqual(adjacentNode))!;
+        //
+        if (adjacentNode.g > openNode.g) {
+          continue;
+        }
+      }
 
-			openList.push(adjacentNode);
-		}
-	}
+      openList.push(adjacentNode);
+    }
+  }
 
-	return [];
-}
+  return [];
+};
diff --git a/src/game/animation/Animation.ts b/src/game/animation/Animation.ts
index 52ea344..52e56cd 100644
--- a/src/game/animation/Animation.ts
+++ b/src/game/animation/Animation.ts
@@ -1,12 +1,12 @@
 import * as PIXI from 'pixi.js';
 
-export const DEFAULT_SPEED = .25;
+export const DEFAULT_SPEED = 0.25;
 
 export class Animation {
   constructor(
     public readonly textures: PIXI.Texture[],
     public readonly speed: number,
-    public readonly loop: boolean,
+    public readonly loop: boolean
   ) {}
 
   public set(sprite: PIXI.AnimatedSprite): void {
@@ -15,4 +15,4 @@ export class Animation {
     sprite.loop = this.loop;
     sprite.play();
   }
-}
\ No newline at end of file
+}
diff --git a/src/game/animation/AnimationManager.ts b/src/game/animation/AnimationManager.ts
index c4ddb13..25a8f20 100644
--- a/src/game/animation/AnimationManager.ts
+++ b/src/game/animation/AnimationManager.ts
@@ -11,11 +11,15 @@ export class AnimationManager {
     this.unitAnimations = animations.load(spritesheet);
   }
 
-  public getModel (color: animations.Color, unit: animations.Unit): Model {
+  public getModel(color: animations.Color, unit: animations.Unit): Model {
     return new Model(`${color}_${unit}`, this.unitAnimations[color][unit]);
   }
 
-  public createAnimator(sprite: PIXI.AnimatedSprite, color: animations.Color, unit: animations.Unit): Animator {
+  public createAnimator(
+    sprite: PIXI.AnimatedSprite,
+    color: animations.Color,
+    unit: animations.Unit
+  ): Animator {
     return new Animator(sprite, this.getModel(color, unit));
   }
-}
\ No newline at end of file
+}
diff --git a/src/game/animation/Animator.ts b/src/game/animation/Animator.ts
index 968419f..76eddbc 100644
--- a/src/game/animation/Animator.ts
+++ b/src/game/animation/Animator.ts
@@ -1,16 +1,16 @@
-import { AnimatedSprite } from "pixi.js";
-import { Model } from "./Model";
+import { AnimatedSprite } from 'pixi.js';
+import { Model } from './Model';
 
-import { Direction, State } from "./utils";
+import { Direction, State } from './utils';
 
 export class Animator {
   constructor(
     public readonly sprite: AnimatedSprite,
-    private readonly model: Model) {
-  }
+    private readonly model: Model
+  ) {}
 
   public set(state: State, direction: Direction): void {
     const animation = this.model.getAnimation(state, direction);
     animation.set(this.sprite);
   }
-}
\ No newline at end of file
+}
diff --git a/src/game/animation/Model.ts b/src/game/animation/Model.ts
index a71691b..12f0af6 100644
--- a/src/game/animation/Model.ts
+++ b/src/game/animation/Model.ts
@@ -1,13 +1,13 @@
-import { Animation } from "./Animation";
-import { Direction, State } from "./utils";
+import { Animation } from './Animation';
+import { Direction, State } from './utils';
 
 export class Model {
-  constructor (
+  constructor(
     public readonly name: string,
     private readonly animations: Record<State, Record<Direction, Animation>>
-  ) { }
+  ) {}
 
   public getAnimation(state: State, direction: Direction): Animation {
     return this.animations[state][direction];
   }
-}
\ No newline at end of file
+}
diff --git a/src/game/animation/utils.ts b/src/game/animation/utils.ts
index 57c892a..72f86e0 100644
--- a/src/game/animation/utils.ts
+++ b/src/game/animation/utils.ts
@@ -4,11 +4,27 @@ import { Animation, DEFAULT_SPEED } from './Animation';
 export const colors = ['red', 'blue'] as const;
 export type Color = typeof colors[number];
 
-export const units = ['swordsmen', 'crosscowsoldier', 'knight', 'juggernaut', 'catapult', 'cannon'] as const;
+export const units = [
+  'swordsmen',
+  'crosscowsoldier',
+  'knight',
+  'juggernaut',
+  'catapult',
+  'cannon',
+] as const;
 export type Unit = typeof units[number];
 const colorlessUnits: readonly Unit[] = ['catapult', 'cannon'];
 
-export const directions = ['north', 'northeast', 'east', 'southeast', 'south', 'southwest', 'west', 'northwest'] as const;
+export const directions = [
+  'north',
+  'northeast',
+  'east',
+  'southeast',
+  'south',
+  'southwest',
+  'west',
+  'northwest',
+] as const;
 export type Direction = typeof directions[number];
 
 export const states = ['idle', 'move', 'attack', 'dying', 'dead'] as const;
@@ -17,78 +33,112 @@ const loopableStates: readonly State[] = ['move', 'attack'];
 
 export type Animations = Record<State, Record<Direction, Animation>>;
 
-const getAnimationKey = (color: Color, unit: Unit, state: State, direction: Direction): string => {
-    if (colorlessUnits.includes(unit)) {
-        // have no color in their texture
-        return `${unit}.${state}.${direction}`;
-    }
-    return `${unit}.${color}.${state}.${direction}`;
-}
+const getAnimationKey = (
+  color: Color,
+  unit: Unit,
+  state: State,
+  direction: Direction
+): string => {
+  if (colorlessUnits.includes(unit)) {
+    // have no color in their texture
+    return `${unit}.${state}.${direction}`;
+  }
+  return `${unit}.${color}.${state}.${direction}`;
+};
 
-const getAnimation = (spritesheet: PIXI.Spritesheet, color: Color, unit: Unit, state: State, direction: Direction): Animation | null => {
-    const key = getAnimationKey(color, unit, state, direction);
-    if (spritesheet.animations[key] != null) {
-        // TODO: move loop check to data
-        return new Animation(spritesheet.animations[key], DEFAULT_SPEED, loopableStates.includes(state));
-    }
-    // dead state is no animation
-    if (spritesheet.textures[key + '.png'] != null) {
-        return new Animation([spritesheet.textures[key + '.png']], DEFAULT_SPEED, false);
-    }
+const getAnimation = (
+  spritesheet: PIXI.Spritesheet,
+  color: Color,
+  unit: Unit,
+  state: State,
+  direction: Direction
+): Animation | null => {
+  const key = getAnimationKey(color, unit, state, direction);
+  if (spritesheet.animations[key] != null) {
+    // TODO: move loop check to data
+    return new Animation(
+      spritesheet.animations[key],
+      DEFAULT_SPEED,
+      loopableStates.includes(state)
+    );
+  }
+  // dead state is no animation
+  if (spritesheet.textures[key + '.png'] != null) {
+    return new Animation(
+      [spritesheet.textures[key + '.png']],
+      DEFAULT_SPEED,
+      false
+    );
+  }
 
-    // else nothing found
-    return null;
-}
+  // else nothing found
+  return null;
+};
 
-const loadByDirection = (spritesheet: PIXI.Spritesheet, color: Color, unit: Unit, state: State): Animations => {
-    return directions.reduce((directionMap, direction) => {
-        return {
-            ...directionMap,
-            [direction]: getAnimation(spritesheet, color, unit, state, direction),
-        }
-    }, {}) as Animations
+const loadByDirection = (
+  spritesheet: PIXI.Spritesheet,
+  color: Color,
+  unit: Unit,
+  state: State
+): Animations => {
+  return directions.reduce((directionMap, direction) => {
+    return {
+      ...directionMap,
+      [direction]: getAnimation(spritesheet, color, unit, state, direction),
+    };
+  }, {}) as Animations;
 };
 
-const loadByUnit = (spritesheet: PIXI.Spritesheet, color: Color, unit: Unit): Animations => {
-    return states.reduce((directionMap, state) => {
-        return {
-            ...directionMap,
-            [state]: loadByDirection(spritesheet, color, unit, state),// todo implement me
-        }
-    }, {}) as Animations
-}
+const loadByUnit = (
+  spritesheet: PIXI.Spritesheet,
+  color: Color,
+  unit: Unit
+): Animations => {
+  return states.reduce((directionMap, state) => {
+    return {
+      ...directionMap,
+      [state]: loadByDirection(spritesheet, color, unit, state), // todo implement me
+    };
+  }, {}) as Animations;
+};
 
-const loadByColor = (spritesheet: PIXI.Spritesheet, color: Color): Record<Unit, Animations> => {
-    return units.reduce((unitMap, unit) => {
-        return {
-            ...unitMap,
-            [unit]: loadByUnit(spritesheet, color, unit),
-        };
-    }, {}) as Record<Unit, Animations>;
-}
+const loadByColor = (
+  spritesheet: PIXI.Spritesheet,
+  color: Color
+): Record<Unit, Animations> => {
+  return units.reduce((unitMap, unit) => {
+    return {
+      ...unitMap,
+      [unit]: loadByUnit(spritesheet, color, unit),
+    };
+  }, {}) as Record<Unit, Animations>;
+};
 
 export type UnitAnimations = Record<Color, Record<Unit, Animations>>;
 
 export const load = (spritesheet: PIXI.Spritesheet): UnitAnimations => {
-    return colors.reduce((colorMap, color) => {
-        return {
-            ...colorMap,
-            [color]: loadByColor(spritesheet, color)
-        }
-    }, {}) as UnitAnimations;
-}
+  return colors.reduce((colorMap, color) => {
+    return {
+      ...colorMap,
+      [color]: loadByColor(spritesheet, color),
+    };
+  }, {}) as UnitAnimations;
+};
 
-const ROTATION_TO_DIRECTION_MAP: ReadonlyMap<number, Direction> = new Map<number, Direction>([
-    [-135, 'northwest'],
-    [-90, 'north'],
-    [-45, 'northeast'],
-    [0, 'east'],
-    [45, 'southeast'],
-    [90, 'south'],
-    [135, 'southwest'],
-    [180, 'west'],
+const ROTATION_TO_DIRECTION_MAP: ReadonlyMap<number, Direction> = new Map<
+  number,
+  Direction
+>([
+  [-135, 'northwest'],
+  [-90, 'north'],
+  [-45, 'northeast'],
+  [0, 'east'],
+  [45, 'southeast'],
+  [90, 'south'],
+  [135, 'southwest'],
+  [180, 'west'],
 ]);
 
 export const rotationToDirection = (rotation: number): Direction => {
-    return ROTATION_TO_DIRECTION_MAP.get(rotation) ?? 'north';
-}
\ No newline at end of file
+  return ROTATION_TO_DIRECTION_MAP.get(rotation) ?? 'north';
+};
diff --git a/src/game/env.d.ts b/src/game/env.d.ts
index aafef95..d970c85 100644
--- a/src/game/env.d.ts
+++ b/src/game/env.d.ts
@@ -1,8 +1,8 @@
 /// <reference types="vite/client" />
 
 declare module '*.vue' {
-  import type { DefineComponent } from 'vue'
+  import type { DefineComponent } from 'vue';
   // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types
-  const component: DefineComponent<{}, {}, any>
-  export default component
+  const component: DefineComponent<{}, {}, any>;
+  export default component;
 }
diff --git a/src/game/levels/BehaviorTreeLevel.ts b/src/game/levels/BehaviorTreeLevel.ts
index 5e33f84..822c031 100644
--- a/src/game/levels/BehaviorTreeLevel.ts
+++ b/src/game/levels/BehaviorTreeLevel.ts
@@ -8,95 +8,97 @@ import { createEmptyGrid, getGridSizeByScreen } from './utils';
 import { BehaviorTreeComponent } from './../systems/ai/BehaviorTreeComponent';
 import { Tree } from '../ai/behaviortree/Tree';
 import {
-    Selector,
-    Timer,
-    Inventer,
-    Sequence,
+  Selector,
+  Timer,
+  Inventer,
+  Sequence,
 } from './../ai/behaviortree/nodes/core';
 import {
-    Follow,
-    Attack,
-    IsControlledByPlayer,
-    IsEnemyInAttackRange,
-    HasTarget, 
-    UnsetTarget, 
-    IsMoving,
-    SetTarget,
-    IsEnemyInAggroRange
+  Follow,
+  Attack,
+  IsControlledByPlayer,
+  IsEnemyInAttackRange,
+  HasTarget,
+  UnsetTarget,
+  IsMoving,
+  SetTarget,
+  IsEnemyInAggroRange,
 } from './../ai/behaviortree/nodes/entity';
-import * as animations  from '../animation/utils';
+import * as animations from '../animation/utils';
 
 export class BehaviorTreeLevel extends Level {
-    private map: number[][];
-    private readonly entityFactory: EntityFactory;
+  private map: number[][];
+  private readonly entityFactory: EntityFactory;
 
-    public readonly unitAnimations: animations.UnitAnimations;
+  public readonly unitAnimations: animations.UnitAnimations;
 
-    constructor(app: PIXI.Application, world: World) {
-        super(app, world);
+  constructor(app: PIXI.Application, world: World) {
+    super(app, world);
 
-        this.map = createEmptyGrid(getGridSizeByScreen(app));
-        this.unitAnimations = animations.load(app.loader.resources.unit.spritesheet!);
-        this.entityFactory = new EntityFactory(world, this.unitAnimations);
-    }
+    this.map = createEmptyGrid(getGridSizeByScreen(app));
+    this.unitAnimations = animations.load(
+      app.loader.resources.unit.spritesheet!
+    );
+    this.entityFactory = new EntityFactory(world, this.unitAnimations);
+  }
 
-    public get collisionMap(): number[][] {
-        return this.map;
-    }
+  public get collisionMap(): number[][] {
+    return this.map;
+  }
 
-    public load(): void {
-        const player = this.entityFactory.createUnit({
-            position: cellPositionToVector(1, 1),
-            color: 'blue',
-            team: {
-                number: 1,
-            }
-        });
+  public load(): void {
+    const player = this.entityFactory.createUnit({
+      position: cellPositionToVector(1, 1),
+      color: 'blue',
+      team: {
+        number: 1,
+      },
+    });
 
-        const enemy = this.entityFactory.createUnit({
-            position: cellPositionToVector(1, 3),
-            color: 'red',
-            team: {
-                number: 2,
-            }
-        });
+    const enemy = this.entityFactory.createUnit({
+      position: cellPositionToVector(1, 3),
+      color: 'red',
+      team: {
+        number: 2,
+      },
+    });
 
-        const entities = [player, enemy];
+    const entities = [player, enemy];
 
-        const tree = new Tree(
-            new Selector([
-                new Sequence([
-                    new Inventer([new HasTarget()]),
-                    new IsEnemyInAggroRange(entities),
-                    new SetTarget(),
-                ]),
-                new Sequence([
-                    new IsMoving(),
-                    new Inventer([new IsEnemyInAggroRange(entities)]),
-                    new UnsetTarget(),
-                ]),
-                new Sequence([
-                    new HasTarget(),
-                    new Selector([
-                        new Sequence([
-                            new IsEnemyInAttackRange(entities),
-                            new Timer({
-                                delay: 1000,
-                                children: [new Attack()]
-                            })
-                        ]),
-                        new Sequence([
-                            new Inventer([new IsControlledByPlayer()]),
-                            new Follow(),
-                        ])
-                    ])
-                ])
-            ])
-        );
-        tree.root.setData('entity', player);
+    const tree = new Tree(
+      new Selector([
+        new Sequence([
+          new Inventer([new HasTarget()]),
+          new IsEnemyInAggroRange(entities),
+          new SetTarget(),
+        ]),
+        new Sequence([
+          new IsMoving(),
+          new Inventer([new IsEnemyInAggroRange(entities)]),
+          new UnsetTarget(),
+        ]),
+        new Sequence([
+          new HasTarget(),
+          new Selector([
+            new Sequence([
+              new IsEnemyInAttackRange(entities),
+              new Timer({
+                delay: 1000,
+                children: [new Attack()],
+              }),
+            ]),
+            new Sequence([
+              new Inventer([new IsControlledByPlayer()]),
+              new Follow(),
+            ]),
+          ]),
+        ]),
+      ])
+    );
+    tree.root.setData('entity', player);
 
-        player.addComponent(BehaviorTreeComponent, {
-            tree,
-        })
-    }
-}
\ No newline at end of file
+    player.addComponent(BehaviorTreeComponent, {
+      tree,
+    });
+  }
+}
diff --git a/src/game/levels/Level.ts b/src/game/levels/Level.ts
index 3ea1f23..c26c611 100644
--- a/src/game/levels/Level.ts
+++ b/src/game/levels/Level.ts
@@ -3,14 +3,13 @@ import * as PIXI from 'pixi.js';
 import { UnitAnimations } from '../animation/utils';
 
 export abstract class Level {
-    abstract get collisionMap(): number[][];
-    abstract get unitAnimations(): UnitAnimations;
+  abstract get collisionMap(): number[][];
+  abstract get unitAnimations(): UnitAnimations;
 
-    constructor(
-        protected readonly app: PIXI.Application,
-        protected readonly world: World
-        ) {
-    }
-    
-    abstract load(app: PIXI.Application, world: World): void;
-}
\ No newline at end of file
+  constructor(
+    protected readonly app: PIXI.Application,
+    protected readonly world: World
+  ) {}
+
+  abstract load(app: PIXI.Application, world: World): void;
+}
diff --git a/src/game/levels/PathFindingLevel.ts b/src/game/levels/PathFindingLevel.ts
index 81c5ef6..02d0f16 100644
--- a/src/game/levels/PathFindingLevel.ts
+++ b/src/game/levels/PathFindingLevel.ts
@@ -8,39 +8,41 @@ import { generateMaze, getGridSizeByScreen } from './utils';
 import * as animations from '../animation/utils';
 
 export class PathFindingLevel extends Level {
-    private map: number[][];
-    private readonly entityFactory: EntityFactory;
-
-    public readonly unitAnimations: animations.UnitAnimations;
-
-    constructor(app: PIXI.Application, world: World) {
-        super(app, world);
-
-        this.map = generateMaze(getGridSizeByScreen(app));
-
-        this.unitAnimations = animations.load(app.loader.resources.unit.spritesheet!);
-        this.entityFactory = new EntityFactory(world, this.unitAnimations);
-    }
-
-    public get collisionMap(): number[][] {
-        return this.map;
-    }
-
-    public load(): void {
-        this.entityFactory.createUnit({
-            position: cellPositionToVector(1, 1),
-            color: 'red',
-            team: {
-                number: 1,
-            }
-        });
-
-        this.entityFactory.createUnit({
-            position: cellPositionToVector(3, 1),
-            color: 'red',
-            team: {
-                number: 2,
-            }
-        });
-    }
-}
\ No newline at end of file
+  private map: number[][];
+  private readonly entityFactory: EntityFactory;
+
+  public readonly unitAnimations: animations.UnitAnimations;
+
+  constructor(app: PIXI.Application, world: World) {
+    super(app, world);
+
+    this.map = generateMaze(getGridSizeByScreen(app));
+
+    this.unitAnimations = animations.load(
+      app.loader.resources.unit.spritesheet!
+    );
+    this.entityFactory = new EntityFactory(world, this.unitAnimations);
+  }
+
+  public get collisionMap(): number[][] {
+    return this.map;
+  }
+
+  public load(): void {
+    this.entityFactory.createUnit({
+      position: cellPositionToVector(1, 1),
+      color: 'red',
+      team: {
+        number: 1,
+      },
+    });
+
+    this.entityFactory.createUnit({
+      position: cellPositionToVector(3, 1),
+      color: 'red',
+      team: {
+        number: 2,
+      },
+    });
+  }
+}
diff --git a/src/game/levels/RandomUnitsLevel.ts b/src/game/levels/RandomUnitsLevel.ts
index 3cf7bdf..0e8effe 100644
--- a/src/game/levels/RandomUnitsLevel.ts
+++ b/src/game/levels/RandomUnitsLevel.ts
@@ -10,42 +10,43 @@ import { Level } from './Level';
 import * as animations from '../animation/utils';
 
 export class RandomUnitsLevel extends Level {
-    private readonly _collisionMap: number[][];
-    private readonly entityFactory: EntityFactory;
-
-    public readonly unitAnimations: animations.UnitAnimations;
-
-    constructor(app: PIXI.Application, world: World) {
-        super(app, world);
-
-        this._collisionMap = createEmptyGrid(getGridSizeByScreen(app));
-
-        this.unitAnimations = animations.load(app.loader.resources.unit.spritesheet!);
-        this.entityFactory = new EntityFactory(world, this.unitAnimations);
-    }
-
-    public get collisionMap(): number[][] {
-        return this._collisionMap;
-    }
-
-    public load(): void {
-        Array.from(Array(100)).forEach(() => {
-            const vector = toWorldPositionCellCenter(new Vector2(
-                Math.round(
-                    Math.random() * this.app.screen.width,
-                ), 
-                Math.round(
-                    Math.random() * this.app.screen.height,
-                ) + (Constants.CELL_SIZE / 2)
-            ));
-    
-            this.entityFactory.createUnit({
-                position: vector,
-                color: 'red',
-                team: {
-                    number: Math.round(Math.random() + 1),
-                }
-            });
-        });
-    }
-}
\ No newline at end of file
+  private readonly _collisionMap: number[][];
+  private readonly entityFactory: EntityFactory;
+
+  public readonly unitAnimations: animations.UnitAnimations;
+
+  constructor(app: PIXI.Application, world: World) {
+    super(app, world);
+
+    this._collisionMap = createEmptyGrid(getGridSizeByScreen(app));
+
+    this.unitAnimations = animations.load(
+      app.loader.resources.unit.spritesheet!
+    );
+    this.entityFactory = new EntityFactory(world, this.unitAnimations);
+  }
+
+  public get collisionMap(): number[][] {
+    return this._collisionMap;
+  }
+
+  public load(): void {
+    Array.from(Array(100)).forEach(() => {
+      const vector = toWorldPositionCellCenter(
+        new Vector2(
+          Math.round(Math.random() * this.app.screen.width),
+          Math.round(Math.random() * this.app.screen.height) +
+            Constants.CELL_SIZE / 2
+        )
+      );
+
+      this.entityFactory.createUnit({
+        position: vector,
+        color: 'red',
+        team: {
+          number: Math.round(Math.random() + 1),
+        },
+      });
+    });
+  }
+}
diff --git a/src/game/levels/utils.spec.ts b/src/game/levels/utils.spec.ts
index a928d42..910c88c 100644
--- a/src/game/levels/utils.spec.ts
+++ b/src/game/levels/utils.spec.ts
@@ -1,21 +1,25 @@
 import * as PIXI from 'pixi.js';
 
-import { getGridSizeByScreen, createEmptyGrid } from "./utils";
+import { getGridSizeByScreen, createEmptyGrid } from './utils';
 
 describe('getWorldCellSizeByScreen', () => {
-    it('should give ceil calculation', () => {
-        expect(getGridSizeByScreen({ screen: { width: 800, height: 600 } } as PIXI.Application)).toEqual({
-            width: 50,
-            height: 38,
-        });
+  it('should give ceil calculation', () => {
+    expect(
+      getGridSizeByScreen({
+        screen: { width: 800, height: 600 },
+      } as PIXI.Application)
+    ).toEqual({
+      width: 50,
+      height: 38,
     });
+  });
 });
 
 describe('createEmptyGrid', () => {
-    it('should create number array with 0\'s by given size', () => {
-        const grid = createEmptyGrid({ width: 100, height: 100 });
+  it("should create number array with 0's by given size", () => {
+    const grid = createEmptyGrid({ width: 100, height: 100 });
 
-        expect(grid.length).toBe(100);
-        expect(grid[0].length).toBe(100);
-    });
-});
\ No newline at end of file
+    expect(grid.length).toBe(100);
+    expect(grid[0].length).toBe(100);
+  });
+});
diff --git a/src/game/levels/utils.ts b/src/game/levels/utils.ts
index 4dbeef3..0361a3c 100644
--- a/src/game/levels/utils.ts
+++ b/src/game/levels/utils.ts
@@ -1,47 +1,61 @@
 import * as PIXI from 'pixi.js';
 import { default as generateEllerMaze } from 'generate-maze';
 
-import { Constants } from "../Constants";
+import { Constants } from '../Constants';
 
 type Size = { width: number; height: number };
 
 export const getGridSizeByScreen = (app: PIXI.Application): Size => {
-    return {
-        width: Math.ceil(app.screen.width / Constants.CELL_SIZE),
-        height: Math.ceil(app.screen.height / Constants.CELL_SIZE),
-    };    
+  return {
+    width: Math.ceil(app.screen.width / Constants.CELL_SIZE),
+    height: Math.ceil(app.screen.height / Constants.CELL_SIZE),
+  };
 };
 
 export const createEmptyGrid = (size: Size): number[][] => {
-    return Array.from({ length: size.height }, () => Array.from({ length: size.width }, () => 0))
-}
+  return Array.from({ length: size.height }, () =>
+    Array.from({ length: size.width }, () => 0)
+  );
+};
 
-type MazeObject = { x: number; y: number; top: boolean; left: boolean; bottom: boolean; right: boolean; };
+type MazeObject = {
+  x: number;
+  y: number;
+  top: boolean;
+  left: boolean;
+  bottom: boolean;
+  right: boolean;
+};
 
 export const generateMaze = (size: Size): number[][] => {
-    const ellerMaze = generateEllerMaze(Math.floor(size.width / 2), Math.floor(size.height / 2), true, Math.random() * 1000) as MazeObject[][];
-    
-    return convertEllerMazeToGrid(ellerMaze);
+  const ellerMaze = generateEllerMaze(
+    Math.floor(size.width / 2),
+    Math.floor(size.height / 2),
+    true,
+    Math.random() * 1000
+  ) as MazeObject[][];
+
+  return convertEllerMazeToGrid(ellerMaze);
 };
 
 const convertEllerMazeToGrid = (ellerMaze: MazeObject[][]): number[][] => {
-    const map: number[][] = [];
-    for(const row of ellerMaze) {
-        map[row[0].y * 2] = [];
-        map[row[0].y * 2 + 1] = [];
-        map[row[0].y * 2 + 2] = [];
-        for(const column of row) {
-            map[column.y * 2][column.x * 2] = 1; // top left
-            map[column.y * 2 + 1][column.x * 2] = column.left ? 1 : 0; // left
-            map[column.y * 2][column.x * 2 + 1] = column.top ? 1 : 0; // top
-            map[column.y * 2][column.x * 2 + 2] = 1; // top right
-            map[column.y * 2 + 1][column.x * 2 + 1] = 0; // center
-            map[column.y * 2 + 1][column.x * 2 + 2] = column.right ? 1 : 0; // right
-            map[column.y * 2 + 2][column.x * 2 + 2] = 1; // right bottom
-            map[column.y * 2 + 2][column.x * 2 + 1] = column.bottom ? 1 : 0; // bottom
-            map[column.y * 2 + 2][column.x * 2] = 1; // bottom right
-        }
+  const map: number[][] = [];
+  for (const row of ellerMaze) {
+    map[row[0].y * 2] = [];
+    map[row[0].y * 2 + 1] = [];
+    map[row[0].y * 2 + 2] = [];
+    for (const column of row) {
+      map[column.y * 2][column.x * 2] = 1; // top left
+      map[column.y * 2 + 1][column.x * 2] = column.left ? 1 : 0; // left
+      map[column.y * 2][column.x * 2 + 1] = column.top ? 1 : 0; // top
+      map[column.y * 2][column.x * 2 + 2] = 1; // top right
+      map[column.y * 2 + 1][column.x * 2 + 1] = 0; // center
+      map[column.y * 2 + 1][column.x * 2 + 2] = column.right ? 1 : 0; // right
+      map[column.y * 2 + 2][column.x * 2 + 2] = 1; // right bottom
+      map[column.y * 2 + 2][column.x * 2 + 1] = column.bottom ? 1 : 0; // bottom
+      map[column.y * 2 + 2][column.x * 2] = 1; // bottom right
     }
+  }
 
-    return map;
-};
\ No newline at end of file
+  return map;
+};
diff --git a/src/game/math/IPosition.ts b/src/game/math/IPosition.ts
index 8058840..2d0a919 100644
--- a/src/game/math/IPosition.ts
+++ b/src/game/math/IPosition.ts
@@ -1 +1,4 @@
-export interface IPosition { x: number; y: number }
\ No newline at end of file
+export interface IPosition {
+  x: number;
+  y: number;
+}
diff --git a/src/game/math/ISize.ts b/src/game/math/ISize.ts
index dae4918..bba6782 100644
--- a/src/game/math/ISize.ts
+++ b/src/game/math/ISize.ts
@@ -1,4 +1,4 @@
 export interface ISize {
-    width: number;
-    height: number;
-}
\ No newline at end of file
+  width: number;
+  height: number;
+}
diff --git a/src/game/math/Vector2.spec.ts b/src/game/math/Vector2.spec.ts
index 8aa6612..b52a046 100644
--- a/src/game/math/Vector2.spec.ts
+++ b/src/game/math/Vector2.spec.ts
@@ -1,124 +1,141 @@
 import { Vector2 } from './Vector2';
 
 describe('Vector2', () => {
-    describe('ZERO', () => {
-        test('values', () => {
-            expect(Vector2.ZERO.x).toEqual(0);
-            expect(Vector2.ZERO.y).toEqual(0);
-        })
-    });
-    describe('constructor', () => {
-        test('set values', () => {
-            const vector = new Vector2(100, 200);
+  describe('ZERO', () => {
+    test('values', () => {
+      expect(Vector2.ZERO.x).toEqual(0);
+      expect(Vector2.ZERO.y).toEqual(0);
+    });
+  });
+  describe('constructor', () => {
+    test('set values', () => {
+      const vector = new Vector2(100, 200);
 
-            expect(vector.x).toEqual(100);
-            expect(vector.y).toEqual(200);
-        });
-    });
-    describe('magnitude', () => {
-        test('simple', () => {
-            const vector = new Vector2(100, 0);
-            expect(vector.magnitude()).toEqual(100);
-        });
-        test('simple2', () => {
-            const vector = new Vector2(100, 100);
-            expect(vector.magnitude()).toBeCloseTo(141.42);
-        });
-    });
-    describe('normalized', () => {
-        test('simple', () => {
-            const vector = new Vector2(3, 4);
-            const normalizedVector = vector.normalized();
-            expect(normalizedVector.x).toBeCloseTo(0.6);
-            expect(normalizedVector.y).toBeCloseTo(0.8);
-        });
-    });
-    describe('distance', () => {
-        test('simple', () => {
-            const a = new Vector2(1, 1);
-            const b = new Vector2(2, 2);
+      expect(vector.x).toEqual(100);
+      expect(vector.y).toEqual(200);
+    });
+  });
+  describe('magnitude', () => {
+    test('simple', () => {
+      const vector = new Vector2(100, 0);
+      expect(vector.magnitude()).toEqual(100);
+    });
+    test('simple2', () => {
+      const vector = new Vector2(100, 100);
+      expect(vector.magnitude()).toBeCloseTo(141.42);
+    });
+  });
+  describe('normalized', () => {
+    test('simple', () => {
+      const vector = new Vector2(3, 4);
+      const normalizedVector = vector.normalized();
+      expect(normalizedVector.x).toBeCloseTo(0.6);
+      expect(normalizedVector.y).toBeCloseTo(0.8);
+    });
+  });
+  describe('distance', () => {
+    test('simple', () => {
+      const a = new Vector2(1, 1);
+      const b = new Vector2(2, 2);
 
-            expect(Vector2.distance(a, b)).toBeCloseTo(1.41);
-        });
+      expect(Vector2.distance(a, b)).toBeCloseTo(1.41);
     });
-    describe('lerp', () => {
-        test('simple', () => {
-            const a = new Vector2(0, 0);
-            const b = new Vector2(1, 0);
+  });
+  describe('lerp', () => {
+    test('simple', () => {
+      const a = new Vector2(0, 0);
+      const b = new Vector2(1, 0);
 
-            expect(Vector2.lerp(a, b, .5)).toEqual({ x: .5, y: 0 });
-        });
-    });
-    describe('angle', () => {
-        test('same location', () => {
-            expect(Vector2.angle(new Vector2(0, 0), new Vector2(0, 0))).toEqual(0);
-        });
-        test('above', () => {
-            expect(Vector2.angle(new Vector2(0, 0), new Vector2(0, -1))).toEqual(-90);
-        });
-        test('above-right', () => {
-            expect(Vector2.angle(new Vector2(0, 0), new Vector2(1, -1))).toEqual(-45);
-        });
-        test('right', () => {
-            expect(Vector2.angle(new Vector2(0, 0), new Vector2(1, 0))).toEqual(0);
-        });
-        test('right-below', () => {
-            expect(Vector2.angle(new Vector2(0, 0), new Vector2(1, 1))).toEqual(45);
-        });
-        test('below', () => {
-            expect(Vector2.angle(new Vector2(0, 0), new Vector2(0, 1))).toEqual(90);
-        });
-        test('below-left', () => {
-            expect(Vector2.angle(new Vector2(0, 0), new Vector2(-1, 1))).toEqual(135);
-        });
-        test('left', () => {
-            expect(Vector2.angle(new Vector2(0, 0), new Vector2(-1, 0))).toEqual(180);
-        });
-        test('left-above', () => {
-            expect(Vector2.angle(new Vector2(0, 0), new Vector2(-1, -1))).toEqual(-135);
-        });
-    });
-    describe('scale', () => {
-        test('simple', () => {
-            expect(Vector2.scale(new Vector2(2, 2), new Vector2(2, 2))).toEqual({ x: 4, y: 4, });
-        });
-    });
-    describe('min', () => {
-        test('simple', () => {
-            expect(Vector2.min(new Vector2(1, 2), new Vector2(2, 1))).toEqual({ x: 1, y: 1, });
-        });
-    });
-    describe('max', () => {
-        test('simple', () => {
-            expect(Vector2.max(new Vector2(1, 2), new Vector2(2, 1))).toEqual({ x: 2, y: 2, });
-        });
-    });
-    describe('subtracts', () => {
-        test('simple', () => {
-            expect(Vector2.subtracts(new Vector2(1, 1), new Vector2(1, 1))).toEqual({ x: 0, y: 0, });
-        });
-    });
-    describe('multiplies', () => {
-        test('simple', () => {
-            expect(Vector2.multiplies(new Vector2(1, 1), 2)).toEqual({ x: 2, y: 2, });
-        });
-    });
-    describe('divides', () => {
-        test('simple', () => {
-            expect(Vector2.divides(new Vector2(2, 2), 2)).toEqual({ x: 1, y: 1, });
-        });
-    });
-    describe('adds', () => {
-        test('simple', () => {
-            expect(Vector2.subtracts(new Vector2(1, 1), new Vector2(1, 1))).toEqual({ x: 0, y: 0, });
-        });
-    });
-    describe('equals', () => {
-        test('false', () => {
-            expect(new Vector2(1, 1).equals(new Vector2(2, 2))).toBe(false);
-        });
-        test('true', () => {
-            expect(new Vector2(1, 1).equals(new Vector2(1, 1))).toBe(true);
-        });
-    });
-});
\ No newline at end of file
+      expect(Vector2.lerp(a, b, 0.5)).toEqual({ x: 0.5, y: 0 });
+    });
+  });
+  describe('angle', () => {
+    test('same location', () => {
+      expect(Vector2.angle(new Vector2(0, 0), new Vector2(0, 0))).toEqual(0);
+    });
+    test('above', () => {
+      expect(Vector2.angle(new Vector2(0, 0), new Vector2(0, -1))).toEqual(-90);
+    });
+    test('above-right', () => {
+      expect(Vector2.angle(new Vector2(0, 0), new Vector2(1, -1))).toEqual(-45);
+    });
+    test('right', () => {
+      expect(Vector2.angle(new Vector2(0, 0), new Vector2(1, 0))).toEqual(0);
+    });
+    test('right-below', () => {
+      expect(Vector2.angle(new Vector2(0, 0), new Vector2(1, 1))).toEqual(45);
+    });
+    test('below', () => {
+      expect(Vector2.angle(new Vector2(0, 0), new Vector2(0, 1))).toEqual(90);
+    });
+    test('below-left', () => {
+      expect(Vector2.angle(new Vector2(0, 0), new Vector2(-1, 1))).toEqual(135);
+    });
+    test('left', () => {
+      expect(Vector2.angle(new Vector2(0, 0), new Vector2(-1, 0))).toEqual(180);
+    });
+    test('left-above', () => {
+      expect(Vector2.angle(new Vector2(0, 0), new Vector2(-1, -1))).toEqual(
+        -135
+      );
+    });
+  });
+  describe('scale', () => {
+    test('simple', () => {
+      expect(Vector2.scale(new Vector2(2, 2), new Vector2(2, 2))).toEqual({
+        x: 4,
+        y: 4,
+      });
+    });
+  });
+  describe('min', () => {
+    test('simple', () => {
+      expect(Vector2.min(new Vector2(1, 2), new Vector2(2, 1))).toEqual({
+        x: 1,
+        y: 1,
+      });
+    });
+  });
+  describe('max', () => {
+    test('simple', () => {
+      expect(Vector2.max(new Vector2(1, 2), new Vector2(2, 1))).toEqual({
+        x: 2,
+        y: 2,
+      });
+    });
+  });
+  describe('subtracts', () => {
+    test('simple', () => {
+      expect(Vector2.subtracts(new Vector2(1, 1), new Vector2(1, 1))).toEqual({
+        x: 0,
+        y: 0,
+      });
+    });
+  });
+  describe('multiplies', () => {
+    test('simple', () => {
+      expect(Vector2.multiplies(new Vector2(1, 1), 2)).toEqual({ x: 2, y: 2 });
+    });
+  });
+  describe('divides', () => {
+    test('simple', () => {
+      expect(Vector2.divides(new Vector2(2, 2), 2)).toEqual({ x: 1, y: 1 });
+    });
+  });
+  describe('adds', () => {
+    test('simple', () => {
+      expect(Vector2.subtracts(new Vector2(1, 1), new Vector2(1, 1))).toEqual({
+        x: 0,
+        y: 0,
+      });
+    });
+  });
+  describe('equals', () => {
+    test('false', () => {
+      expect(new Vector2(1, 1).equals(new Vector2(2, 2))).toBe(false);
+    });
+    test('true', () => {
+      expect(new Vector2(1, 1).equals(new Vector2(1, 1))).toBe(true);
+    });
+  });
+});
diff --git a/src/game/math/Vector2.ts b/src/game/math/Vector2.ts
index cce43e8..077497f 100644
--- a/src/game/math/Vector2.ts
+++ b/src/game/math/Vector2.ts
@@ -1,102 +1,102 @@
 export class Vector2 {
-	public static ZERO: Vector2 = Object.seal(new Vector2(0, 0));
-
-	public constructor(public x: number, public y: number) {}
-
-	/**
-	 * Result is never greater than 180 degrees or lower than -180 degrees.
-	 *
-	 * @param {Vector2} from
-	 * @param {Vector2} to
-	 * @returns {number} angle in degrees between from and to
-	 */
-	public static angle(from: Vector2, to: Vector2): number {
-		return Math.atan2(to.y - from.y, to.x - from.x) * (180 / Math.PI);
-	}
-
-	public static distance(from: Vector2, to: Vector2): number {
-		return Math.sqrt(Math.pow(to.x - from.x, 2) + Math.pow(to.y - from.y, 2));
-	}
-
-	public static scale(a: Vector2, b: Vector2): Vector2 {
-		return new Vector2(a.x * b.x, a.y * b.y);
-	}
-
-	/**
-	 * @param {Vector2} a
-	 * @param {Vector2} b
-	 *
-	 * @returns {Vector2} made from the smallest components of two vectors
-	 */
-	public static min(a: Vector2, b: Vector2): Vector2 {
-		return new Vector2(Math.min(a.x, b.x), Math.min(a.y, b.y));
-	}
-
-	/**
-	 * @param {Vector2} a
-	 * @param {Vector2} b
-	 *
-	 * @returns {Vector2} made from the largest components of two vectors.
-	 */
-	public static max(a: Vector2, b: Vector2): Vector2 {
-		return new Vector2(Math.max(a.x, b.x), Math.max(a.y, b.y));
-	}
-
-	public static lerp(from: Vector2, to: Vector2, percentage: number): Vector2 {
-		return new Vector2(
-			from.x * (1 - percentage) + to.x * percentage,
-			from.y * (1 - percentage) + to.y * percentage
-		);
-	}
-
-	public static subtracts(vector: Vector2, subtractor: Vector2): Vector2 {
-		return new Vector2(vector.x - subtractor.x, vector.y - subtractor.y);
-	}
-
-	public static multiplies(a: Vector2, multiplier: number): Vector2 {
-		return new Vector2(a.x * multiplier, a.y * multiplier);
-	}
-
-	public static divides(
-		a: Vector2,
-		devider: number,
-		round?: 'floor' | 'ceil'
-	): Vector2 {
-		let x = a.x / devider;
-		let y = a.y / devider;
-		if (round) {
-			x = Math[round](x);
-			y = Math[round](y);
-		}
-
-		return new Vector2(x, y);
-	}
-
-	public static adds(a: Vector2, b: Vector2): Vector2 {
-		return new Vector2(a.x + b.x, a.y + b.y);
-	}
-
-	/**
-	 * @returns {number} length of the vector
-	 */
-	public magnitude(): number {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	}
-
-	public normalized(): Vector2 {
-		const magnitude = this.magnitude();
-
-		return new Vector2(
-			this.x !== 0 ? this.x / magnitude : 0,
-			this.y !== 0 ? this.y / magnitude : 0
-		);
-	}
-
-	public equals(other: Vector2): boolean {
-		return this.x === other.x && this.y === other.y;
-	}
-
-	public toString(): string {
-		return `${this.x},${this.y}`;
-	}
+  public static ZERO: Vector2 = Object.seal(new Vector2(0, 0));
+
+  public constructor(public x: number, public y: number) {}
+
+  /**
+   * Result is never greater than 180 degrees or lower than -180 degrees.
+   *
+   * @param {Vector2} from
+   * @param {Vector2} to
+   * @returns {number} angle in degrees between from and to
+   */
+  public static angle(from: Vector2, to: Vector2): number {
+    return Math.atan2(to.y - from.y, to.x - from.x) * (180 / Math.PI);
+  }
+
+  public static distance(from: Vector2, to: Vector2): number {
+    return Math.sqrt(Math.pow(to.x - from.x, 2) + Math.pow(to.y - from.y, 2));
+  }
+
+  public static scale(a: Vector2, b: Vector2): Vector2 {
+    return new Vector2(a.x * b.x, a.y * b.y);
+  }
+
+  /**
+   * @param {Vector2} a
+   * @param {Vector2} b
+   *
+   * @returns {Vector2} made from the smallest components of two vectors
+   */
+  public static min(a: Vector2, b: Vector2): Vector2 {
+    return new Vector2(Math.min(a.x, b.x), Math.min(a.y, b.y));
+  }
+
+  /**
+   * @param {Vector2} a
+   * @param {Vector2} b
+   *
+   * @returns {Vector2} made from the largest components of two vectors.
+   */
+  public static max(a: Vector2, b: Vector2): Vector2 {
+    return new Vector2(Math.max(a.x, b.x), Math.max(a.y, b.y));
+  }
+
+  public static lerp(from: Vector2, to: Vector2, percentage: number): Vector2 {
+    return new Vector2(
+      from.x * (1 - percentage) + to.x * percentage,
+      from.y * (1 - percentage) + to.y * percentage
+    );
+  }
+
+  public static subtracts(vector: Vector2, subtractor: Vector2): Vector2 {
+    return new Vector2(vector.x - subtractor.x, vector.y - subtractor.y);
+  }
+
+  public static multiplies(a: Vector2, multiplier: number): Vector2 {
+    return new Vector2(a.x * multiplier, a.y * multiplier);
+  }
+
+  public static divides(
+    a: Vector2,
+    devider: number,
+    round?: 'floor' | 'ceil'
+  ): Vector2 {
+    let x = a.x / devider;
+    let y = a.y / devider;
+    if (round) {
+      x = Math[round](x);
+      y = Math[round](y);
+    }
+
+    return new Vector2(x, y);
+  }
+
+  public static adds(a: Vector2, b: Vector2): Vector2 {
+    return new Vector2(a.x + b.x, a.y + b.y);
+  }
+
+  /**
+   * @returns {number} length of the vector
+   */
+  public magnitude(): number {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+
+  public normalized(): Vector2 {
+    const magnitude = this.magnitude();
+
+    return new Vector2(
+      this.x !== 0 ? this.x / magnitude : 0,
+      this.y !== 0 ? this.y / magnitude : 0
+    );
+  }
+
+  public equals(other: Vector2): boolean {
+    return this.x === other.x && this.y === other.y;
+  }
+
+  public toString(): string {
+    return `${this.x},${this.y}`;
+  }
 }
diff --git a/src/game/math/collision/Bounds.ts b/src/game/math/collision/Bounds.ts
index 42b0935..e103071 100644
--- a/src/game/math/collision/Bounds.ts
+++ b/src/game/math/collision/Bounds.ts
@@ -4,35 +4,34 @@ import { Vector2 } from '../Vector2';
  * Represents an axis aligned bounding box.
  */
 export class Bounds {
-    /**
-     * Extend size from the center.
-     * Its half of {@link size}.
-     */
-    public readonly extends: Vector2;
+  /**
+   * Extend size from the center.
+   * Its half of {@link size}.
+   */
+  public readonly extends: Vector2;
 
-    /**
-     * This is always equal to center-extents.
-     */
-    public readonly min: Vector2;
+  /**
+   * This is always equal to center-extents.
+   */
+  public readonly min: Vector2;
 
-    /**
-     * This is always equal to center+extents.
-     */
-    public readonly max: Vector2;
+  /**
+   * This is always equal to center+extents.
+   */
+  public readonly max: Vector2;
 
-    constructor(public readonly center: Vector2,
-        public readonly size: Vector2) {
-        this.extends = new Vector2(size.x / 2, size.y / 2);
-        this.min = Vector2.subtracts(this.center, this.extends);
-        this.max = Vector2.adds(this.center, this.extends);
-    }
+  constructor(public readonly center: Vector2, public readonly size: Vector2) {
+    this.extends = new Vector2(size.x / 2, size.y / 2);
+    this.min = Vector2.subtracts(this.center, this.extends);
+    this.max = Vector2.adds(this.center, this.extends);
+  }
 
-    public contains(point: Vector2): boolean {
-        return (
-            point.x >= this.min.x &&
-            point.x <= this.max.x &&
-            point.y >= this.min.y &&
-            point.y <= this.max.y
-        );
-    }
-}
\ No newline at end of file
+  public contains(point: Vector2): boolean {
+    return (
+      point.x >= this.min.x &&
+      point.x <= this.max.x &&
+      point.y >= this.min.y &&
+      point.y <= this.max.y
+    );
+  }
+}
diff --git a/src/game/systems/AttackComponent.spec.ts b/src/game/systems/AttackComponent.spec.ts
index cdbe0ee..c428afa 100644
--- a/src/game/systems/AttackComponent.spec.ts
+++ b/src/game/systems/AttackComponent.spec.ts
@@ -1,25 +1,23 @@
-import { World } from "ecsy";
+import { World } from 'ecsy';
 
 import { AttackComponent } from './AttackComponent';
 import { HealthComponent } from './health/HealthComponent';
 
 describe('AttackComponent', () => {
-	describe('attack', () => {
-		const world = new World()
-			.registerComponent(HealthComponent);
+  describe('attack', () => {
+    const world = new World().registerComponent(HealthComponent);
 
-		it('should take hit to enemy', () => {
-			const enemy = world.createEntity()
-				.addComponent(HealthComponent, {
-					points: 100,
-				});
-			const attackComponent = new AttackComponent({
-				attackDamage: 10,
-			});
+    it('should take hit to enemy', () => {
+      const enemy = world.createEntity().addComponent(HealthComponent, {
+        points: 100,
+      });
+      const attackComponent = new AttackComponent({
+        attackDamage: 10,
+      });
 
-			attackComponent.attack(enemy);
+      attackComponent.attack(enemy);
 
-			expect(enemy.getComponent(HealthComponent)!.points).toEqual(90);
-		});
-	});
-});
\ No newline at end of file
+      expect(enemy.getComponent(HealthComponent)!.points).toEqual(90);
+    });
+  });
+});
diff --git a/src/game/systems/AttackComponent.ts b/src/game/systems/AttackComponent.ts
index 59162bf..78f009b 100644
--- a/src/game/systems/AttackComponent.ts
+++ b/src/game/systems/AttackComponent.ts
@@ -2,24 +2,24 @@ import { HealthComponent } from './health/HealthComponent';
 import { Component, Entity, Types } from 'ecsy';
 
 interface AttackComponentProps {
-	aggroRange: number;
-	attackRange: number;
-	attackDamage: number;
+  aggroRange: number;
+  attackRange: number;
+  attackDamage: number;
 }
 
 export class AttackComponent extends Component<AttackComponentProps> {
-	static schema = {
-		aggroRange: { type: Types.Number },
-		attackRange: { type: Types.Number },
-		attackDamage: { type: Types.Number },
-	};
+  static schema = {
+    aggroRange: { type: Types.Number },
+    attackRange: { type: Types.Number },
+    attackDamage: { type: Types.Number },
+  };
 
-	aggroRange!: number;
-	attackRange!: number;
-	attackDamage!: number;
+  aggroRange!: number;
+  attackRange!: number;
+  attackDamage!: number;
 
-	attack(enemy: Entity): void {
-		const enemyHealthComponent = enemy.getMutableComponent(HealthComponent)!;
-		enemyHealthComponent.takeHit(this.attackDamage);
-	}
+  attack(enemy: Entity): void {
+    const enemyHealthComponent = enemy.getMutableComponent(HealthComponent)!;
+    enemyHealthComponent.takeHit(this.attackDamage);
+  }
 }
diff --git a/src/game/systems/ControlledComponent.ts b/src/game/systems/ControlledComponent.ts
index 6611aa9..4ac8948 100644
--- a/src/game/systems/ControlledComponent.ts
+++ b/src/game/systems/ControlledComponent.ts
@@ -3,14 +3,13 @@ import { Component, Types } from 'ecsy';
 export type By = 'player' | 'ai';
 
 interface ControlledComponentProps {
-	by?: By | null;
+  by?: By | null;
 }
 
 export class ControlledComponent extends Component<ControlledComponentProps> {
-	static schema = {
-		by: { type: Types.String, default: null, },
-	};
-	
+  static schema = {
+    by: { type: Types.String, default: null },
+  };
 
-	declare by: By | null;
+  declare by: By | null;
 }
diff --git a/src/game/systems/DefaultAttributes.ts b/src/game/systems/DefaultAttributes.ts
index 6cfaa90..085105a 100644
--- a/src/game/systems/DefaultAttributes.ts
+++ b/src/game/systems/DefaultAttributes.ts
@@ -1,7 +1,7 @@
 import { EventBus } from './../EventBus';
-import { Attributes } from "ecsy";
+import { Attributes } from 'ecsy';
 import { Events } from '../Events';
 
 export interface DefaultAttributes extends Attributes {
-    eventBus: EventBus<Events>;
-}
\ No newline at end of file
+  eventBus: EventBus<Events>;
+}
diff --git a/src/game/systems/GameTimeSystem.ts b/src/game/systems/GameTimeSystem.ts
index 667a096..6f47321 100644
--- a/src/game/systems/GameTimeSystem.ts
+++ b/src/game/systems/GameTimeSystem.ts
@@ -2,7 +2,7 @@ import { System } from 'ecsy';
 import { GameTime } from '../GameTime';
 
 export class GameTimeSystem extends System {
-    public execute(delta: number, time: number): void {
-        GameTime.delta = delta;
-    }
-}
\ No newline at end of file
+  public execute(delta: number, time: number): void {
+    GameTime.delta = delta;
+  }
+}
diff --git a/src/game/systems/InputSystem.ts b/src/game/systems/InputSystem.ts
index ab6659f..9cbe243 100644
--- a/src/game/systems/InputSystem.ts
+++ b/src/game/systems/InputSystem.ts
@@ -3,58 +3,61 @@ import { Input, KeyStatus, MouseButtonStatus } from '../Input';
 import { Vector2 } from '../math/Vector2';
 
 export class InputSystem extends System {
-    private readonly canvas: HTMLCanvasElement;
-    private keyQueue: KeyboardEvent[] = [];
-    private mouseEvents: MouseEvent[] = [];
+  private readonly canvas: HTMLCanvasElement;
+  private keyQueue: KeyboardEvent[] = [];
+  private mouseEvents: MouseEvent[] = [];
 
-    constructor(world: World, attributes: Attributes) {
-        super(world, attributes);
-        this.canvas = attributes.canvas;
+  constructor(world: World, attributes: Attributes) {
+    super(world, attributes);
+    this.canvas = attributes.canvas;
 
-        this.canvas.addEventListener('mousedown', (event: MouseEvent) => {
-            this.mouseEvents.push(event);
-        });
-        this.canvas.addEventListener('mouseup', (event: MouseEvent) => {
-            this.mouseEvents.push(event);
-        });
-        this.canvas.addEventListener('click', (event: MouseEvent) => {
-            this.mouseEvents.push(event);
-        });
-        this.canvas.addEventListener('dblclick', (event: MouseEvent) => {
-            this.mouseEvents.push(event);
-        });
+    this.canvas.addEventListener('mousedown', (event: MouseEvent) => {
+      this.mouseEvents.push(event);
+    });
+    this.canvas.addEventListener('mouseup', (event: MouseEvent) => {
+      this.mouseEvents.push(event);
+    });
+    this.canvas.addEventListener('click', (event: MouseEvent) => {
+      this.mouseEvents.push(event);
+    });
+    this.canvas.addEventListener('dblclick', (event: MouseEvent) => {
+      this.mouseEvents.push(event);
+    });
 
-        this.canvas.addEventListener('mousemove', (event: MouseEvent) => {
-            Input.mousePosition = new Vector2(event.offsetX, event.offsetY);
-        });
+    this.canvas.addEventListener('mousemove', (event: MouseEvent) => {
+      Input.mousePosition = new Vector2(event.offsetX, event.offsetY);
+    });
 
-        window.addEventListener('keydown', (event: KeyboardEvent) => {
-            this.keyQueue.push(event);
-        });
-        window.addEventListener('keyup', (event: KeyboardEvent) => {
-            this.keyQueue.push(event);
-        });
-        window.addEventListener('keypress', (event: KeyboardEvent) => {
-            this.keyQueue.push(event);
-        });
-    }
+    window.addEventListener('keydown', (event: KeyboardEvent) => {
+      this.keyQueue.push(event);
+    });
+    window.addEventListener('keyup', (event: KeyboardEvent) => {
+      this.keyQueue.push(event);
+    });
+    window.addEventListener('keypress', (event: KeyboardEvent) => {
+      this.keyQueue.push(event);
+    });
+  }
 
-    public execute(delta: number, time: number): void {
-        Input.clearMouseStatuses();
-        if (this.mouseEvents.length > 0) {
-            let mouseEvent;
-            while ((mouseEvent = this.mouseEvents.shift())) {
-                Input.setMouseButton(mouseEvent.button, mouseEvent.type as MouseButtonStatus);
-            }
-        }
+  public execute(delta: number, time: number): void {
+    Input.clearMouseStatuses();
+    if (this.mouseEvents.length > 0) {
+      let mouseEvent;
+      while ((mouseEvent = this.mouseEvents.shift())) {
+        Input.setMouseButton(
+          mouseEvent.button,
+          mouseEvent.type as MouseButtonStatus
+        );
+      }
+    }
 
-        Input.clearKeysStatus();
-        if (this.keyQueue.length > 0) {
-            let event;
-            while ((event = this.keyQueue.pop())) {
-                Input.addKeyStatus(event.key, event.type as KeyStatus);
-            }
-            this.keyQueue = [];
-        }
+    Input.clearKeysStatus();
+    if (this.keyQueue.length > 0) {
+      let event;
+      while ((event = this.keyQueue.pop())) {
+        Input.addKeyStatus(event.key, event.type as KeyStatus);
+      }
+      this.keyQueue = [];
     }
+  }
 }
diff --git a/src/game/systems/PixiJsSystem.ts b/src/game/systems/PixiJsSystem.ts
index 97ab3ac..404ea72 100644
--- a/src/game/systems/PixiJsSystem.ts
+++ b/src/game/systems/PixiJsSystem.ts
@@ -2,10 +2,10 @@ import { System, World, Attributes } from 'ecsy';
 import * as PIXI from 'pixi.js';
 
 export abstract class PixiJsSystem extends System {
-	protected readonly app: PIXI.Application; 
+  protected readonly app: PIXI.Application;
 
-	constructor(world: World, attributes: Attributes) {
-        super(world, attributes);
-        this.app = attributes.app;
-	}
-}
\ No newline at end of file
+  constructor(world: World, attributes: Attributes) {
+    super(world, attributes);
+    this.app = attributes.app;
+  }
+}
diff --git a/src/game/systems/SizeComponent.ts b/src/game/systems/SizeComponent.ts
index e154ede..b5560f2 100644
--- a/src/game/systems/SizeComponent.ts
+++ b/src/game/systems/SizeComponent.ts
@@ -1,16 +1,16 @@
 import { Component, Types } from 'ecsy';
 
 interface ISizeComponentProps {
-	width?: number;
-	height?: number;
+  width?: number;
+  height?: number;
 }
 
 export class SizeComponent extends Component<ISizeComponentProps> {
-	static schema = {
-		width: { type: Types.Number, default: 0 },
-		height: { type: Types.Number, default: 0 },
-	};
+  static schema = {
+    width: { type: Types.Number, default: 0 },
+    height: { type: Types.Number, default: 0 },
+  };
 
-	declare width: number;
-	declare height: number;
+  declare width: number;
+  declare height: number;
 }
diff --git a/src/game/systems/TeamComponent.ts b/src/game/systems/TeamComponent.ts
index 3b7c423..1b7d2ee 100644
--- a/src/game/systems/TeamComponent.ts
+++ b/src/game/systems/TeamComponent.ts
@@ -1,14 +1,13 @@
 import { Component, Types } from 'ecsy';
 
 interface TeamComponentProps {
-	number?: number;
+  number?: number;
 }
 
 export class TeamComponent extends Component<TeamComponentProps> {
-	static schema = {
-		number: { type: Types.Number },
-	};
-	
+  static schema = {
+    number: { type: Types.Number },
+  };
 
-	declare number: number;
+  declare number: number;
 }
diff --git a/src/game/systems/TransformComponent.ts b/src/game/systems/TransformComponent.ts
index 65544dd..df25be6 100644
--- a/src/game/systems/TransformComponent.ts
+++ b/src/game/systems/TransformComponent.ts
@@ -3,27 +3,27 @@ import { Vector2 } from '../math/Vector2';
 import { toGridPosition } from '../utils';
 
 export interface TransformComponentProps {
-	position: Vector2;
-	rotation?: number;
+  position: Vector2;
+  rotation?: number;
 }
 
 export class TransformComponent extends Component<TransformComponentProps> {
-	static schema = {
-		position: { type: Types.Ref },
-		rotation: { type: Types.Number, default: 0 },
-	};
+  static schema = {
+    position: { type: Types.Ref },
+    rotation: { type: Types.Number, default: 0 },
+  };
 
-	position!: Vector2;
-	/**
-	 * in degrees (-180 to 180)
-	 */
-	rotation!: number;
+  position!: Vector2;
+  /**
+   * in degrees (-180 to 180)
+   */
+  rotation!: number;
 
-	public get gridPosition (): Vector2 {
-		return toGridPosition(this.position);
-	}
+  public get gridPosition(): Vector2 {
+    return toGridPosition(this.position);
+  }
 
-	public distance(other: TransformComponent): number {
-		return Vector2.distance(this.position, other.position);
-	}
-}
\ No newline at end of file
+  public distance(other: TransformComponent): number {
+    return Vector2.distance(this.position, other.position);
+  }
+}
diff --git a/src/game/systems/ai/BehaviorTreeComponent.ts b/src/game/systems/ai/BehaviorTreeComponent.ts
index 17aa0f2..954052b 100644
--- a/src/game/systems/ai/BehaviorTreeComponent.ts
+++ b/src/game/systems/ai/BehaviorTreeComponent.ts
@@ -2,13 +2,13 @@ import { Component, Types } from 'ecsy';
 import { Tree } from '../../ai/behaviortree/Tree';
 
 export interface BehaviorTreeComponentProps {
-	tree: Tree;
+  tree: Tree;
 }
 
 export class BehaviorTreeComponent extends Component<BehaviorTreeComponentProps> {
-	static schema = {
-		tree: { type: Types.Ref, default: false },
-	};	
+  static schema = {
+    tree: { type: Types.Ref, default: false },
+  };
 
-	declare tree: Tree;
-}
\ No newline at end of file
+  declare tree: Tree;
+}
diff --git a/src/game/systems/ai/BehaviorTreeSystem.ts b/src/game/systems/ai/BehaviorTreeSystem.ts
index 44665ce..8eeff04 100644
--- a/src/game/systems/ai/BehaviorTreeSystem.ts
+++ b/src/game/systems/ai/BehaviorTreeSystem.ts
@@ -2,21 +2,21 @@ import { BehaviorTreeComponent } from './BehaviorTreeComponent';
 import { System, SystemQueries } from 'ecsy';
 
 export class BehaviorTreeSystem extends System {
-    static queries: SystemQueries = {
-        entities: {
-            components: [BehaviorTreeComponent]
-        }
-    };
+  static queries: SystemQueries = {
+    entities: {
+      components: [BehaviorTreeComponent],
+    },
+  };
 
-    timePassed = 0;
-    triggerTime = 1000;
+  timePassed = 0;
+  triggerTime = 1000;
 
-    public execute(delta: number, time: number): void {
-        this.timePassed += delta;
-        for(const entity of this.queries.entities.results) {
-            const behaviorTreeComponent = entity.getComponent(BehaviorTreeComponent)!;
+  public execute(delta: number, time: number): void {
+    this.timePassed += delta;
+    for (const entity of this.queries.entities.results) {
+      const behaviorTreeComponent = entity.getComponent(BehaviorTreeComponent)!;
 
-            behaviorTreeComponent.tree.update();
-        }
+      behaviorTreeComponent.tree.update();
     }
-}
\ No newline at end of file
+  }
+}
diff --git a/src/game/systems/ai/TargetComponent.ts b/src/game/systems/ai/TargetComponent.ts
index 3758b82..39b6d4d 100644
--- a/src/game/systems/ai/TargetComponent.ts
+++ b/src/game/systems/ai/TargetComponent.ts
@@ -1,13 +1,13 @@
 import { Component, Entity, Types } from 'ecsy';
 
 interface TargetComponentProps {
-	target: Entity|null;
+  target: Entity | null;
 }
 
 export class TargetComponent extends Component<TargetComponentProps> {
-    static schema = {
-        target: { type: Types.Ref, default: null },
-    };
+  static schema = {
+    target: { type: Types.Ref, default: null },
+  };
 
-	declare target: Entity|null;
-}
\ No newline at end of file
+  declare target: Entity | null;
+}
diff --git a/src/game/systems/ai/TargetSystem.ts b/src/game/systems/ai/TargetSystem.ts
index 4e4bea4..ea32939 100644
--- a/src/game/systems/ai/TargetSystem.ts
+++ b/src/game/systems/ai/TargetSystem.ts
@@ -1,33 +1,33 @@
-import { Follow } from './../../ai/behaviortree/nodes/entity/Follow';
 import { System, SystemQueries } from 'ecsy';
-
+import { Follow } from './../../ai/behaviortree/nodes/entity/Follow';
 import { TargetComponent } from './TargetComponent';
 import { FollowComponent } from './../movement/FollowComponent';
 import { AliveComponent } from './../alive/AliveComponent';
 
 export class TargetSystem extends System {
-    static queries: SystemQueries = {
-        entities: {
-            components: [TargetComponent]
-        }
-    };
+  static queries: SystemQueries = {
+    entities: {
+      components: [TargetComponent],
+    },
+  };
 
-    public execute(delta: number, time: number): void {
-        this.checkDead();
-    }
+  public execute(delta: number, time: number): void {
+    this.checkDead();
+  }
+
+  private checkDead(): void {
+    for (const entity of this.queries.entities.results) {
+      const targetComponent = entity.getComponent(TargetComponent)!;
+      if (targetComponent.target === null) {
+        return;
+      }
 
-    private checkDead (): void {
-        for (const entity of this.queries.entities.results) {
-            const targetComponent = entity.getComponent(TargetComponent)!;
-            if (targetComponent.target === null) {
-                return;
-            }
-            
-            const targetAliveComponent = targetComponent.target.getComponent(AliveComponent)
+      const targetAliveComponent =
+        targetComponent.target.getComponent(AliveComponent);
 
-            if(targetAliveComponent !== null && !targetAliveComponent!.alive){
-                entity.getMutableComponent(TargetComponent)!.target = null;
-            }
-        }
+      if (targetAliveComponent !== null && !targetAliveComponent!.alive) {
+        entity.getMutableComponent(TargetComponent)!.target = null;
+      }
     }
-}
\ No newline at end of file
+  }
+}
diff --git a/src/game/systems/alive/AliveComponent.ts b/src/game/systems/alive/AliveComponent.ts
index f89d11b..b8ce65b 100644
--- a/src/game/systems/alive/AliveComponent.ts
+++ b/src/game/systems/alive/AliveComponent.ts
@@ -1,13 +1,13 @@
 import { Component, Types } from 'ecsy';
 
 export interface IAliveComponentProps {
-    alive?: boolean;
+  alive?: boolean;
 }
 
 export class AliveComponent extends Component<IAliveComponentProps> {
-    static schema = {
-        alive: { type: Types.Boolean, default: true },
-    };    
+  static schema = {
+    alive: { type: Types.Boolean, default: true },
+  };
 
-    declare alive: boolean
-}
\ No newline at end of file
+  declare alive: boolean;
+}
diff --git a/src/game/systems/alive/AliveSystem.ts b/src/game/systems/alive/AliveSystem.ts
index 570c912..5163a01 100644
--- a/src/game/systems/alive/AliveSystem.ts
+++ b/src/game/systems/alive/AliveSystem.ts
@@ -8,45 +8,47 @@ import { PixiJsSystem } from '../PixiJsSystem';
 import { AnimatedSpriteComponent } from '../render/sprite/AnimatedSpriteComponent';
 
 export class AliveSystem extends PixiJsSystem {
-	public static queries: SystemQueries = {
-		alives: {
-			components: [AliveComponent],
-			listen: {
-				changed: true,
-			}
-		},
-	};
+  public static queries: SystemQueries = {
+    alives: {
+      components: [AliveComponent],
+      listen: {
+        changed: true,
+      },
+    },
+  };
 
-	public execute(delta: number, time: number): void {
-		if (this.queries.alives.changed) {
-			this.queries.alives.changed.forEach((entity) => {
-				if (this.isDead(entity)) {
-					this.handleDead(entity);
-				}
-			});
-		}
-	}
+  public execute(delta: number, time: number): void {
+    if (this.queries.alives.changed) {
+      this.queries.alives.changed.forEach((entity) => {
+        if (this.isDead(entity)) {
+          this.handleDead(entity);
+        }
+      });
+    }
+  }
 
-	private isDead(entity: Entity): boolean {
-		const alive = entity.getMutableComponent(AliveComponent);
-		if (!alive) {
-			return false;
-		}
+  private isDead(entity: Entity): boolean {
+    const alive = entity.getMutableComponent(AliveComponent);
+    if (!alive) {
+      return false;
+    }
 
-		return !alive.alive;
-	}
+    return !alive.alive;
+  }
 
-	private handleDead(entity: Entity): void {
-		entity.removeComponent(SelectableComponent);
-		entity.removeComponent(HealthComponent);
+  private handleDead(entity: Entity): void {
+    entity.removeComponent(SelectableComponent);
+    entity.removeComponent(HealthComponent);
 
-		if (entity.hasComponent(SpriteComponent)) {
-			const spriteComponent = entity.getComponent(SpriteComponent)!;
-			spriteComponent.sprite.texture = this.app.loader.resources.dead.texture!;
-		}
-		if (entity.hasComponent(AnimatedSpriteComponent)) {
-			const spriteComponent = entity.getComponent(AnimatedSpriteComponent)!;
-			spriteComponent.sprite.textures = [this.app.loader.resources.dead.texture!];
-		}
-	}
+    if (entity.hasComponent(SpriteComponent)) {
+      const spriteComponent = entity.getComponent(SpriteComponent)!;
+      spriteComponent.sprite.texture = this.app.loader.resources.dead.texture!;
+    }
+    if (entity.hasComponent(AnimatedSpriteComponent)) {
+      const spriteComponent = entity.getComponent(AnimatedSpriteComponent)!;
+      spriteComponent.sprite.textures = [
+        this.app.loader.resources.dead.texture!,
+      ];
+    }
+  }
 }
diff --git a/src/game/systems/health/HealthComponent.spec.ts b/src/game/systems/health/HealthComponent.spec.ts
index e1a19f4..e5d12aa 100644
--- a/src/game/systems/health/HealthComponent.spec.ts
+++ b/src/game/systems/health/HealthComponent.spec.ts
@@ -1,14 +1,14 @@
 import { HealthComponent } from './HealthComponent';
 describe('HealthComponent', () => {
-	describe('takeHit', () => {
-		it('should subtract damage from health', () => {
-			const component = new HealthComponent({
-				points: 100,
-			});
+  describe('takeHit', () => {
+    it('should subtract damage from health', () => {
+      const component = new HealthComponent({
+        points: 100,
+      });
 
-			component.takeHit(10);
+      component.takeHit(10);
 
-			expect(component.points).toEqual(90);
-		});
-	});
-});
\ No newline at end of file
+      expect(component.points).toEqual(90);
+    });
+  });
+});
diff --git a/src/game/systems/health/HealthComponent.ts b/src/game/systems/health/HealthComponent.ts
index 4c7dd9e..989c951 100644
--- a/src/game/systems/health/HealthComponent.ts
+++ b/src/game/systems/health/HealthComponent.ts
@@ -1,21 +1,21 @@
 import { Component, Types } from 'ecsy';
 
 export interface IHealthComponentProps {
-	points: number;
-	maxPoints: number;
+  points: number;
+  maxPoints: number;
 }
 
 export class HealthComponent extends Component<IHealthComponentProps> {
-	static schema = {
-		points: { type: Types.Number, default: 10 },
-		maxPoints: { type: Types.Number, default: 10 },
-	};	
+  static schema = {
+    points: { type: Types.Number, default: 10 },
+    maxPoints: { type: Types.Number, default: 10 },
+  };
 
-	points!: number;
-	maxPoints!: number;
+  points!: number;
+  maxPoints!: number;
 
-	takeHit(damage: number): void {
-		this.points -= damage;
-		console.log('take hit');
-	}
-}
\ No newline at end of file
+  takeHit(damage: number): void {
+    this.points -= damage;
+    console.log('take hit');
+  }
+}
diff --git a/src/game/systems/health/HealthSystem.ts b/src/game/systems/health/HealthSystem.ts
index 9e0e184..2b31e02 100644
--- a/src/game/systems/health/HealthSystem.ts
+++ b/src/game/systems/health/HealthSystem.ts
@@ -3,41 +3,42 @@ import { AliveComponent } from '../alive/AliveComponent';
 import { HealthComponent } from './HealthComponent';
 
 export class HealthSystem extends System {
-    // Define a query of entities that have "Velocity" and "Position" components
-    public static queries: SystemQueries = {
-        healthy: {
-            components: [HealthComponent],
-            listen: {
-                added: true,
-                changed: true,
-            },
-        },
-    };
+  // Define a query of entities that have "Velocity" and "Position" components
+  public static queries: SystemQueries = {
+    healthy: {
+      components: [HealthComponent],
+      listen: {
+        added: true,
+        changed: true,
+      },
+    },
+  };
 
-    public execute(delta: number, time: number): void {
-        if (this.queries.healthy.added !== undefined) {
-            this.queries.healthy.added.forEach(this.updateStatus);
-        }
-        if (this.queries.healthy.changed !== undefined) {
-            this.queries.healthy.changed.forEach(this.updateStatus);
-        }
+  public execute(delta: number, time: number): void {
+    if (this.queries.healthy.added !== undefined) {
+      this.queries.healthy.added.forEach(this.updateStatus);
     }
+    if (this.queries.healthy.changed !== undefined) {
+      this.queries.healthy.changed.forEach(this.updateStatus);
+    }
+  }
 
-    private updateStatus(entity: Entity): void {
-        const health = entity.getComponent(HealthComponent);
-        if (!health) {
-            return;
-        }
-        if (!entity.hasComponent(AliveComponent)) {// if not alive
-            return;
-        }
+  private updateStatus(entity: Entity): void {
+    const health = entity.getComponent(HealthComponent);
+    if (!health) {
+      return;
+    }
+    if (!entity.hasComponent(AliveComponent)) {
+      // if not alive
+      return;
+    }
 
-        if (health.points === 0) {
-            const aliveComponent = entity.getMutableComponent(AliveComponent);
-            if (!aliveComponent) {
-                return;
-            }
-            aliveComponent.alive = false;
-        }
+    if (health.points === 0) {
+      const aliveComponent = entity.getMutableComponent(AliveComponent);
+      if (!aliveComponent) {
+        return;
+      }
+      aliveComponent.alive = false;
     }
+  }
 }
diff --git a/src/game/systems/health/utils.ts b/src/game/systems/health/utils.ts
index 6294c81..0f02e99 100644
--- a/src/game/systems/health/utils.ts
+++ b/src/game/systems/health/utils.ts
@@ -1,9 +1,9 @@
 export const getHealthColor = (percentage: number): number => {
-    if (percentage >= .66) {
-        return 0x00FF00;
-    } else if (percentage >= .33) {
-        return 0xFFFF00;
-    } else {
-        return 0xFF0000;
-    }
-}
\ No newline at end of file
+  if (percentage >= 0.66) {
+    return 0x00ff00;
+  } else if (percentage >= 0.33) {
+    return 0xffff00;
+  } else {
+    return 0xff0000;
+  }
+};
diff --git a/src/game/systems/movement/CollidableComponent.ts b/src/game/systems/movement/CollidableComponent.ts
index cc4f214..a7c58b8 100644
--- a/src/game/systems/movement/CollidableComponent.ts
+++ b/src/game/systems/movement/CollidableComponent.ts
@@ -1,3 +1,3 @@
 import { TagComponent } from 'ecsy';
 
-export class CollidableComponent extends TagComponent {}
\ No newline at end of file
+export class CollidableComponent extends TagComponent {}
diff --git a/src/game/systems/movement/FollowComponent.ts b/src/game/systems/movement/FollowComponent.ts
index 8d59db3..41c2b86 100644
--- a/src/game/systems/movement/FollowComponent.ts
+++ b/src/game/systems/movement/FollowComponent.ts
@@ -1,13 +1,13 @@
 import { Component, Types, Entity } from 'ecsy';
 
 type FollowComponentProps = {
-	follow: Entity | null;
+  follow: Entity | null;
 };
 
 export class FollowComponent extends Component<FollowComponentProps> {
-	static schema = {
-		follow: { type: Types.Ref, default: null },
-	};
+  static schema = {
+    follow: { type: Types.Ref, default: null },
+  };
 
-	follow!: Entity | null;
+  follow!: Entity | null;
 }
diff --git a/src/game/systems/movement/FollowSystem.ts b/src/game/systems/movement/FollowSystem.ts
index 461c6f2..a5df586 100644
--- a/src/game/systems/movement/FollowSystem.ts
+++ b/src/game/systems/movement/FollowSystem.ts
@@ -1,59 +1,68 @@
 import { TransformComponent } from './../TransformComponent';
-import { Entity, System, World } from "ecsy";
-import { astar } from "../../ai/pathfinding";
-import { LevelLoadedEvent } from "../../Events";
-import { DefaultAttributes } from "../DefaultAttributes";
-import { FollowComponent } from "./FollowComponent";
+import { Entity, System, World } from 'ecsy';
+import { astar } from '../../ai/pathfinding';
+import { LevelLoadedEvent } from '../../Events';
+import { DefaultAttributes } from '../DefaultAttributes';
+import { FollowComponent } from './FollowComponent';
 import { MovePathComponent } from './MovePathComponent';
 import { convertPathfindingPathToPositions } from '../../utils';
 
 export class FollowSystem extends System {
-    public static queries = {
-		entities: {
-			components: [FollowComponent],
-            listen: {
+  public static queries = {
+    entities: {
+      components: [FollowComponent],
+      listen: {
+        changed: true,
+      },
+    },
+  };
 
-                changed: true,
-            },
-		},
-	};
+  private map: number[][] | null = null;
 
-    private map: number[][]|null = null;
+  constructor(world: World, attributes: DefaultAttributes) {
+    super(world, attributes);
 
-	constructor(world: World, attributes: DefaultAttributes) {
-        super(world, attributes);
+    attributes.eventBus.on<LevelLoadedEvent>('level:loaded', (event) => {
+      this.map = event.detail.level.collisionMap;
+    });
+  }
 
-        attributes.eventBus.on<LevelLoadedEvent>('level:loaded', (event) => {
-            this.map = event.detail.level.collisionMap;
-        });
+  public execute(delta: number, time: number): void {
+    if ((this.queries.entities.changed ?? []).length > 0) {
+      for (const entity of this.queries.entities.changed!) {
+        this.updateFollowingEntity(entity);
+      }
     }
 
-    public execute(delta: number, time: number): void {
-        if((this.queries.entities.changed ?? []).length > 0) {
-            for(const entity of this.queries.entities.changed!) {
-                this.updateFollowingEntity(entity);
-            }
-        }
-
-        for(const entity of this.queries.entities.results) {
-            if (entity.getComponent(FollowComponent)!.follow != null && entity.getComponent(MovePathComponent)?.path != null) {
-                // when following and move-path is done
-                this.updateFollowingEntity(entity);
-            }
-        }
+    for (const entity of this.queries.entities.results) {
+      if (
+        entity.getComponent(FollowComponent)!.follow != null &&
+        entity.getComponent(MovePathComponent)?.path != null
+      ) {
+        // when following and move-path is done
+        this.updateFollowingEntity(entity);
+      }
     }
+  }
 
-    private updateFollowingEntity(entity: Entity): void {
-        const followComponent = entity.getComponent(FollowComponent)!;
-        if (followComponent.follow == null) {
-            return;
-        }
-        
-        const transformComponent = followComponent.follow!.getComponent(TransformComponent)!;
-        
-        const path = astar(this.map!, entity.getComponent(TransformComponent)!.gridPosition, transformComponent.gridPosition);
-            
-        const movePathComponent = entity.getMutableComponent(MovePathComponent)!;
-        movePathComponent.path = convertPathfindingPathToPositions(path.slice(1).slice(0, -1));// move to the other entity
+  private updateFollowingEntity(entity: Entity): void {
+    const followComponent = entity.getComponent(FollowComponent)!;
+    if (followComponent.follow == null) {
+      return;
     }
-}
\ No newline at end of file
+
+    const transformComponent =
+      followComponent.follow!.getComponent(TransformComponent)!;
+
+    const path = astar(
+      this.map!,
+      entity.getComponent(TransformComponent)!.gridPosition,
+      transformComponent.gridPosition
+    );
+
+    const movePathComponent = entity.getMutableComponent(MovePathComponent)!;
+    movePathComponent.path = convertPathfindingPathToPositions(
+      path.slice(1).slice(0, -1)
+    ); // move to the other entity
+  }
+}
diff --git a/src/game/systems/movement/MovableComponent.ts b/src/game/systems/movement/MovableComponent.ts
index 1317e97..eb6334d 100644
--- a/src/game/systems/movement/MovableComponent.ts
+++ b/src/game/systems/movement/MovableComponent.ts
@@ -1,13 +1,13 @@
 import { Component, Types } from 'ecsy';
 
 type MovableComponentProps = {
-	moving: boolean;
+  moving: boolean;
 };
 
 export class MovableComponent extends Component<MovableComponentProps> {
-	static schema = {
-		moving: { type: Types.Boolean, default: false },
-	};
+  static schema = {
+    moving: { type: Types.Boolean, default: false },
+  };
 
-	declare moving: boolean;
+  declare moving: boolean;
 }
diff --git a/src/game/systems/movement/MovePathComponent.ts b/src/game/systems/movement/MovePathComponent.ts
index bf14155..7daa523 100644
--- a/src/game/systems/movement/MovePathComponent.ts
+++ b/src/game/systems/movement/MovePathComponent.ts
@@ -5,13 +5,13 @@ import { Position } from '../../utils';
 type Path = Position[];
 
 type MovePathComponentProps = {
-	path: Path;
+  path: Path;
 };
 
 export class MovePathComponent extends Component<MovePathComponentProps> {
-	static schema = {
-		path: { type: Types.Array, default: [] },
-	};	
+  static schema = {
+    path: { type: Types.Array, default: [] },
+  };
 
-    path!: Path;
-}
\ No newline at end of file
+  path!: Path;
+}
diff --git a/src/game/systems/movement/MovePathSystem.ts b/src/game/systems/movement/MovePathSystem.ts
index dc7d737..78e115c 100644
--- a/src/game/systems/movement/MovePathSystem.ts
+++ b/src/game/systems/movement/MovePathSystem.ts
@@ -1,7 +1,7 @@
 import { setEntityAnimation } from './../render/sprite/utils';
 import { MoveVelocityComponent } from './MoveVelocityComponent';
 import { TransformComponent } from './../TransformComponent';
-import { Entity, System } from "ecsy";
+import { Entity, System } from 'ecsy';
 
 import { getCell, not, Position } from './../../utils';
 import { CollidableComponent } from './CollidableComponent';
@@ -16,66 +16,90 @@ import { AnimatedSpriteComponent } from './../render/sprite/AnimatedSpriteCompon
 import { Vector2 } from '../../math/Vector2';
 
 export class MovePathSystem extends System {
-    public static queries = {
-		entities: {
-			components: [MovePathComponent],
-		},
-        colliders: {
-            components: [CollidableComponent],
-        }
-	};
+  public static queries = {
+    entities: {
+      components: [MovePathComponent],
+    },
+    colliders: {
+      components: [CollidableComponent],
+    },
+  };
 
-    public execute(delta: number, time: number): void {
-        for(const entity of this.queries.entities.results) {            
-            const movePathComponent = entity.getMutableComponent(MovePathComponent)!;
+  public execute(delta: number, time: number): void {
+    for (const entity of this.queries.entities.results) {
+      const movePathComponent = entity.getMutableComponent(MovePathComponent)!;
 
-            if(movePathComponent.path.length == 0) {
-                const moveVelocityComponent = entity.getComponent(MoveVelocityComponent);
-                if (moveVelocityComponent?.velocity != null && Vector2.ZERO.equals(moveVelocityComponent.velocity)) {
-                    if (entity.hasComponent(ControlledComponent)) {
-                        entity.getMutableComponent(ControlledComponent)!.by = null;
-                    }
-                    if (!entity.getComponent(AnimatedSpriteComponent)?.state.startsWith('attack')) {
-                        setEntityAnimation(entity, 'idle');
-                    }
-                }
+      if (movePathComponent.path.length == 0) {
+        const moveVelocityComponent = entity.getComponent(
+          MoveVelocityComponent
+        );
+        if (
+          moveVelocityComponent?.velocity != null &&
+          Vector2.ZERO.equals(moveVelocityComponent.velocity)
+        ) {
+          if (entity.hasComponent(ControlledComponent)) {
+            entity.getMutableComponent(ControlledComponent)!.by = null;
+          }
+          if (
+            !entity
+              .getComponent(AnimatedSpriteComponent)
+              ?.state.startsWith('attack')
+          ) {
+            setEntityAnimation(entity, 'idle');
+          }
+        }
 
-                continue;
-            }
+        continue;
+      }
 
-            const movePositionDirectComponent = entity.getMutableComponent(MovePositionDirectComponent)!;
-            if (movePositionDirectComponent.movePosition != null) {
-                // is currently moving
-                continue;
-            }
+      const movePositionDirectComponent = entity.getMutableComponent(
+        MovePositionDirectComponent
+      )!;
+      if (movePositionDirectComponent.movePosition != null) {
+        // is currently moving
+        continue;
+      }
 
-            const nextCell = movePathComponent.path[0];
+      const nextCell = movePathComponent.path[0];
 
-            if (!this.canEntityMoveToCell(entity, nextCell)) {
-                // cancel move
-                continue;
-            }
-            movePathComponent.path.shift();
+      if (!this.canEntityMoveToCell(entity, nextCell)) {
+        // cancel move
+        continue;
+      }
+      movePathComponent.path.shift();
 
-            movePositionDirectComponent.movePosition = cellPositionToVector(nextCell.x, nextCell.y);
-            const transformComponent = entity.getMutableComponent(TransformComponent)!;
-            if (!transformComponent.position.equals(movePositionDirectComponent.movePosition)) {
-				transformComponent.rotation = Vector2.angle(transformComponent.position, movePositionDirectComponent.movePosition);
-			}
+      movePositionDirectComponent.movePosition = cellPositionToVector(
+        nextCell.x,
+        nextCell.y
+      );
+      const transformComponent =
+        entity.getMutableComponent(TransformComponent)!;
+      if (
+        !transformComponent.position.equals(
+          movePositionDirectComponent.movePosition
+        )
+      ) {
+        transformComponent.rotation = Vector2.angle(
+          transformComponent.position,
+          movePositionDirectComponent.movePosition
+        );
+      }
 
-            setEntityAnimation(entity, 'move');
-        }
+      setEntityAnimation(entity, 'move');
     }
+  }
 
-    private canEntityMoveToCell(entity: Entity, cell: Position): boolean {
-        const colliders = this.queries.colliders.results.filter(not(isSameEntity(entity)));
+  private canEntityMoveToCell(entity: Entity, cell: Position): boolean {
+    const colliders = this.queries.colliders.results.filter(
+      not(isSameEntity(entity))
+    );
 
-        const collider = colliders.find((collider) => {
-            const colliderCell = getCell(collider);
+    const collider = colliders.find((collider) => {
+      const colliderCell = getCell(collider);
 
-            return cell.x === colliderCell.x && cell.y === colliderCell.y;
-        });
+      return cell.x === colliderCell.x && cell.y === colliderCell.y;
+    });
 
-        return collider == null;
-    }
-}
\ No newline at end of file
+    return collider == null;
+  }
+}
diff --git a/src/game/systems/movement/MovePositionDirectComponent.ts b/src/game/systems/movement/MovePositionDirectComponent.ts
index f5a7cb7..e68a2e9 100644
--- a/src/game/systems/movement/MovePositionDirectComponent.ts
+++ b/src/game/systems/movement/MovePositionDirectComponent.ts
@@ -3,13 +3,13 @@ import { Component, Types } from 'ecsy';
 import { Vector2 } from '../../math/Vector2';
 
 export interface IMovePositionDirectComponentProps {
-	movePosition: Vector2 | null;
+  movePosition: Vector2 | null;
 }
 
 export class MovePositionDirectComponent extends Component<IMovePositionDirectComponentProps> {
-	static schema = {
-		movePosition: { type: Types.Ref, default: null, },
-	};
+  static schema = {
+    movePosition: { type: Types.Ref, default: null },
+  };
 
-	movePosition!: Vector2 | null;
+  movePosition!: Vector2 | null;
 }
diff --git a/src/game/systems/movement/MovePositionDirectSystem.ts b/src/game/systems/movement/MovePositionDirectSystem.ts
index aa7632c..77d9175 100644
--- a/src/game/systems/movement/MovePositionDirectSystem.ts
+++ b/src/game/systems/movement/MovePositionDirectSystem.ts
@@ -7,56 +7,90 @@ import { TransformComponent } from '../TransformComponent';
 import { Vector2 } from '../../math/Vector2';
 
 export class MovePositionDirectSystem extends System {
-	public static queries = {
-		entities: {
-			components: [MovePositionDirectComponent],
-		},
-	};
-
-	public execute(delta: number, time: number): void {
-		for (const entity of this.queries.entities.results) {
-			const movePositionDirectComponent = entity.getMutableComponent(MovePositionDirectComponent);
-			if (null == movePositionDirectComponent?.movePosition) {
-				continue;
-			}
-			const transformComponent = entity.getMutableComponent(TransformComponent);
-			if (!transformComponent) {
-				continue;
-			}
-			
-			// TODO: remove this?
-			// this.moveByTransformVelocity(entity, transformComponent, movePositionDirectComponent);
-			this.moveByMoveVelocity(entity, transformComponent, movePositionDirectComponent);
-		}
-	}
-
-	private moveByTransformVelocity(entity: Entity, transformComponent: TransformComponent, movePositionDirectComponent: MovePositionDirectComponent): void {
-		const moveTransformVelocityComponent = entity.getMutableComponent(MoveTransformVelocityComponent);
-		if (moveTransformVelocityComponent) {
-			if (Vector2.distance(transformComponent.position, movePositionDirectComponent.movePosition!) < 1) {
-				transformComponent.position = movePositionDirectComponent.movePosition!;
-				// stop					
-				movePositionDirectComponent.movePosition = null;
-				moveTransformVelocityComponent.velocity = Vector2.ZERO;
-				return;
-			}
-
-			moveTransformVelocityComponent.velocity = Vector2.subtracts(movePositionDirectComponent.movePosition!, transformComponent.position).normalized();
-		}
-	}
-
-	private moveByMoveVelocity(entity: Entity, transformComponent: TransformComponent, movePositionDirectComponent: MovePositionDirectComponent): void {
-		const moveVelocityComponent = entity.getMutableComponent(MoveVelocityComponent);
-		if (moveVelocityComponent) {
-			if (Vector2.distance(transformComponent.position, movePositionDirectComponent.movePosition!) < 1) {
-				transformComponent.position = movePositionDirectComponent.movePosition!;
-				// stop
-				movePositionDirectComponent.movePosition = null;
-				moveVelocityComponent.velocity = Vector2.ZERO;
-				return;
-			}
-
-			moveVelocityComponent.velocity = Vector2.subtracts(movePositionDirectComponent.movePosition!, transformComponent.position).normalized();
-		}
-	}
+  public static queries = {
+    entities: {
+      components: [MovePositionDirectComponent],
+    },
+  };
+
+  public execute(delta: number, time: number): void {
+    for (const entity of this.queries.entities.results) {
+      const movePositionDirectComponent = entity.getMutableComponent(
+        MovePositionDirectComponent
+      );
+      if (null == movePositionDirectComponent?.movePosition) {
+        continue;
+      }
+      const transformComponent = entity.getMutableComponent(TransformComponent);
+      if (!transformComponent) {
+        continue;
+      }
+
+      // TODO: remove this?
+      // this.moveByTransformVelocity(entity, transformComponent, movePositionDirectComponent);
+      this.moveByMoveVelocity(
+        entity,
+        transformComponent,
+        movePositionDirectComponent
+      );
+    }
+  }
+
+  private moveByTransformVelocity(
+    entity: Entity,
+    transformComponent: TransformComponent,
+    movePositionDirectComponent: MovePositionDirectComponent
+  ): void {
+    const moveTransformVelocityComponent = entity.getMutableComponent(
+      MoveTransformVelocityComponent
+    );
+    if (moveTransformVelocityComponent) {
+      if (
+        Vector2.distance(
+          transformComponent.position,
+          movePositionDirectComponent.movePosition!
+        ) < 1
+      ) {
+        transformComponent.position = movePositionDirectComponent.movePosition!;
+        // stop
+        movePositionDirectComponent.movePosition = null;
+        moveTransformVelocityComponent.velocity = Vector2.ZERO;
+        return;
+      }
+
+      moveTransformVelocityComponent.velocity = Vector2.subtracts(
+        movePositionDirectComponent.movePosition!,
+        transformComponent.position
+      ).normalized();
+    }
+  }
+
+  private moveByMoveVelocity(
+    entity: Entity,
+    transformComponent: TransformComponent,
+    movePositionDirectComponent: MovePositionDirectComponent
+  ): void {
+    const moveVelocityComponent = entity.getMutableComponent(
+      MoveVelocityComponent
+    );
+    if (moveVelocityComponent) {
+      if (
+        Vector2.distance(
+          transformComponent.position,
+          movePositionDirectComponent.movePosition!
+        ) < 1
+      ) {
+        transformComponent.position = movePositionDirectComponent.movePosition!;
+        // stop
+        movePositionDirectComponent.movePosition = null;
+        moveVelocityComponent.velocity = Vector2.ZERO;
+        return;
+      }
+
+      moveVelocityComponent.velocity = Vector2.subtracts(
+        movePositionDirectComponent.movePosition!,
+        transformComponent.position
+      ).normalized();
+    }
+  }
 }
diff --git a/src/game/systems/movement/MoveTransformVelocityComponent.ts b/src/game/systems/movement/MoveTransformVelocityComponent.ts
index c6f8bc7..186c08c 100644
--- a/src/game/systems/movement/MoveTransformVelocityComponent.ts
+++ b/src/game/systems/movement/MoveTransformVelocityComponent.ts
@@ -2,8 +2,8 @@ import { Component, Types } from 'ecsy';
 import { Vector2 } from '../../math/Vector2';
 
 export interface IMoveTransformVelocityComponentProps {
-	moveSpeed?: number;
-	velocity?: Vector2;
+  moveSpeed?: number;
+  velocity?: Vector2;
 }
 
 /**
@@ -11,15 +11,15 @@ export interface IMoveTransformVelocityComponentProps {
  * Use {@link MoveVelocityComponent} when physics is required.
  */
 export class MoveTransformVelocityComponent extends Component<IMoveTransformVelocityComponentProps> {
-	static schema = {
-		moveSpeed: { type: Types.Number, default: 100 },
-		velocity: { type: Types.Ref, default: Vector2.ZERO },
-	};
+  static schema = {
+    moveSpeed: { type: Types.Number, default: 100 },
+    velocity: { type: Types.Ref, default: Vector2.ZERO },
+  };
 
-	moveSpeed!: number;
-	velocity!: Vector2;
+  moveSpeed!: number;
+  velocity!: Vector2;
 
-	public calculateMovement(delta: number): Vector2 {
-		return Vector2.multiplies(this.velocity, this.moveSpeed * (delta / 1000));
-	}
+  public calculateMovement(delta: number): Vector2 {
+    return Vector2.multiplies(this.velocity, this.moveSpeed * (delta / 1000));
+  }
 }
diff --git a/src/game/systems/movement/MoveVelocityComponent.ts b/src/game/systems/movement/MoveVelocityComponent.ts
index ba4a3ae..706c3b7 100644
--- a/src/game/systems/movement/MoveVelocityComponent.ts
+++ b/src/game/systems/movement/MoveVelocityComponent.ts
@@ -3,8 +3,8 @@ import { Component, Types } from 'ecsy';
 import { Vector2 } from '../../math/Vector2';
 
 export interface IMoveVelocityComponentProps {
-	moveSpeed?: number;
-	velocity?: Vector2;
+  moveSpeed?: number;
+  velocity?: Vector2;
 }
 
 /**
@@ -12,15 +12,15 @@ export interface IMoveVelocityComponentProps {
  * Use {@link MoveTransformVelocityComponent} when physics is not nesesery.
  */
 export class MoveVelocityComponent extends Component<IMoveVelocityComponentProps> {
-	static schema = {
-		moveSpeed: { type: Types.Number, default: 100 },
-		velocity: { type: Types.Ref, default: Vector2.ZERO },
-	};	
+  static schema = {
+    moveSpeed: { type: Types.Number, default: 100 },
+    velocity: { type: Types.Ref, default: Vector2.ZERO },
+  };
 
-	moveSpeed!: number;
-	velocity!: Vector2;
+  moveSpeed!: number;
+  velocity!: Vector2;
 
-	public calculateMovement(delta: number): Vector2 {
-		return Vector2.multiplies(this.velocity, this.moveSpeed * (delta / 1000));
-	}
-}
\ No newline at end of file
+  public calculateMovement(delta: number): Vector2 {
+    return Vector2.multiplies(this.velocity, this.moveSpeed * (delta / 1000));
+  }
+}
diff --git a/src/game/systems/movement/MoveVelocitySystem.ts b/src/game/systems/movement/MoveVelocitySystem.ts
index 633f38b..c4a453c 100644
--- a/src/game/systems/movement/MoveVelocitySystem.ts
+++ b/src/game/systems/movement/MoveVelocitySystem.ts
@@ -4,31 +4,37 @@ import { MoveVelocityComponent } from './MoveVelocityComponent';
 import { TransformComponent } from '../TransformComponent';
 
 export class MoveVelocitySystem extends System {
-	public static queries: SystemQueries = {
-		bodies: {
-			components: [MoveVelocityComponent, TransformComponent],
-			listen: {
-				added: true,
-			}
-		},
-	};
+  public static queries: SystemQueries = {
+    bodies: {
+      components: [MoveVelocityComponent, TransformComponent],
+      listen: {
+        added: true,
+      },
+    },
+  };
 
-	public execute(delta: number, time: number): void {
-		this.queries.bodies.results.forEach((entity) => this.updateEntityBody(entity, delta));
-	}
+  public execute(delta: number, time: number): void {
+    this.queries.bodies.results.forEach((entity) =>
+      this.updateEntityBody(entity, delta)
+    );
+  }
 
-	private updateEntityBody(entity: Entity, delta: number): void {
-		const moveVelocityComponent = entity.getMutableComponent(MoveVelocityComponent);
-		if (moveVelocityComponent?.velocity == null) {
-			return;
-		}
+  private updateEntityBody(entity: Entity, delta: number): void {
+    const moveVelocityComponent = entity.getMutableComponent(
+      MoveVelocityComponent
+    );
+    if (moveVelocityComponent?.velocity == null) {
+      return;
+    }
 
-		const transformComponent = entity.getMutableComponent(TransformComponent);
-		if (!transformComponent) {
-			return;
-		}
+    const transformComponent = entity.getMutableComponent(TransformComponent);
+    if (!transformComponent) {
+      return;
+    }
 
-		transformComponent.position.x = transformComponent.position.x + moveVelocityComponent.velocity.x;
-		transformComponent.position.y = transformComponent.position.y + moveVelocityComponent.velocity.y;
-	}
+    transformComponent.position.x =
+      transformComponent.position.x + moveVelocityComponent.velocity.x;
+    transformComponent.position.y =
+      transformComponent.position.y + moveVelocityComponent.velocity.y;
+  }
 }
diff --git a/src/game/systems/player/PlayerMovementKeysComponent.ts b/src/game/systems/player/PlayerMovementKeysComponent.ts
index 797adf3..7e5b9e5 100644
--- a/src/game/systems/player/PlayerMovementKeysComponent.ts
+++ b/src/game/systems/player/PlayerMovementKeysComponent.ts
@@ -1,3 +1,3 @@
 import { TagComponent } from 'ecsy';
 
-export class PlayerMovementKeysComponent extends TagComponent { }
\ No newline at end of file
+export class PlayerMovementKeysComponent extends TagComponent {}
diff --git a/src/game/systems/player/PlayerMovementKeysSystem.ts b/src/game/systems/player/PlayerMovementKeysSystem.ts
index 3c0159c..a6f6ce8 100644
--- a/src/game/systems/player/PlayerMovementKeysSystem.ts
+++ b/src/game/systems/player/PlayerMovementKeysSystem.ts
@@ -9,68 +9,73 @@ import { MoveVelocityComponent } from '../movement/MoveVelocityComponent';
 import { TransformComponent } from '../TransformComponent';
 
 export class PlayerMovementKeysSystem extends System {
-	public static queries = {
-		entities: {
-			components: [PlayerMovementKeysComponent, SelectableComponent],
-		},
-	};
+  public static queries = {
+    entities: {
+      components: [PlayerMovementKeysComponent, SelectableComponent],
+    },
+  };
 
-	public execute(delta: number, time: number): void {
-		for (const entity of this.queries.entities.results) {
-			const selectableComponent = entity.getComponent(SelectableComponent);
-			if (!selectableComponent || !selectableComponent.selected) {
-				continue;
-			}
+  public execute(delta: number, time: number): void {
+    for (const entity of this.queries.entities.results) {
+      const selectableComponent = entity.getComponent(SelectableComponent);
+      if (!selectableComponent || !selectableComponent.selected) {
+        continue;
+      }
 
-			this.handleMovement(entity);
-			this.handleAction(entity);
-		}
-	}
+      this.handleMovement(entity);
+      this.handleAction(entity);
+    }
+  }
 
-	private handleMovement(entity: Entity): void {
-		let moveX = 0;
-		let moveY = 0;
+  private handleMovement(entity: Entity): void {
+    let moveX = 0;
+    let moveY = 0;
 
-		if (Input.isKeyDown('w')) {
-			moveY -= 1;
-		}
-		if (Input.isKeyDown('s')) {
-			moveY += 1;
-		}
-		if (Input.isKeyDown('a')) {
-			moveX -= 1;
-		}
-		if (Input.isKeyDown('d')) {
-			moveX += 1;
-		}
+    if (Input.isKeyDown('w')) {
+      moveY -= 1;
+    }
+    if (Input.isKeyDown('s')) {
+      moveY += 1;
+    }
+    if (Input.isKeyDown('a')) {
+      moveX -= 1;
+    }
+    if (Input.isKeyDown('d')) {
+      moveX += 1;
+    }
 
-		const moveVelocity = new Vector2(moveX, moveY).normalized();
+    const moveVelocity = new Vector2(moveX, moveY).normalized();
 
-		const moveTransformVelocityComponent = entity.getMutableComponent(MoveTransformVelocityComponent);
-		if (moveTransformVelocityComponent) {
-			moveTransformVelocityComponent.velocity = moveVelocity;
-		}
-		const moveVelocityComponent = entity.getMutableComponent(MoveVelocityComponent);
-		if (moveVelocityComponent) {
-			moveVelocityComponent.velocity = moveVelocity;
-		}
+    const moveTransformVelocityComponent = entity.getMutableComponent(
+      MoveTransformVelocityComponent
+    );
+    if (moveTransformVelocityComponent) {
+      moveTransformVelocityComponent.velocity = moveVelocity;
+    }
+    const moveVelocityComponent = entity.getMutableComponent(
+      MoveVelocityComponent
+    );
+    if (moveVelocityComponent) {
+      moveVelocityComponent.velocity = moveVelocity;
+    }
 
-		const transformComponent = entity.getMutableComponent(TransformComponent);
-		if (!transformComponent) {
-			return;
-		}
+    const transformComponent = entity.getMutableComponent(TransformComponent);
+    if (!transformComponent) {
+      return;
+    }
 
-		if (!moveVelocity.equals(Vector2.ZERO)) {
-			transformComponent.rotation = Vector2.angle(Vector2.ZERO, moveVelocity) - 90;
-		}
-	}
+    if (!moveVelocity.equals(Vector2.ZERO)) {
+      transformComponent.rotation =
+        Vector2.angle(Vector2.ZERO, moveVelocity) - 90;
+    }
+  }
 
-	private handleAction(entity: Entity): void {
-		if(Input.isKeyDown('Escape')) {
-			const component = entity.getMutableComponent(SelectableComponent);
-			if(component != null) {
-				component.selected = false;
-			}
-		}
-	}
+  private handleAction(entity: Entity): void {
+    if (Input.isKeyDown('Escape')) {
+      const component = entity.getMutableComponent(SelectableComponent);
+      if (component != null) {
+        component.selected = false;
+      }
+    }
+  }
 }
diff --git a/src/game/systems/player/PlayerMovementMouseComponent.ts b/src/game/systems/player/PlayerMovementMouseComponent.ts
index 0a3f023..7bb1dd5 100644
--- a/src/game/systems/player/PlayerMovementMouseComponent.ts
+++ b/src/game/systems/player/PlayerMovementMouseComponent.ts
@@ -1,3 +1,3 @@
 import { TagComponent } from 'ecsy';
 
-export class PlayerMovementMouseComponent extends TagComponent { }
\ No newline at end of file
+export class PlayerMovementMouseComponent extends TagComponent {}
diff --git a/src/game/systems/player/PlayerMovementMouseSystem.ts b/src/game/systems/player/PlayerMovementMouseSystem.ts
index 1b2bd8d..63f3636 100644
--- a/src/game/systems/player/PlayerMovementMouseSystem.ts
+++ b/src/game/systems/player/PlayerMovementMouseSystem.ts
@@ -17,64 +17,75 @@ import { DefaultAttributes } from './../DefaultAttributes';
 import { getEntityAtPosition } from '../utils';
 
 export class PlayerMovementMouseSystem extends PixiJsSystem {
-	public static queries = {
-		playerEntities: {
-			components: [PlayerMovementMouseComponent],
-		},
-		entities: {
-			components: [TransformComponent, SizeComponent],
-		}
-	};
+  public static queries = {
+    playerEntities: {
+      components: [PlayerMovementMouseComponent],
+    },
+    entities: {
+      components: [TransformComponent, SizeComponent],
+    },
+  };
 
-	private map: number[][]|null = null;
+  private map: number[][] | null = null;
 
-	constructor(world: World, attributes: DefaultAttributes) {
-        super(world, attributes);
+  constructor(world: World, attributes: DefaultAttributes) {
+    super(world, attributes);
 
-        attributes.eventBus.on<LevelLoadedEvent>('level:loaded', (event) => {
-            this.map = event.detail.level.collisionMap;
-        });
-    }
+    attributes.eventBus.on<LevelLoadedEvent>('level:loaded', (event) => {
+      this.map = event.detail.level.collisionMap;
+    });
+  }
+
+  public execute(delta: number, time: number): void {
+    if (Input.isMouseButtonUp(2) || Input.isMouseDblClick()) {
+      for (const entity of this.queries.playerEntities.results) {
+        const selectableComponent = entity.getComponent(SelectableComponent);
+        if (!selectableComponent || !selectableComponent.selected) {
+          continue;
+        }
 
-	public execute(delta: number, time: number): void {
-		if (Input.isMouseButtonUp(2) || Input.isMouseDblClick()) {
-			for (const entity of this.queries.playerEntities.results) {
-				const selectableComponent = entity.getComponent(SelectableComponent);
-				if (!selectableComponent || !selectableComponent.selected) {
-					continue;
-				}
+        const transformComponent = entity.getComponent(TransformComponent);
+        if (!transformComponent) {
+          continue;
+        }
 
-				const transformComponent = entity.getComponent(TransformComponent);
-				if (!transformComponent) {
-					continue;
-				}
+        if (this.map != null) {
+          const clickedEntity = getEntityAtPosition(
+            this.queries.entities.results,
+            Input.mousePosition.x,
+            Input.mousePosition.y
+          );
+          if (clickedEntity != null) {
+            const followComponent = entity.getMutableComponent(FollowComponent);
+            if (followComponent != null) {
+              followComponent.follow = clickedEntity;
+              continue;
+            }
+          }
 
-				if(this.map != null) {
-					const clickedEntity = getEntityAtPosition(this.queries.entities.results, Input.mousePosition.x, Input.mousePosition.y);
-					if (clickedEntity != null) {
-						const followComponent = entity.getMutableComponent(FollowComponent);
-						if (followComponent != null) {
-							followComponent.follow = clickedEntity;
-							continue;
-						}
-					}
+          // unfollow
+          const followComponent = entity.getMutableComponent(FollowComponent);
+          if (followComponent != null && followComponent.follow != null) {
+            followComponent.follow = null;
+          }
 
-					// unfollow
-					const followComponent = entity.getMutableComponent(FollowComponent);
-					if (followComponent != null && followComponent.follow != null) {
-						followComponent.follow = null;
-					}
+          const path = astar(
+            this.map,
+            transformComponent.gridPosition,
+            getMouseGridPosition()
+          );
 
-					const path = astar(this.map, transformComponent.gridPosition, getMouseGridPosition());
-					
-					const movePathComponent = entity.getMutableComponent(MovePathComponent)!;
-					movePathComponent.path = convertPathfindingPathToPositions(path.slice(1));
+          const movePathComponent =
+            entity.getMutableComponent(MovePathComponent)!;
+          movePathComponent.path = convertPathfindingPathToPositions(
+            path.slice(1)
+          );
 
-					if (entity.hasComponent(ControlledComponent)) {
-						entity.getMutableComponent(ControlledComponent)!.by = 'player';
-					}
-				}
-			}
-		}
-	}
-}
\ No newline at end of file
+          if (entity.hasComponent(ControlledComponent)) {
+            entity.getMutableComponent(ControlledComponent)!.by = 'player';
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/src/game/systems/render/AssetComponent.ts b/src/game/systems/render/AssetComponent.ts
index 2f9058a..c5c5396 100644
--- a/src/game/systems/render/AssetComponent.ts
+++ b/src/game/systems/render/AssetComponent.ts
@@ -3,13 +3,13 @@ import { Component, Types } from 'ecsy';
 import { Animations } from '../../animation/utils';
 
 export interface AssetComponentProps {
-    animations: Animations;
+  animations: Animations;
 }
 
 export class AssetComponent extends Component<AssetComponentProps> {
-    static schema = {
-        animations: { type: Types.Ref },
-    };   
+  static schema = {
+    animations: { type: Types.Ref },
+  };
 
-    animations!: Animations;
-}
\ No newline at end of file
+  animations!: Animations;
+}
diff --git a/src/game/systems/render/GridSystem.ts b/src/game/systems/render/GridSystem.ts
index 246c9ee..fa21406 100644
--- a/src/game/systems/render/GridSystem.ts
+++ b/src/game/systems/render/GridSystem.ts
@@ -1,52 +1,56 @@
 import { World, Attributes } from 'ecsy';
 import * as PIXI from 'pixi.js';
-import { DashLine }  from 'pixi-dashed-line';
+import { DashLine } from 'pixi-dashed-line';
 
 import { Constants } from './../../Constants';
-import { PixiJsSystem } from "../PixiJsSystem"
+import { PixiJsSystem } from '../PixiJsSystem';
 import { Options } from '../../utils';
 
 export class GridSystem extends PixiJsSystem {
+  private graphics: PIXI.Graphics;
+  private options: Options;
 
-    private graphics: PIXI.Graphics;
-    private options: Options;
+  constructor(world: World, attributes: Attributes) {
+    super(world, attributes);
+    this.options = attributes.options;
 
-    constructor(world: World, attributes: Attributes) {
-        super(world, attributes);
-        this.options = attributes.options;
+    window.onresize = () => this.draw();
 
-        window.onresize = () => this.draw();
+    this.graphics = this.app.stage.addChildAt(new PIXI.Graphics(), 0);
+    this.draw();
+  }
 
-        this.graphics = this.app.stage.addChildAt(new PIXI.Graphics(), 0);
-        this.draw();
-    }
-
-    public execute(delta: number, time: number): void {}
-
-    private draw(): void {
-        this.graphics.clear();
-
-        if (!this.options.debug?.includes('grid')) {
-            return;
-        }
+  public execute(delta: number, time: number): void {}
 
-        const dash = new DashLine(this.graphics, {
-            dash: [5, 5],
-            width: 1,
-            color: 0xAAAAAA,
-        })
+  private draw(): void {
+    this.graphics.clear();
 
-        for(let height = Constants.CELL_SIZE; height < this.app.screen.height; height += Constants.CELL_SIZE) {
-            // horizontal lines
-            dash.moveTo(0, height)
-                .lineTo(this.app.screen.width, height);
-        }
+    if (!this.options.debug?.includes('grid')) {
+      return;
+    }
 
-        for(let width = Constants.CELL_SIZE; width < this.app.screen.width; width += Constants.CELL_SIZE) {
-            // vertical lines
-            dash.moveTo(width, 0)
-                .lineTo(width, this.app.screen.height);
-        }
-    };
+    const dash = new DashLine(this.graphics, {
+      dash: [5, 5],
+      width: 1,
+      color: 0xaaaaaa,
+    });
+
+    for (
+      let height = Constants.CELL_SIZE;
+      height < this.app.screen.height;
+      height += Constants.CELL_SIZE
+    ) {
+      // horizontal lines
+      dash.moveTo(0, height).lineTo(this.app.screen.width, height);
+    }
 
-}
\ No newline at end of file
+    for (
+      let width = Constants.CELL_SIZE;
+      width < this.app.screen.width;
+      width += Constants.CELL_SIZE
+    ) {
+      // vertical lines
+      dash.moveTo(width, 0).lineTo(width, this.app.screen.height);
+    }
+  }
+}
diff --git a/src/game/systems/render/MapSystem.ts b/src/game/systems/render/MapSystem.ts
index fca6d48..b670223 100644
--- a/src/game/systems/render/MapSystem.ts
+++ b/src/game/systems/render/MapSystem.ts
@@ -3,44 +3,43 @@ import * as PIXI from 'pixi.js';
 
 import { DefaultAttributes } from './../DefaultAttributes';
 import { LevelLoadedEvent } from './../../Events';
-import { PixiJsSystem } from "../PixiJsSystem";
+import { PixiJsSystem } from '../PixiJsSystem';
 import { cellPositionToVector } from './../../utils';
 
 export class MapSystem extends PixiJsSystem {
+  private graphics: PIXI.Graphics;
+  private map: number[][] | null = null;
 
-    private graphics: PIXI.Graphics;
-    private map: number[][]|null = null;
+  constructor(world: World, attributes: DefaultAttributes) {
+    super(world, attributes);
 
-    constructor(world: World, attributes: DefaultAttributes) {
-        super(world, attributes);
+    this.graphics = this.app.stage.addChildAt(new PIXI.Graphics(), 0);
 
-        this.graphics = this.app.stage.addChildAt(new PIXI.Graphics(), 0);
+    attributes.eventBus.on<LevelLoadedEvent>('level:loaded', (event) => {
+      this.map = event.detail.level.collisionMap;
+      this.draw();
+    });
+  }
 
-        attributes.eventBus.on<LevelLoadedEvent>('level:loaded', (event) => {
-            this.map  = event.detail.level.collisionMap;
-            this.draw();
-        });
-    }
+  public execute(delta: number, time: number): void {}
 
-    public execute(delta: number, time: number): void {}
+  private draw(): void {
+    this.graphics.clear();
 
-    private draw(): void {
-        this.graphics.clear();
+    if (this.map == null) {
+      return;
+    }
 
-        if (this.map == null) {
-            return;
-        }
+    this.graphics.beginFill(0x000000);
 
-        this.graphics.beginFill(0x000000);
-
-        this.map.forEach((row, y) => {
-            row.forEach((cell, x) => {
-                if (cell == 1) {
-                    const vector = cellPositionToVector(x, y);
-                    this.graphics.drawRect(vector.x - 8, vector.y - 8, 16, 16);
-                }
-            });
-        });
-        this.graphics.endFill();
-    }
-}
\ No newline at end of file
+    this.map.forEach((row, y) => {
+      row.forEach((cell, x) => {
+        if (cell == 1) {
+          const vector = cellPositionToVector(x, y);
+          this.graphics.drawRect(vector.x - 8, vector.y - 8, 16, 16);
+        }
+      });
+    });
+    this.graphics.endFill();
+  }
+}
diff --git a/src/game/systems/render/graphics/GraphicsComponent.ts b/src/game/systems/render/graphics/GraphicsComponent.ts
index daacfb6..474641e 100644
--- a/src/game/systems/render/graphics/GraphicsComponent.ts
+++ b/src/game/systems/render/graphics/GraphicsComponent.ts
@@ -2,15 +2,15 @@ import { Component, Types } from 'ecsy';
 import * as PIXI from 'pixi.js';
 
 export interface GraphicsComponentProps {
-    sprite: PIXI.Graphics;
+  sprite: PIXI.Graphics;
 }
 
 export class GraphicsComponent extends Component<GraphicsComponentProps> {
-    static schema = {
-        graphics: { type: Types.Ref },
-        addedToStage: { type: Types.Boolean },
-    };   
+  static schema = {
+    graphics: { type: Types.Ref },
+    addedToStage: { type: Types.Boolean },
+  };
 
-    declare graphics: PIXI.Graphics;
-    addedToStage: boolean = false;
+  declare graphics: PIXI.Graphics;
+  addedToStage: boolean = false;
 }
diff --git a/src/game/systems/render/graphics/GraphicsSystem.ts b/src/game/systems/render/graphics/GraphicsSystem.ts
index 6b13963..84b8189 100644
--- a/src/game/systems/render/graphics/GraphicsSystem.ts
+++ b/src/game/systems/render/graphics/GraphicsSystem.ts
@@ -2,7 +2,7 @@ import { AnimatedSpriteComponent } from './../sprite/AnimatedSpriteComponent';
 import { TransformComponent } from './../../TransformComponent';
 import { SelectableComponent } from './../../selection/SelectableComponent';
 import { AttackComponent } from './../../AttackComponent';
-import { Attributes, Entity, World } from "ecsy";
+import { Attributes, Entity, World } from 'ecsy';
 import * as PIXI from 'pixi.js';
 
 import { EntityHelper } from '../../../EntityHelper';
@@ -14,98 +14,119 @@ import { SizeComponent } from '../../SizeComponent';
 import { PixiJsSystem } from '../../PixiJsSystem';
 
 export class GraphicsSystem extends PixiJsSystem {
-	public static queries = {
-		graphics: { components: [GraphicsComponent] },
-	};
-
-	private readonly showAllHealth: boolean;
-	private readonly showDebugAggro: boolean;
-
-	constructor(world: World, attributes: Attributes) {
-		super(world, attributes);
-
-		this.showAllHealth = attributes.options.showallhealth !== undefined ? attributes.options.showallhealth[0] == 'true' : false;
-		this.showDebugAggro = attributes.options.debug?.includes('aggro');
-	}
-
-	private drawHealthBar(entity: Entity, graphics: PIXI.Graphics, sprite: PIXI.Sprite): void {
-		graphics.beginFill(0x000000);
-		graphics.drawRect(-8, 12, 16, 5);
-		graphics.endFill();
-
-		const health = entity.getComponent(HealthComponent);
-		if(health){
-			const percentage = health.points / health.maxPoints;
-			graphics.beginFill(getHealthColor(percentage));
-			graphics.drawRect(-7, 13, 14 * percentage, 3);
-			graphics.endFill();
-		}
-	}
-
-	private drawSelectionIndicators(entity: Entity, graphics: PIXI.Graphics, sprite: PIXI.Sprite): void {
-		const sizeComponent = entity.getComponent(SizeComponent)!;
-
-		const offset = 4;
-		const left = -sizeComponent.width / 2 - offset;
-		const top = -sizeComponent.height / 2 - offset;
-		const right = sizeComponent.width / 2 + offset;
-
-		// top left
-		graphics.lineStyle(1, 0x000000)
-			.moveTo(left, -6)
-       		.lineTo(left, top)
-			.lineTo(left / 2, top);
-
-		// top right
-		graphics.lineStyle(1, 0x000000)
-			.moveTo(right / 2, top)
-			.lineTo(right, top)
-			.lineTo(right, -6);
-	}
-
-	private drawAggroRadius(entity: Entity, graphics: PIXI.Graphics, sprite: PIXI.Sprite): void {
-		const attackComponent = entity.getComponent(AttackComponent);
-		if (attackComponent == null) {
-			return;
-		}
-
-		graphics.lineStyle(1, 0xFF0000);
-
-		graphics.drawCircle(0, 0, attackComponent.aggroRange);
-	}
-
-	public execute(delta: number, time: number): void {
-		if ((this.queries.graphics.results?.length ?? 0) > 0) {
-			for (const entity of this.queries.graphics.results) {
-				const component = entity.getMutableComponent(GraphicsComponent) as GraphicsComponent;
-
-				if (!component.addedToStage) {
-					this.app.stage.addChild(component.graphics);
-
-					component.addedToStage = true;
-				}
-
-				if (entity.hasComponent(SelectableComponent)) {
-					const position = entity.getComponent(TransformComponent)!.position;
-					const sprite = entity.getComponent(SpriteComponent)?.sprite ?? entity.getComponent(AnimatedSpriteComponent)!.sprite;
-
-					component.graphics.clear();
-					component.graphics.position.set(position.x, position.y);
-
-					if (EntityHelper.isSelected(entity)) {
-						this.drawSelectionIndicators(entity, component.graphics, sprite);
-					}
-					if (this.showAllHealth || EntityHelper.isSelected(entity)) {
-						this.drawHealthBar(entity, component.graphics, sprite);
-					}
-
-					if (this.showDebugAggro) {
-						this.drawAggroRadius(entity, component.graphics, sprite);
-					}
-				} else {
-					component.graphics.clear();
-				}
-			}
-		}
-	}
+  public static queries = {
+    graphics: { components: [GraphicsComponent] },
+  };
+
+  private readonly showAllHealth: boolean;
+  private readonly showDebugAggro: boolean;
+
+  constructor(world: World, attributes: Attributes) {
+    super(world, attributes);
+
+    this.showAllHealth =
+      attributes.options.showallhealth !== undefined
+        ? attributes.options.showallhealth[0] == 'true'
+        : false;
+    this.showDebugAggro = attributes.options.debug?.includes('aggro');
+  }
+
+  private drawHealthBar(
+    entity: Entity,
+    graphics: PIXI.Graphics,
+    sprite: PIXI.Sprite
+  ): void {
+    graphics.beginFill(0x000000);
+    graphics.drawRect(-8, 12, 16, 5);
+    graphics.endFill();
+
+    const health = entity.getComponent(HealthComponent);
+    if (health) {
+      const percentage = health.points / health.maxPoints;
+      graphics.beginFill(getHealthColor(percentage));
+      graphics.drawRect(-7, 13, 14 * percentage, 3);
+      graphics.endFill();
+    }
+  }
+
+  private drawSelectionIndicators(
+    entity: Entity,
+    graphics: PIXI.Graphics,
+    sprite: PIXI.Sprite
+  ): void {
+    const sizeComponent = entity.getComponent(SizeComponent)!;
+
+    const offset = 4;
+    const left = -sizeComponent.width / 2 - offset;
+    const top = -sizeComponent.height / 2 - offset;
+    const right = sizeComponent.width / 2 + offset;
+
+    // top left
+    graphics
+      .lineStyle(1, 0x000000)
+      .moveTo(left, -6)
+      .lineTo(left, top)
+      .lineTo(left / 2, top);
+
+    // top right
+    graphics
+      .lineStyle(1, 0x000000)
+      .moveTo(right / 2, top)
+      .lineTo(right, top)
+      .lineTo(right, -6);
+  }
+
+  private drawAggroRadius(
+    entity: Entity,
+    graphics: PIXI.Graphics,
+    sprite: PIXI.Sprite
+  ): void {
+    const attackComponent = entity.getComponent(AttackComponent);
+    if (attackComponent == null) {
+      return;
+    }
+
+    graphics.lineStyle(1, 0xff0000);
+
+    graphics.drawCircle(0, 0, attackComponent.aggroRange);
+  }
+
+  public execute(delta: number, time: number): void {
+    if ((this.queries.graphics.results?.length ?? 0) > 0) {
+      for (const entity of this.queries.graphics.results) {
+        const component = entity.getMutableComponent(
+          GraphicsComponent
+        ) as GraphicsComponent;
+
+        if (!component.addedToStage) {
+          this.app.stage.addChild(component.graphics);
+
+          component.addedToStage = true;
+        }
+
+        if (entity.hasComponent(SelectableComponent)) {
+          const position = entity.getComponent(TransformComponent)!.position;
+          const sprite =
+            entity.getComponent(SpriteComponent)?.sprite ??
+            entity.getComponent(AnimatedSpriteComponent)!.sprite;
+
+          component.graphics.clear();
+          component.graphics.position.set(position.x, position.y);
+
+          if (EntityHelper.isSelected(entity)) {
+            this.drawSelectionIndicators(entity, component.graphics, sprite);
+          }
+          if (this.showAllHealth || EntityHelper.isSelected(entity)) {
+            this.drawHealthBar(entity, component.graphics, sprite);
+          }
+
+          if (this.showDebugAggro) {
+            this.drawAggroRadius(entity, component.graphics, sprite);
+          }
+        } else {
+          component.graphics.clear();
+        }
+      }
+    }
+  }
 }
diff --git a/src/game/systems/render/sprite/AnimatedSpriteComponent.ts b/src/game/systems/render/sprite/AnimatedSpriteComponent.ts
index 2b629ae..e679a94 100644
--- a/src/game/systems/render/sprite/AnimatedSpriteComponent.ts
+++ b/src/game/systems/render/sprite/AnimatedSpriteComponent.ts
@@ -4,17 +4,16 @@ import { Direction, State } from '../../../animation/utils';
 
 type AnimationState = `${State}_${Direction}`;
 export interface AnimatedSpriteComponentProps {
-    sprite: PIXI.AnimatedSprite;
-    state: AnimationState;
+  sprite: PIXI.AnimatedSprite;
+  state: AnimationState;
 }
 
 export class AnimatedSpriteComponent extends Component<AnimatedSpriteComponentProps> {
-    static schema = {
-        sprite: { type: Types.Ref },
-        state: { type: Types.String },
-    };   
+  static schema = {
+    sprite: { type: Types.Ref },
+    state: { type: Types.String },
+  };
 
-    declare sprite: PIXI.AnimatedSprite;
-    state!: AnimationState;
-
-}
\ No newline at end of file
+  declare sprite: PIXI.AnimatedSprite;
+  state!: AnimationState;
+}
diff --git a/src/game/systems/render/sprite/SpriteComponent.ts b/src/game/systems/render/sprite/SpriteComponent.ts
index 6cfd502..d25e919 100644
--- a/src/game/systems/render/sprite/SpriteComponent.ts
+++ b/src/game/systems/render/sprite/SpriteComponent.ts
@@ -2,13 +2,13 @@ import { Component, Types } from 'ecsy';
 import * as PIXI from 'pixi.js';
 
 export interface SpriteComponentProps {
-    sprite: PIXI.Sprite;
+  sprite: PIXI.Sprite;
 }
 
 export class SpriteComponent extends Component<SpriteComponentProps> {
-    static schema = {
-        sprite: { type: Types.Ref },
-    };   
+  static schema = {
+    sprite: { type: Types.Ref },
+  };
 
-    declare sprite: PIXI.Sprite;
-}
\ No newline at end of file
+  declare sprite: PIXI.Sprite;
+}
diff --git a/src/game/systems/render/sprite/SpriteSystem.ts b/src/game/systems/render/sprite/SpriteSystem.ts
index 5ad6bf6..be44789 100644
--- a/src/game/systems/render/sprite/SpriteSystem.ts
+++ b/src/game/systems/render/sprite/SpriteSystem.ts
@@ -1,61 +1,70 @@
 import { AnimatedSpriteComponent } from './AnimatedSpriteComponent';
 import { TransformComponent } from './../../TransformComponent';
-import { PixiJsSystem } from "../../PixiJsSystem";
+import { PixiJsSystem } from '../../PixiJsSystem';
 import { SpriteComponent } from './SpriteComponent';
 
 export class SpriteSystem extends PixiJsSystem {
-	public static queries = {
-		sprites: {
-			components: [SpriteComponent],
-			listen: {
-				added: true
-			}
-		},
-		animatedSprites: {
-			components: [AnimatedSpriteComponent],
-			listen: {
-				added: true
-			}
-		},
-	};
-
-	// This method will get called on every frame by default
-	public execute(delta: number, time: number): void {
-		if ((this.queries.sprites.added?.length ?? 0) > 0) {
-			for (const entity of this.queries.sprites.added!) {
-				const component = entity.getMutableComponent(SpriteComponent)!;
-				
-				this.app.stage.addChild(component.sprite);
-			}
-		}
-
-		this.queries.sprites.results.forEach((entity) => {
-			const component = entity.getMutableComponent(SpriteComponent)!;
-			const transformComponent = entity.getComponent(TransformComponent);
-			if (transformComponent != null) {
-				component.sprite.position.set(transformComponent.position.x, transformComponent.position.y);
-			}
-		});
-
-		if ((this.queries.animatedSprites.added?.length ?? 0) > 0) {
-			for (const entity of this.queries.animatedSprites.added!) {
-				const component = entity.getMutableComponent(AnimatedSpriteComponent)!;
-				
-				this.app.stage.addChild(component.sprite);
-
-				const transformComponent = entity.getComponent(TransformComponent);
-				if (transformComponent != null) {
-					component.sprite.position.set(transformComponent.position.x, transformComponent.position.y);
-				}
-			}
-		}
-
-		this.queries.animatedSprites.results.forEach((entity) => {
-			const component = entity.getMutableComponent(AnimatedSpriteComponent)!;
-			const transformComponent = entity.getComponent(TransformComponent);
-			if (transformComponent != null) {
-				component.sprite.position.set(transformComponent.position.x, transformComponent.position.y);
-			}
-		});
-	}
+  public static queries = {
+    sprites: {
+      components: [SpriteComponent],
+      listen: {
+        added: true,
+      },
+    },
+    animatedSprites: {
+      components: [AnimatedSpriteComponent],
+      listen: {
+        added: true,
+      },
+    },
+  };
+
+  // This method will get called on every frame by default
+  public execute(delta: number, time: number): void {
+    if ((this.queries.sprites.added?.length ?? 0) > 0) {
+      for (const entity of this.queries.sprites.added!) {
+        const component = entity.getMutableComponent(SpriteComponent)!;
+
+        this.app.stage.addChild(component.sprite);
+      }
+    }
+
+    this.queries.sprites.results.forEach((entity) => {
+      const component = entity.getMutableComponent(SpriteComponent)!;
+      const transformComponent = entity.getComponent(TransformComponent);
+      if (transformComponent != null) {
+        component.sprite.position.set(
+          transformComponent.position.x,
+          transformComponent.position.y
+        );
+      }
+    });
+
+    if ((this.queries.animatedSprites.added?.length ?? 0) > 0) {
+      for (const entity of this.queries.animatedSprites.added!) {
+        const component = entity.getMutableComponent(AnimatedSpriteComponent)!;
+
+        this.app.stage.addChild(component.sprite);
+
+        const transformComponent = entity.getComponent(TransformComponent);
+        if (transformComponent != null) {
+          component.sprite.position.set(
+            transformComponent.position.x,
+            transformComponent.position.y
+          );
+        }
+      }
+    }
+
+    this.queries.animatedSprites.results.forEach((entity) => {
+      const component = entity.getMutableComponent(AnimatedSpriteComponent)!;
+      const transformComponent = entity.getComponent(TransformComponent);
+      if (transformComponent != null) {
+        component.sprite.position.set(
+          transformComponent.position.x,
+          transformComponent.position.y
+        );
+      }
+    });
+  }
 }
diff --git a/src/game/systems/render/sprite/utils.ts b/src/game/systems/render/sprite/utils.ts
index 0a37d6b..19c37d4 100644
--- a/src/game/systems/render/sprite/utils.ts
+++ b/src/game/systems/render/sprite/utils.ts
@@ -1,26 +1,32 @@
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
 import { TransformComponent } from './../../TransformComponent';
 import { AssetComponent } from './../AssetComponent';
 import { AnimatedSpriteComponent } from './AnimatedSpriteComponent';
-import { rotationToDirection, State } from "../../../animation/utils";
+import { rotationToDirection, State } from '../../../animation/utils';
 
 export const setEntityAnimation = (entity: Entity, state: State): void => {
-    const spriteComponent = entity.getMutableComponent(AnimatedSpriteComponent);
-    if (spriteComponent != null) {
-        const assetComponent = entity.getComponent(AssetComponent);
-        if (assetComponent == null) {
-            return;
-        }
-        const transformComponent = entity.getComponent(TransformComponent);
-        const direction = rotationToDirection(transformComponent?.rotation ?? 0)!;
+  const spriteComponent = entity.getMutableComponent(AnimatedSpriteComponent);
+  if (spriteComponent != null) {
+    const assetComponent = entity.getComponent(AssetComponent);
+    if (assetComponent == null) {
+      return;
+    }
+    const transformComponent = entity.getComponent(TransformComponent);
+    const direction = rotationToDirection(transformComponent?.rotation ?? 0)!;
 
-        if (spriteComponent.state !== `${state}_${direction}`) {
-            const oldState = spriteComponent.state;
-            assetComponent.animations[state][direction].set(spriteComponent.sprite);
-            spriteComponent.state = `${state}_${direction}`;
-            console.log(entity.id + ': update state from ' + oldState + ' to ' + spriteComponent.state);
-            spriteComponent.sprite.play();
-        }
+    if (spriteComponent.state !== `${state}_${direction}`) {
+      const oldState = spriteComponent.state;
+      assetComponent.animations[state][direction].set(spriteComponent.sprite);
+      spriteComponent.state = `${state}_${direction}`;
+      console.log(
+        entity.id +
+          ': update state from ' +
+          oldState +
+          ' to ' +
+          spriteComponent.state
+      );
+      spriteComponent.sprite.play();
     }
-}
\ No newline at end of file
+  }
+};
diff --git a/src/game/systems/selection/PlayerSelectionSystem.ts b/src/game/systems/selection/PlayerSelectionSystem.ts
index 087c255..4be6ddc 100644
--- a/src/game/systems/selection/PlayerSelectionSystem.ts
+++ b/src/game/systems/selection/PlayerSelectionSystem.ts
@@ -12,133 +12,148 @@ import { isOnTeam } from './../utils/index';
  * System for selecting units with {@link Input}'s' mouse.
  */
 export class PlayerSelectionSystem extends System {
-	public static queries: SystemQueries = {
-		selectable: {
-			components: [SelectableComponent],
-		},
-	};
-	private static readonly SINGLE_UNIT_DISTANCE = 5;
-
-	/**
-	 * Start selection.
-	 */
-	private startPosition: Vector2 | null = null;
-
-	/**
-	 * Used for deselecting units when clicking,
-	 * but can be cancelled when dblclick-ing for moving entities.
-	 */
-	private deselectEntitiesTimeout: NodeJS.Timeout | null = null;
-
-	private readonly app: PIXI.Application;
-	private rectangle: PIXI.Graphics;
-
-	constructor(world: World, attributes: Attributes) {
-        super(world, attributes);
-        this.app = attributes.app;
-			
-		this.rectangle = new PIXI.Graphics();
-		this.rectangle.visible = false;
-		this.app.stage.addChild(this.rectangle);
-	}
-
-	private getSelected(): Entity[] {
-		return this.queries.selectable.results.filter(
-			(entity) => entity.getComponent(SelectableComponent)?.selected || false
-		);
-	}
-
-	private startSelect(): void {
-		this.rectangle.visible = true;
-	}
-
-	private updateSelect(): void {
-		const width = Input.mousePosition.x - this.startPosition!.x;
-		const height = Input.mousePosition.y - this.startPosition!.y;
-
-		this.getSelected().forEach(EntityHelper.deselect);
-
-		this.rectangle.clear();
-		this.rectangle.lineStyle(1, 0x000000);
-		this.rectangle.drawRect(this.startPosition!.x, this.startPosition!.y, width, height);
-	}
-
-	private endSelect(): void {
-		this.selectEntities();
-
-		this.startPosition = null;
-
-		this.rectangle.visible = false;
-		this.rectangle.clear();
-	}
-
-	private selectEntities(): void {
-		if (this.isSimpleClick()) {
-			this.selectOneEntity();
-		} else {
-			this.selectMultipleEntities();
-		}
-	}
-
-	private isSimpleClick(): boolean {
-		return Vector2.distance(this.startPosition!, Input.mousePosition) < PlayerSelectionSystem.SINGLE_UNIT_DISTANCE;
-	}
-
-	private selectOneEntity(): void {
-		// single unit select
-		const entity = this.getEntityAtPosition(Input.mousePosition.x, Input.mousePosition.y);
-		if (entity && isOnTeam(1)(entity)) {
-			EntityHelper.select(entity);
-		} else {
-			if (!Input.isMouseDblClick()) {
-				// deselect entities in .3 sec, or do double-click action
-				this.deselectEntitiesTimeout = setTimeout(() => {
-					this.getSelected().forEach(EntityHelper.deselect);
-				}, 300);
-			}
-			return;
-		}
-	}
-
-	private selectMultipleEntities(): void {
-		const width = Input.mousePosition.x - this.startPosition!.x;
-		const height = Input.mousePosition.y - this.startPosition!.y;
-
-		// get entities inside selector
-		this.queries.selectable.results.filter((entity) =>
-			EntityHelper.isObjectInsideContainer(entity, {
-				x: this.startPosition!.x,
-				y: this.startPosition!.y,
-				width,
-				height,
-			})
-		)
-		.filter(isOnTeam(1))
-		.forEach((entity) => EntityHelper.select(entity));
-	}
-
-	private getEntityAtPosition(x: number, y: number): Entity | null {
-		return getEntityAtPosition(this.queries.selectable.results, x, y);
-	}
-
-	public execute(delta: number, time: number): void {
-		if (Input.isMouseDblClick() && this.deselectEntitiesTimeout !== null) {
-			clearTimeout(this.deselectEntitiesTimeout);
-		}
-
-		if (this.startPosition === null) {
-			if (Input.isMouseButtonDown(0)) {
-				this.startPosition = Input.mousePosition;
-				this.startSelect();
-			}
-		} else {
-			// selector is active
-			if (Input.isMouseButtonUp(0)) {
-				this.endSelect();
-			} else if (Vector2.distance(this.startPosition, Input.mousePosition) > PlayerSelectionSystem.SINGLE_UNIT_DISTANCE) {
-				// mouse is dragging
-				this.updateSelect();
-			}
-		}
-	}
+  public static queries: SystemQueries = {
+    selectable: {
+      components: [SelectableComponent],
+    },
+  };
+  private static readonly SINGLE_UNIT_DISTANCE = 5;
+
+  /**
+   * Start selection.
+   */
+  private startPosition: Vector2 | null = null;
+
+  /**
+   * Used for deselecting units when clicking,
+   * but can be cancelled when dblclick-ing for moving entities.
+   */
+  private deselectEntitiesTimeout: NodeJS.Timeout | null = null;
+
+  private readonly app: PIXI.Application;
+  private rectangle: PIXI.Graphics;
+
+  constructor(world: World, attributes: Attributes) {
+    super(world, attributes);
+    this.app = attributes.app;
+
+    this.rectangle = new PIXI.Graphics();
+    this.rectangle.visible = false;
+    this.app.stage.addChild(this.rectangle);
+  }
+
+  private getSelected(): Entity[] {
+    return this.queries.selectable.results.filter(
+      (entity) => entity.getComponent(SelectableComponent)?.selected || false
+    );
+  }
+
+  private startSelect(): void {
+    this.rectangle.visible = true;
+  }
+
+  private updateSelect(): void {
+    const width = Input.mousePosition.x - this.startPosition!.x;
+    const height = Input.mousePosition.y - this.startPosition!.y;
+
+    this.getSelected().forEach(EntityHelper.deselect);
+
+    this.rectangle.clear();
+    this.rectangle.lineStyle(1, 0x000000);
+    this.rectangle.drawRect(
+      this.startPosition!.x,
+      this.startPosition!.y,
+      width,
+      height
+    );
+  }
+
+  private endSelect(): void {
+    this.selectEntities();
+
+    this.startPosition = null;
+
+    this.rectangle.visible = false;
+    this.rectangle.clear();
+  }
+
+  private selectEntities(): void {
+    if (this.isSimpleClick()) {
+      this.selectOneEntity();
+    } else {
+      this.selectMultipleEntities();
+    }
+  }
+
+  private isSimpleClick(): boolean {
+    return (
+      Vector2.distance(this.startPosition!, Input.mousePosition) <
+      PlayerSelectionSystem.SINGLE_UNIT_DISTANCE
+    );
+  }
+
+  private selectOneEntity(): void {
+    // single unit select
+    const entity = this.getEntityAtPosition(
+      Input.mousePosition.x,
+      Input.mousePosition.y
+    );
+    if (entity && isOnTeam(1)(entity)) {
+      EntityHelper.select(entity);
+    } else {
+      if (!Input.isMouseDblClick()) {
+        // deselect entities in .3 sec, or do double-click action
+        this.deselectEntitiesTimeout = setTimeout(() => {
+          this.getSelected().forEach(EntityHelper.deselect);
+        }, 300);
+      }
+      return;
+    }
+  }
+
+  private selectMultipleEntities(): void {
+    const width = Input.mousePosition.x - this.startPosition!.x;
+    const height = Input.mousePosition.y - this.startPosition!.y;
+
+    // get entities inside selector
+    this.queries.selectable.results
+      .filter((entity) =>
+        EntityHelper.isObjectInsideContainer(entity, {
+          x: this.startPosition!.x,
+          y: this.startPosition!.y,
+          width,
+          height,
+        })
+      )
+      .filter(isOnTeam(1))
+      .forEach((entity) => EntityHelper.select(entity));
+  }
+
+  private getEntityAtPosition(x: number, y: number): Entity | null {
+    return getEntityAtPosition(this.queries.selectable.results, x, y);
+  }
+
+  public execute(delta: number, time: number): void {
+    if (Input.isMouseDblClick() && this.deselectEntitiesTimeout !== null) {
+      clearTimeout(this.deselectEntitiesTimeout);
+    }
+
+    if (this.startPosition === null) {
+      if (Input.isMouseButtonDown(0)) {
+        this.startPosition = Input.mousePosition;
+        this.startSelect();
+      }
+    } else {
+      // selector is active
+      if (Input.isMouseButtonUp(0)) {
+        this.endSelect();
+      } else if (
+        Vector2.distance(this.startPosition, Input.mousePosition) >
+        PlayerSelectionSystem.SINGLE_UNIT_DISTANCE
+      ) {
+        // mouse is dragging
+        this.updateSelect();
+      }
+    }
+  }
 }
diff --git a/src/game/systems/selection/SelectableComponent.ts b/src/game/systems/selection/SelectableComponent.ts
index 043576d..210afa3 100644
--- a/src/game/systems/selection/SelectableComponent.ts
+++ b/src/game/systems/selection/SelectableComponent.ts
@@ -1,13 +1,13 @@
 import { Component, Types } from 'ecsy';
 
 export interface ISelectableComponentProps {
-	selected?: boolean;
+  selected?: boolean;
 }
 
 export class SelectableComponent extends Component<ISelectableComponentProps> {
-	static schema = {
-		selected: { type: Types.Boolean, default: false },
-	};	
+  static schema = {
+    selected: { type: Types.Boolean, default: false },
+  };
 
-	declare selected: boolean;
-}
\ No newline at end of file
+  declare selected: boolean;
+}
diff --git a/src/game/systems/utils/index.spec.ts b/src/game/systems/utils/index.spec.ts
index 2baff95..bb1a9d5 100644
--- a/src/game/systems/utils/index.spec.ts
+++ b/src/game/systems/utils/index.spec.ts
@@ -4,79 +4,75 @@ import { World } from 'ecsy';
 import { isOnTeam, isSameEntity, isAlive } from './index';
 
 const world = new World()
-        .registerComponent(TeamComponent)
-        .registerComponent(AliveComponent);
+  .registerComponent(TeamComponent)
+  .registerComponent(AliveComponent);
 
 describe('isOnTeam', () => {
-    it('should return false if entity has no TeamComponent', () => {
-        const entity = world.createEntity();
-        const predicate = isOnTeam(1);
+  it('should return false if entity has no TeamComponent', () => {
+    const entity = world.createEntity();
+    const predicate = isOnTeam(1);
 
-        expect(predicate(entity)).toBe(false);
-    });
-
-    it('should return true if entity team is the same', () => {
-        const entity = world.createEntity()
-            .addComponent(TeamComponent, {
-                number: 1,
-            });
-        const predicate = isOnTeam(1);
+    expect(predicate(entity)).toBe(false);
+  });
 
-        expect(predicate(entity)).toBe(true);
+  it('should return true if entity team is the same', () => {
+    const entity = world.createEntity().addComponent(TeamComponent, {
+      number: 1,
     });
+    const predicate = isOnTeam(1);
 
-    it('should return false if entity team is different', () => {
-        const entity = world.createEntity()
-            .addComponent(TeamComponent, {
-                number: 2,
-            });
-        const predicate = isOnTeam(1);
+    expect(predicate(entity)).toBe(true);
+  });
 
-        expect(predicate(entity)).toBe(false);
+  it('should return false if entity team is different', () => {
+    const entity = world.createEntity().addComponent(TeamComponent, {
+      number: 2,
     });
+    const predicate = isOnTeam(1);
+
+    expect(predicate(entity)).toBe(false);
+  });
 });
 
 describe('isSameEntity', () => {
-    it('should return false entities are different', () => {
-        const a = world.createEntity();
-        const b = world.createEntity();
+  it('should return false entities are different', () => {
+    const a = world.createEntity();
+    const b = world.createEntity();
 
-        const predictate = isSameEntity(a);
+    const predictate = isSameEntity(a);
 
-        expect(predictate(b)).toBe(false);
-    });
+    expect(predictate(b)).toBe(false);
+  });
 
-    it('should return true if given entities are the same', () => {
-        const a = world.createEntity();
+  it('should return true if given entities are the same', () => {
+    const a = world.createEntity();
 
-        const predictate = isSameEntity(a);
+    const predictate = isSameEntity(a);
 
-        expect(predictate(a)).toBe(true);
-    });
+    expect(predictate(a)).toBe(true);
+  });
 });
 
-describe('isAlive', () => {   
-    it('should return true when component is not set', () => {
-        const entity = world.createEntity();
+describe('isAlive', () => {
+  it('should return true when component is not set', () => {
+    const entity = world.createEntity();
 
-        expect(isAlive()(entity)).toBe(true);
-    });
-
-    it('should return true when component is set and true', () => {
-        const entity = world.createEntity()
-            .addComponent(AliveComponent, {
-                alive: true
-            });
+    expect(isAlive()(entity)).toBe(true);
+  });
 
-        expect(isAlive()(entity)).toBe(true);
+  it('should return true when component is set and true', () => {
+    const entity = world.createEntity().addComponent(AliveComponent, {
+      alive: true,
     });
 
-    it('should return false when component is set and false', () => {
-        const entity = world.createEntity()
-            .addComponent(AliveComponent, {
-                alive: false
-            });
+    expect(isAlive()(entity)).toBe(true);
+  });
 
-        expect(isAlive()(entity)).toBe(false);
+  it('should return false when component is set and false', () => {
+    const entity = world.createEntity().addComponent(AliveComponent, {
+      alive: false,
     });
-});
\ No newline at end of file
+
+    expect(isAlive()(entity)).toBe(false);
+  });
+});
diff --git a/src/game/systems/utils/index.ts b/src/game/systems/utils/index.ts
index cf31aeb..57568bc 100644
--- a/src/game/systems/utils/index.ts
+++ b/src/game/systems/utils/index.ts
@@ -1,29 +1,38 @@
-import { Entity } from "ecsy";
+import { Entity } from 'ecsy';
 
 import { AliveComponent } from './../alive/AliveComponent';
-import { EntityHelper } from "../../EntityHelper";
-import { Predicate } from "../../utils";
-import { TeamComponent } from "../TeamComponent";
+import { EntityHelper } from '../../EntityHelper';
+import { Predicate } from '../../utils';
+import { TeamComponent } from '../TeamComponent';
 export * from './transform';
 
 export const isOnTeam = (team: number): Predicate<Entity> => {
-    return (entity: Entity) => {
-        if (!entity.hasComponent(TeamComponent)){
-            return false;
-        }
+  return (entity: Entity) => {
+    if (!entity.hasComponent(TeamComponent)) {
+      return false;
+    }
 
-        const teamComponent = entity.getComponent(TeamComponent)!;
+    const teamComponent = entity.getComponent(TeamComponent)!;
 
-        return teamComponent.number === team;
-    };
+    return teamComponent.number === team;
+  };
 };
 
 export const isSameEntity = (entity: Entity): Predicate<Entity> => {
-	return (other: Entity) => other.id === entity.id;
+  return (other: Entity) => other.id === entity.id;
 };
 
-export const getEntityAtPosition = (entities: Entity[], x: number, y: number): Entity | null => {
-    return entities.find((entity) => EntityHelper.isPositionInsideEntity(entity, x, y)) ?? null;
-}
+export const getEntityAtPosition = (
+  entities: Entity[],
+  x: number,
+  y: number
+): Entity | null => {
+  return (
+    entities.find((entity) =>
+      EntityHelper.isPositionInsideEntity(entity, x, y)
+    ) ?? null
+  );
+};
 
-export const isAlive = (): Predicate<Entity> => (entity: Entity) => entity.getComponent(AliveComponent)?.alive ?? true;
\ No newline at end of file
+export const isAlive = (): Predicate<Entity> => (entity: Entity) =>
+  entity.getComponent(AliveComponent)?.alive ?? true;
diff --git a/src/game/systems/utils/transform.spec.ts b/src/game/systems/utils/transform.spec.ts
index 72a2967..99f4066 100644
--- a/src/game/systems/utils/transform.spec.ts
+++ b/src/game/systems/utils/transform.spec.ts
@@ -3,118 +3,112 @@ import { World } from 'ecsy';
 import { byClosestDistance, isInRange } from './transform';
 import { Vector2 } from '../../math/Vector2';
 import { TransformComponent } from './../TransformComponent';
-import { constructCreateRandomEntities, CreateRandomEntities } from '../../__tests__/utils';
+import {
+  constructCreateRandomEntities,
+  CreateRandomEntities,
+} from '../../__tests__/utils';
 import { TeamComponent } from '../TeamComponent';
 
 let world: World;
 let createRandomEntities: CreateRandomEntities;
 
 beforeEach(() => {
-    world = new World()
-        .registerComponent(TransformComponent)
-        .registerComponent(TeamComponent);
-    createRandomEntities = constructCreateRandomEntities(world);    
+  world = new World()
+    .registerComponent(TransformComponent)
+    .registerComponent(TeamComponent);
+  createRandomEntities = constructCreateRandomEntities(world);
 });
 
 describe('isInRange', () => {
-    it('should filter everything when targetEntity has no TransformComponent', () => {
-        const targetEntity = world.createEntity();
+  it('should filter everything when targetEntity has no TransformComponent', () => {
+    const targetEntity = world.createEntity();
 
-        const filter = isInRange(targetEntity, 100);
+    const filter = isInRange(targetEntity, 100);
 
-        const filtered = [
-            ...createRandomEntities(),
-        ].filter(filter);
+    const filtered = [...createRandomEntities()].filter(filter);
 
-        expect(filtered).toHaveLength(0);
+    expect(filtered).toHaveLength(0);
+  });
+
+  it('should filter out entities that have no TransformComponent', () => {
+    const targetEntity = world.createEntity().addComponent(TransformComponent, {
+      position: Vector2.ZERO,
     });
+    const entitiesWithoutTransform = createRandomEntities();
+    entitiesWithoutTransform.forEach((entity) =>
+      entity.removeComponent(TransformComponent)
+    );
 
-    it('should filter out entities that have no TransformComponent', () => {
-        const targetEntity = world.createEntity()
-            .addComponent(TransformComponent, {
-                position: Vector2.ZERO,
-            });
-        const entitiesWithoutTransform = createRandomEntities();
-        entitiesWithoutTransform.forEach((entity) => entity.removeComponent(TransformComponent));
+    const filter = isInRange(targetEntity, 100);
 
-        const filter = isInRange(targetEntity, 100);
+    const filtered = [...entitiesWithoutTransform].filter(filter);
 
-        const filtered = [
-            ...entitiesWithoutTransform,
-        ].filter(filter);
+    expect(filtered).toHaveLength(0);
+  });
 
-        expect(filtered).toHaveLength(0);
+  it('should filter out entities that are out of given range', () => {
+    const targetEntity = world.createEntity().addComponent(TransformComponent, {
+      position: Vector2.ZERO,
     });
+    const inRangeEntities = createRandomEntities(
+      10,
+      { x: 3, y: 0 },
+      { x: 50, y: 0 }
+    );
+    const outOfRangeEntities = createRandomEntities(
+      10,
+      { x: 150, y: 0 },
+      { x: 200, y: 0 }
+    );
+
+    const filter = isInRange(targetEntity, 100);
+
+    const filtered = [...inRangeEntities, ...outOfRangeEntities].filter(filter);
+
+    expect(filtered).toHaveLength(10);
+  });
+});
 
-    it('should filter out entities that are out of given range', () => {
-        const targetEntity = world.createEntity()
-            .addComponent(TransformComponent, {
-                position: Vector2.ZERO,
-            });
-        const inRangeEntities = createRandomEntities(10, { x: 3, y: 0 }, { x: 50, y: 0 });
-        const outOfRangeEntities = createRandomEntities(10, { x: 150, y: 0 }, { x: 200, y: 0 });
+describe('byClosestDistance', () => {
+  it('should keep order sort when targetEntity has no TransformComponent', () => {
+    const targetEntity = world.createEntity();
 
-        const filter = isInRange(targetEntity, 100);
+    const entities = createRandomEntities();
+    const sorted = [...entities].sort(byClosestDistance(targetEntity));
 
-        const filtered = [
-            ...inRangeEntities,
-            ...outOfRangeEntities,
-        ].filter(filter);
+    expect(sorted).toEqual(entities);
+  });
 
-        expect(filtered).toHaveLength(10);
+  it('should sort entities without TransformComponent to the back', () => {
+    const targetEntity = world.createEntity().addComponent(TransformComponent, {
+      position: Vector2.ZERO,
     });
-});
 
-describe('byClosestDistance', () => {
-    it('should keep order sort when targetEntity has no TransformComponent', () => {
-        const targetEntity = world.createEntity();
-        
-        const entities = createRandomEntities();
-        const sorted = [
-            ...entities,
-        ].sort(byClosestDistance(targetEntity));
-
-        expect(sorted).toEqual(entities);
-    });
+    const entities = createRandomEntities();
+    entities[0].removeComponent(TransformComponent);
+    entities[1].removeComponent(TransformComponent);
+    entities[2].removeComponent(TransformComponent);
 
-    it('should sort entities without TransformComponent to the back', () => {
-        const targetEntity = world.createEntity()
-            .addComponent(TransformComponent, {
-                position: Vector2.ZERO,
-            });
-        
-        const entities = createRandomEntities();
-        entities[0].removeComponent(TransformComponent);
-        entities[1].removeComponent(TransformComponent);
-        entities[2].removeComponent(TransformComponent);
-
-        const sorted = [
-            ...entities,
-        ].sort(byClosestDistance(targetEntity));
-
-        const last3Ids = sorted.slice(-3).map((entity) => entity.id);
-        expect(last3Ids).toEqual([
-            entities[0].id,
-            entities[1].id,
-            entities[2].id,
-        ]);
-    });
+    const sorted = [...entities].sort(byClosestDistance(targetEntity));
 
-    it('should sort entities by distance', () => {
-        const targetEntity = world.createEntity()
-            .addComponent(TransformComponent, {
-                position: Vector2.ZERO,
-            });
-        const closestEntity = world.createEntity()
-            .addComponent(TransformComponent, {
-                position: new Vector2(1, 1),
-            });
-
-        const sorted = [
-            ...createRandomEntities(),
-            closestEntity,
-        ].sort(byClosestDistance(targetEntity));
-
-        expect(sorted[0]).toBe(closestEntity);
+    const last3Ids = sorted.slice(-3).map((entity) => entity.id);
+    expect(last3Ids).toEqual([entities[0].id, entities[1].id, entities[2].id]);
+  });
+
+  it('should sort entities by distance', () => {
+    const targetEntity = world.createEntity().addComponent(TransformComponent, {
+      position: Vector2.ZERO,
     });
-});
\ No newline at end of file
+    const closestEntity = world
+      .createEntity()
+      .addComponent(TransformComponent, {
+        position: new Vector2(1, 1),
+      });
+
+    const sorted = [...createRandomEntities(), closestEntity].sort(
+      byClosestDistance(targetEntity)
+    );
+
+    expect(sorted[0]).toBe(closestEntity);
+  });
+});
diff --git a/src/game/systems/utils/transform.ts b/src/game/systems/utils/transform.ts
index d34173a..7b5d3c5 100644
--- a/src/game/systems/utils/transform.ts
+++ b/src/game/systems/utils/transform.ts
@@ -1,45 +1,58 @@
-import { Entity } from "ecsy";
-import { Vector2 } from "../../math/Vector2";
-import { TransformComponent } from "../TransformComponent";
-import { Comparator, falsePredicate, keepOrder, Predicate } from "../../utils";
-
-export const isInRange = (targetEntity: Entity, maxRange: number): Predicate<Entity> => {
-    if (!targetEntity.hasComponent(TransformComponent)) {
-        return falsePredicate;
+import { Entity } from 'ecsy';
+import { Vector2 } from '../../math/Vector2';
+import { TransformComponent } from '../TransformComponent';
+import { Comparator, falsePredicate, keepOrder, Predicate } from '../../utils';
+
+export const isInRange = (
+  targetEntity: Entity,
+  maxRange: number
+): Predicate<Entity> => {
+  if (!targetEntity.hasComponent(TransformComponent)) {
+    return falsePredicate;
+  }
+  const targetPosition =
+    targetEntity.getComponent(TransformComponent)!.position;
+
+  return (entity) => {
+    if (!entity.hasComponent(TransformComponent)) {
+      return false;
     }
-    const targetPosition = targetEntity.getComponent(TransformComponent)!.position;
+    const transformComponent = entity.getComponent(TransformComponent)!;
 
-    return (entity) => {
-        if (!entity.hasComponent(TransformComponent)) {
-            return false;
-        }
-        const transformComponent = entity.getComponent(TransformComponent)!;
-
-        return Vector2.distance(targetPosition, transformComponent.position) <= maxRange;
-    };
+    return (
+      Vector2.distance(targetPosition, transformComponent.position) <= maxRange
+    );
+  };
 };
 
 export const byClosestDistance = (targetEntity: Entity): Comparator<Entity> => {
-    if (!targetEntity.hasComponent(TransformComponent)) {
-        return keepOrder;
+  if (!targetEntity.hasComponent(TransformComponent)) {
+    return keepOrder;
+  }
+
+  const targetTransformComponent =
+    targetEntity.getComponent(TransformComponent)!;
+
+  return (a: Entity, b: Entity) => {
+    if (
+      !a.hasComponent(TransformComponent) &&
+      !b.hasComponent(TransformComponent)
+    ) {
+      return 0;
+    }
+    if (!a.hasComponent(TransformComponent)) {
+      return 1;
+    }
+    if (!b.hasComponent(TransformComponent)) {
+      return -1;
     }
 
-    const targetTransformComponent = targetEntity.getComponent(TransformComponent)!;
-
-    return (a: Entity, b: Entity) => {
-        if (!a.hasComponent(TransformComponent) && !b.hasComponent(TransformComponent)) {
-            return 0;
-        }
-        if (!a.hasComponent(TransformComponent)) {
-            return 1;
-        }
-        if (!b.hasComponent(TransformComponent)) {
-            return -1;
-        }
-
-        const aTransformComponent = a.getComponent(TransformComponent)!;
-        const bTransformComponent = b.getComponent(TransformComponent)!;
+    const aTransformComponent = a.getComponent(TransformComponent)!;
+    const bTransformComponent = b.getComponent(TransformComponent)!;
 
-        return targetTransformComponent.distance(aTransformComponent) - targetTransformComponent.distance(bTransformComponent);
-    }
-}
+    return (
+      targetTransformComponent.distance(aTransformComponent) -
+      targetTransformComponent.distance(bTransformComponent)
+    );
+  };
+};
diff --git a/src/game/utils.spec.ts b/src/game/utils.spec.ts
index 8635966..4099d92 100644
--- a/src/game/utils.spec.ts
+++ b/src/game/utils.spec.ts
@@ -1,148 +1,158 @@
 import { Vector2 } from './math/Vector2';
-import { arrayIncludesByEquals, getOptions, toEqual, toWorldPositionCellCenter, toWorldPosition, toGridPosition, convertPathfindingPathToPositions, not } from './utils';
+import {
+  arrayIncludesByEquals,
+  getOptions,
+  toEqual,
+  toWorldPositionCellCenter,
+  toWorldPosition,
+  toGridPosition,
+  convertPathfindingPathToPositions,
+  not,
+} from './utils';
 import * as PathFinding from './ai/pathfinding';
 
 describe('getOptions', () => {
-    const mockWindowLocation = (url: string) => {
-        // @ts-ignore
-        delete window.location;
-        // @ts-ignore
-        window.location = new URL(url);
-    };
+  const mockWindowLocation = (url: string) => {
+    // @ts-ignore
+    delete window.location;
+    // @ts-ignore
+    window.location = new URL(url);
+  };
 
-    it('should give empty object when location.hash is empty', () => {
-        mockWindowLocation('http://localhost:3000/');
+  it('should give empty object when location.hash is empty', () => {
+    mockWindowLocation('http://localhost:3000/');
 
-        expect(getOptions()).toEqual({});
-    });
+    expect(getOptions()).toEqual({});
+  });
 
-    it('should give empty array when only key is set', () => {
-        mockWindowLocation('http://localhost:3000/#/game?debug=');
+  it('should give empty array when only key is set', () => {
+    mockWindowLocation('http://localhost:3000/#/game?debug=');
 
-        expect(getOptions()).toEqual({ debug: [] });
-    });
+    expect(getOptions()).toEqual({ debug: [] });
+  });
 
-    it('should give array when key value is set', () => {
-        mockWindowLocation('http://localhost:3000/#/game?debug=grid');
+  it('should give array when key value is set', () => {
+    mockWindowLocation('http://localhost:3000/#/game?debug=grid');
 
-        expect(getOptions()).toEqual({ debug: ['grid'] });
-    });
+    expect(getOptions()).toEqual({ debug: ['grid'] });
+  });
 
-    it('should give array when value with commas is set', () => {
-        mockWindowLocation('http://localhost:3000/#/game?debug=grid,fps');
+  it('should give array when value with commas is set', () => {
+    mockWindowLocation('http://localhost:3000/#/game?debug=grid,fps');
 
-        expect(getOptions()).toEqual({ debug: ['grid', 'fps'] });
-    });
+    expect(getOptions()).toEqual({ debug: ['grid', 'fps'] });
+  });
 });
 
 const returnTrue = (other: unknown) => true;
 const returnFalse = (other: unknown) => false;
 
 describe('toEqual', () => {
-    it('should return false when item is not equal', () => {
-        const object = {
-            equals: returnTrue,
-        };
+  it('should return false when item is not equal', () => {
+    const object = {
+      equals: returnTrue,
+    };
 
-        const predicate = toEqual(object);
+    const predicate = toEqual(object);
 
-        expect(predicate({ equals: returnFalse }, 0, [])).toEqual(false);
-    });
+    expect(predicate({ equals: returnFalse }, 0, [])).toEqual(false);
+  });
 
-    it('should return true when item is equal', () => {
-        const object = {
-            equals: returnFalse,
-        };
+  it('should return true when item is equal', () => {
+    const object = {
+      equals: returnFalse,
+    };
 
-        const predicate = toEqual(object);
+    const predicate = toEqual(object);
 
-        expect(predicate({ equals: returnTrue }, 0, [])).toEqual(true);
-    });
+    expect(predicate({ equals: returnTrue }, 0, [])).toEqual(true);
+  });
 });
 
 describe('arrayIncludesByEquals', () => {
-    it('should return false if no item is found by equals', () => {
-        const array = Array.from({ length: 3 }, () => ({ equals: returnFalse }));
+  it('should return false if no item is found by equals', () => {
+    const array = Array.from({ length: 3 }, () => ({ equals: returnFalse }));
 
-        expect(arrayIncludesByEquals(array, { equals: returnFalse })).toBe(false);
-    });
+    expect(arrayIncludesByEquals(array, { equals: returnFalse })).toBe(false);
+  });
 
-    it('should return true when item is found by equals', () => {
-        const array = Array.from({ length: 3 }, () => ({ equals: returnTrue }));
+  it('should return true when item is found by equals', () => {
+    const array = Array.from({ length: 3 }, () => ({ equals: returnTrue }));
 
-        expect(arrayIncludesByEquals(array, { equals: returnFalse })).toBe(true);
-    });
+    expect(arrayIncludesByEquals(array, { equals: returnFalse })).toBe(true);
+  });
 });
 
 describe('toWorldPositionCellCenter', () => {
-    it('should center to grid position', () => {
-        const position = toWorldPositionCellCenter(new Vector2(101, 60));
+  it('should center to grid position', () => {
+    const position = toWorldPositionCellCenter(new Vector2(101, 60));
 
-        expect(position.x).toEqual(104);
-        expect(position.y).toEqual(56);
-    });
+    expect(position.x).toEqual(104);
+    expect(position.y).toEqual(56);
+  });
 });
 
 describe('toWorldPosition', () => {
-    it('should center to grid position', () => {
-        const position = toWorldPosition(new Vector2(10, 2));
+  it('should center to grid position', () => {
+    const position = toWorldPosition(new Vector2(10, 2));
 
-        expect(position.x).toEqual(168);
-        expect(position.y).toEqual(40);
-    });
+    expect(position.x).toEqual(168);
+    expect(position.y).toEqual(40);
+  });
 });
 
 describe('toGridPosition', () => {
-    it('should 0,0 when position is 8,8', () => {
-        expect(toGridPosition(new Vector2(8, 8))).toMatchObject({
-            x: 0,
-            y: 0,
-        })
+  it('should 0,0 when position is 8,8', () => {
+    expect(toGridPosition(new Vector2(8, 8))).toMatchObject({
+      x: 0,
+      y: 0,
     });
+  });
 
-    it('should round down', () => {
-        expect(toGridPosition(new Vector2(47, 47))).toMatchObject({
-            x: 2,
-            y: 2,
-        })
+  it('should round down', () => {
+    expect(toGridPosition(new Vector2(47, 47))).toMatchObject({
+      x: 2,
+      y: 2,
     });
+  });
 });
 
 describe('convertPathfindingPathToPositions', () => {
-    it('should convert positions', () => {
-        const positions = convertPathfindingPathToPositions([
-            {
-                position: {
-                    x: 100,
-                    y: 200,
-                },
-            } as PathFinding.Node,
-            {
-                position: {
-                    x: 300,
-                    y: 400,
-                },
-            } as PathFinding.Node,
-        ]);
-
-        expect(positions).toHaveLength(2);
-        expect(positions).toEqual([
-            {
-                x: 100,
-                y: 200,
-            }, {
-                x: 300,
-                y: 400,
-            }
-        ]);
-    });
+  it('should convert positions', () => {
+    const positions = convertPathfindingPathToPositions([
+      {
+        position: {
+          x: 100,
+          y: 200,
+        },
+      } as PathFinding.Node,
+      {
+        position: {
+          x: 300,
+          y: 400,
+        },
+      } as PathFinding.Node,
+    ]);
+
+    expect(positions).toHaveLength(2);
+    expect(positions).toEqual([
+      {
+        x: 100,
+        y: 200,
+      },
+      {
+        x: 300,
+        y: 400,
+      },
+    ]);
+  });
 });
 
 describe('not', () => {
-    it.each([
-        [true, false],
-        [false, true]
-    ])('should reverse predicate\'s response %s to %s', (request, response) => {
-        expect(not(() => request)(undefined)).toEqual(response);
-    });
-});
\ No newline at end of file
+  it.each([
+    [true, false],
+    [false, true],
+  ])("should reverse predicate's response %s to %s", (request, response) => {
+    expect(not(() => request)(undefined)).toEqual(response);
+  });
+});
diff --git a/src/game/utils.ts b/src/game/utils.ts
index 390d8ca..767b50a 100644
--- a/src/game/utils.ts
+++ b/src/game/utils.ts
@@ -1,8 +1,9 @@
+import { Entity } from 'ecsy';
+
 import { Input } from './Input';
 import { Constants } from './Constants';
 import { Vector2 } from './math/Vector2';
 import * as PathFinding from './ai/pathfinding';
-import { Entity } from 'ecsy';
 import { TransformComponent } from './systems/TransformComponent';
 
 export const filterEmpty = Boolean as <T>(t: T) => NonNullable<T>;
@@ -10,74 +11,79 @@ export const filterEmpty = Boolean as <T>(t: T) => NonNullable<T>;
 export type Options = Record<string, string[] | undefined>;
 
 export const getOptions = (): Options => {
-    if (window.location.hash.indexOf('?') === -1) {
-        return {};
-    }
-
-    return window.location.hash
-        .substring(window.location.hash.indexOf('?') + 1)
-        .split('&')
-        .filter(filterEmpty)
-        .map((option) => option.split('='))
-        .reduce((acc, curr) => {
-            acc[curr[0]] = curr[1].split(',').filter(filterEmpty);
-            return acc;
-        }, {} as Options)
+  if (window.location.hash.indexOf('?') === -1) {
+    return {};
+  }
+
+  return window.location.hash
+    .substring(window.location.hash.indexOf('?') + 1)
+    .split('&')
+    .filter(filterEmpty)
+    .map((option) => option.split('='))
+    .reduce((acc, curr) => {
+      acc[curr[0]] = curr[1].split(',').filter(filterEmpty);
+      return acc;
+    }, {} as Options);
 };
 
 export type HasEquals = { equals: (other: unknown) => boolean };
 export type Predicate<T> = (value: T, index?: number, obj?: T[]) => boolean;
 
 export const toEqual = <T extends HasEquals>(other: T): Predicate<T> => {
-    return (item: T) => item.equals(other)
+  return (item: T) => item.equals(other);
 };
 
-export const arrayIncludesByEquals = <T extends HasEquals>(array: T[], object: T): boolean => {
-    return array.find(toEqual(object)) != null;
+export const arrayIncludesByEquals = <T extends HasEquals>(
+  array: T[],
+  object: T
+): boolean => {
+  return array.find(toEqual(object)) != null;
 };
 
 export const toWorldPositionCellCenter = (vector: Vector2): Vector2 => {
-    return new Vector2(
-        vector.x - (vector.x % Constants.CELL_SIZE) + (Constants.CELL_SIZE / 2),
-        vector.y - (vector.y % Constants.CELL_SIZE) + (Constants.CELL_SIZE / 2)
-    );
+  return new Vector2(
+    vector.x - (vector.x % Constants.CELL_SIZE) + Constants.CELL_SIZE / 2,
+    vector.y - (vector.y % Constants.CELL_SIZE) + Constants.CELL_SIZE / 2
+  );
 };
 
 export const toWorldPosition = (vector: Vector2): Vector2 => {
-    return new Vector2(
-        (vector.x * Constants.CELL_SIZE) + (Constants.CELL_SIZE / 2),
-        (vector.y * Constants.CELL_SIZE) + (Constants.CELL_SIZE / 2)
-    );
+  return new Vector2(
+    vector.x * Constants.CELL_SIZE + Constants.CELL_SIZE / 2,
+    vector.y * Constants.CELL_SIZE + Constants.CELL_SIZE / 2
+  );
 };
 
 /**
- * 
- * @param {number} x 
- * @param {number} y 
+ *
+ * @param {number} x
+ * @param {number} y
  * @returns {Vector2} centered cell vector
  */
 export const cellPositionToVector = (x: number, y: number): Vector2 => {
-    return toWorldPosition(new Vector2(x, y));
+  return toWorldPosition(new Vector2(x, y));
 };
 
 export const toGridPosition = (vector: Vector2): Vector2 => {
-    return Vector2.divides(vector, Constants.CELL_SIZE, 'floor');
+  return Vector2.divides(vector, Constants.CELL_SIZE, 'floor');
 };
 
 export const getMouseGridPosition = () => toGridPosition(Input.mousePosition);
 
-export type Position = { x: number; y: number; };
+export type Position = { x: number; y: number };
 
-export const convertPathfindingPathToPositions = (path: PathFinding.Path): Position[] => {
-    return path.map(({ position }) => (position));
-}
+export const convertPathfindingPathToPositions = (
+  path: PathFinding.Path
+): Position[] => {
+  return path.map(({ position }) => position);
+};
 
 export const getCell = (entity: Entity): Position => {
-    const component = entity.getComponent(TransformComponent)!;
-    const { x, y } = toGridPosition(component.position)
+  const component = entity.getComponent(TransformComponent)!;
+  const { x, y } = toGridPosition(component.position);
 
-    return { x, y };
-}
+  return { x, y };
+};
 
 export type Comparator<T> = (a: T, b: T) => number;
 
@@ -86,5 +92,5 @@ export const falsePredicate: Predicate<unknown> = () => false;
 export const keepOrder: Comparator<unknown> = () => 0;
 
 export const not = <T>(predicate: Predicate<T>): Predicate<T> => {
-    return (obj) => !predicate(obj);
-}
\ No newline at end of file
+  return (obj) => !predicate(obj);
+};
diff --git a/src/index.css b/src/index.css
index bd6213e..b5c61c9 100644
--- a/src/index.css
+++ b/src/index.css
@@ -1,3 +1,3 @@
 @tailwind base;
 @tailwind components;
-@tailwind utilities;
\ No newline at end of file
+@tailwind utilities;
diff --git a/src/shims-vue.d.ts b/src/shims-vue.d.ts
index cd04b72..c218476 100644
--- a/src/shims-vue.d.ts
+++ b/src/shims-vue.d.ts
@@ -1 +1,9 @@
-declare module '*.vue';
\ No newline at end of file
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue';
+  const component: DefineComponent<
+    Record<string, unknown>,
+    Record<string, unknown>,
+    unknown
+  >;
+  export default component;
+}
diff --git a/src/types/global.d.ts b/src/types/global.d.ts
index 51b9e86..ac7cb04 100644
--- a/src/types/global.d.ts
+++ b/src/types/global.d.ts
@@ -1,7 +1,7 @@
 declare module '@vue/runtime-core' {
-    export interface ComponentCustomProperties {
-        window: typeof Window,
-    }
+  export interface ComponentCustomProperties {
+    window: typeof Window;
+  }
 }
 
-export {}  // Important! See note.
\ No newline at end of file
+export {}; // Important! See note.
diff --git a/src/views/GameView.vue b/src/views/GameView.vue
index a2444ba..10de609 100644
--- a/src/views/GameView.vue
+++ b/src/views/GameView.vue
@@ -8,15 +8,15 @@
 </template>
 
 <script setup lang="ts">
-import { onMounted, ref } from "vue";
+import { onMounted, ref } from 'vue';
 
-import { PixiApplicationInstance } from "../components/pixi/types";
-import { Engine } from "../game/Engine";
+import { PixiApplicationInstance } from '../components/pixi/types';
+import { Engine } from '../game/Engine';
 
 const pixi = ref<PixiApplicationInstance>();
 let engine: Engine;
 
-window.addEventListener("contextmenu", (event) => {
+window.addEventListener('contextmenu', (event) => {
   event.preventDefault();
 });