solanapolis 1.0.0

package/convex/util/minheap.ts

@@ -0,0 +1,38 @@
+// Basic 1-indexed minheap implementation
+export function MinHeap<T>(compare: (a: T, b: T) => boolean) {
+  const tree = [null as T];
+  let endIndex = 1;
+  return {
+    peek: (): T | undefined => tree[1],
+    length: () => endIndex - 1,
+    push: (newValue: T) => {
+      let destinationIndex = endIndex++;
+      let nextToCheck;
+      while ((nextToCheck = destinationIndex >> 1) > 0) {
+        const existing = tree[nextToCheck];
+        if (compare(newValue, existing)) break;
+        tree[destinationIndex] = existing;
+        destinationIndex = nextToCheck;
+      }
+      tree[destinationIndex] = newValue;
+    },
+    pop: () => {
+      if (endIndex == 1) return undefined;
+      endIndex--;
+      const value = tree[1];
+      const lastValue = tree[endIndex];
+      let destinationIndex = 1;
+      let nextToCheck;
+      while ((nextToCheck = destinationIndex << 1) < endIndex) {
+        if (nextToCheck + 1 <= endIndex && compare(tree[nextToCheck], tree[nextToCheck + 1]))
+          nextToCheck++;
+        const existing = tree[nextToCheck];
+        if (compare(existing, lastValue)) break;
+        tree[destinationIndex] = existing;
+        destinationIndex = nextToCheck;
+      }
+      tree[destinationIndex] = lastValue;
+      return value;
+    },
+  };
+}

package/convex/util/object.ts

@@ -0,0 +1,22 @@
+export function parseMap<Id, Serialized, Parsed>(
+  records: Serialized[],
+  constructor: new (r: Serialized) => Parsed,
+  getId: (r: Parsed) => Id,
+): Map<Id, Parsed> {
+  const out = new Map();
+  for (const record of records) {
+    const parsed = new constructor(record);
+    const id = getId(parsed);
+    if (out.has(id)) {
+      throw new Error(`Duplicate ID ${id}`);
+    }
+    out.set(id, parsed);
+  }
+  return out;
+}
+
+export function serializeMap<Serialized, T extends { serialize(): Serialized }>(
+  map: Map<string, T>,
+): Serialized[] {
+  return [...map.values()].map((v) => v.serialize());
+}

package/convex/util/sleep.ts

@@ -0,0 +1,3 @@
+export async function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/convex/util/types.ts

@@ -0,0 +1,33 @@
+import { Infer, v } from 'convex/values';
+
+export const point = v.object({
+  x: v.number(),
+  y: v.number(),
+});
+export type Point = Infer<typeof point>;
+
+export const vector = v.object({
+  dx: v.number(),
+  dy: v.number(),
+});
+export type Vector = Infer<typeof vector>;
+
+// Paths are arrays of [x, y, dx, dy, t] tuples;
+export const path = v.array(v.array(v.number()));
+export type Path = [number, number, number, number, number][];
+
+export type PathComponent = { position: Point; facing: Vector; t: number };
+
+export function queryPath(p: Path, at: number): PathComponent {
+  return unpackPathComponent(p[at]);
+}
+export function packPathComponent(p: PathComponent): [number, number, number, number, number] {
+  return [p.position.x, p.position.y, p.facing.dx, p.facing.dy, p.t];
+}
+export function unpackPathComponent(p: [number, number, number, number, number]): PathComponent {
+  return {
+    position: { x: p[0], y: p[1] },
+    facing: { dx: p[2], dy: p[3] },
+    t: p[4],
+  };
+}

package/convex/util/xxhash.ts

