gaesup-world 0.0.1

package/src/gaesup/physics/character/direction.ts

@@ -0,0 +1,104 @@
+import { RootState } from "@react-three/fiber";
+import { activeStateType } from "../../stores/active/type";
+
+import { gaesupControllerPropType } from "../../stores/context/gaesupworld/type";
+import { joyStickType } from "../../stores/joystick/type";
+import { V3 } from "../../utils/vector";
+import { calcPropType } from "../type";
+
+export function joystickDirection() {}
+
+export function orbitDirection({
+  activeState,
+  control,
+  mode,
+  joystick,
+  state,
+}: {
+  state: RootState;
+  activeState: activeStateType;
+  mode: gaesupControllerPropType;
+  joystick: joyStickType;
+  control: {
+    [key: string]: boolean;
+  };
+}) {
+  const { forward, backward, leftward, rightward } = control;
+  let start = 0;
+  if (mode.controller === "joystick") {
+    activeState.euler.y =
+      -state.camera.rotation.y - joystick.joyStickOrigin.angle - Math.PI / 2;
+    start = joystick.joyStickOrigin.isOn ? 1 : 0;
+  } else {
+    activeState.euler.y +=
+      ((Number(leftward) - Number(rightward)) * Math.PI) / 32;
+    start = Number(forward) - Number(backward);
+  }
+  const front = V3(start, 0, start);
+  activeState.direction = front.multiply(
+    V3(Math.sin(activeState.euler.y), 0, Math.cos(activeState.euler.y))
+  );
+  activeState.dir = activeState.direction.normalize();
+}
+
+export function normalDirection({
+  activeState,
+  control,
+  mode,
+  joystick,
+  state,
+}: {
+  state: RootState;
+  activeState: activeStateType;
+  mode: gaesupControllerPropType;
+  joystick: joyStickType;
+  control: {
+    [key: string]: boolean;
+  };
+}) {
+  const { forward, backward, leftward, rightward } = control;
+  let start = 0;
+  if (mode.controller === "joystick") {
+    activeState.euler.y =
+      -state.camera.rotation.y - joystick.joyStickOrigin.angle - Math.PI / 2;
+    start = joystick.joyStickOrigin.isOn ? 1 : 0;
+  } else {
+    if (forward) {
+      activeState.euler.y =
+        -state.camera.rotation.y +
+        (leftward ? Math.PI / 4 : 0) -
+        (rightward ? Math.PI / 4 : 0);
+    } else if (backward) {
+      activeState.euler.y =
+        -state.camera.rotation.y +
+        Math.PI -
+        (leftward ? Math.PI / 4 : 0) +
+        (rightward ? Math.PI / 4 : 0);
+    } else if (leftward) {
+      activeState.euler.y = -state.camera.rotation.y + Math.PI / 2;
+    } else if (rightward) {
+      activeState.euler.y = -state.camera.rotation.y - Math.PI / 2;
+    }
+  }
+  const front = V3(
+    Number(backward) - Number(forward),
+    0,
+    Number(leftward) - Number(rightward)
+  );
+  activeState.direction = front;
+  activeState.dir = activeState.direction.normalize();
+}
+
+export default function direction(prop: calcPropType) {
+  const {
+    control,
+    state,
+    worldContext: { joystick, mode, activeState },
+    controllerContext: { cameraMode },
+  } = prop;
+  if (cameraMode.controlType === "normal") {
+    normalDirection({ activeState, control, mode, joystick, state });
+  } else if (cameraMode.controlType === "orbit") {
+    orbitDirection({ activeState, control, mode, joystick, state });
+  }
+}

package/src/gaesup/physics/character/impulse.ts

@@ -0,0 +1,24 @@
+import { V3 } from "../../utils/vector";
+import { calcPropType } from "../type";
+
+export default function impulse(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    slopeRay,
+    worldContext: { states, activeState },
+  } = prop;
+  const { isMoving } = states;
+
+  if (isMoving) {
+    const M = rigidBodyRef.current.mass();
+    const A = activeState.acceleration;
+    const F = A.multiplyScalar(M);
+
+    activeState.impulse = V3(
+      F.x,
+      activeState.direction.normalize().y * Math.abs(Math.sin(slopeRay.angle)),
+      F.z
+    );
+    rigidBodyRef.current.applyImpulse(activeState.impulse, false);
+  }
+}

package/src/gaesup/physics/character/index.tsx

