VAM Scripter

Provides a JavaScript-like scripting environment inside Virt-A-Mate for automating poses, animations, audio, interactions, and scene control with lifecycle a...

Security Scan

The skill's files, documentation, and runtime instructions are consistent with a Virt‑A‑Mate scripting helper and do not request unrelated credentials or risky install behavior.

Purpose & Capability

The name/description (VAM Scripter) matches the provided SKILL.md, API reference, and example scripts. All required functionality (scene, player, keybindings, fs, Time, Random, etc.) is appropriate for an in‑game scripting environment — nothing in the manifest asks for unrelated system access, cloud credentials, or external tooling.

Instruction Scope

SKILL.md and the example scripts limit actions to the VAM API: atom transforms, audio actions, keybindings, timers, and scene‑scoped filesystem reads/writes. The instructions do not ask the agent to read host env vars or system files outside the scene, nor to transmit data to arbitrary external endpoints. (Note: scene.getAudioClip uses a 'URL' type in examples — that implies VAM may reference external audio resources at runtime, but the skill itself does not include any hardcoded network endpoints or exfiltration steps.)

Install Mechanism

There is no install spec that downloads or executes external code; the package is instruction‑ and example‑file based and intended to be copied into the user's skills folder. No archives or remote URLs are fetched by the skill metadata itself.

Credentials

The skill declares no required environment variables, binaries, or credentials. The only persistent access is to scene‑scoped files via the fs module, which the documentation restricts to .txt/.json and scene storage.

Persistence & Privilege

The skill is not marked always:true and does not request elevated platform privileges. It writes/reads a scene file (app-state.json) within the VAM Scripter directory to persist state, which is expected behavior for such a plugin and scoped to the scene area rather than system configuration or other skills.

Assessment

This skill appears coherent and implements in‑game scripting examples for Virt‑A‑Mate. Before installing, review the example scripts (especially state-persistence.js) to confirm you are comfortable with scene‑scoped file writes (app-state.json). If you are concerned about external audio resources, check any uses of getAudioClip(..., "URL", ...) inside your VAM instance to see whether it will fetch remote assets. Because the package comes from an unknown owner, only install if you trust the source or after inspecting the files; otherwise copy individual example scripts you need rather than installing wholesale.

VAM Scripter Skill

Virt-A-Mate Scripter v1.5.1 Language Support

Scripter is a JavaScript-inspired scripting language that runs inside Virt-A-Mate. It provides high-performance scripting without reflection, enabling automation of poses, animations, audio, and interactions.

gotolm

Scripter v1.5.1 - JavaScript-inspired VAM scripting language.

Syntax Overview

Scripter syntax closely resembles JavaScript with these characteristics:

Module System

import { module } from "vam-scripter";
export const name = value;

Variables

const name = value;  // immutable binding
let name = value;    // mutable binding
var name = value;    // mutable binding

Functions

function name(args) { body }
() => { body }       // arrow function syntax

Control Flow

if (condition) { ... } else { ... }
for (init; condition; update) { ... }
while (condition) { ... }
break; continue;

Exception Handling

try { ... } catch (e) { ... }
throw error;

Data Structures

[1, 2, 3]                        // array
{ key: value }                   // object

Core Modules

vam-scripter Module

The main module imported as "vam-scripter" exports:

Export	Type	Description
scripter	Object	Main plugin interface, lifecycle hooks
scene	Object	Scene access (atoms, audio clips)
Time	Object	Unity Time properties
Random	Object	Random number generation
DateTime	Object	Date/Time operations
player	Object	Player (VR/monitor status, hand/head transforms)
keybindings	Object	Keybinding management
Input	Object	Input handling
fs	Object	File system operations

scripter Module

Provides lifecycle hooks and plugin management.

Property/Method	Arguments	Returns	Description
scripter.onUpdate(fn)	fn: () => void	FunctionLink	Run every frame
scripter.onLateUpdate(fn)	fn: () => void	FunctionLink	Run after Update
scripter.onFixedUpdate(fn)	fn: () => void	FunctionLink	Run on physics updates
scripter.onEnable(fn)	fn: () => void	FunctionLink	Run when enabled
scripter.onDisable(fn)	fn: () => void	FunctionLink	Run when disabled
scripter.onDestroy(fn)	fn: () => void	FunctionLink	Run when destroyed
scripter.declareFloatParam(config)	config: {name, default, min, max, constrain, onChange}	FloatParamDeclaration	Create float parameter
scripter.declareStringParam(config)	config: {name, default, onChange}	StringParamDeclaration	Create string parameter
scripter.declareBoolParam(config)	config: {name, default, onChange}	BoolParamDeclaration	Create boolean parameter
scripter.declareAction(name, fn)	name: string, fn: () => void	ActionDeclaration	Create action
scripter.containingAtom	-	AtomReference	Reference to the atom housing the script

scene Module

Provides access to atoms and audio clips in the scene.

Property/Method	Arguments	Returns	Description
scene.getAtom(name)	name: string	AtomReference	Get atom by name/UID
scene.getAtoms()	-	Array<AtomReference>	Get all atoms
scene.getAtomIds()	-	Array<string>	Get all atom UIDs
scene.getAudioClip(type, category, clip)	type: "Embedded|URL", category: string, clip: string	NamedAudioClipReference	Get audio clip

player Module

Provides access to player state and transforms.

Property	Type	Description
player.isVR	boolean	True if in VR mode
player.lHand	TransformReference	Left hand position/rotation
player.rHand	TransformReference	Right hand position/rotation
player.head	TransformReference	Head position/rotation

