Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@oogg/scripting

Package Overview
Dependencies
Maintainers
2
Versions
2
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@oogg/scripting - npm Package Compare versions

Comparing version 0.0.0 to 0.0.1

api-report.md
tutorial.md

796

index.d.ts

@@ -1,4 +0,5 @@

/// <reference types="node" />
/// <reference types="react" />
import { Audio as Audio_2 } from 'three';
import { BaseRoomState } from '@oogg/game-mp-shared';
import { Box3 } from 'three';

@@ -8,9 +9,16 @@ import { BoxGeometry } from 'three';

import { BufferGeometry } from 'three';
import { CharacterCollision } from '@dimforge/rapier3d';
import { CircleGeometry } from 'three';
import { Clock } from 'three';
import { Color } from 'three';
import { Euler } from 'three';
import EventEmitter from 'events';
import { Firestore } from 'firebase/firestore';
import { GameAction } from '@oogg/game-mp-shared';
import { Group } from 'three';
import _gsap from 'gsap';
import { InterpolatedSnapshot } from '../../game-snapshots/src';
import { InterpolationResolver } from '../../game-snapshots/src';
import { Interpolator } from '@oogg/game-snapshots';
import { JSX as JSX_2 } from 'react';
import { MapSchema } from '@colyseus/schema';
import { Material } from 'three';

@@ -25,2 +33,5 @@ import { Matrix4 } from 'three';

import { PlaneGeometry } from 'three';
import { PlayerData as PlayerData_3 } from '@oogg/players';
import { PlayerManager } from '@oogg/players';
import { PlayerWrapper as PlayerWrapper_2 } from '@oogg/players';
import { Quaternion } from 'three';

@@ -36,2 +47,115 @@ import { Ray } from 'three';

declare class AbstractCamera extends PerspectiveCamera {
constructor(fov: any, aspect: any, near: any, far: any);
resizeEvent: any;
resize(w: any, h: any): void;
}
declare class AnimatedWrapper {
constructor(meshes: any, opts?: {});
data: any;
factory: any;
isLOD: boolean;
plugins: any;
main: boolean;
ignoreLOD: boolean;
textureIndex: number;
runThresholdCount: number;
runThresholdCountMax: number;
picture: any;
_url: any;
set url(arg: any);
get url(): any;
_atlas: {
x: number;
y: number;
z: number;
w: number;
};
usePFPs: any;
headPosition: Vector3;
originalHeadPosition: Vector3;
originalHipPosition: Vector3;
originalSpinePosition: Vector3;
hipPosition: Vector3;
legPosition: Vector3;
spinePosition: Vector3;
isMixerVRM: boolean;
highQualityMeshes: any;
firstFrame: boolean;
actionConfirmation: number;
_position: Vector3;
_opacity: number;
_rotation: number;
_color: any;
_visible: boolean;
floorVelocity: number;
lastFloorVelocityPosition: Vector3;
smoothedFloorVelocity: number;
currentAnimationIndex: number;
currentAction: any;
lastAction: any;
onFloor: boolean;
isJumping: boolean;
currentEmote: any;
emoteResolve: (value: any) => void;
isSitting: boolean;
outOfFloorAttempt: number;
now: number;
_animations: number[];
_scale: Vector3;
baseScaleRatio: number;
prevScaleVal: any;
set position(arg: Vector3);
get position(): Vector3;
updateVRM(meshes: any, first?: boolean): void;
vrmName: any;
gltf: any;
vrm: any;
isVersion0: boolean;
absoluteRatio: any;
metaIds: any[];
setScale(val: any, force?: boolean): void;
vrmScale: number;
getScale(): number;
playEmote: (emote: any) => Promise<any>;
setAnimation(animName: any): void;
stopEmote: () => void;
setPlayerOnFloor(val: any): void;
setPlayerIsJumping(val: any): void;
setCurrentAction(action: any, force?: boolean): void;
fadeToAction(previousAction: any, activeAction: any, duration: any): void;
set color(arg: any);
get color(): any;
set visible(arg: boolean);
get visible(): boolean;
set opacity(arg: number);
get opacity(): number;
set animations(arg: number[]);
get animations(): number[];
set rotation(arg: number);
get rotation(): number;
set rotationY(arg: number);
get rotationY(): number;
set atlas(arg: {
x: number;
y: number;
z: number;
w: number;
});
get atlas(): {
x: number;
y: number;
z: number;
w: number;
};
set scale(arg: Vector3);
get scale(): Vector3;
dispose(): void;
update(url: any, data: any): Promise<void>;
save(): void;
saved: any;
restore(): void;
}
declare class AudioComponent extends Component3D {

@@ -70,4 +194,9 @@ #private;

updateEvent: any;
_factory: any;
constructor(opts: any);
init(): Promise<void>;
set avatarScale(scale: number);
get avatarScale(): number;
update3D(): void;
_legacy_idx_to_name(idx: any): string;
get animation(): any;

@@ -80,6 +209,7 @@ set animation(value: any);

get visible(): boolean;
getBBox(): any;
getBBox(): Vector3;
_collisionMesh: any;
getCollisionMesh(): Mesh<BoxGeometry, MeshBasicMaterial, Object3DEventMap>;
getDimensions(): any;
updateVRM(url: any): Promise<void>;
getDimensions(): Vector3;
updateVRM(url: any, data?: {}): Promise<void>;
dispose(): void;

@@ -92,3 +222,7 @@ }