@@ -0,0 +1,228 @@
+/*
+From https://github.com/Jason3S/xxhash
+
+MIT License
+
+Copyright (c) 2019 Jason Dent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+const PRIME32_1 = 2654435761;
+const PRIME32_2 = 2246822519;
+const PRIME32_3 = 3266489917;
+const PRIME32_4 = 668265263;
+const PRIME32_5 = 374761393;
+
+export function toUtf8(text: string): Uint8Array {
+  const bytes: number[] = [];
+  for (let i = 0, n = text.length; i < n; ++i) {
+    const c = text.charCodeAt(i);
+    if (c < 0x80) {
+      bytes.push(c);
+    } else if (c < 0x800) {
+      bytes.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+    } else if (c < 0xd800 || c >= 0xe000) {
+      bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+    } else {
+      const cp = 0x10000 + (((c & 0x3ff) << 10) | (text.charCodeAt(++i) & 0x3ff));
+      bytes.push(
+        0xf0 | ((cp >> 18) & 0x7),
+        0x80 | ((cp >> 12) & 0x3f),
+        0x80 | ((cp >> 6) & 0x3f),
+        0x80 | (cp & 0x3f),
+      );
+    }
+  }
+  return new Uint8Array(bytes);
+}
+
+/**
+ *
+ * @param buffer - byte array or string
+ * @param seed - optional seed (32-bit unsigned);
+ */
+export function xxHash32(buffer: Uint8Array | string, seed = 0): number {
+  buffer = typeof buffer === 'string' ? toUtf8(buffer) : buffer;
+  const b = buffer;
+
+  /*
+        Step 1. Initialize internal accumulators
+        Each accumulator gets an initial value based on optional seed input. Since the seed is optional, it can be 0.
+
+        ```
+            u32 acc1 = seed + PRIME32_1 + PRIME32_2;
+            u32 acc2 = seed + PRIME32_2;
+            u32 acc3 = seed + 0;
+            u32 acc4 = seed - PRIME32_1;
+        ```
+        Special case : input is less than 16 bytes
+        When input is too small (< 16 bytes), the algorithm will not process any stripe. Consequently, it will not
+        make use of parallel accumulators.
+
+        In which case, a simplified initialization is performed, using a single accumulator :
+
+        u32 acc  = seed + PRIME32_5;
+        The algorithm then proceeds directly to step 4.
+    */
+
+  let acc = (seed + PRIME32_5) & 0xffffffff;
+  let offset = 0;
+
+  if (b.length >= 16) {
+    const accN = [
+      (seed + PRIME32_1 + PRIME32_2) & 0xffffffff,
+      (seed + PRIME32_2) & 0xffffffff,
+      (seed + 0) & 0xffffffff,
+      (seed - PRIME32_1) & 0xffffffff,
+    ];
+
+    /*
+            Step 2. Process stripes
+            A stripe is a contiguous segment of 16 bytes. It is evenly divided into 4 lanes, of 4 bytes each.
+            The first lane is used to update accumulator 1, the second lane is used to update accumulator 2, and so on.
+
+            Each lane read its associated 32-bit value using little-endian convention.
+
+            For each {lane, accumulator}, the update process is called a round, and applies the following formula :
+
+            ```
+            accN = accN + (laneN * PRIME32_2);
+            accN = accN <<< 13;
+            accN = accN * PRIME32_1;
+            ```
+
+            This shuffles the bits so that any bit from input lane impacts several bits in output accumulator.
+            All operations are performed modulo 2^32.
+
+            Input is consumed one full stripe at a time. Step 2 is looped as many times as necessary to consume
+            the whole input, except the last remaining bytes which cannot form a stripe (< 16 bytes). When that
+            happens, move to step 3.
+        */
+
+    const b = buffer;
+    const limit = b.length - 16;
+    let lane = 0;
+    for (offset = 0; (offset & 0xfffffff0) <= limit; offset += 4) {
+      const i = offset;
+      const laneN0 = (b[i + 0] as any) + ((b[i + 1] as any) << 8);
+      const laneN1 = (b[i + 2] as any) + ((b[i + 3] as any) << 8);
+      const laneNP = laneN0 * PRIME32_2 + ((laneN1 * PRIME32_2) << 16);
+      let acc = (accN[lane] + laneNP) & 0xffffffff;
+      acc = (acc << 13) | (acc >>> 19);
+      const acc0 = acc & 0xffff;
+      const acc1 = acc >>> 16;
+      accN[lane] = (acc0 * PRIME32_1 + ((acc1 * PRIME32_1) << 16)) & 0xffffffff;
+      lane = (lane + 1) & 0x3;
+    }
+
+    /*
+            Step 3. Accumulator convergence
+            All 4 lane accumulators from previous steps are merged to produce a single remaining accumulator
+            of same width (32-bit). The associated formula is as follows :
+
+            ```
+            acc = (acc1 <<< 1) + (acc2 <<< 7) + (acc3 <<< 12) + (acc4 <<< 18);
+            ```
+        */
+    acc =
+      (((accN[0] << 1) | (accN[0] >>> 31)) +
+        ((accN[1] << 7) | (accN[1] >>> 25)) +
+        ((accN[2] << 12) | (accN[2] >>> 20)) +
+        ((accN[3] << 18) | (accN[3] >>> 14))) &
+      0xffffffff;
+  }
+
+  /*
+        Step 4. Add input length
+        The input total length is presumed known at this stage. This step is just about adding the length to
+        accumulator, so that it participates to final mixing.
+
+        ```
+        acc = acc + (u32)inputLength;
+        ```
+    */
+  acc = (acc + buffer.length) & 0xffffffff;
+
+  /*
+        Step 5. Consume remaining input
+        There may be up to 15 bytes remaining to consume from the input. The final stage will digest them according
+        to following pseudo-code :
+        ```
+        while (remainingLength >= 4) {
+            lane = read_32bit_little_endian(input_ptr);
+            acc = acc + lane * PRIME32_3;
+            acc = (acc <<< 17) * PRIME32_4;
+            input_ptr += 4; remainingLength -= 4;
+        }
+        ```
+        This process ensures that all input bytes are present in the final mix.
+    */
+
+  const limit = buffer.length - 4;
+  for (; offset <= limit; offset += 4) {
+    const i = offset;
+    const laneN0 = (b[i + 0] as any) + ((b[i + 1] as any) << 8);
+    const laneN1 = (b[i + 2] as any) + ((b[i + 3] as any) << 8);
+    const laneP = laneN0 * PRIME32_3 + ((laneN1 * PRIME32_3) << 16);
+    acc = (acc + laneP) & 0xffffffff;
+    acc = (acc << 17) | (acc >>> 15);
+    acc = ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) & 0xffffffff;
+  }
+
+  /*
+        ```
+        while (remainingLength >= 1) {
+            lane = read_byte(input_ptr);
+            acc = acc + lane * PRIME32_5;
+            acc = (acc <<< 11) * PRIME32_1;
+            input_ptr += 1; remainingLength -= 1;
+        }
+        ```
+    */
+
+  for (; offset < b.length; ++offset) {
+    const lane = b[offset];
+    acc = acc + (lane as any) * PRIME32_5;
+    acc = (acc << 11) | (acc >>> 21);
+    acc = ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) & 0xffffffff;
+  }
+
+  /*
+        Step 6. Final mix (avalanche)
+        The final mix ensures that all input bits have a chance to impact any bit in the output digest,
+        resulting in an unbiased distribution. This is also called avalanche effect.
+        ```
+        acc = acc xor (acc >> 15);
+        acc = acc * PRIME32_2;
+        acc = acc xor (acc >> 13);
+        acc = acc * PRIME32_3;
+        acc = acc xor (acc >> 16);
+        ```
+    */
+
+  acc = acc ^ (acc >>> 15);
+  acc = (((acc & 0xffff) * PRIME32_2) & 0xffffffff) + (((acc >>> 16) * PRIME32_2) << 16);
+  acc = acc ^ (acc >>> 13);
+  acc = (((acc & 0xffff) * PRIME32_3) & 0xffffffff) + (((acc >>> 16) * PRIME32_3) << 16);
+  acc = acc ^ (acc >>> 16);
+
+  // turn any negatives back into a positive number;
+  return acc < 0 ? acc + 4294967296 : acc;
+}