keybindings Module

Manages keybindings and commands.

Property/Method	Arguments	Returns	Description
keybindings.invokeCommand(name)	name: string	void	Invoke a keybinding action
keybindings.declareCommand(name, fn)	name: string, fn: () => void	KeybindingDeclaration	Declare a new keybinding

fs Module

File system operations for script persistence.

Property/Method	Arguments	Returns	Description
fs.writeSceneFileSync(path, content)	path: string, content: string	void	Write to scene-specific file
fs.readSceneFileSync(path)	path: string	string|undefined	Read scene-specific file
fs.unlinkSceneFileSync(path)	path: string	void	Delete scene-specific file

Time Module

Unity Time properties.

Property	Type	Description
Time.time	float	Time since level load
Time.deltaTime	float	Time since last frame
Time.fixedDeltaTime	float	Fixed timestep for physics

Random Module

Random number generation.

Property/Method	Arguments	Returns	Description
Random.value	-	float	Random float 0.0-1.0
Random.range(min, max)	min, max: int|float	int|float	Random number in range

Math Module

Math utilities (available as Math).

Method	Arguments	Returns	Description
Math.abs, Math.ceil, Math.floor	number	number	Basic math
Math.sin, Math.cos, Math.tan	number	number	Trigonometry
Math.sqrt, Math.pow(base, exp)	number	number	Powers/square root
Math.log, Math.log10	number	number	Logarithms
Math.max, Math.min(...args)	numbers	number	Min/max
Math.random()	-	float	Random 0-1
Math.lerp(start, end, t)	numbers	number	Linear interpolation
Math.clamp(value, min, max)	numbers	number	Clamp value
Math.round, Math.sign	number	number	Rounding/sign

Reference Types

AtomReference

Property/Method	Arguments	Returns	Description
atom.name	-	string	Atom name
atom.type	-	string	Atom type
atom.on	-	boolean	Is atom on
atom.getStorableIds()	-	Array<string>	Get storable IDs
atom.getStorable(name)	name: string	StorableReference	Get storable
atom.getController(name)	name: string	ControllerReference	Get controller
atom.distance(other)	other: AtomReference	float	Distance to another atom

TransformReference

Property/Method	Arguments	Returns	Description
transform.position	-	Vector3	Position
transform.rotation	-	Quaternion	Rotation
transform.forward	-	Vector3	Forward direction
transform.up	-	Vector3	Up direction
transform.right	-	Vector3	Right direction
transform.lookAt(target)	target: TransformReference	void	Rotate to face target
transform.lookAt(x, y, z)	coords: Vector3	void	Rotate to face position

StorableReference

Property/Method	Arguments	Returns	Description
storable.getId()	-	string	Get storable ID
storable.getType()	-	string	Get storable type
storable.getAudioAction(name)	name: string	AudioActionReference	Get audio action

ControllerReference

Property/Method	Arguments	Returns	Description
controller.name	-	string	Controller name
controller.transform	-	TransformReference	Controller transform

AudioActionReference

Property/Method	Arguments	Returns	Description
audioAction.play(clip)	clip: NamedAudioClipReference	void	Play audio clip
audioAction.stop()	-	void	Stop audio

NamedAudioClipReference

Property/Method	Arguments	Returns	Description
clip.name	-	string	Clip name
clip.clip	-	AudioClip	Unity audio clip

Common Patterns

Simple Update Loop

import { scripter, scene } from "vam-scripter";

const ball = scene.getAtom("Ball");
const person = scene.getAtom("Person");

scripter.onUpdate(() => {
    // Run every frame
});

Interaction Detection

import { scripter, scene } from "vam-scripter";

const ball = scene.getAtom("Ball");
const person = scene.getAtom("Person");
const personVoice = person.getStorable("HeadAudioSource").getAudioAction("PlayNow");
const surprisedSound = scene.getAudioClip("URL", "web", "surprised.wav");

scripter.onUpdate(() => {
    if (ball.distance(person) < 0.5) {
        personVoice.play(surprisedSound);
    }
});

Keybinding Handler

import { keybindings, scripter } from "vam-scripter";

const action = scripter.declareAction("MyAction", () => {
    // Handle action
});

keybindings.declareCommand("MyActionKey", () => {
    keybindings.invokeCommand("MyAction");
});

Parameter-Driven Animation

import { scripter, scene } from "vam-scripter";

const person = scene.getAtom("Person");
const head = person.getController("head");

const speedParam = scripter.declareFloatParam({
    name: "Animation Speed",
    default: 1.0,
    min: 0.1,
    max: 5.0,
    onChange: (value) => {
        // Parameter changed
    }
});

File Operations

import { fs, scripter } from "vam-scripter";

const state = JSON.parse(fs.readSceneFileSync("state.json") || "{}");

scripter.onUpdate(() => {
    // Use state
});

scripter.onDisable(() => {
    fs.writeSceneFileSync("state.json", JSON.stringify(state));
});

Date/Time Operations

const now = DateTime.now;
const year = now.year;
const month = now.month;
const day = now.day;

// DateTime properties: year, month, day, hour, minute, second, dayOfWeek

Development Notes

• scripts must be loaded as index.js
• Use import { ... } from "vam-scripter" to access modules
• The language is case-sensitive (JavaScript-style)
• Use // for single-line comments and /* */ for multi-line
• All modules are singletons - each import gets the same reference

Files

• SKILL.md - This documentation
• scripts/ - Sample scripts and patterns
• references/ - API reference details