gaesup-world 0.0.781 → 0.0.783

package/dist/gaesup/controller/context/index.js

@@ -12,33 +12,9 @@ var __assign = (this && this.__assign) || function () {
 import { createContext } from "react";
 import { V3 } from "../../utils/vector";
 export var gaesupControllerDefault = {
-    cameraMode: {
-        cameraType: "perspective",
-        controlType: "normal",
-    },
-    cameraOption: {
-        offset: V3(-10, -10, -10),
-        initDistance: -5,
-        maxDistance: -7,
-        minDistance: -0.7,
-        initDir: 0,
-        collisionOff: 0.7,
-        distance: -1,
-        camFollow: 11,
-    },
-    perspectiveCamera: {
-        isFront: true,
-        XZDistance: 8,
-        YDistance: 1,
-    },
-    orthographicCamera: {
-        zoom: 1,
-        near: 0.1,
-        far: 1000,
-    },
     airplane: {
-        angleDelta: V3(0.01, 0.005, 0.005),
-        maxAngle: V3(0.1, 0.1, 0.1),
+        angleDelta: V3(Math.PI / 256, Math.PI / 256, Math.PI / 256),
+        maxAngle: V3(Math.PI / 8, Math.PI / 8, Math.PI / 8),
         maxSpeed: 60,
         accelRatio: 2,
         brakeRatio: 5,
@@ -53,10 +29,10 @@ export var gaesupControllerDefault = {
         linearDamping: 0.5,
     },
     character: {
-        walkSpeed: 4,
-        runSpeed: 10,
+        walkSpeed: 10,
+        runSpeed: 20,
         turnSpeed: 10,
-        jumpSpeed: 0.5,
+        jumpSpeed: 1,
         linearDamping: 1,
     },
     callbacks: {

package/dist/gaesup/controller/context/reducer.d.ts

@@ -3,10 +3,6 @@ export declare function gaesupControllerReducer(props: gaesupControllerType, act
     type: string;
     payload?: Partial<gaesupControllerType>;
 }): {
-    cameraMode: import("./type").gaesupCameraPropType;
-    cameraOption: import("./type").cameraOptionType;
-    perspectiveCamera: import("./type").perspectiveCameraPropType;
-    orthographicCamera: import("@react-three/fiber").OrthographicCameraProps;
     airplane: import("./type").airplaneType;
     vehicle: import("./type").vehicleType;
     character: import("./type").characterType;

package/dist/gaesup/controller/context/type.d.ts

@@ -31,39 +31,6 @@ export interface vehicleType extends GroupProps, vehicleDebugType {
 }
 export interface characterType extends GroupProps, characterDebugType {
 }
-export type perspectiveCameraType = {
-    cameraType?: "perspective";
-    controlType?: "orbit" | "normal";
-};
-export type orthographicCameraType = {
-    cameraType?: "orthographic";
-    controlType?: "orbit";
-};
-export type gaesupCameraPropType = perspectiveCameraType | orthographicCameraType;
-export type gaesupCameraOptionDebugType = {
-    initDistance?: number;
-    maxDistance?: number;
-    minDistance?: number;
-    initDir?: number;
-    distance?: number;
-    camFollow?: number;
-};
-export type cameraOptionType = {
-    offset?: THREE.Vector3;
-    collisionOff?: number;
-} & gaesupCameraOptionDebugType;
-export type perspectiveCameraDebugType = {
-    XZDistance?: number;
-    YDistance?: number;
-};
-export type orthographicCameraDebugType = {
-    zoom?: number;
-    near?: number;
-    far?: number;
-};
-export type perspectiveCameraPropType = {
-    isFront?: boolean;
-} & perspectiveCameraDebugType;
 export type gaesupControllerType = gaesupControllerContextPropType & {
     callbacks?: callbackType;
     refs?: refsType;

package/dist/gaesup/controller/debug/index.js

@@ -10,42 +10,17 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { useContext, useEffect } from "react";
-import { buttonGroup, useControls } from "leva";
 import { update } from "../../utils/context";
 import debug from "../../utils/debug";
 import { GaesupWorldContext } from "../../world/context";
 import { airplaneDebugMap } from "./airplane";
-import { cameraOptionDebugMap } from "./cameraOption";
 import { characterDebugMap } from "./character";
-import { orthographicCameraDebugMap } from "./orthographicCamera";
-import { perspectiveCameraDebugMap } from "./perspectiveCamera";
 import { vehicleDebugMap } from "./vehicle";
 export default function initDebug(_a) {
     var controllerContext = _a.controllerContext, controllerDispatch = _a.controllerDispatch;
     var worldDebug = useContext(GaesupWorldContext).debug;
-    var cameraMode = controllerContext.cameraMode;
     if (!worldDebug)
         return;
-    var _b = useControls(function () { return ({
-        cameraType: cameraMode.cameraType,
-        "   ": buttonGroup({
-            perspective: function () { return setcameraType({ cameraType: "perspective" }); },
-            orthographic: function () { return setcameraType({ cameraType: "orthographic" }); },
-        }),
-    }); }), cameraType = _b[0], setcameraType = _b[1];
-    var _c = useControls(function () { return ({
-        controlType: cameraMode.controlType,
-        "    ": buttonGroup({
-            orbit: function () { return controlTypeSet({ controlType: "orbit" }); },
-            normal: function () { return controlTypeSet({ controlType: "normal" }); },
-        }),
-    }); }), controlType = _c[0], controlTypeSet = _c[1];
-    var cameraOptionValue = debug({
-        debug: worldDebug,
-        debugProps: controllerContext.cameraOption,
-        tag: "cameraOption",
-        debugMap: cameraOptionDebugMap,
-    });
     var characterOptionValue = debug({
         debug: worldDebug,
         debugProps: controllerContext.character,
@@ -64,39 +39,11 @@ export default function initDebug(_a) {
         tag: "airplane",
         debugMap: airplaneDebugMap,
     });
-    var orthographicCameraOptionValue = debug({
-        debug: worldDebug,
-        debugProps: controllerContext.orthographicCamera,
-        tag: "orthographicCamera",
-        debugMap: orthographicCameraDebugMap,
-    });
-    var perspectiveCameraOptionValue = debug({
-        debug: worldDebug,
-        debugProps: controllerContext.perspectiveCamera,
-        tag: "perspectiveCamera",
-        debugMap: perspectiveCameraDebugMap,
-    });
     useEffect(function () {
         update({
-            cameraOption: __assign({}, cameraOptionValue),
             character: __assign({}, characterOptionValue),
             vehicle: __assign({}, vehicleOptionValue),
             airplane: __assign({}, airplaneOptionValue),
-            perspectiveCamera: __assign(__assign({}, controllerContext.perspectiveCamera), perspectiveCameraOptionValue),
-            orthographicCamera: __assign(__assign({}, controllerContext.orthographicCamera), orthographicCameraOptionValue),
-            cameraMode: {
-                cameraType: cameraType.cameraType,
-                controlType: controlType.controlType,
-            },
         }, controllerDispatch);
-    }, [
-        cameraOptionValue,
-        characterOptionValue,
-        vehicleOptionValue,
-        airplaneOptionValue,
-        perspectiveCameraOptionValue,
-        orthographicCameraOptionValue,
-        cameraType,
-        controlType,
-    ]);
+    }, [characterOptionValue, vehicleOptionValue, airplaneOptionValue]);
 }

package/dist/gaesup/controller/index.js

@@ -26,10 +26,6 @@ export function GaesupController(props) {
     var characterInnerRef = useRef(null);
     var passiveRigidBodyRef = useRef(null);
     var _a = useReducer(gaesupControllerReducer, {
-        cameraMode: Object.assign(gaesupControllerDefault.cameraMode, props.cameraMode || {}),
-        cameraOption: Object.assign(gaesupControllerDefault.cameraOption, props.cameraOption || {}),
-        perspectiveCamera: Object.assign(gaesupControllerDefault.perspectiveCamera, props.perspectiveCamera || {}),
-        orthographicCamera: Object.assign(gaesupControllerDefault.orthographicCamera, props.orthographicCamera || {}),
         airplane: Object.assign(gaesupControllerDefault.airplane, props.airplane || {}),
         vehicle: Object.assign(gaesupControllerDefault.vehicle, props.vehicle || {}),
         character: Object.assign(gaesupControllerDefault.character, props.character || {}),
@@ -65,7 +61,6 @@ export function GaesupController(props) {
         };
     }, []);
     var prop = __assign(__assign(__assign(__assign({}, initControllerProps({
-        controllerContext: gaesupControl.value,
         refs: refs,
     })), { children: props.children, groupProps: props.groupProps }), gaesupControl.value.callbacks), refs);
     initDebug({

package/dist/gaesup/controller/initialize/index.d.ts

@@ -1,9 +1,7 @@
 import { groundRayType, refsType, slopeRayType } from "../../controller/type";
 import { cameraRayType } from "../../camera/type";
 import { keyControlType } from "../../world/context/type";
-import { gaesupControllerType } from "../context/type";
-export default function initControllerProps({ controllerContext, refs, }: {
-    controllerContext: gaesupControllerType;
+export default function initControllerProps({ refs }: {
     refs: refsType;
 }): {
     slopeRay: slopeRayType;

package/dist/gaesup/controller/initialize/index.js

@@ -16,7 +16,7 @@ import * as THREE from "three";
 import { update } from "../../utils/context";
 import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context";
 export default function initControllerProps(_a) {
-    var controllerContext = _a.controllerContext, refs = _a.refs;
+    var refs = _a.refs;
     var context = useContext(GaesupWorldContext);
     var dispatch = useContext(GaesupWorldDispatchContext);
     var _b = useKeyboardControls(), _ = _b[0], getKeys = _b[1];
@@ -63,13 +63,12 @@ export default function initControllerProps(_a) {
             rayCast: new THREE.Raycaster(vec3(), vec3(), 0, -7),
             dir: vec3(),
             position: vec3(),
-            length: -controllerContext.cameraOption.maxDistance,
+            length: -context.cameraOption.maxDistance,
             detected: [],
             intersects: [],
             intersectObjectMap: {},
         };
     }, []);
-    cameraRay.rayCast = new THREE.Raycaster(cameraRay.origin, cameraRay.dir, 0, -controllerContext.cameraOption.maxDistance);
     var initRefs = useCallback(function (refs) {
         update({
             refs: __assign({}, refs),

package/dist/gaesup/controller/type.d.ts

@@ -1,11 +1,11 @@
 import { Collider, Ray, RayColliderToi } from "@dimforge/rapier3d-compat";
-import { GroupProps, OrthographicCameraProps } from "@react-three/fiber";
+import { GroupProps } from "@react-three/fiber";
 import { RapierRigidBody, RigidBodyProps } from "@react-three/rapier";
 import { ReactNode, RefObject } from "react";
 import * as THREE from "three";
 import { cameraRayType } from "../camera/type";
 import { keyControlType } from "../world/context/type";
-import { airplaneType, cameraOptionType, characterType, gaesupCameraPropType, perspectiveCameraPropType, vehicleType } from "./context/type";
+import { airplaneType, characterType, vehicleType } from "./context/type";
 import { callbackType } from "./initialize/callback/type";
 export type optionsType = {
     debug: boolean;
@@ -44,6 +44,7 @@ export type slopeRayType = Omit<rayType, "parent">;
 export type groundRayType = Omit<rayType, "current" | "angle">;
 export type controllerInnerType = {
     isRider?: boolean;
+    name?: string;
     slopeRay: slopeRayType;
     groundRay: groundRayType;
     cameraRay: cameraRayType;
@@ -73,10 +74,6 @@ export type refsType = {
     characterInnerRef: RefObject<THREE.Group>;
 };
 export type gaesupControllerContextPropType = {
-    cameraMode: gaesupCameraPropType;
-    cameraOption: cameraOptionType;
-    perspectiveCamera: perspectiveCameraPropType;
-    orthographicCamera: OrthographicCameraProps;
     airplane: airplaneType;
     vehicle: vehicleType;
     character: characterType;

package/dist/gaesup/gaesupProps/index.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="react" />
-export declare function GaeSupProps({ text, position, jumpPoint, children, }: {
+export declare function GaeSupProps({ text, position, children, }: {
     text?: string;
     position?: [number, number, number];
-    jumpPoint?: boolean;
     children: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/gaesupProps/index.js

@@ -9,38 +9,17 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { jsx as _jsx } from "react/jsx-runtime";
 import { vec3 } from "@react-three/rapier";
 import { Suspense, useContext, useEffect, useRef } from "react";
 import * as THREE from "three";
 import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../world/context/index.js";
 export function GaeSupProps(_a) {
-    var text = _a.text, position = _a.position, jumpPoint = _a.jumpPoint, children = _a.children;
+    var text = _a.text, position = _a.position, children = _a.children;
     var groupRef = useRef(null);
-    var _b = useContext(GaesupWorldContext), minimap = _b.minimap, points = _b.points;
+    var minimap = useContext(GaesupWorldContext).minimap;
     var dispatch = useContext(GaesupWorldDispatchContext);
     useEffect(function () {
-        if (jumpPoint && position) {
-            points.push({
-                text: text || null,
-                position: vec3().set(position[0], 5, position[2]),
-            });
-            dispatch({
-                type: "update",
-                payload: {
-                    points: __spreadArray([], points, true),
-                },
-            });
-        }
         if (groupRef.current) {
             var box = new THREE.Box3().setFromObject(groupRef.current);
             var size = vec3(box.getSize(new THREE.Vector3())).clone();

package/dist/gaesup/{tools/joystick/default.d.ts → hooks/useJoyStick/index.d.ts}

@@ -1,4 +1,4 @@
-import { joyStickBallType, joyStickOriginType } from "./type.js";
+import { joyStickBallType, joyStickOriginType } from "../../tools/joyStick/type";
 export declare const joyStickBallDefault: {
     top: string;
     left: string;

package/dist/gaesup/{tools/joystick/default.js → hooks/useJoyStick/index.js}

@@ -10,7 +10,7 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { useContext } from "react";
-import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context/index.js";
+import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context";
 export var joyStickBallDefault = {
     top: "50%",
     left: "50%",

package/dist/gaesup/physics/airplane/direction.js

@@ -1,7 +1,7 @@
 import { quat } from "@react-three/rapier";
 import { V3 } from "../../utils/vector";
 export default function direction(prop) {
-    var state = prop.state, innerGroupRef = prop.innerGroupRef, _a = prop.worldContext, joystick = _a.joystick, activeState = _a.activeState, control = _a.control, mode = _a.mode, airplane = prop.controllerContext.airplane;
+    var state = prop.state, innerGroupRef = prop.innerGroupRef, _a = prop.worldContext, joystick = _a.joystick, activeState = _a.activeState, control = _a.control, mode = _a.mode, airplane = prop.controllerContext.airplane, delta = prop.delta;
     var forward = control.forward, backward = control.backward, leftward = control.leftward, rightward = control.rightward, shift = control.shift, space = control.space;
     var angleDelta = airplane.angleDelta, maxAngle = airplane.maxAngle, accelRatio = airplane.accelRatio;
     var boost = 0;
@@ -23,16 +23,12 @@ export default function direction(prop) {
     var _euler = activeState.euler.clone();
     var __euler = activeState.euler.clone();
     if (mode.controller === "joystick") {
-        __euler.y =
-            -state.camera.rotation.y - joystick.joyStickOrigin.angle - Math.PI / 2;
+        __euler.y = -Math.PI / 2 + joystick.joyStickOrigin.angle;
+        activeState.euler.setFromQuaternion(quat().setFromEuler(_euler).slerp(quat().setFromEuler(__euler), 1));
     }
     else {
         activeState.euler.y += -leftRight * angleDelta.y;
     }
-    if (mode.controller === "joystick")
-        activeState.euler.setFromQuaternion(quat()
-            .setFromEuler(_euler)
-            .slerp(quat().setFromEuler(__euler), joystick.joyStickOrigin.isIn ? 0.01 : 0.1));
     var X = maxAngle.x * upDown;
     var Z = maxAngle.z * leftRight;
     var _x = innerGroupRef.current.rotation.x;
@@ -40,23 +36,29 @@ export default function direction(prop) {
     var maxX = maxAngle.x;
     var maxZ = maxAngle.z;
     var innerGrounRefRotation = innerGroupRef.current.clone();
-    if (_x < -maxX)
+    if (_x < -maxX) {
         innerGrounRefRotation.rotation.x = -maxX + X;
-    else if (_x > maxX)
+    }
+    else if (_x > maxX) {
         innerGrounRefRotation.rotation.x = maxX + X;
-    else
+    }
+    else {
         innerGrounRefRotation.rotateX(X);
+    }
     if (_z < -maxZ)
         innerGrounRefRotation.rotation.z = -maxZ + Z;
     else if (_z > maxZ)
         innerGrounRefRotation.rotation.z = maxZ + Z;
     else
         innerGrounRefRotation.rotateZ(Z);
+    activeState.euler.x = innerGrounRefRotation.rotation.x;
+    activeState.euler.z = innerGrounRefRotation.rotation.z;
+    innerGrounRefRotation.rotation.y = 0;
     innerGroupRef.current.setRotationFromQuaternion(quat()
         .setFromEuler(innerGroupRef.current.rotation.clone())
-        .slerp(quat().setFromEuler(innerGrounRefRotation.rotation), 0.1));
+        .slerp(quat().setFromEuler(innerGrounRefRotation.rotation.clone()), 0.2));
     activeState.rotation = innerGrounRefRotation.rotation;
     activeState.direction = front.multiply(V3(Math.sin(activeState.euler.y), -upDown, Math.cos(activeState.euler.y)));
     activeState.dir = activeState.direction.normalize();
-    activeState.euler = innerGroupRef.current.rotation;
+    // activeState.euler = innerGroupRef.current.rotation;
 }

package/dist/gaesup/physics/airplane/index.js

@@ -1,14 +1,12 @@
-import currentSetting from "./currentSetting";
 import damping from "./damping";
 import direction from "./direction";
 import gravity from "./gravity";
 import impulse from "./impulse";
-import turn from "./turn";
+import innerCalc from "./innerCalc";
 export default function airplaneCalculation(calcProp) {
     direction(calcProp);
-    turn(calcProp);
     impulse(calcProp);
     damping(calcProp);
     gravity(calcProp);
-    currentSetting(calcProp);
+    innerCalc(calcProp);
 }

package/dist/gaesup/physics/airplane/innerCalc.d.ts

@@ -0,0 +1,2 @@
+import { calcPropType } from "../type";
+export default function innerCalc(prop: calcPropType): void;

package/dist/gaesup/physics/{vehicle/currentSetting.js → airplane/innerCalc.js}

@@ -9,11 +9,15 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { vec3 } from "@react-three/rapier";
-export default function currentSetting(prop) {
+import { quat, vec3 } from "@react-three/rapier";
+export default function innerCalc(prop) {
     var rigidBodyRef = prop.rigidBodyRef, activeState = prop.worldContext.activeState, dispatch = prop.dispatch;
     activeState.position = vec3(rigidBodyRef.current.translation());
     activeState.velocity = vec3(rigidBodyRef.current.linvel());
+    var _euler = activeState.euler.clone();
+    _euler.x = 0;
+    _euler.z = 0;
+    rigidBodyRef.current.setRotation(quat().setFromEuler(_euler), true);
     dispatch({
         type: "update",
         payload: {

package/dist/gaesup/physics/character/direction.d.ts

@@ -1,5 +1,5 @@
 import { RootState } from "@react-three/fiber";
-import { joyStickInnerType } from "../../tools/joystick/type";
+import { joyStickInnerType } from "../../tools/joyStick/type";
 import { activeStateType, modeType } from "../../world/context/type";
 import { calcPropType } from "../type";
 export declare function orbitDirection({ activeState, control, mode, joystick, state, }: {

package/dist/gaesup/physics/character/direction.js

@@ -4,16 +4,16 @@ export function orbitDirection(_a) {
     var forward = control.forward, backward = control.backward, leftward = control.leftward, rightward = control.rightward;
     var dirX = Number(leftward) - Number(rightward);
     var dirZ = Number(forward) - Number(backward);
-    if (dirX === 0 && dirZ === 0)
-        return;
     var start = 0;
     if (mode.controller === "joystick") {
-        if (!joystick.joyStickOrigin.isCenter)
-            activeState.euler.y =
-                -state.camera.rotation.y - joystick.joyStickOrigin.angle - Math.PI / 2;
-        start = joystick.joyStickOrigin.isOn ? 1 : 0;
+        if (joystick.joyStickOrigin.isCenter)
+            return;
+        activeState.euler.y = Math.PI / 2 - joystick.joyStickOrigin.angle;
+        start = 1;
     }
     else {
+        if (dirX === 0 && dirZ === 0)
+            return;
         activeState.euler.y += (dirX * Math.PI) / 32;
         start = dirZ;
     }
@@ -26,10 +26,10 @@ export function normalDirection(_a) {
     var forward = control.forward, backward = control.backward, leftward = control.leftward, rightward = control.rightward;
     var start = 0;
     if (mode.controller === "joystick") {
-        if (!joystick.joyStickOrigin.isCenter)
-            activeState.euler.y =
-                -state.camera.rotation.y - joystick.joyStickOrigin.angle - Math.PI / 2;
-        start = joystick.joyStickOrigin.isOn ? 1 : 0;
+        if (joystick.joyStickOrigin.isCenter)
+            return;
+        activeState.euler.y = Math.PI / 2 - joystick.joyStickOrigin.angle;
+        start = 1;
     }
     else {
         // 일반 컨트롤
@@ -45,11 +45,11 @@ export function normalDirection(_a) {
     }
 }
 export default function direction(prop) {
-    var state = prop.state, _a = prop.worldContext, joystick = _a.joystick, mode = _a.mode, activeState = _a.activeState, control = _a.control, cameraMode = prop.controllerContext.cameraMode;
-    if (cameraMode.controlType === "normal") {
+    var state = prop.state, _a = prop.worldContext, joystick = _a.joystick, mode = _a.mode, activeState = _a.activeState, control = _a.control;
+    if (mode.control === "normal") {
         normalDirection({ activeState: activeState, control: control, mode: mode, joystick: joystick, state: state });
     }
-    else if (cameraMode.controlType === "orbit") {
+    else if (mode.control === "orbit") {
         orbitDirection({ activeState: activeState, control: control, mode: mode, joystick: joystick, state: state });
     }
 }

package/dist/gaesup/physics/character/innerCalc.js

@@ -11,12 +11,16 @@ var __assign = (this && this.__assign) || function () {
 };
 import { quat, vec3 } from "@react-three/rapier";
 export default function innerCalc(prop) {
-    var rigidBodyRef = prop.rigidBodyRef, innerGroupRef = prop.innerGroupRef, linearDamping = prop.controllerContext.character.linearDamping, activeState = prop.worldContext.activeState, dispatch = prop.dispatch, delta = prop.delta;
+    var rigidBodyRef = prop.rigidBodyRef, innerGroupRef = prop.innerGroupRef, linearDamping = prop.controllerContext.character.linearDamping, _a = prop.worldContext, activeState = _a.activeState, states = _a.states, dispatch = prop.dispatch, delta = prop.delta;
     activeState.position = vec3(rigidBodyRef.current.translation());
     activeState.velocity = vec3(rigidBodyRef.current.linvel());
-    rigidBodyRef.current.setLinearDamping(linearDamping);
+    if (states.isJumping || rigidBodyRef.current.linvel().y < 0) {
+        rigidBodyRef.current.setLinearDamping(linearDamping);
+    }
+    else {
+        rigidBodyRef.current.setLinearDamping(states.isNotMoving ? linearDamping * 5 : linearDamping);
+    }
     rigidBodyRef.current.setEnabledRotations(false, false, false, false);
-    // rigidBodyRef.current.setTranslation(activeState.position.clone(), false);
     innerGroupRef.current.quaternion.rotateTowards(quat().setFromEuler(activeState.euler), 10 * delta);
     dispatch({
         type: "update",

package/dist/gaesup/physics/check/ground.d.ts

@@ -1,2 +1,2 @@
 import { calcPropType } from "../type";
-export default function checkOnTheGround(prop: calcPropType): any;
+export default function checkOnTheGround(prop: calcPropType): void;

package/dist/gaesup/physics/check/ground.js

@@ -2,8 +2,10 @@ import { vec3 } from "@react-three/rapier";
 export default function checkOnTheGround(prop) {
     var capsuleColliderRef = prop.capsuleColliderRef, groundRay = prop.groundRay, _a = prop.worldContext, collider = _a.characterCollider, states = _a.states, activeState = _a.activeState;
     groundRay.origin.addVectors(activeState.position, vec3(groundRay.offset));
-    if (!groundRay.hit || !groundRay.rayCast || !capsuleColliderRef.current)
-        return null;
+    if (!groundRay.hit || !groundRay.rayCast || !capsuleColliderRef.current) {
+        states.isOnTheGround = false;
+        return;
+    }
     if (groundRay.hit.toi < collider.radius + 0.4) {
         states.isOnTheGround = true;
     }

package/dist/gaesup/physics/check/moving.js

@@ -10,8 +10,7 @@ export default function moving(prop) {
     else if (mode.controller === "joystick") {
         states.isMoving = joystick.joyStickOrigin.isOn;
         states.isNotMoving = !joystick.joyStickOrigin.isOn;
-        states.isRunning =
-            joystick.joyStickOrigin.isOn && joystick.joyStickOrigin.isIn;
+        states.isRunning = shift && states.isMoving;
         states.isJumping = space;
     }
 }

package/dist/gaesup/physics/index.js

@@ -24,13 +24,14 @@ export default function calculation(prop) {
     var worldContext = useContext(GaesupWorldContext);
     var controllerContext = useContext(GaesupControllerContext);
     var dispatch = useContext(GaesupWorldDispatchContext);
-    var mode = worldContext.mode, activeState = worldContext.activeState;
+    var mode = worldContext.mode, activeState = worldContext.activeState, controlBlock = worldContext.controlBlock;
     useEffect(function () {
-        var _a;
         var rigidBodyRef = prop.rigidBodyRef;
-        if (rigidBodyRef.current)
-            (_a = rigidBodyRef.current) === null || _a === void 0 ? void 0 : _a.setTranslation(activeState.position.add(V3(0, 1, 0)), false);
-    }, []);
+        if (rigidBodyRef.current) {
+            rigidBodyRef.current.lockRotations(true, true);
+            rigidBodyRef.current.setTranslation(activeState.position.clone().add(V3(0, 5, 0)), true);
+        }
+    }, [mode.type]);
     useFrame(function (state, delta) {
         var rigidBodyRef = prop.rigidBodyRef, outerGroupRef = prop.outerGroupRef, innerGroupRef = prop.innerGroupRef;
         if (!rigidBodyRef ||
@@ -40,6 +41,8 @@ export default function calculation(prop) {
             !innerGroupRef ||
             !innerGroupRef.current)
             return null;
+        if (controlBlock)
+            return null;
         var calcProp = __assign(__assign({}, prop), { state: state, delta: delta, worldContext: worldContext, controllerContext: controllerContext, dispatch: dispatch, world: world });
         if (mode.type === "vehicle")
             vehicleCalculation(calcProp);

package/dist/gaesup/physics/vehicle/direction.d.ts

@@ -1,2 +1,4 @@
 import { calcPropType } from "../type";
+export declare function joystick(prop: calcPropType): import("three").Vector3;
+export declare function normal(prop: calcPropType): import("three").Vector3;
 export default function direction(prop: calcPropType): void;