@@ -0,0 +1,20 @@
+import { calcPropType } from "../type";
+import accelaration from "./accelaration";
+import currentSetting from "./currentSetting";
+import damping from "./damping";
+import direction from "./direction";
+import impulse from "./impulse";
+import jump from "./jump";
+import stabilizing from "./stabilizing";
+import turn from "./turn";
+
+export default function characterCalculation(calcProp: calcPropType) {
+  direction(calcProp);
+  turn(calcProp);
+  jump(calcProp);
+  accelaration(calcProp);
+  impulse(calcProp);
+  damping(calcProp);
+  stabilizing(calcProp);
+  currentSetting(calcProp);
+}

package/src/gaesup/physics/character/jump.ts

@@ -0,0 +1,21 @@
+import { V3 } from "../../utils/vector";
+import { calcPropType } from "../type";
+
+export default function jump(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    slopeRay,
+    constant,
+    worldContext: { states, activeState },
+  } = prop;
+  const { isOnTheGround, isJumping } = states;
+  const { jumpSpeed } = constant;
+  if (isJumping && isOnTheGround) {
+    rigidBodyRef.current.setLinvel(
+      V3(0, jumpSpeed * 0.25, 0)
+        .projectOnVector(slopeRay.current)
+        .add(activeState.velocity.setY(jumpSpeed)),
+      false
+    );
+  }
+}

package/src/gaesup/physics/character/stabilizing.ts

@@ -0,0 +1,6 @@
+import { calcPropType } from "../type";
+
+export default function stabilizing(prop: calcPropType) {
+  const { rigidBodyRef } = prop;
+  rigidBodyRef.current.setEnabledRotations(false, false, false, false);
+}

package/src/gaesup/physics/character/turn.ts

@@ -0,0 +1,17 @@
+import { calcPropType } from "../type";
+
+export default function turn(prop: calcPropType) {
+  const {
+    outerGroupRef,
+    constant,
+    delta,
+    worldContext: { activeState },
+  } = prop;
+  const { turnSpeed } = constant;
+
+  activeState.quat.setFromEuler(activeState.euler);
+  outerGroupRef.current.quaternion.rotateTowards(
+    activeState.quat,
+    delta * turnSpeed
+  );
+}

package/src/gaesup/physics/check/ground.ts

@@ -0,0 +1,19 @@
+import { vec3 } from "@react-three/rapier";
+import { calcPropType } from "../type";
+
+export default function checkOnTheGround(prop: calcPropType) {
+  const {
+    capsuleColliderRef,
+    groundRay,
+    worldContext: { characterCollider: collider, states, activeState },
+  } = prop;
+
+  groundRay.origin.addVectors(activeState.position, vec3(groundRay.offset));
+  if (!groundRay.hit || !groundRay.rayCast || !capsuleColliderRef.current)
+    return null;
+  if (groundRay.hit.toi < collider.radius + 0.4) {
+    states.isOnTheGround = true;
+  } else {
+    states.isOnTheGround = false;
+  }
+}

package/src/gaesup/physics/check/index.ts

@@ -0,0 +1,12 @@
+import { calcPropType } from "../type";
+import ground from "./ground";
+import moving from "./moving";
+import rotate from "./rotate";
+import slope from "./slope";
+
+export default function check(calcProp: calcPropType) {
+  ground(calcProp);
+  slope(calcProp);
+  moving(calcProp);
+  rotate(calcProp);
+}

package/src/gaesup/physics/check/moving.ts

@@ -0,0 +1,21 @@
+import { calcPropType } from "../type";
+
+export default function moving(prop: calcPropType) {
+  const {
+    control: calcControl,
+    worldContext: { states, joystick, mode },
+  } = prop;
+  const { forward, backward, leftward, rightward, shift, space } = calcControl;
+  if (mode.controller === "gameboy" || mode.controller === "keyboard") {
+    states.isMoving = forward || backward || leftward || rightward;
+    states.isNotMoving = !states.isMoving;
+    states.isRunning = shift && states.isMoving;
+    states.isJumping = space;
+  } else if (mode.controller === "joystick") {
+    states.isMoving = joystick.joyStickOrigin.isOn;
+    states.isNotMoving = !joystick.joyStickOrigin.isOn;
+    states.isRunning =
+      joystick.joyStickOrigin.isOn && joystick.joyStickOrigin.isIn;
+    states.isJumping = space;
+  }
+}

