gaesup-world 0.2.24 → 0.2.26

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

@@ -0,0 +1,85 @@
+import { Collider, Ray, RayColliderToi } from "@dimforge/rapier3d-compat";
+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, urlsType } from "../world/context/type";
+import { airplaneType, characterType, vehicleType } from "./context/type";
+import { callbackType } from "./initialize/callback/type";
+export type optionsType = {
+    debug: boolean;
+    mode?: "normal" | "vehicle" | "airplane";
+    controllerType: "none" | "gameboy" | "joystick" | "keyboard";
+    cameraCollisionType: "transparent" | "closeUp";
+    camera: {
+        type: "perspective" | "orthographic";
+        control: "orbit" | "normal";
+    };
+    minimap: boolean;
+    minimapRatio: number;
+};
+export type partialOptionsType = Partial<optionsType>;
+export type jumpInnerType = {
+    velocity: THREE.Vector3;
+    direction: THREE.Vector3;
+};
+export type jumpConstType = {
+    speed: number;
+    gravity: number;
+};
+export type jumpPropType = jumpInnerType & jumpConstType;
+export type rayType = {
+    origin: THREE.Vector3;
+    hit: RayColliderToi | null;
+    rayCast: Ray | null;
+    dir: THREE.Vector3;
+    offset: THREE.Vector3;
+    length: number;
+    current?: THREE.Vector3;
+    angle?: number;
+    parent?: RapierRigidBody | null | undefined;
+};
+export type slopeRayType = Omit<rayType, "parent">;
+export type groundRayType = Omit<rayType, "current" | "angle">;
+export type controllerInnerType = {
+    name?: string;
+    groundRay: groundRayType;
+    cameraRay: cameraRayType;
+    keyControl: keyControlType;
+} & controllerOtherPropType & refsType & callbackType;
+export type animationTagType = {
+    idle: string;
+    walk: string;
+    run: string;
+    jump: string;
+    jumpIdle: string;
+    jumpLand: string;
+    fall: string;
+    ride: string;
+    land: string;
+    sit: string;
+};
+export type actionsType = animationTagType & {
+    [key: string]: string;
+};
+export type refsType = {
+    colliderRef: RefObject<Collider>;
+    rigidBodyRef: RefObject<RapierRigidBody>;
+    outerGroupRef: RefObject<THREE.Group>;
+    innerGroupRef: RefObject<THREE.Group>;
+    characterInnerRef: RefObject<THREE.Group>;
+};
+export type gaesupControllerContextPropType = {
+    airplane: airplaneType;
+    vehicle: vehicleType;
+    character: characterType;
+    urls: urlsType;
+};
+export interface controllerOtherPropType extends RigidBodyProps {
+    children?: ReactNode;
+    groupProps?: GroupProps;
+    rigidBodyProps?: RigidBodyProps;
+    debug?: boolean;
+}
+export type controllerType = controllerOtherPropType & Partial<gaesupControllerContextPropType> & callbackType;

package/dist/gaesup/controller/type.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/gaesup/gaesupProps/index.js

@@ -0,0 +1,46 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { vec3 } from "@react-three/rapier";
+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 _b = _a.type, type = _b === void 0 ? "normal" : _b, 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,
+            };
+            minimap.props[text] = obj;
+            dispatch({
+                type: "update",
+                payload: {
+                    minimap: __assign({}, minimap),
+                },
+            });
+        }
+    }, []);
+    return _jsx(Suspense, { fallback: null, children: groupComponent });
+}

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