constructor(opts?: {});
vrm: any;
/**
* @type {import("engine/components/avatar/vrm/wrapper").default}
*/
vrm: AnimatedWrapper;
userNameFactory: any;
picture: any;

@@ -104,4 +238,4 @@ _text: any;

get position(): Vector3;
set rotation(arg: any);
get rotation(): any;
set rotation(arg: number);
get rotation(): number;
loadPicture(val: any): Promise<any>;

@@ -116,3 +250,3 @@ name: any;

get visible(): boolean;
updateVRM(url: any): Promise<void>;
updateVRM(url: any, data: any): Promise<void>;
dispose(): void;

@@ -152,3 +286,6 @@ }

export declare let Camera: PerspectiveCamera;
/**
* @public
*/
export declare let Camera: MainCamera;

@@ -164,2 +301,20 @@ declare interface CCObject extends Object3D {

export declare class CGameClient<S extends BaseRoomState = any, CM = any, RM = any> {
opts: {
roomId: string;
gameId: string;
playerManager: PlayerManager;
};
constructor(opts: {
roomId: string;
gameId: string;
playerManager: PlayerManager;
});
join(opts: {
host: string;
roomId?: string;
disableSnapshots?: boolean;
}): GameRoom<S, CM, RM>;
}
/**

@@ -169,12 +324,45 @@ * @public

export declare class CharacterController {
#private;
private _rapierController;
private _rapierWorld;
velocity: Vector3;
controlVelocity: Vector3;
previousVelocity: Vector3;
rotation: Euler;
dampling: number;
forces: any[];
accumulator: number;
gravity: Vector3;
onFloor: boolean;
private _opts;
constructor(opts?: CharacterOptions);
constructor(opts?: Partial<CharacterOptions>);
getCCState(object: CCObject): CCObjectState;
updateGravity(object: CCObject, velocity: Vector3, dt: number): CCObjectState;
update(object: CCObject, velocity: Vector3, dt: number, collisions?: any[]): CCObjectState;
update(object: CCObject, velocity: Vector3, _gravityFunc: any, dt: number, onCollision?: (collision: CharacterCollision) => void, elapsedTime?: number): CCObjectState;
castCallback(collider: any, now: any, onCollision: any, collision: any, delta: any, playerCollider: any): void;
castSensors(rigidbody: any, rpos: any, collider: any): any[];
negateForces(onFloor: any): void;
applyForces(vel: any, deltaTime: any, options?: {}): void;
setForce(velocity?: {
x: number;
y: number;
z: number;
}, opts?: {
unique: any;
dampling: number;
once: boolean;
negateOnFloor: {
xz: boolean;
y: boolean;
};
override: {
xz: boolean;
y: boolean;
};
overrideJumpVelocity: boolean;
overrideVelocity: boolean;
}): void;
setRotationForce(direction: any): void;
setRebound(normal: any, opts?: {
force: number;
}): void;
removeForce(force: any): void;
}

@@ -184,2 +372,52 @@

declare class CircleComponent extends Component3D {
_factory: CircleFactory;
_circle: any;
constructor(opts: any);
init(): Promise<void>;
collision: any;
onCollisionCallback: (player: any, collision: any) => void;
getCollisionMesh(): any;
dispose(): void;
}
declare class CircleFactory {
isInit: boolean;
_init: boolean;
_instances: {};
preload(): Promise<void>;
geometry: CircleGeometry;
get(parent: any, data?: {}): Promise<InstancedMeshWrapper>;
_isInit: boolean;
initialisation: Promise<void>;
mesh: InstancedPipelineMesh;
onCollision(collision: any): void;
buildCollisionMesh: () => Mesh<CircleGeometry, MeshBasicMaterial, Object3DEventMap>;
_material: MeshBasicMaterial;
_collisionMesh: Mesh<CircleGeometry, MeshBasicMaterial, Object3DEventMap>;
disposeAll(): void;
}
declare class CloudComponent extends Component3D {
_factory: CloudFactory;
_platform: any;
constructor(opts: any);
init(): Promise<void>;
collision: any;
onCollisionCallback: (player: any, collision: any) => void;
getCollisionMesh(): any;
dispose(): void;
}
declare class CloudFactory {
isInit: boolean;
_init: boolean;
_instances: {};
preload(): Promise<void>;
get(parent: any, data?: {}): Promise<any>;
_isInit: boolean;
initialisation: Promise<void>;
disposeAll(): void;
}
declare class Collider {

@@ -202,2 +440,3 @@ private engine;

radius: number;
center: any;
};

@@ -215,3 +454,3 @@ vertices: TypedArray;

private createColliderDesc;
setGroups(groups: number[]): void;
setGroups(membership: number[], filter: number[]): void;
private createBody;

@@ -390,2 +629,3 @@ set enabledTranslation(enabledTranslation: [boolean, boolean, boolean]);

private _postLoadTasks;

@@ -398,3 +638,7 @@ private _componentsByScriptId;

private factoryPromises;
getFactory(type: any): Promise<any>;
private getFactoryType;
addLoadTask(promise: Promise<any>): void;

@@ -504,2 +748,5 @@

/**
* @public
*/
export declare let Components: ComponentManager;

@@ -523,7 +770,17 @@

image: ImageComponent;
wind: WindComponent;
kitbash: KitBashComponent;
script: ScriptComponent;
avatar: AvatarComponent;
wave: WaterComponent;
magenticfield: MagneticFieldComponent;
platform: PlatformComponent;
cloud: CloudComponent;
circle: CircleComponent;
dust: DustComponent;
};
/**
* @public
*/
export declare let Controls: ControlsFactory;