package/src/gaesup/physics/check/rotate.ts

@@ -0,0 +1,13 @@
+import { calcPropType } from "../type";
+
+export default function rotate(prop: calcPropType) {
+  const {
+    outerGroupRef,
+    worldContext: { states, activeState },
+  } = prop;
+  if (states.isMoving && outerGroupRef && outerGroupRef.current) {
+    states.isRotated =
+      Math.sin(outerGroupRef.current.rotation.y).toFixed(3) ===
+      Math.sin(activeState.euler.y).toFixed(3);
+  }
+}

package/src/gaesup/physics/check/slope.ts

@@ -0,0 +1,50 @@
+import { vec3 } from "@react-three/rapier";
+import { calcPropType } from "../type";
+
+export default function slope(prop: calcPropType) {
+  const {
+    capsuleColliderRef,
+    slopeRayOriginRef,
+    slopeRay,
+    groundRay,
+    worldContext,
+    world,
+  } = prop;
+  const { characterCollider: collider } = worldContext;
+  if (
+    !slopeRayOriginRef.current ||
+    !capsuleColliderRef.current ||
+    !slopeRay.rayCast
+  )
+    return null;
+  slopeRayOriginRef.current.getWorldPosition(slopeRay.origin);
+  slopeRay.origin.y = groundRay.origin.y;
+  slopeRay.hit = world.castRay(
+    slopeRay.rayCast,
+    slopeRay.length,
+    true,
+    undefined,
+    undefined,
+    capsuleColliderRef.current
+  );
+
+  if (slopeRay.hit && groundRay.rayCast) {
+    const castRayNormal = slopeRay.hit.collider.castRayAndGetNormal(
+      groundRay.rayCast,
+      slopeRay.length,
+      false
+    );
+    if (castRayNormal) slopeRay.current = vec3(castRayNormal.normal);
+  }
+  if (
+    slopeRay.hit &&
+    groundRay.hit &&
+    slopeRay.hit.toi < collider.radius + 0.3 + 0.5
+  ) {
+    slopeRay.angle = Number(
+      Math.atan(
+        (groundRay.hit.toi - slopeRay.hit.toi) / slopeRay.offset.z
+      ).toFixed(2)
+    );
+  }
+}

package/src/gaesup/physics/index.ts

@@ -0,0 +1,50 @@
+import { useFrame } from "@react-three/fiber";
+
+import { useKeyboardControls } from "@react-three/drei";
+import { useContext } from "react";
+import { propType } from "../controller/type";
+
+import { useRapier } from "@react-three/rapier";
+import { GaesupControllerContext } from "../stores/context/controller";
+import {
+  GaesupWorldContext,
+  GaesupWorldDispatchContext,
+} from "../stores/context/gaesupworld";
+import airplaneCalculation from "./airplane";
+import characterCalculation from "./character";
+import check from "./check";
+import { calcPropType } from "./type";
+import vehicleCalculation from "./vehicle";
+
+export default function calculation(prop: propType) {
+  const { world } = useRapier();
+  const worldContext = useContext(GaesupWorldContext);
+  const controllerContext = useContext(GaesupControllerContext);
+  const dispatch = useContext(GaesupWorldDispatchContext);
+  const control = useKeyboardControls()[1]();
+  const { mode } = worldContext;
+  useFrame((state, delta) => {
+    const { rigidBodyRef, outerGroupRef } = prop;
+    if (
+      !rigidBodyRef ||
+      !rigidBodyRef.current ||
+      !outerGroupRef ||
+      !outerGroupRef.current
+    )
+      return null;
+    const calcProp: calcPropType = {
+      ...prop,
+      control,
+      state,
+      delta,
+      worldContext,
+      controllerContext,
+      dispatch,
+      world,
+    };
+    if (mode.type === "vehicle") vehicleCalculation(calcProp);
+    else if (mode.type === "character") characterCalculation(calcProp);
+    else if (mode.type === "airplane") airplaneCalculation(calcProp);
+    check(calcProp);
+  });
+}

package/src/gaesup/physics/type.ts

