gaesup-world 0.0.783 → 0.1.0

package/dist/gaesup/gaesupProps/index.js

@@ -11,20 +11,24 @@ var __assign = (this && this.__assign) || function () {
 };
 import { jsx as _jsx } from "react/jsx-runtime";
 import { vec3 } from "@react-three/rapier";
-import { Suspense, useContext, useEffect, useRef } from "react";
+import { Suspense, useContext, useEffect, useMemo, 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, children = _a.children;
+    var type = _a.type, text = _a.text, position = _a.position, children = _a.children;
     var groupRef = useRef(null);
     var minimap = useContext(GaesupWorldContext).minimap;
     var dispatch = useContext(GaesupWorldDispatchContext);
+    var groupComponent = useMemo(function () {
+        return (_jsx("group", { ref: groupRef, position: position, children: children }));
+    }, []);
     useEffect(function () {
         if (groupRef.current) {
             var box = new THREE.Box3().setFromObject(groupRef.current);
             var size = vec3(box.getSize(new THREE.Vector3())).clone();
             var center = vec3(box.getCenter(new THREE.Vector3())).clone();
             var obj = {
+                type: type ? type : "normal",
                 text: text,
                 size: size,
                 center: center,
@@ -38,5 +42,5 @@ export function GaeSupProps(_a) {
             });
         }
     }, []);
-    return (_jsx(Suspense, { fallback: null, children: _jsx("group", { ref: groupRef, position: position, children: children }) }));
+    return _jsx(Suspense, { fallback: null, children: groupComponent });
 }

package/dist/gaesup/hooks/useGaesupAnimation/index.d.ts

@@ -0,0 +1,8 @@
+import { animationAtomType } from "../../world/context/type";
+export declare function useGaesupAnimation(): {
+    subscribe: ({ tag, condition, action, animationName, key, }: animationAtomType) => void;
+    subscribeAll: (props: animationAtomType[]) => void;
+    store: {};
+    unsubscribe: (tag: string) => void;
+    notify: () => string;
+};

package/dist/gaesup/hooks/useGaesupAnimation/index.js

@@ -0,0 +1,94 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { useContext } from "react";
+import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context";
+export function useGaesupAnimation() {
+    var animations = useContext(GaesupWorldContext).animations;
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var getAnimationTag = function (tag) {
+        var animation = animations.store[tag];
+        if (!animation)
+            return { name: animations.default, isValid: false };
+        if (animation.condition()) {
+            return { name: animation.animationName, isValid: true };
+        }
+        else {
+            return { name: animations.default, isValid: false };
+        }
+    };
+    var notify = function () {
+        var tag = animations.default;
+        for (var _i = 0, _a = Object.keys(animations.store); _i < _a.length; _i++) {
+            var key = _a[_i];
+            var checked = getAnimationTag(key);
+            if (checked.isValid) {
+                tag = checked.name;
+                break;
+            }
+        }
+        animations.current = tag;
+        dispatch({
+            type: "update",
+            payload: {
+                animations: __assign({}, animations),
+            },
+        });
+        return tag;
+    };
+    var unsubscribe = function (tag) {
+        delete animations.store[tag];
+        dispatch({
+            type: "update",
+            payload: {
+                animations: __assign({}, animations),
+            },
+        });
+    };
+    var subscribe = function (_a) {
+        var tag = _a.tag, condition = _a.condition, action = _a.action, animationName = _a.animationName, key = _a.key;
+        animations.store[tag] = {
+            condition: condition,
+            action: action || (function () { }),
+            animationName: animationName || tag,
+            key: key || tag,
+        };
+        dispatch({
+            type: "update",
+            payload: {
+                animations: __assign({}, animations),
+            },
+        });
+    };
+    var subscribeAll = function (props) {
+        props.forEach(function (item) {
+            animations.store[item.tag] = {
+                condition: item.condition,
+                action: item.action,
+                animationName: item.animationName,
+                key: item.key,
+            };
+        });
+        dispatch({
+            type: "update",
+            payload: {
+                animations: __assign({}, animations),
+            },
+        });
+    };
+    return {
+        subscribe: subscribe,
+        subscribeAll: subscribeAll,
+        store: animations.store,
+        unsubscribe: unsubscribe,
+        notify: notify,
+    };
+}