package/convex/world.ts

@@ -0,0 +1,257 @@
+import { ConvexError, v } from 'convex/values';
+import { internalMutation, mutation, query } from './_generated/server';
+import { characters } from '../data/characters';
+import { insertInput } from './aiTown/insertInput';
+import {
+  DEFAULT_NAME,
+  ENGINE_ACTION_DURATION,
+  IDLE_WORLD_TIMEOUT,
+  WORLD_HEARTBEAT_INTERVAL,
+} from './constants';
+import { playerId } from './aiTown/ids';
+import { kickEngine, startEngine, stopEngine } from './aiTown/main';
+import { engineInsertInput } from './engine/abstractGame';
+
+export const defaultWorldStatus = query({
+  handler: async (ctx) => {
+    const worldStatus = await ctx.db
+      .query('worldStatus')
+      .filter((q) => q.eq(q.field('isDefault'), true))
+      .first();
+    return worldStatus;
+  },
+});
+
+export const heartbeatWorld = mutation({
+  args: {
+    worldId: v.id('worlds'),
+  },
+  handler: async (ctx, args) => {
+    const worldStatus = await ctx.db
+      .query('worldStatus')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId))
+      .first();
+    if (!worldStatus) {
+      throw new Error(`Invalid world ID: ${args.worldId}`);
+    }
+    const now = Date.now();
+
+    // Skip the update (and then potentially make the transaction readonly)
+    // if it's been viewed sufficiently recently..
+    if (!worldStatus.lastViewed || worldStatus.lastViewed < now - WORLD_HEARTBEAT_INTERVAL / 2) {
+      await ctx.db.patch(worldStatus._id, {
+        lastViewed: Math.max(worldStatus.lastViewed ?? now, now),
+      });
+    }
+
+    // Restart inactive worlds, but leave worlds explicitly stopped by the developer alone.
+    if (worldStatus.status === 'stoppedByDeveloper') {
+      console.debug(`World ${worldStatus._id} is stopped by developer, not restarting.`);
+    }
+    if (worldStatus.status === 'inactive') {
+      console.log(`Restarting inactive world ${worldStatus._id}...`);
+      await ctx.db.patch(worldStatus._id, { status: 'running' });
+      await startEngine(ctx, worldStatus.worldId);
+    }
+  },
+});
+
+export const stopInactiveWorlds = internalMutation({
+  handler: async (ctx) => {
+    const cutoff = Date.now() - IDLE_WORLD_TIMEOUT;
+    const worlds = await ctx.db.query('worldStatus').collect();
+    for (const worldStatus of worlds) {
+      if (cutoff < worldStatus.lastViewed || worldStatus.status !== 'running') {
+        continue;
+      }
+      console.log(`Stopping inactive world ${worldStatus._id}`);
+      await ctx.db.patch(worldStatus._id, { status: 'inactive' });
+      await stopEngine(ctx, worldStatus.worldId);
+    }
+  },
+});
+
+export const restartDeadWorlds = internalMutation({
+  handler: async (ctx) => {
+    const now = Date.now();
+
+    // Restart an engine if it hasn't run for 2x its action duration.
+    const engineTimeout = now - ENGINE_ACTION_DURATION * 2;
+    const worlds = await ctx.db.query('worldStatus').collect();
+    for (const worldStatus of worlds) {
+      if (worldStatus.status !== 'running') {
+        continue;
+      }
+      const engine = await ctx.db.get(worldStatus.engineId);
+      if (!engine) {
+        throw new Error(`Invalid engine ID: ${worldStatus.engineId}`);
+      }
+      if (engine.currentTime && engine.currentTime < engineTimeout) {
+        console.warn(`Restarting dead engine ${engine._id}...`);
+        await kickEngine(ctx, worldStatus.worldId);
+      }
+    }
+  },
+});
+
+export const userStatus = query({
+  args: {
+    worldId: v.id('worlds'),
+  },
+  handler: async (ctx, args) => {
+    // const identity = await ctx.auth.getUserIdentity();
+    // if (!identity) {
+    //   return null;
+    // }
+    // return identity.tokenIdentifier;
+    return DEFAULT_NAME;
+  },
+});
+
+export const joinWorld = mutation({
+  args: {
+    worldId: v.id('worlds'),
+  },
+  handler: async (ctx, args) => {
+    // const identity = await ctx.auth.getUserIdentity();
+    // if (!identity) {
+    //   throw new ConvexError(`Not logged in`);
+    // }
+    // const name =
+    //   identity.givenName || identity.nickname || (identity.email && identity.email.split('@')[0]);
+    const name = DEFAULT_NAME;
+
+    // if (!name) {
+    //   throw new ConvexError(`Missing name on ${JSON.stringify(identity)}`);
+    // }
+    const world = await ctx.db.get(args.worldId);
+    if (!world) {
+      throw new ConvexError(`Invalid world ID: ${args.worldId}`);
+    }
+    // const { tokenIdentifier } = identity;
+    return await insertInput(ctx, world._id, 'join', {
+      name,
+      character: characters[Math.floor(Math.random() * characters.length)].name,
+      description: `${DEFAULT_NAME} is a human player`,
+      // description: `${identity.givenName} is a human player`,
+      tokenIdentifier: DEFAULT_NAME,
+    });
+  },
+});
+
+export const leaveWorld = mutation({
+  args: {
+    worldId: v.id('worlds'),
+  },
+  handler: async (ctx, args) => {
+    // const identity = await ctx.auth.getUserIdentity();
+    // if (!identity) {
+    //   throw new Error(`Not logged in`);
+    // }
+    // const { tokenIdentifier } = identity;
+    const world = await ctx.db.get(args.worldId);
+    if (!world) {
+      throw new Error(`Invalid world ID: ${args.worldId}`);
+    }
+    // const existingPlayer = world.players.find((p) => p.human === tokenIdentifier);
+    const existingPlayer = world.players.find((p) => p.human === DEFAULT_NAME);
+    if (!existingPlayer) {
+      return;
+    }
+    await insertInput(ctx, world._id, 'leave', {
+      playerId: existingPlayer.id,
+    });
+  },
+});
+
+export const sendWorldInput = mutation({
+  args: {
+    engineId: v.id('engines'),
+    name: v.string(),
+    args: v.any(),
+  },
+  handler: async (ctx, args) => {
+    // const identity = await ctx.auth.getUserIdentity();
+    // if (!identity) {
+    //   throw new Error(`Not logged in`);
+    // }
+    return await engineInsertInput(ctx, args.engineId, args.name as any, args.args);
+  },
+});
+
+export const worldState = query({
+  args: {
+    worldId: v.id('worlds'),
+  },
+  handler: async (ctx, args) => {
+    const world = await ctx.db.get(args.worldId);
+    if (!world) {
+      throw new Error(`Invalid world ID: ${args.worldId}`);
+    }
+    const worldStatus = await ctx.db
+      .query('worldStatus')
+      .withIndex('worldId', (q) => q.eq('worldId', world._id))
+      .unique();
+    if (!worldStatus) {
+      throw new Error(`Invalid world status ID: ${world._id}`);
+    }
+    const engine = await ctx.db.get(worldStatus.engineId);
+    if (!engine) {
+      throw new Error(`Invalid engine ID: ${worldStatus.engineId}`);
+    }
+    return { world, engine };
+  },
+});
+
+export const gameDescriptions = query({
+  args: {
+    worldId: v.id('worlds'),
+  },
+  handler: async (ctx, args) => {
+    const playerDescriptions = await ctx.db
+      .query('playerDescriptions')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId))
+      .collect();
+    const agentDescriptions = await ctx.db
+      .query('agentDescriptions')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId))
+      .collect();
+    const worldMap = await ctx.db
+      .query('maps')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId))
+      .first();
+    if (!worldMap) {
+      throw new Error(`No map for world: ${args.worldId}`);
+    }
+    return { worldMap, playerDescriptions, agentDescriptions };
+  },
+});
+
+export const previousConversation = query({
+  args: {
+    worldId: v.id('worlds'),
+    playerId,
+  },
+  handler: async (ctx, args) => {
+    // Walk the player's history in descending order, looking for a nonempty
+    // conversation.
+    const members = ctx.db
+      .query('participatedTogether')
+      .withIndex('playerHistory', (q) => q.eq('worldId', args.worldId).eq('player1', args.playerId))
+      .order('desc');
+
+    for await (const member of members) {
+      const conversation = await ctx.db
+        .query('archivedConversations')
+        .withIndex('worldId', (q) => q.eq('worldId', args.worldId).eq('id', member.conversationId))
+        .unique();
+      if (!conversation) {
+        throw new Error(`Invalid conversation ID: ${member.conversationId}`);
+      }
+      if (conversation.numMessages > 0) {
+        return conversation;
+      }
+    }
+    return null;
+  },
+});

package/data/animations/campfire.json

@@ -0,0 +1,45 @@
+{"frames": {
+
+"pixels_large1.png":
+{
+	"frame": {"x":0,"y":0,"w":32,"h":32},
+	"rotated": false,
+	"trimmed": true,
+	"spriteSourceSize": {"x":0,"y":0,"w":32,"h":32},
+	"sourceSize": {"w":32,"h":32}
+},
+"pixels_large2.png":
+{
+	"frame": {"x":32,"y":0,"w":32,"h":32},
+	"rotated": false,
+	"trimmed": true,
+	"spriteSourceSize": {"x":0,"y":0,"w":32,"h":32},
+	"sourceSize": {"w":32,"h":32}
+},
+"pixels_large3.png":
+{
+	"frame": {"x":64,"y":0,"w":32,"h":32},
+	"rotated": false,
+	"trimmed": true,
+	"spriteSourceSize": {"x":0,"y":0,"w":32,"h":32},
+	"sourceSize": {"w":32,"h":32}
+},
+"pixels_large4.png":
+{
+	"frame": {"x":96,"y":0,"w":32,"h":32},
+	"rotated": false,
+	"trimmed": true,
+	"spriteSourceSize": {"x":0,"y":0,"w":32,"h":32},
+	"sourceSize": {"w":32,"h":32}
+}
+},
+"animations": {
+	"pixels_large": ["pixels_large1.png","pixels_large2.png","pixels_large3.png","pixels_large4.png"]
+},
+"meta": {
+	"image": "./spritesheets/campfire.png",
+	"format": "RGBA8888",
+	"size": {"w":128,"h":32},
+	"scale": "1"
+}
+}

package/data/animations/gentlesparkle.json

@@ -0,0 +1,37 @@
+{"frames": {
+
+"pixels_large1.png":
+{
+	"frame": {"x":0,"y":0,"w":32,"h":32},
+	"rotated": false,
+	"trimmed": true,
+	"spriteSourceSize": {"x":0,"y":0,"w":32,"h":32},
+	"sourceSize": {"w":32,"h":32}
+},
+"pixels_large2.png":
+{
+	"frame": {"x":32,"y":0,"w":32,"h":32},
+	"rotated": false,
+	"trimmed": true,
+	"spriteSourceSize": {"x":0,"y":0,"w":32,"h":32},
+	"sourceSize": {"w":32,"h":32}
+},
+"pixels_large3.png":
+{
+	"frame": {"x":64,"y":0,"w":32,"h":32},
+	"rotated": false,
+	"trimmed": true,
+	"spriteSourceSize": {"x":0,"y":0,"w":32,"h":32},
+	"sourceSize": {"w":32,"h":32}
+}
+},
+"animations": {
+	"pixels_large": ["pixels_large1.png","pixels_large2.png","pixels_large3.png"]
+},
+"meta": {
+	"image": "./spritesheets/gentlesparkle32.png",
+	"format": "RGBA8888",
+	"size": {"w":192,"h":320},
+	"scale": "1"
+}
+}