@@ -0,0 +1,35 @@
+import { RootState } from "@react-three/fiber";
+import { propType } from "../controller/type";
+
+import { World } from "@dimforge/rapier3d-compat";
+import { gaesupControllerType } from "../stores/context/controller/type";
+import {
+  gaesupDisptachType,
+  gaesupWorldPropType,
+} from "../stores/context/gaesupworld/type";
+
+export type SetAtom<Args extends unknown[], Result> = (...args: Args) => Result;
+
+export type calcPropType = propType & {
+  control: {
+    [key: string]: boolean;
+  };
+  state?: RootState;
+  checkCollision?: (delta: number) => void;
+  worldContext?: gaesupWorldPropType;
+  controllerContext?: gaesupControllerType;
+  delta?: number;
+  dispatch?: gaesupDisptachType;
+  world: World;
+};
+
+export type cameraPropType = propType & {
+  control: {
+    [key: string]: boolean;
+  };
+  state?: RootState;
+  worldContext?: gaesupWorldPropType;
+  checkCollision?: (delta: number) => void;
+  controllerContext?: gaesupControllerType;
+  delta?: number;
+};

package/src/gaesup/physics/vehicle/currentSetting.ts

@@ -0,0 +1,20 @@
+import { vec3 } from "@react-three/rapier";
+import { calcPropType } from "../type";
+
+export default function currentSetting(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    worldContext: { activeState },
+    dispatch,
+  } = prop;
+  activeState.position = vec3(rigidBodyRef.current.translation());
+  activeState.velocity = vec3(rigidBodyRef.current.linvel());
+  dispatch({
+    type: "update",
+    payload: {
+      activeState: {
+        ...activeState,
+      },
+    },
+  });
+}

package/src/gaesup/physics/vehicle/damping.ts

@@ -0,0 +1,8 @@
+import { calcPropType } from "../type";
+
+export default function damping(prop: calcPropType) {
+  const { rigidBodyRef, constant, control } = prop;
+  const { space } = control;
+  const { brakeRate } = constant;
+  rigidBodyRef.current.setLinearDamping(space ? brakeRate : 0.5);
+}

package/src/gaesup/physics/vehicle/direction.ts

@@ -0,0 +1,27 @@
+import { vec3 } from "@react-three/rapier";
+import { V3 } from "../../utils/vector";
+import { calcPropType } from "../type";
+
+export default function direction(prop: calcPropType) {
+  const {
+    worldContext: { activeState },
+  } = prop;
+  const { forward, backward, leftward, rightward } = prop.control;
+
+  const start = Number(forward) - Number(backward);
+  const front = vec3().set(start, 0, start);
+  activeState.euler.y +=
+    ((Number(leftward) - Number(rightward)) * Math.PI) / 64;
+  // current.dir = V3(
+  //   Math.sin(current.euler.y),
+  //   0,
+  //   Math.cos(current.euler.y)
+  // ).normalize();
+  // current.direction = front
+  //   .multiply(current.dir)
+  //   .multiplyScalar(shift ? accelRate : 1);
+  activeState.direction = front.multiply(
+    V3(Math.sin(activeState.euler.y), 0, Math.cos(activeState.euler.y))
+  );
+  activeState.dir = activeState.direction.normalize();
+}

package/src/gaesup/physics/vehicle/impulse.ts

@@ -0,0 +1,22 @@
+import { vec3 } from "@react-three/rapier";
+import { calcPropType } from "../type";
+
+export default function impulse(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    constant,
+    control,
+    worldContext: { activeState },
+  } = prop;
+  const { shift } = control;
+  const { accelRate } = constant;
+
+  rigidBodyRef.current.applyImpulse(
+    vec3({
+      x: activeState.direction.x,
+      y: 0,
+      z: activeState.direction.z,
+    }).multiplyScalar(shift ? accelRate : 1),
+    false
+  );
+}

package/src/gaesup/physics/vehicle/index.tsx

@@ -0,0 +1,14 @@
+import { calcPropType } from "../type";
+import currentSetting from "./currentSetting";
+import damping from "./damping";
+import direction from "./direction";
+import impulse from "./impulse";
+import turn from "./turn";
+
+export default function vehicleCalculation(calcProp: calcPropType) {
+  direction(calcProp);
+  turn(calcProp);
+  impulse(calcProp);
+  damping(calcProp);
+  currentSetting(calcProp);
+}

package/src/gaesup/physics/vehicle/turn.ts

@@ -0,0 +1,11 @@
+import { calcPropType } from "../type";
+
+export default function turn(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    worldContext: { activeState },
+  } = prop;
+
+  activeState.quat.setFromEuler(activeState.euler);
+  rigidBodyRef.current.setRotation(activeState.quat, false);
+}

package/src/gaesup/stores/active/index.ts

@@ -0,0 +1,19 @@
+import { euler, quat, vec3 } from "@react-three/rapier";
+import { V3 } from "../../utils/vector";
+
+export const activeStateDefault = {
+  position: V3(0, 2, 5),
+  impulse: vec3(),
+  velocity: vec3(),
+  acceleration: vec3(),
+  quat: quat(),
+  euler: euler(),
+  dir: vec3(),
+  direction: vec3(),
+  axisX: V3(1, 0, 0),
+  axisY: V3(0, 1, 0),
+  axisZ: V3(0, 0, 1),
+  yaw: 0,
+  pitch: 0,
+  roll: 0,
+};

package/src/gaesup/stores/active/type.ts

@@ -0,0 +1,16 @@
+export type activeStateType = {
+  position: THREE.Vector3;
+  impulse: THREE.Vector3;
+  velocity: THREE.Vector3;
+  acceleration: THREE.Vector3;
+  quat: THREE.Quaternion;
+  euler: THREE.Euler;
+  direction: THREE.Vector3;
+  dir: THREE.Vector3;
+  axisX: THREE.Vector3;
+  axisY: THREE.Vector3;
+  axisZ: THREE.Vector3;
+  yaw: number;
+  pitch: number;
+  roll: number;
+};

package/src/gaesup/stores/airplane/index.ts

@@ -0,0 +1,6 @@
+import { V3 } from "../../utils/vector";
+
+export const airplaneDefault = {
+  angleChange: V3(0.02, 0.01, 0.01),
+  maxAngle: V3(0.2, 0.2, 0.2),
+};

package/src/gaesup/stores/airplane/type.ts

@@ -0,0 +1,4 @@
+export type airplaneType = {
+  angleChange: THREE.Vector3;
+  maxAngle: THREE.Vector3;
+};

package/src/gaesup/stores/animation/index.ts

@@ -0,0 +1,18 @@
+import { animationTagType } from "../../controller/type";
+
+export const animationDefault = {
+  current: "idle" as keyof animationTagType,
+  animationNames: {
+    idle: "idle",
+    walk: "walk",
+    run: "run",
+    accel: "accel",
+    break: "break",
+    ride: "ride",
+    jump: "jump",
+    jumpIdle: "jumpIdle",
+    jumpLand: "jumpLand",
+    fall: "fall",
+  },
+  keyControl: {},
+};

package/src/gaesup/stores/animation/type.ts

@@ -0,0 +1,9 @@
+import { actionsType, animationTagType } from "../../controller/type";
+
+export type animationPropType = {
+  current: keyof animationTagType;
+  animationNames: actionsType;
+  keyControl: {
+    [key: string]: boolean;
+  };
+};

package/src/gaesup/stores/collider/index.ts

@@ -0,0 +1,55 @@
+export type characterColliderType = {
+  halfHeight?: number;
+  height?: number;
+  radius?: number;
+  diameter?: number;
+};
+
+export type vehicleColliderType = {
+  wheelSizeX?: number;
+  wheelSizeY?: number;
+  wheelSizeZ?: number;
+  vehicleSizeX?: number;
+  vehicleSizeY?: number;
+  vehicleSizeZ?: number;
+  vehicleX?: number;
+  vehicleY?: number;
+  vehicleZ?: number;
+};
+
+export type airplaneColliderType = {
+  airplaneSizeX?: number;
+  airplaneSizeY?: number;
+  airplaneSizeZ?: number;
+  airplaneX?: number;
+  airplaneY?: number;
+  airplaneZ?: number;
+};
+
+export const characterColliderDefault = {
+  halfHeight: 0.35,
+  height: 0.7,
+  radius: 0.3,
+  diameter: 0.6,
+};
+
+export const vehicleColliderDefault = {
+  wheelSizeX: 0.5,
+  wheelSizeY: 0.5,
+  wheelSizeZ: 0.5,
+  vehicleSizeX: 1,
+  vehicleSizeY: 1,
+  vehicleSizeZ: 1,
+  vehicleX: 0.5,
+  vehicleY: 0.5,
+  vehicleZ: 0.5,
+};
+
+export const airplaneColliderDefault = {
+  airplaneSizeX: 1,
+  airplaneSizeY: 1,
+  airplaneSizeZ: 1,
+  airplaneX: 0.5,
+  airplaneY: 0.5,
+  airplaneZ: 0.5,
+};