paganaye · gavriel200 · Dec 10, 2021 · Feb 2, 2023 · Feb 2, 2023 · Feb 2, 2023
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1 @@
+node_modules
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "pwa-chrome",
+            "request": "launch",
+            "name": "Launch Chrome against localhost",
+            "url": "http://localhost:3000/",
+            "webRoot": "${workspaceFolder}",
+            "trace": true
+        }
+    ]
+}
diff --git a/README.md b/README.md
diff --git a/index.html b/index.html
@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8" />
+  <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Vite + TS</title>
+</head>
+
+<body>
+  <div id="app"></div>
+  <script type="module" src="/src/app.ts"></script>
+</body>
+
+</html>
diff --git a/package.json b/package.json
@@ -0,0 +1,30 @@
+{
+  "name": "global-game-jam-2023",
+  "version": "1.0.0",
+  "main": "index.js",
+  "repository": "[email protected]:DaveRubin/global-game-jam-2023.git",
+  "author": "David Rubin <[email protected]>",
+  "license": "MIT",
+  "scripts": {
+    "build": "webpack",
+    "start": "webpack-dev-server --port 8080",
+    "dev": "vite"
+  },
+  "devDependencies": {
+    "@babylonjs/core": "^5.44.0",
+    "@babylonjs/gui": "^5.44.0",
+    "@babylonjs/gui-editor": "^5.44.0",
+    "@babylonjs/inspector": "^5.44.0",
+    "@babylonjs/loaders": "^5.44.0",
+    "@babylonjs/materials": "^5.44.0",
+    "@babylonjs/serializers": "^5.44.0",
+    "@types/node": "^18.11.18",
+    "html-webpack-plugin": "^5.5.0",
+    "ts-loader": "^9.4.2",
+    "typescript": "^4.9.5",
+    "vite": "^4.1.1",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.1",
+    "webpack-dev-server": "^4.11.1"
+  }
+}
diff --git a/public/index.html b/public/index.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="UTF-8">
+        <title>Title of Your Project</title>
+    </head>
+    <body>
+    </body>
+</html>
diff --git a/public/textures/Flare.png b/public/textures/Flare.png
diff --git a/public/textures/forest_ground_04_ao_1k.jpeg b/public/textures/forest_ground_04_ao_1k.jpeg
diff --git a/public/textures/forest_ground_04_diff_1k.jpg b/public/textures/forest_ground_04_diff_1k.jpg
diff --git a/public/textures/forest_ground_04_disp_1k.png b/public/textures/forest_ground_04_disp_1k.png
diff --git a/public/textures/forest_ground_04_nor_gl_1k.jpeg b/public/textures/forest_ground_04_nor_gl_1k.jpeg
diff --git a/public/vite.svg b/public/vite.svg
diff --git a/src/CameraController.ts b/src/CameraController.ts
@@ -0,0 +1,37 @@
+import { Camera, Engine, Mesh, TransformNode, Vector3 } from "@babylonjs/core";
+import { animateTo, animateToVector } from "./animations";
+
+const REGULAR_ZOOM = -12;
+const CLOSE_UP = -5;
+
+export class CameraConrtoller {
+  cameraContainer: TransformNode;
+  target?: Mesh;
+  constructor(camera: Camera) {
+    this.cameraContainer = new TransformNode("cameraNode");
+
+    camera.parent = this.cameraContainer;
+    this.cameraContainer.position.set(0, 0.1, REGULAR_ZOOM);
+    Engine.LastCreatedScene?.onBeforeRenderObservable.add(() => {
+      if (this.target) {
+        const diff = this.target.position.subtract(this.cameraContainer.position);
+        diff.z = 0;
+
+        this.cameraContainer.position.x += diff.x / 4;
+        this.cameraContainer.position.y += diff.y / 4;
+      }
+    });
+  }
+  startFollow = (target: Mesh) => {
+    this.target = target;
+    animateTo(this.cameraContainer, "position.z", 1, [REGULAR_ZOOM, CLOSE_UP]);
+  };
+  stopFollow = () => {
+    this.target = undefined;
+    animateTo(this.cameraContainer, "position.z", 1, [CLOSE_UP, REGULAR_ZOOM]);
+    animateToVector(this.cameraContainer, "position", 1, [
+      this.cameraContainer.position,
+      new Vector3(0, 0.1, REGULAR_ZOOM),
+    ]);
+  };
+}
diff --git a/src/MainGame.ts b/src/MainGame.ts
@@ -0,0 +1,29 @@
+const INITIAL_ENERGY = 1000;
+const ENERGY_USAGE = 7;
+const INITIAL_ENERGY_PER_TICK = 2;
+
+export class MainGame {
+  maxEnergy = INITIAL_ENERGY;
+  currentEnergy = INITIAL_ENERGY;
+  energyPerTick = INITIAL_ENERGY_PER_TICK;
+
+  constructor() {}
+
+  get energyRatio() {
+    return this.currentEnergy / this.maxEnergy;
+  }
+
+  updateEnergy = () => {
+    this.currentEnergy += this.energyPerTick;
+    if (this.currentEnergy > this.maxEnergy) {
+      this.currentEnergy = this.maxEnergy;
+    }
+  };
+
+  useEnergy = () => {
+    this.currentEnergy -= ENERGY_USAGE;
+    if (this.currentEnergy < 0) {
+      this.currentEnergy = 0;
+    }
+  };
+}
diff --git a/src/animations.ts b/src/animations.ts
@@ -0,0 +1,29 @@
+import { Animation, CubicEase, EasingFunction, Engine, Vector3 } from "@babylonjs/core";
+
+let runner = 1;
+const ease = new CubicEase()
+ease.setEasingMode(EasingFunction.EASINGMODE_EASEINOUT)
+export const animateTo = (target: any, key: string, duration: number, values: any[]) => new Promise((resolve) => {
+    const frameRate = 10;
+
+    const animation = new Animation("xSlide" + runner, key, frameRate, Animation.ANIMATIONTYPE_FLOAT, Animation.ANIMATIONLOOPMODE_CONSTANT);
+    animation.setEasingFunction(ease)
+    const keyDuration = duration / values.length;
+
+    animation.setKeys(values.map((value, index) => ({
+        frame: index * keyDuration * frameRate,
+        value
+    })));
+
+    Engine.LastCreatedScene?.beginDirectAnimation(target, [animation], 0, duration * frameRate, false, undefined, () => {
+        resolve(true);
+    });
+
+})
+
+export const animateToVector = (target: any, key: string, duration: number, values: Vector3[]) => new Promise((resolve) => {
+    animateTo(target, key + ".x", duration, values.map(val => val.x));
+    animateTo(target, key + ".y", duration, values.map(val => val.y));
+    animateTo(target, key + ".z", duration, values.map(val => val.z));
+
+})
diff --git a/src/app.ts b/src/app.ts
@@ -0,0 +1,120 @@
+import { Engine, FreeCamera, HemisphericLight, Matrix, Scene, TransformNode, Vector3 } from "@babylonjs/core";
+import "@babylonjs/core/Debug/debugLayer";
+import "@babylonjs/inspector";
+import "@babylonjs/loaders";
+import "@babylonjs/loaders/glTF";
+import { animateTo } from "./animations";
+import { CameraConrtoller } from "./CameraController";
+import { MainGUI } from "./gui";
+import { MainGame } from "./MainGame";
+import { createMainStage } from "./mainStage";
+import { Roots } from "./roots";
+
+class App {
+  constructor() {
+    // create the canvas html element and attach it to the webpage
+    var canvas = document.createElement("canvas");
+    canvas.style.width = "100%";
+    canvas.style.height = "100%";
+    canvas.id = "gameCanvas";
+    document.body.appendChild(canvas);
+
+    var engine = new Engine(canvas, true);
+    var scene = new Scene(engine);
+
+    const camera = new FreeCamera("camera1", Vector3.Zero(), scene);
+    const controller = new CameraConrtoller(camera);
+    var mainLight: HemisphericLight = new HemisphericLight("light1", new Vector3(0, 1, 1), scene);
+    mainLight.intensity = 0.2;
+    const game = new MainGame();
+    const mainGui = new MainGUI();
+    mainGui.progress = game.energyRatio;
+    // animateFloat(mainGui, "progress", 4, [0, 1]).then(() => console.log("DONE!"));
+    const dirt = createMainStage();
+    scene.registerBeforeRender(() => {
+      // leaf.addRotation(0, 0.05, 0);
+    });
+    // scene.onPointerDown = function castRay() {
+    //   var ray = scene.createPickingRay(scene.pointerX, scene.pointerY, Matrix.Identity(), camera, false);
+
+    //   var hit = scene.pickWithRay(ray);
+
+    //   if (hit?.pickedMesh?.id === "plantBase") {
+    //     const p = hit?.pickedMesh?.position;
+    //     animateTo(CoT, "position.x", 1, [CoT.position.x, p.x]);
+    //     animateTo(CoT, "position.y", 1, [CoT.position.y, p.y]);
+    //   }
+    // };
+
+    // hide/show the Inspector
+    window.addEventListener("keydown", (ev) => {
+      // Shift+Ctrl+Alt+I
+      if (ev.key === "i") {
+        // if (ev.shiftKey && ev.ctrlKey && ev.altKey && ev.key === 'i') {
+        if (scene.debugLayer.isVisible()) {
+          scene.debugLayer.hide();
+        } else {
+          scene.debugLayer.show();
+        }
+      }
+    });
+
+    const roots = new Roots(scene);
+
+    canvas.addEventListener("pointerdown", (event) => {
+      const pickRoots = scene.pick(event.clientX, event.clientY, (mesh) => roots.isMeshInRoots(mesh));
+      if (pickRoots.hit) {
+        const pickDirt = scene.pick(event.clientX, event.clientY, (mesh) => mesh === dirt);
+
+        if (pickDirt.hit) {
+          const target = pickDirt.pickedPoint;
+          target!.z = 0;
+          const sph = roots.createSphere(target!);
+          controller.startFollow(sph);
+          roots.updateMousePosition(target!);
+          roots.addRoot();
+          roots.addTime();
+        }
+      }
+    });
+    const finishFollow = () => {
+      roots.deleteSphere();
+      controller.stopFollow();
+    };
+
+    canvas.addEventListener("pointermove", (event) => {
+      if (roots.getIsDragging() && game.currentEnergy > 0) {
+        let pickResult = scene.pick(event.clientX, event.clientY, (mesh) => {
+          return mesh === dirt;
+        });
+        let target = pickResult.pickedPoint;
+        target!.z = 0;
+        roots.updateMousePosition(target!);
+        game.useEnergy();
+      } else if (game.currentEnergy <= 0) {
+        finishFollow();
+      }
+    });
+
+    canvas.addEventListener("pointerup", () => {
+      if (roots.getIsDragging()) {
+        finishFollow();
+      }
+    });
+
+    scene.registerBeforeRender(() => {
+      roots.moveSphere();
+    });
+
+    // run the main render loop
+    engine.runRenderLoop(() => {
+      if (!roots.getIsDragging()) {
+        game.updateEnergy();
+      }
+
+      mainGui.progress = game.energyRatio;
+      scene.render();
+    });
+  }
+}
+new App();
diff --git a/src/consts.ts b/src/consts.ts
@@ -0,0 +1 @@
+export const DEGREE = Math.PI / 180;