@@ -0,0 +1,10 @@
+import { animationAtomType } from "../../world/context/type";
+export declare function useGaesupAnimation({ type, }: {
+    type: "character" | "vehicle" | "airplane";
+}): {
+    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,95 @@
+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(_a) {
+    var type = _a.type;
+    var animationState = useContext(GaesupWorldContext).animationState;
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var getAnimationTag = function (tag) {
+        var animation = animationState[type].store[tag];
+        if (!animation)
+            return { name: animationState[type].default, isValid: false };
+        if (animation.condition()) {
+            return { name: animation.animationName, isValid: true };
+        }
+        else {
+            return { name: animationState[type].default, isValid: false };
+        }
+    };
+    var notify = function () {
+        var tag = animationState[type].default;
+        for (var _i = 0, _a = Object.keys(animationState[type].store); _i < _a.length; _i++) {
+            var key = _a[_i];
+            var checked = getAnimationTag(key);
+            if (checked.isValid) {
+                tag = checked.name;
+                break;
+            }
+        }
+        animationState[type].current = tag;
+        dispatch({
+            type: "update",
+            payload: {
+                animationState: __assign({}, animationState),
+            },
+        });
+        return tag;
+    };
+    var unsubscribe = function (tag) {
+        delete animationState[type].store[tag];
+        dispatch({
+            type: "update",
+            payload: {
+                animationState: __assign({}, animationState),
+            },
+        });
+    };
+    var subscribe = function (_a) {
+        var tag = _a.tag, condition = _a.condition, action = _a.action, animationName = _a.animationName, key = _a.key;
+        animationState[type].store[tag] = {
+            condition: condition,
+            action: action || (function () { }),
+            animationName: animationName || tag,
+            key: key || tag,
+        };
+        dispatch({
+            type: "update",
+            payload: {
+                animationState: __assign({}, animationState),
+            },
+        });
+    };
+    var subscribeAll = function (props) {
+        props.forEach(function (item) {
+            animationState[type].store[item.tag] = {
+                condition: item.condition,
+                action: item.action,
+                animationName: item.animationName,
+                key: item.key,
+            };
+        });
+        dispatch({
+            type: "update",
+            payload: {
+                animationState: __assign({}, animationState),
+            },
+        });
+    };
+    return {
+        subscribe: subscribe,
+        subscribeAll: subscribeAll,
+        store: animationState[type].store,
+        unsubscribe: unsubscribe,
+        notify: notify,
+    };
+}

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { activeStateType, modeType, urlsType } from "../../world/context/type";
+export declare function useGaesupController(): gaesupPassivePropsType;
+export type gaesupPassivePropsType = {
+    state: activeStateType;
+    mode: modeType;
+    urls: urlsType;
+    currentAnimation: string;
+    children?: React.ReactNode;
+};

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

@@ -0,0 +1,14 @@
+// "Please use this only as a subcomponent of GaesupWorld."
+import { useContext } from "react";
+import { GaesupWorldContext } from "../../world/context";
+export function useGaesupController() {
+    var worldContext = useContext(GaesupWorldContext);
+    return {
+        state: worldContext.activeState,
+        mode: worldContext.mode,
+        urls: worldContext.urls,
+        currentAnimation: worldContext.mode.type
+            ? worldContext.animationState[worldContext.mode.type].current
+            : "idle",
+    };
+}

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

@@ -0,0 +1,25 @@
+import * as THREE from "three";
+import { GLTFResult } from "../../component/type";
+import { urlsType } from "../../world/context/type";
+export type gltfAndSizeType = {
+    size: THREE.Vector3;
+    setSize: (size: THREE.Vector3, keyName?: string) => void;
+    getSize: () => THREE.Vector3;
+};
+export type useGltfAndSizeType = {
+    url: string;
+};
+export declare const useGltfAndSize: ({ url }: useGltfAndSizeType) => {
+    gltf: GLTFResult;
+    size: THREE.Vector3;
+    setSize: (size?: THREE.Vector3, keyName?: string) => THREE.Vector3;
+    getSize: (keyName?: string) => THREE.Vector3;
+};
+export declare const useGaesupGltf: () => {
+    getSizesByUrls: (urls?: urlsType) => {
+        characterUrl?: THREE.Vector3;
+        vehicleUrl?: THREE.Vector3;
+        airplaneUrl?: THREE.Vector3;
+        wheelUrl?: THREE.Vector3;
+    };
+};

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

@@ -0,0 +1,73 @@
+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 { useGLTF } from "@react-three/drei";
+import { useContext } from "react";
+import * as THREE from "three";
+import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context";
+export var useGltfAndSize = function (_a) {
+    var url = _a.url;
+    var sizes = useContext(GaesupWorldContext).sizes;
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var gltf = useGLTF(url);
+    var scene = gltf.scene;
+    var makeGltfSize = function () {
+        return new THREE.Box3().setFromObject(scene).getSize(new THREE.Vector3());
+    };
+    // getter
+    var getSize = function (keyName) {
+        var key = keyName || url;
+        if (key in sizes) {
+            return sizes[key];
+        }
+        else {
+            return null;
+        }
+    };
+    // setter
+    var setSize = function (size, keyName) {
+        var key = keyName || url;
+        if (!(key in sizes)) {
+            sizes[key] = size || makeGltfSize();
+            dispatch({
+                type: "update",
+                payload: {
+                    sizes: __assign({}, sizes),
+                },
+            });
+            return sizes[key];
+        }
+        else {
+            return sizes[key];
+        }
+    };
+    return { gltf: gltf, size: setSize(), setSize: setSize, getSize: getSize };
+};
+export var useGaesupGltf = function () {
+    var sizes = useContext(GaesupWorldContext).sizes;
+    // get size by url
+    var getSizesByUrls = function (urls) {
+        var matchedSizes = {};
+        if (!urls)
+            return matchedSizes;
+        Object.keys(urls).forEach(function (key) {
+            var url = urls[key];
+            if (url in sizes) {
+                matchedSizes[key] = sizes[url];
+            }
+            else {
+                matchedSizes[key] = null;
+            }
+        });
+        return matchedSizes;
+    };
+    return { getSizesByUrls: getSizesByUrls };
+};

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

@@ -0,0 +1,39 @@
+import { joyStickBallType, joyStickOriginType } from "../../tools/joyStick/type";
+export declare const joyStickBallDefault: {
+    top: string;
+    left: string;
+};
+export declare const joyStickOriginDefault: {
+    x: number;
+    y: number;
+    angle: number;
+    currentRadius: number;
+    originRadius: number;
+    isIn: boolean;
+    isOn: boolean;
+    isUp: boolean;
+    isCenter: boolean;
+};
+export declare const joyStickInnerDefault: {
+    joyStickBall: {
+        top: string;
+        left: string;
+    };
+    joyStickOrigin: {
+        x: number;
+        y: number;
+        angle: number;
+        currentRadius: number;
+        originRadius: number;
+        isIn: boolean;
+        isOn: boolean;
+        isUp: boolean;
+        isCenter: boolean;
+    };
+};
+export default function useJoyStick(): {
+    joyStickOrigin: joyStickOriginType;
+    joyStickBall: joyStickBallType;
+    setBall: (ball: joyStickBallType) => void;
+    setOrigin: (origin: joyStickOriginType) => void;
+};

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

@@ -0,0 +1,61 @@
+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 var joyStickBallDefault = {
+    top: "50%",
+    left: "50%",
+};
+export var joyStickOriginDefault = {
+    x: 0,
+    y: 0,
+    angle: Math.PI / 2,
+    currentRadius: 0,
+    originRadius: 0,
+    isIn: true,
+    isOn: false,
+    isUp: true,
+    isCenter: true,
+};
+export var joyStickInnerDefault = {
+    joyStickBall: joyStickBallDefault,
+    joyStickOrigin: joyStickOriginDefault,
+};
+export default function useJoyStick() {
+    var joystick = useContext(GaesupWorldContext).joystick;
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var joyStickBall = joystick.joyStickBall, joyStickOrigin = joystick.joyStickOrigin;
+    var setBall = function (ball) {
+        joystick.joyStickBall = Object.assign(joyStickBall, ball);
+        dispatch({
+            type: "update",
+            payload: {
+                joystick: __assign(__assign({}, joystick), { joyStickBall: __assign({}, joystick.joyStickBall) }),
+            },
+        });
+    };
+    var setOrigin = function (origin) {
+        joystick.joyStickOrigin = Object.assign(joyStickOrigin, origin);
+        dispatch({
+            type: "update",
+            payload: {
+                joystick: __assign(__assign({}, joystick), { joyStickOrigin: __assign({}, joystick.joyStickOrigin) }),
+            },
+        });
+    };
+    return {
+        joyStickOrigin: joyStickOrigin,
+        joyStickBall: joyStickBall,
+        setBall: setBall,
+        setOrigin: setOrigin,
+    };
+}

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

@@ -0,0 +1,3 @@
+export declare function usePushKey(): {
+    pushKey: (key: string, value: boolean) => void;
+};

package/dist/gaesup/hooks/usePushKey/index.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);
+};
+import { useContext } from "react";
+import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context";
+export function usePushKey() {
+    var control = useContext(GaesupWorldContext).control;
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var pushKey = function (key, value) {
+        control[key] = value;
+        dispatch({
+            type: "update",
+            payload: {
+                control: __assign({}, control),
+            },
+        });
+    };
+    return {
+        pushKey: pushKey,
+    };
+}

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;
+};