package/dist/gaesup/hooks/useRideable/index.d.ts

@@ -0,0 +1,28 @@
+import { CollisionEnterPayload } from "@react-three/rapier";
+import { rideableType } from "../../world/context/type";
+/**
+ * Default rideable object properties.
+ * @type {Object}
+ */
+export declare const rideableDefault: {
+    objectkey: any;
+    objectType: any;
+    isRiderOn: boolean;
+    url: any;
+    wheelUrl: any;
+    position: import("three").Vector3;
+    rotation: import("three").Euler;
+    offset: import("three").Vector3;
+    visible: boolean;
+};
+/**
+ * Custom hook for managing rideable objects.
+ * @returns {Object} An object containing functions to initialize, set, get, ride, and land rideable objects.
+ */
+export declare function useRideable(): {
+    initRideable: (props: rideableType) => void;
+    setRideable: (props: rideableType) => void;
+    getRideable: (objectkey: string) => rideableType;
+    ride: (e: CollisionEnterPayload, props: rideableType) => Promise<void>;
+    landing: (objectkey: string) => void;
+};

package/dist/gaesup/hooks/useRideable/index.js

@@ -0,0 +1,198 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { euler, vec3 } from "@react-three/rapier";
+import { useContext } from "react";
+import { V3 } from "../../utils";
+import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context";
+/**
+ * Default rideable object properties.
+ * @type {Object}
+ */
+export var rideableDefault = {
+    objectkey: null,
+    objectType: null,
+    isRiderOn: false,
+    url: null,
+    wheelUrl: null,
+    position: vec3(),
+    rotation: euler(),
+    offset: vec3(),
+    visible: true,
+};
+/**
+ * Custom hook for managing rideable objects.
+ * @returns {Object} An object containing functions to initialize, set, get, ride, and land rideable objects.
+ */
+export function useRideable() {
+    var _this = this;
+    var worldContext = useContext(GaesupWorldContext);
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    /**
+     * Initialize a rideable object with the provided properties.
+     * @param {rideableType} props - The properties of the rideable object to initialize.
+     */
+    var initRideable = function (props) {
+        worldContext.rideable[props.objectkey] = __assign(__assign({}, rideableDefault), props);
+    };
+    /**
+     * Set the properties of a rideable object.
+     * @param {rideableType} props - The properties to set for the rideable object.
+     */
+    var setRideable = function (props) {
+        worldContext.rideable[props.objectkey] = props;
+    };
+    /**
+     * Get the rideable object with the specified object key.
+     * @param {string} objectkey - The key of the rideable object to retrieve.
+     * @returns {rideableType} The rideable object with the specified key.
+     */
+    var getRideable = function (objectkey) {
+        return worldContext.rideable[objectkey];
+    };
+    /**
+     * Handle landing of a rideable object.
+     * @param {string} objectkey - The key of the rideable object to land.
+     */
+    var landing = function (objectkey) {
+        var activeState = worldContext.activeState, vehicleCollider = worldContext.vehicleCollider, airplaneCollider = worldContext.airplaneCollider;
+        worldContext.characterCollider.riderOffsetX = 0;
+        worldContext.characterCollider.riderOffsetY = 0;
+        worldContext.characterCollider.riderOffsetZ = 0;
+        worldContext.states.isRiding = false;
+        worldContext.rideable[objectkey].visible = true;
+        worldContext.rideable[objectkey].position.copy(activeState.position
+            .clone()
+            .add(worldContext.rideable[objectkey].objectType === "vehicle"
+            ? V3(vehicleCollider.vehicleSizeX, vehicleCollider.vehicleSizeY, vehicleCollider.vehicleSizeZ).multiplyScalar(1.5)
+            : V3(airplaneCollider.airplaneSizeX, airplaneCollider.airplaneSizeY, airplaneCollider.airplaneSizeZ).multiplyScalar(1.5)));
+        worldContext.rideable[objectkey].rotation.copy(activeState.euler.clone());
+        dispatch({
+            type: "update",
+            payload: {
+                rideable: __assign({}, worldContext.rideable),
+                states: __assign({}, worldContext.states),
+                characterCollider: __assign({}, worldContext.characterCollider),
+            },
+        });
+    };
+    /**
+     * Set the URL properties of a rideable object. (inner function)
+     * @param {rideableType} props - The properties containing URLs for the rideable object.
+     */
+    var setUrl = function (props) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            if (props.objectType === "vehicle") {
+                worldContext.url.vehicleUrl = props.url;
+                worldContext.url.wheelUrl = props.wheelUrl || null;
+            }
+            else if (props.objectType === "airplane") {
+                worldContext.url.airplaneUrl = props.url;
+            }
+            dispatch({
+                type: "update",
+                payload: {
+                    url: __assign({}, worldContext.url),
+                },
+            });
+            return [2 /*return*/];
+        });
+    }); };
+    /**
+     * Set the mode and riding state for a rideable object. (inner function)
+     * @param {rideableType} props - The properties of the rideable object to set mode and riding state.
+     */
+    var setModeAndRiding = function (props) { return __awaiter(_this, void 0, void 0, function () {
+        var _a, _b, _c;
+        return __generator(this, function (_d) {
+            worldContext.mode.type = props.objectType;
+            worldContext.states.isRiding = true;
+            worldContext.states.isRiderOn = props.isRiderOn;
+            worldContext.characterCollider.riderOffsetX = ((_a = props === null || props === void 0 ? void 0 : props.offset) === null || _a === void 0 ? void 0 : _a.x) || 0;
+            worldContext.characterCollider.riderOffsetY = ((_b = props === null || props === void 0 ? void 0 : props.offset) === null || _b === void 0 ? void 0 : _b.y) || 0;
+            worldContext.characterCollider.riderOffsetZ = ((_c = props === null || props === void 0 ? void 0 : props.offset) === null || _c === void 0 ? void 0 : _c.z) || 0;
+            worldContext.rideable[props.objectkey].visible = false;
+            dispatch({
+                type: "update",
+                payload: {
+                    mode: __assign({}, worldContext.mode),
+                    states: __assign({}, worldContext.states),
+                    characterCollider: __assign({}, worldContext.characterCollider),
+                },
+            });
+            return [2 /*return*/];
+        });
+    }); };
+    /**
+     * Handle the ride event for a rideable object.
+     * @param {CollisionEnterPayload} e - The collision event payload.
+     * @param {rideableType} props - The properties of the rideable object.
+     */
+    var ride = function (e, props) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(e.other.rigidBodyObject.name === "character")) return [3 /*break*/, 3];
+                    return [4 /*yield*/, setUrl(props)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, setModeAndRiding(props)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); };
+    return {
+        initRideable: initRideable,
+        setRideable: setRideable,
+        getRideable: getRideable,
+        ride: ride,
+        landing: landing,
+    };
+}

package/dist/gaesup/hooks/useTeleport/index.d.ts

@@ -0,0 +1,3 @@
+export declare function useTeleport(): {
+    Teleport: (position: THREE.Vector3) => void;
+};

package/dist/gaesup/hooks/useTeleport/index.js

@@ -0,0 +1,12 @@
+import { useContext } from "react";
+import { GaesupWorldContext } from "../../world/context";
+export function useTeleport() {
+    var refs = useContext(GaesupWorldContext).refs;
+    var Teleport = function (position) {
+        var _a, _b;
+        (_b = (_a = refs.rigidBodyRef) === null || _a === void 0 ? void 0 : _a.current) === null || _b === void 0 ? void 0 : _b.setTranslation(position, true);
+    };
+    return {
+        Teleport: Teleport,
+    };
+}

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

@@ -60,5 +60,4 @@ export default function direction(prop) {
     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;
 }

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

@@ -3,10 +3,12 @@ import direction from "./direction";
 import gravity from "./gravity";
 import impulse from "./impulse";
 import innerCalc from "./innerCalc";
+import landing from "./landing";
 export default function airplaneCalculation(calcProp) {
     direction(calcProp);
     impulse(calcProp);
     damping(calcProp);
     gravity(calcProp);
+    landing(calcProp);
     innerCalc(calcProp);
 }

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

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

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

@@ -0,0 +1,29 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+export default function landing(prop) {
+    var _a = prop.worldContext, states = _a.states, rideable = _a.rideable, mode = _a.mode, dispatch = prop.dispatch;
+    var isLanding = states.isLanding;
+    if (isLanding) {
+        rideable.objectType = null;
+        rideable.key = null;
+        mode.type = "character";
+        states.isLanding = false;
+        states.isRiding = false;
+    }
+    dispatch({
+        type: "update",
+        payload: {
+            mode: __assign({}, mode),
+            rideable: __assign({}, rideable),
+        },
+    });
+}

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

@@ -1,5 +1,7 @@
 import ground from "./ground";
 import moving from "./moving";
+import push from "./push";
+import riding from "./riding";
 import rotate from "./rotate";
 import slope from "./slope";
 export default function check(calcProp) {
@@ -7,4 +9,6 @@ export default function check(calcProp) {
     slope(calcProp);
     moving(calcProp);
     rotate(calcProp);
+    push(calcProp);
+    riding(calcProp);
 }

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

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

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

@@ -0,0 +1,6 @@
+export default function push(prop) {
+    var _a = prop.worldContext, states = _a.states, joystick = _a.joystick, mode = _a.mode, control = _a.control;
+    Object.keys(control).forEach(function (key) {
+        states.isPush[key] = control[key];
+    });
+}

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

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

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

@@ -0,0 +1,7 @@
+export default function riding(prop) {
+    var _a = prop.worldContext, states = _a.states, rideable = _a.rideable, mode = _a.mode;
+    var isRiding = states.isRiding;
+    if (isRiding && states.isPush["keyR"]) {
+        states.isLanding = true;
+    }
+}

package/dist/gaesup/physics/index.js

@@ -29,7 +29,7 @@ export default function calculation(prop) {
         var rigidBodyRef = prop.rigidBodyRef;
         if (rigidBodyRef.current) {
             rigidBodyRef.current.lockRotations(true, true);
-            rigidBodyRef.current.setTranslation(activeState.position.clone().add(V3(0, 5, 0)), true);
+            rigidBodyRef.current.setTranslation(activeState.position.clone().add(V3(0, 2, 0)), true);
         }
     }, [mode.type]);
     useFrame(function (state, delta) {

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

@@ -7,12 +7,6 @@ export function joystick(prop) {
     if (joystick.joyStickOrigin.isCenter)
         return front;
     activeState.euler.y = Math.PI / 2 - joystick.joyStickOrigin.angle;
-    // const _euler = activeState.euler.clone();
-    // const __euler = activeState.euler.clone();
-    // __euler.y = Math.PI / 2 - joystick.joyStickOrigin.angle;
-    // activeState.euler.setFromQuaternion(
-    //   quat().setFromEuler(_euler).slerp(quat().setFromEuler(__euler), 1)
-    // );
     return front;
 }
 export function normal(prop) {

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

@@ -2,9 +2,11 @@ import damping from "./damping";
 import direction from "./direction";
 import impulse from "./impulse";
 import innerCalc from "./innerCalc";
+import landing from "./landing";
 export default function vehicleCalculation(calcProp) {
     direction(calcProp);
     impulse(calcProp);
     damping(calcProp);
+    landing(calcProp);
     innerCalc(calcProp);
 }

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

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

package/dist/gaesup/physics/vehicle/landing.js

@@ -0,0 +1,29 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+export default function landing(prop) {
+    var _a = prop.worldContext, states = _a.states, rideable = _a.rideable, mode = _a.mode, dispatch = prop.dispatch;
+    var isLanding = states.isLanding;
+    if (isLanding) {
+        rideable.objectType = null;
+        rideable.key = null;
+        mode.type = "character";
+        states.isLanding = false;
+        states.isRiding = false;
+    }
+    dispatch({
+        type: "update",
+        payload: {
+            mode: __assign({}, mode),
+            rideable: __assign({}, rideable),
+        },
+    });
+}

package/dist/gaesup/tools/jumpPortal/index.d.ts

@@ -1,3 +1,3 @@
 import { portalType } from "../../world/context/type";
 import "./style.css";
-export declare function JumpPortal(props: portalType): import("react/jsx-runtime").JSX.Element;
+export declare function JumpPortal({ text, position, jumpPortalStlye }: portalType): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/tools/jumpPortal/index.js

@@ -1,11 +1,10 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext } from "react";
-import { GaesupWorldContext } from "../../world/context";
+import { useTeleport } from "../../hooks/useTeleport";
 import "./style.css";
-export function JumpPortal(props) {
-    var refs = useContext(GaesupWorldContext).refs;
+export function JumpPortal(_a) {
+    var text = _a.text, position = _a.position, jumpPortalStlye = _a.jumpPortalStlye;
+    var Teleport = useTeleport().Teleport;
     return (_jsx("div", { className: "jumpPortal", onClick: function () {
-            var _a, _b;
-            (_b = (_a = refs.rigidBodyRef) === null || _a === void 0 ? void 0 : _a.current) === null || _b === void 0 ? void 0 : _b.setTranslation(props.position, true);
-        }, style: props.jumpPortalStlye, children: props.text }));
+            Teleport(position);
+        }, style: jumpPortalStlye, children: text }));
 }

package/dist/gaesup/tools/keyBoardToolTip/type.d.ts

@@ -2,6 +2,8 @@ import { CSSProperties } from "react";
 export type keyboardMapType = {
     name: string;
     keys: string[];
+    label?: string;
+    match?: string;
 }[];
 export type keyMapItemType = {
     name: string;

package/dist/gaesup/tools/miniMap/index.js

@@ -35,17 +35,31 @@ export function MiniMap(props) {
                 upscale();
             else
                 downscale();
-        }, children: [_jsx("div", { className: "minimapOuter", style: objectStyle }), _jsxs("div", { className: "minimapInner", style: __assign({ 
-                    // transform: props.blockRotate
-                    //   ? `translate(-50%, -50%) rotate(180deg) `
-                    //   : `translate(-50%, -50%) rotate(${
-                    //       (activeState.euler.y * 180) / Math.PI + 180
-                    //     }deg) `,
-                    transform: "translate(-50%, -50%) rotate(180deg)" }, innerStyle), children: [_jsx("div", { className: "east direction", style: __assign({ transform: "translate(-50%, 50%) rotate(180deg)" }, directionStyle), children: "E" }), _jsx("div", { className: "west direction", style: __assign({ transform: "translate(50%, 50%) rotate(180deg)" }, directionStyle), children: "W" }), _jsx("div", { className: "south direction", style: __assign({ transform: "translate(-50%, 50%) rotate(180deg)" }, directionStyle), children: "S" }), _jsx("div", { className: "north direction", style: __assign({ transform: "translate(-50%, -50%) rotate(180deg)" }, directionStyle), children: "N" }), Object.values(minimap.props).map(function (_a, key) {
+        }, children: [_jsx("div", { className: "minimapOuter", style: objectStyle }), _jsxs("div", { className: "minimapInner", style: __assign({ transform: props.blockRotate || mode.control === "normal"
+                        ? "translate(-50%, -50%) rotate(180deg) "
+                        : "translate(-50%, -50%) rotate(".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }, innerStyle), children: [_jsx("div", { className: "east direction", style: __assign({ transform: props.blockRotate || mode.control === "normal"
+                                ? "translate(-50%, -50%) rotate(180deg) "
+                                : "translate(-50%, -50%) rotate(-".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }, directionStyle), children: "E" }), _jsx("div", { className: "west direction", style: __assign({ transform: props.blockRotate || mode.control === "normal"
+                                ? "translate(50%, -50%) rotate(180deg) "
+                                : "translate(50%, -50%) rotate(-".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }, directionStyle), children: "W" }), _jsx("div", { className: "south direction", style: __assign({ transform: props.blockRotate || mode.control === "normal"
+                                ? "translate(-50%, 50%) rotate(180deg) "
+                                : "translate(-50%, 50%) rotate(-".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }, directionStyle), children: "S" }), _jsx("div", { className: "north direction", style: __assign({ transform: props.blockRotate || mode.control === "normal"
+                                ? "translate(-50%, -50%) rotate(180deg) "
+                                : "translate(-50%, -50%) rotate(-".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }, directionStyle), children: "N" }), Object.values(minimap.props).map(function (_a, key) {
                         var center = _a.center, size = _a.size, text = _a.text;
                         var X = (center.x - activeState.position.x) * scale;
                         var Z = (center.z - activeState.position.z) * scale;
-                        return (_jsx("div", { className: "minimapObject", style: __assign({ width: "".concat(size.x * scale, "rem"), height: "".concat(size.z * scale, "rem"), top: "50%", left: "50%", transform: "translate(-50%, -50%) translate(".concat(-X, "rem, ").concat(-Z, "rem)"), transformOrigin: "50% 50%" }, objectStyle), children: text && (_jsx("div", { className: "text", style: __assign(__assign({}, textStyle), { transform: "rotate(-180deg)" }), children: text })) }, key));
+                        return (_jsxs("div", { children: [_jsx("div", { className: "minimapObject", style: __assign({ width: "".concat(size.x * scale, "rem"), height: "".concat(size.z * scale, "rem"), top: "50%", left: "50%", transform: "translate(-50.1%, -50.1%) translate(".concat(-X, "rem, ").concat(-Z, "rem)"), transformOrigin: "50% 50%", zIndex: 1 + key }, objectStyle) }, key), _jsx("div", { className: "textObject", style: {
+                                        width: "".concat(size.x * scale, "rem"),
+                                        height: "".concat(size.z * scale, "rem"),
+                                        top: "50.1%",
+                                        left: "50.1%",
+                                        transform: "translate(-50.1%, -50.1%) translate(".concat(-X, "rem, ").concat(-Z, "rem)"),
+                                        transformOrigin: "50.1% 50.1%",
+                                        zIndex: 1001 + key,
+                                    }, children: text && (_jsx("div", { className: "text", style: __assign(__assign({}, textStyle), { zIndex: 1001 + key, transform: props.blockRotate || mode.control === "normal"
+                                                ? " rotate(180deg) "
+                                                : " rotate(-".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }), children: text })) })] }, key));
                     }), _jsx("div", { className: "avatar", style: avatarStyle })] }), !props.blockScaleControl && (_jsxs("div", { className: "scale", style: scaleStyle, children: [_jsx("div", { className: "plusMinus", style: plusMinusStyle, onClick: function () {
                             if (props.blockScale)
                                 return;

package/dist/gaesup/tools/miniMap/type.d.ts

@@ -1,9 +1,12 @@
-import { CSSProperties } from "react";
+import { CSSProperties, ReactElement } from "react";
 import * as THREE from "three";
 export type minimapPropsType = {
+    type: "normal" | "ground";
     text?: string;
     center: THREE.Vector3;
     size: THREE.Vector3;
+    children?: ReactElement;
+    position?: THREE.Vector3;
 };
 export type minimapInnerType = {
     props: {