@@ -560,2 +817,12 @@

declare function Counter({ color, endColor, xp, pts, icon, }: CounterProps): JSX_2.Element;
declare type CounterProps = {
color?: string;
endColor?: string;
xp?: number;
pts?: number;
icon?: string;
};
declare type CType = keyof ComponentTypes;

@@ -565,3 +832,4 @@

constructor(opts: any);
set active(value: any);
get active(): boolean;
set active(value: boolean);
}

@@ -582,2 +850,4 @@

};
maxVelocity: number;
dampling: number;
};

@@ -617,2 +887,11 @@

declare class DustComponent extends Component3D {
#private;
init(): Promise<void>;
dispose(): void;
}
/**
* @public
*/
export declare let Emitter: {

@@ -629,2 +908,35 @@ on: (name: string, callback: Function) => void;

declare function EventEmitter(): void;
declare class EventEmitter {
_events: any;
_eventsCount: number;
_maxListeners: number;
setMaxListeners(n: any): EventEmitter;
getMaxListeners(): any;
emit(type: any, ...args: any[]): boolean;
addListener(type: any, listener: any): any;
on: any;
prependListener(type: any, listener: any): any;
once(type: any, listener: any): EventEmitter;
prependOnceListener(type: any, listener: any): EventEmitter;
removeListener(type: any, listener: any): EventEmitter;
off: any;
removeAllListeners(type: any, ...args: any[]): EventEmitter;
listeners(type: any): any[];
rawListeners(type: any): any[];
listenerCount: typeof listenerCount;
eventNames(): any;
}
declare namespace EventEmitter {
{ EventEmitter };
const defaultMaxListeners: number;
function init(): void;
function listenerCount(emitter: any, type: any): any;
}
/**
* @public
*/
export declare let Events: typeof ScriptEvents;

@@ -705,2 +1017,97 @@

export declare const GameClient: CGameClient<any, any, any>;
export declare class GameRoom<S extends BaseRoomState = any, RM = any, CM = any> {
opts: {
host: string;
roomId: string;
partyId: string;
gameId: string;
playerManager: PlayerManager;
disableSnapshots?: boolean;
timeout?: number;
};
GAME_ACTIONS: {
readonly START: 1;
readonly STOP: 2;
};
private _socket;
private _serializer;
private _status;
private _lastError;
private _emitter;
private _sessionId;
private _tickRate;
private _synced;
private _ready;
private _interpolator;
private _playerStateSync;
private _connectDeferred;
constructor(opts: {
host: string;
roomId: string;
partyId: string;
gameId: string;
playerManager: PlayerManager;
disableSnapshots?: boolean;
timeout?: number;
});
private _connect;
private _utf8Length;
private get _roomState();
private _bytesQueue;
stats: {
bytes: number;
mb: number;
mbs: number;
};
private _MB;
private _computeStats;
private _handleRawMsg;
private _handleDecodedMsg;
private _handleJoin;
private _handleLeave;
private _addSnapshot;
private _syncPlayers;
private _addPlayerToScene;
private _removePlayerFromScene;
private _sendSocket;
get ready(): Promise<void>;
get host(): string;
get roomId(): string;
get status(): "disconnected" | "connecting" | "connected";
get lastError(): string;
get sessionId(): string;
get tickRate(): number;
get synced(): boolean;
get state(): S;
get isHost(): boolean;
private _handleConnect;
private _handleDisconnect;
leave(): void;
send(data: CM): void;
private _requestGameAction;
requestStart(countdown: number): void;
private _onEventFiltered;
private _onGameActionFilter;
onGameAction(listener: (action: GameAction) => unknown): () => void;
onStart(listener: (data: any) => unknown): () => void;
onStop(listener: (data: any) => unknown): () => void;
onMessage(listener: (data: any) => unknown): () => void;
onConnect(listener: () => void): () => void;
onDisconnect(listener: () => void): () => void;
onSync(listener: () => void): () => void;
onState(listener: () => void): () => void;
onPlayerJoined(listener: (data: PlayerWrapper_2) => void): () => void;
onPlayerLeft(listener: (data: {
sessionId: string;
}) => void): () => void;
get interpolator(): Interpolator;
_defaultSelector: (state: S) => MapSchema<PlayerData_3, string>;
getPlayerStateSync(selector?: (state: S) => Record<string, any>): PlayerStateSync;
}
/**
* @public
*/
export declare let GameStorage: GameStorageApi;

@@ -725,2 +1132,5 @@

/**
* @public
*/
declare let gsap_2: typeof _gsap;

@@ -757,2 +1167,8 @@ export { gsap_2 as gsap }

declare interface IndicatorImgProps {
name: string;
width?: number;
height?: number;
}
declare class InstancedMeshWrapper {

@@ -764,2 +1180,5 @@ constructor(mesh: any, geometry: any, id: any, opts: any);

opts: any;
_dynamicShadow: boolean;
set dynamicShadow(arg: boolean);
get dynamicShadow(): boolean;
scale: Vector3;

@@ -826,16 +1245,11 @@ color: Color;

declare type KitBashBaseItem = {
name: string;
mesh: InstancedPipelineMesh;
collision: Mesh<BufferGeometry, Material>;
raycastGeometry: BufferGeometry;
};
declare class KitBashComponent extends Component3D {
instances: InstancedMeshWrapper[];
collisionMesh: Mesh;
_kitbashType: KitBashElementType;
_kitbashType: any;
_title: string;
constructor(opts: KitBashElementOpts);
init(): Promise<void>;
setPlugins(item: any, val: any): void;
getPlugins(item: any): any;
getCollisionMesh(): Mesh<BufferGeometry<NormalBufferAttributes>, Material | Material[], Object3DEventMap>;

@@ -848,14 +1262,5 @@ update3D(): void;

declare interface KitBashElementOpts extends ComponentOpts {
kitbashType: KitBashElementType;
kitbashType: any;
}
declare type KitBashElementType = {
baseItems: KitBashBaseItem[];
baseBox: Box3;
collision: Mesh;
raycastGeometry: BufferGeometry;
previewImg?: string;
accessors?: Array<any>;
};
declare class LightingComponent extends Component3D {

@@ -869,2 +1274,50 @@ init(): Promise<void>;

declare function listenerCount(type: any): any;
declare class MagneticFieldComponent extends Component3D {
_factory: MagneticFieldFactory;
_mesh: MagneticFieldMesh;
constructor(opts: any);
init(): Promise<void>;
get color(): any;
set color(value: any);
get radius(): number;
set radius(value: number);
dispose(): void;
}
declare class MagneticFieldFactory {
preload(): Promise<void>;
get(data?: {}): Promise<MagneticFieldMesh>;
disposeAll(): void;
}
declare class MagneticFieldMesh extends Mesh<BufferGeometry<NormalBufferAttributes>, Material | Material[], Object3DEventMap> {
constructor(opts?: {});
set color(arg: any);
get color(): any;
set radius(arg: number);
get radius(): number;
}
/**
* @public
*/
declare class MainCamera extends AbstractCamera {
/**
* @param {"firstperson" | "thirdperson"} type - camera mode
*/
set mode(arg: "firstperson" | "thirdperson");
get mode(): "firstperson" | "thirdperson";
controls: any;
set target(arg: any);
get target(): any;
set maxZoomOut(arg: any);
get maxZoomOut(): any;
set heightOffset(arg: any);
get heightOffset(): any;
getShadowTarget(): any;
reset(): void;
}
declare class MeshComponent extends Component3D {

@@ -898,2 +1351,4 @@ #private;

updateToInstance(res: any, data: any): any[];
flattenScene(scene: any): void;
traverseHierarchy(object: any, parentMatrix: any): void;
flattenSceneHierarchy(res: any): void;

@@ -909,2 +1364,3 @@ computeBoundingSphere(object: any): Sphere;

center(object: any): void;
removeInstance(wrapper: any): void;
dispose(wrapper: any): void;

@@ -915,2 +1371,7 @@ disposeAll(): void;

export declare const OOUI: any;
/**
* @public
*/
export declare let Physics: PhysicsManager;

@@ -1032,2 +1493,13 @@

declare class PlatformComponent extends Component3D {
_factory: PlatformFactory;
_platform: any;
constructor(opts: any);
init(): Promise<void>;
collision: any;
onCollisionCallback: (player: any, collision: any) => void;
getCollisionMesh(): any;
dispose(): void;
}
declare class PlatformerControlsWrapper extends ControlsAbstract {

@@ -1043,2 +1515,4 @@ private quaternion;

private prevJumpKeyState;
private lastAnim;
private airTime;
private reachedPeak;

@@ -1054,8 +1528,12 @@ private jumpDuration;

currentSpeed: number;
mass: number;
isMoving: boolean;
isJumping: boolean;
hasJump: boolean;
collidesWith: any[];
gravity: Vector3;
private characterController;
autoAnimate: boolean;
actions: {
_seq: number;
forward: boolean;

@@ -1073,2 +1551,3 @@ backward: boolean;

acceleration: number;
boost: number;
deceleration: number;

@@ -1092,2 +1571,6 @@ slide: number;

};
ccState: {
onFloor: boolean;
yVelocity: number;
};
constructor(opts: any);

@@ -1100,15 +1583,54 @@ set active(value: boolean);

update: (deltaTime: any) => void;
staticUpdate(deltaTime: any): void;
_getDirection(): void;
_run(deltaTime: any): void;
_dynamicJump(deltaTime: any): boolean;
_gravity(deltaTime: any, vel: any, elapsed: any): void;
_jump(deltaTime: any): void;
_rotation(deltaTime: any): void;
pushCollider: (collision: CharacterCollision) => void;
_correct(deltaTime: any): void;
_animation(): void;
_animation(delta: any): void;
}
declare class PlatformFactory {
isInit: boolean;
_init: boolean;
_instances: {};
preload(): Promise<void>;
gltf: any;
get(parent: any, data?: {}): Promise<InstancedMeshWrapper>;
_isInit: boolean;
initialisation: Promise<void>;
object: any;
mesh: InstancedPipelineMesh;
onCollision(collision: any): void;
buildCollisionMesh: () => Mesh<any, MeshBasicMaterial, Object3DEventMap>;
_material: MeshBasicMaterial;
_collisionMesh: Mesh<any, MeshBasicMaterial, Object3DEventMap>;
disposeAll(): void;
}
/**
* @public
*/
export declare let Player: PlayerWrapper;
declare const PLAYER_ROLES: {
readonly host: "host";
readonly player: "player";
};
declare interface PlayerAvatarOpts {
collision?: boolean;
avatarScale?: number;
}
/**
* @public
*/
export declare interface PlayerData {
main?: boolean;
id: string;
sessionId: string;
userId?: string;
name: string;

@@ -1118,2 +1640,15 @@ vrmUrl?: string;

isAnonymous?: boolean;
role?: PlayerRole;
latency: number;
position: {
x: number;
y: number;
z: number;
};
rotation: {
x: number;
y: number;
z: number;
};
animation: string;
}

@@ -1129,21 +1664,100 @@

declare type PlayerRole = keyof typeof PLAYER_ROLES;
declare interface PlayerState {
id: string;
position: XYZ;
rotation: XYZ;
animation: string;
}
declare type PlayerStateMap = Record<string, PlayerState>;
declare class PlayerStateSync {
prevPast: number;
packetsPerSecs: number;
sendFrame: number;
delta: number;
playerManager: PlayerManager;
gameClient: GameRoom<any>;
_iresolver: InterpolationResolver;
localPayload: {
type: string;
position: {
x: number;
y: number;
z: number;
};
rotation: {
x: number;
y: number;
z: number;
};
animation: string;
};
constructor(config: {
client: GameRoom<any, any>;
selector: (s: any) => PlayerStateMap;
});
_target: InterpolatedSnapshot;
update(delta: number): void;
getPayload: () => {
type: string;
position: {
x: number;
y: number;
z: number;
};
rotation: {
x: number;
y: number;
z: number;
};
animation: string;
};
dispose(): void;
}
/**
* @public
*/
export declare class PlayerWrapper {
#private;
id: string;
name: string;
isAnonymous: boolean;
data: PlayerData;
avatarData: any;
avatarReady: Promise<AvatarComponent_2>;
avatar: AvatarComponent_2;
space: Space;
private _colliderData;
private _avatarScale;
constructor(opts: {
data: PlayerData;
avatarOpts?: PlayerAvatarOpts;
});
get sessionId(): string;
get userId(): string;
get name(): string;
get isAnonymous(): boolean;
get isHost(): boolean;
private getAvatarData;
setAvatarData(data: any): void;
init(opts: {
space: Space;
}): void;
}): Promise<ComponentTypes>;
update(): void;
dispose(): void;
}
export declare namespace Plugins {
export namespace VISUALS {
{ DissolvePlugin };
{ RainbowPlugin };
{ RotateAndDissolvePlugin };
{ ShrinkPlugin };
}
export namespace PHYSICS {
{ BalancerPhysics };
}
}
declare class PostProcessingComponent extends Component3D {

@@ -1155,2 +1769,19 @@ init(): Promise<void>;

declare function Power({ icon, className, active, title, color, children, ...rest }: PowerProps): React_2.JSX.Element;
declare type PowerProps = ProgressProps & {
className: string;
icon?: string;
active?: boolean;
title?: string;
color?: string;
children?: React_2.ReactNode;
};
declare type ProgressProps = {
level: string;
background?: string;
className?: string;
};
declare function Prompt({ title, className, children, style, }: PromptProps): React_2.JSX.Element;

@@ -1184,2 +1815,3 @@

declare const RIGIDBODY_TYPES: Readonly<{
DYNAMIC_PLAYER: "DYNAMIC_PLAYER";
DYNAMIC: "DYNAMIC";

@@ -1212,2 +1844,3 @@ KINEMATIC: "KINEMATIC";

WHEEL: string;
GAME_SPACE_LOADED: string;
GAME_INIT: string;

@@ -1217,2 +1850,8 @@ GAME_READY: string;

GAME_DISPOSE: string;
GAME_END: string;
GAME_PAUSE: string;
GAME_UPDATE: string;
GAME_RESUME: string;
GAME_NOTIFY_PAUSE: string;
GAME_NOTIFY_RESUME: string;
};

@@ -1250,5 +1889,4 @@

*/
export declare class Space extends Group<Object3DEventMap> {
export declare class Space extends AugmentedGroup {
constructor(opts: any);
_api: {};
/**

@@ -1269,3 +1907,7 @@ * @type { ComponentManager }

get envMap(): any;
start(): void;
start(payload?: any): void;
stop(payload?: any): void;
pause(payload?: any): void;
resume(payload?: any): void;
dispose(): void;
#private;

@@ -1305,7 +1947,5 @@ }

materials: any;
mesh: any;
geometryNeedsUpdate: boolean;
textureNeedsUpdate: boolean;
mesh: PipeLineMesh;
init(): Promise<void>;
getCollisionMesh(): any;
getCollisionMesh(): PipeLineMesh;
getBBox(box?: Box3): Box3;

@@ -1320,3 +1960,4 @@ update3D(): Promise<void>;

updateTexturing(): Promise<void>;
computeGeometry(): Promise<unknown>;
computeGeometry(): Promise<void>;
computeNoiseGeometryInWorker(): Promise<unknown>;
dispose(): void;

@@ -1328,2 +1969,3 @@ }

init(): Promise<void>;
update(opts?: {}): void;
getFontParams(): {

@@ -1347,2 +1989,3 @@ font: any;

maxZoomOut: number;
heightOffset: number;
private targetRadius;

@@ -1361,10 +2004,11 @@ private idealCameraPosition;

private playerCameraWorldDir;
raycast: (ray: any) => {
distance: number;
};
ray: Ray;
private minRatioToRotateY;
private nearPlaneCorners;
private world;
private cameraDistance;
constructor(opts: any);
raycast(origin: any, direction: any, distance: any): {
distance: number;
};
set active(value: boolean);

@@ -1390,2 +2034,18 @@ get active(): boolean;

declare function Tutorial({ data, className, title, onClick, }: TutorialProps): React_2.JSX.Element;
declare type TutorialProps = {
title: string;
data: Array<{
id: string;
image: string;
description: string;
}>;
className?: string;
onClick: () => void;
};
/**
* @public
*/
export declare const UI: {

@@ -1398,3 +2058,7 @@ getRoot(container?: HTMLElement): {

Heading: typeof Heading;
Power: typeof Power;
Prompt: typeof Prompt;
Counter: typeof Counter;
Tutorial: typeof Tutorial;
IndicatorImg: ({ name, width, height }: IndicatorImgProps) => JSX_2.Element;
};

@@ -1411,4 +2075,34 @@

declare class WindComponent extends Component3D {
#private;
static getInfo(): void;
init(): Promise<void>;
update3D(): void;
onCollisionCallback: (player: any, collision: any) => void;
getCollisionDimension(): {
radius: any;
height: number;
};
getCollisionMesh(): WindMesh;
dispose(): void;
}
declare class WindMesh extends PipeLineMesh {
constructor(opts: any);
}
/**
* @public
*/
export declare let World: Space;
declare type XYZ = {
x: number;
y: number;
z: number;
};
export * from "@oogg/game-mp-shared/src/types";
export { }

2

package.json
{
"name": "@oogg/scripting",
"version": "0.0.0",
"version": "0.0.1",
"private": false,

@@ -5,0 +5,0 @@ "types": "./index.d.ts",

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc